919 lines
33 KiB
PHP
919 lines
33 KiB
PHP
<?php
|
|
|
|
namespace Tests\Feature\Schedule;
|
|
|
|
use App\Auth\CreateSessionDto;
|
|
use App\Auth\Clock;
|
|
use App\Auth\SessionRepository;
|
|
use App\Element\CreateElementDto;
|
|
use App\Element\ElementModel;
|
|
use App\Element\ElementRepository;
|
|
use App\Http\Middleware\AuthMiddleware;
|
|
use App\Set\CreateSetDto;
|
|
use App\Set\CreateSetLevelDto;
|
|
use App\Set\Set;
|
|
use App\Set\SetLevel;
|
|
use App\Set\SetLevelModel;
|
|
use App\Set\SetLevelRepository;
|
|
use App\Set\SetModel;
|
|
use App\Set\SetRepository;
|
|
use App\Shared\ValueObject\EmailAddress;
|
|
use App\User\CreateUserDto;
|
|
use App\User\User;
|
|
use App\User\UserRepository;
|
|
use DateTimeImmutable;
|
|
use DateTimeZone;
|
|
use Illuminate\Foundation\Testing\RefreshDatabase;
|
|
use Illuminate\Testing\TestResponse;
|
|
use Tests\TestCase;
|
|
use Tests\Fakes\FakeClock;
|
|
|
|
class ScheduleEndpointTest extends TestCase
|
|
{
|
|
use RefreshDatabase;
|
|
|
|
public function test_it_creates_and_returns_a_schedule(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$creator = $this->createUser('creator@example.com');
|
|
$set = $this->createSet($creator, 'Bible');
|
|
$bookLevel = $this->createLevel($set, 'book');
|
|
$portionLevel = $this->createLevel($set, 'portion');
|
|
$chapterLevel = $this->createLevel($set, 'chapter');
|
|
$repository = app(ElementRepository::class);
|
|
$genesis = $repository->create(new CreateElementDto(
|
|
name: 'Genesis',
|
|
level: $bookLevel,
|
|
parentElement: null,
|
|
));
|
|
$creation = $repository->create(new CreateElementDto(
|
|
name: 'Creation',
|
|
level: $portionLevel,
|
|
parentElement: $genesis,
|
|
));
|
|
$repository->create(new CreateElementDto(
|
|
name: 'Chapter 1',
|
|
level: $chapterLevel,
|
|
parentElement: $creation,
|
|
));
|
|
$exodus = $repository->create(new CreateElementDto(
|
|
name: 'Exodus',
|
|
level: $bookLevel,
|
|
parentElement: null,
|
|
));
|
|
$shemot = $repository->create(new CreateElementDto(
|
|
name: 'Shemot',
|
|
level: $portionLevel,
|
|
parentElement: $exodus,
|
|
));
|
|
$repository->create(new CreateElementDto(
|
|
name: 'Chapter 1',
|
|
level: $chapterLevel,
|
|
parentElement: $shemot,
|
|
));
|
|
$this->createSession($user, 'valid-token');
|
|
|
|
$response = $this->credentialedPost('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $chapterLevel->getId(),
|
|
'startDate' => '2026-08-10',
|
|
'targetDate' => '2026-08-12',
|
|
]);
|
|
|
|
$response->assertCreated()->assertExactJson([
|
|
'schedule' => [
|
|
'id' => 1,
|
|
'set' => [
|
|
'name' => 'Bible',
|
|
],
|
|
'elementKind' => 'chapter',
|
|
'startDate' => '2026-08-10',
|
|
'targetDate' => '2026-08-12',
|
|
'assignmentCount' => 2,
|
|
'days' => [
|
|
[
|
|
'date' => '2026-08-10',
|
|
'assignments' => [
|
|
[
|
|
'id' => 1,
|
|
'completedAt' => null,
|
|
'element' => [
|
|
'name' => 'Chapter 1',
|
|
'kind' => 'chapter',
|
|
'path' => [
|
|
'Genesis',
|
|
'Creation',
|
|
'Chapter 1',
|
|
],
|
|
],
|
|
],
|
|
],
|
|
],
|
|
[
|
|
'date' => '2026-08-11',
|
|
'assignments' => [],
|
|
],
|
|
[
|
|
'date' => '2026-08-12',
|
|
'assignments' => [
|
|
[
|
|
'id' => 2,
|
|
'completedAt' => null,
|
|
'element' => [
|
|
'name' => 'Chapter 1',
|
|
'kind' => 'chapter',
|
|
'path' => [
|
|
'Exodus',
|
|
'Shemot',
|
|
'Chapter 1',
|
|
],
|
|
],
|
|
],
|
|
],
|
|
],
|
|
],
|
|
],
|
|
]);
|
|
$this->assertDatabaseHas('schedules', [
|
|
'user_id' => $user->getId(),
|
|
'set_name' => 'Bible',
|
|
'element_kind' => 'chapter',
|
|
'start_date' => '2026-08-10',
|
|
'target_date' => '2026-08-12',
|
|
]);
|
|
$this->assertDatabaseHas('schedule_assignments', [
|
|
'schedule_id' => 1,
|
|
'element_name' => 'Chapter 1',
|
|
'element_kind' => 'chapter',
|
|
'element_path' => json_encode([
|
|
'Genesis',
|
|
'Creation',
|
|
'Chapter 1',
|
|
]),
|
|
'scheduled_date' => '2026-08-10',
|
|
'position' => 1,
|
|
]);
|
|
$this->assertDatabaseCount('schedule_assignments', 2);
|
|
|
|
$this->credentialedGet('/api/schedules/1')
|
|
->assertOk()
|
|
->assertExactJson($response->json());
|
|
}
|
|
|
|
public function test_it_places_heavier_days_at_the_requested_end(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$set = $this->createSet($user, 'Course');
|
|
$lessonLevel = $this->createLevel($set, 'lesson');
|
|
$repository = app(ElementRepository::class);
|
|
|
|
foreach (range(1, 11) as $number) {
|
|
$repository->create(new CreateElementDto(
|
|
name: "Lesson {$number}",
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
}
|
|
$this->createSession($user, 'valid-token');
|
|
|
|
$response = $this->credentialedPost('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-08-10',
|
|
'targetDate' => '2026-08-14',
|
|
'workloadPlacement' => 'end',
|
|
])->assertCreated();
|
|
|
|
$days = $response->json('schedule.days');
|
|
$this->assertIsArray($days);
|
|
$this->assertSame(
|
|
[2, 2, 2, 2, 3],
|
|
array_map(function (array $day): int {
|
|
return count($day['assignments']);
|
|
}, $days),
|
|
);
|
|
$this->assertDatabaseCount('schedule_assignments', 11);
|
|
$this->assertDatabaseCount('schedules', 1);
|
|
}
|
|
|
|
public function test_it_packs_sparse_assignments_at_the_requested_end(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$set = $this->createSet($user, 'Course');
|
|
$lessonLevel = $this->createLevel($set, 'lesson');
|
|
$repository = app(ElementRepository::class);
|
|
|
|
foreach (range(1, 4) as $number) {
|
|
$repository->create(new CreateElementDto(
|
|
name: "Lesson {$number}",
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
}
|
|
$this->createSession($user, 'valid-token');
|
|
|
|
$response = $this->credentialedPost('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-08-10',
|
|
'targetDate' => '2026-08-15',
|
|
'workloadPlacement' => 'end',
|
|
])->assertCreated();
|
|
|
|
$days = $response->json('schedule.days');
|
|
$this->assertIsArray($days);
|
|
$this->assertSame(
|
|
[0, 0, 1, 1, 1, 1],
|
|
array_map(function (array $day): int {
|
|
return count($day['assignments']);
|
|
}, $days),
|
|
);
|
|
}
|
|
|
|
public function test_it_rejects_an_unknown_workload_placement(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$set = $this->createSet($user, 'Course');
|
|
$lessonLevel = $this->createLevel($set, 'lesson');
|
|
app(ElementRepository::class)->create(new CreateElementDto(
|
|
name: 'Lesson 1',
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
$this->createSession($user, 'valid-token');
|
|
|
|
$this->credentialedPost('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-08-10',
|
|
'targetDate' => '2026-08-14',
|
|
'workloadPlacement' => 'sideways',
|
|
])->assertBadRequest()->assertExactJson([
|
|
'error' => 'workloadPlacement must be spread, start, middle, or end',
|
|
]);
|
|
}
|
|
|
|
public function test_it_spreads_heavier_days_across_the_full_range(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$set = $this->createSet($user, 'Course');
|
|
$lessonLevel = $this->createLevel($set, 'lesson');
|
|
$repository = app(ElementRepository::class);
|
|
|
|
foreach (range(1, 13) as $number) {
|
|
$repository->create(new CreateElementDto(
|
|
name: "Lesson {$number}",
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
}
|
|
$this->createSession($user, 'valid-token');
|
|
|
|
$response = $this->credentialedPost('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-08-10',
|
|
'targetDate' => '2026-08-14',
|
|
'workloadPlacement' => 'spread',
|
|
])->assertCreated();
|
|
|
|
$days = $response->json('schedule.days');
|
|
$this->assertIsArray($days);
|
|
$this->assertSame(
|
|
[3, 2, 3, 2, 3],
|
|
array_map(function (array $day): int {
|
|
return count($day['assignments']);
|
|
}, $days),
|
|
);
|
|
}
|
|
|
|
public function test_it_lists_only_the_users_schedules_newest_first(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$otherUser = $this->createUser('other@example.com');
|
|
$set = $this->createSet($user, 'Course');
|
|
$lessonLevel = $this->createLevel($set, 'lesson');
|
|
app(ElementRepository::class)->create(new CreateElementDto(
|
|
name: 'Welcome',
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
$this->createSession($user, 'valid-token');
|
|
$this->createSession($otherUser, 'other-token');
|
|
|
|
$this->credentialedPost('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-08-01',
|
|
'targetDate' => '2026-08-01',
|
|
])->assertCreated();
|
|
$this->credentialedPost('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-09-01',
|
|
'targetDate' => '2026-09-01',
|
|
])->assertCreated();
|
|
$this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'other-token',
|
|
)->postJson('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-10-01',
|
|
'targetDate' => '2026-10-01',
|
|
])->assertCreated();
|
|
|
|
$this->credentialedGet('/api/schedules')
|
|
->assertOk()
|
|
->assertExactJson([
|
|
'schedules' => [
|
|
[
|
|
'id' => 2,
|
|
'set' => [
|
|
'name' => 'Course',
|
|
],
|
|
'elementKind' => 'lesson',
|
|
'startDate' => '2026-09-01',
|
|
'targetDate' => '2026-09-01',
|
|
'assignmentCount' => 1,
|
|
],
|
|
[
|
|
'id' => 1,
|
|
'set' => [
|
|
'name' => 'Course',
|
|
],
|
|
'elementKind' => 'lesson',
|
|
'startDate' => '2026-08-01',
|
|
'targetDate' => '2026-08-01',
|
|
'assignmentCount' => 1,
|
|
],
|
|
],
|
|
]);
|
|
}
|
|
|
|
public function test_it_lists_the_users_assignments_due_through_a_date(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$otherUser = $this->createUser('other@example.com');
|
|
$olderSet = $this->createSet($user, 'Older course');
|
|
$olderLevel = $this->createLevel($olderSet, 'lesson');
|
|
$olderRepository = app(ElementRepository::class);
|
|
$olderRepository->create(new CreateElementDto(
|
|
name: 'First lesson',
|
|
level: $olderLevel,
|
|
parentElement: null,
|
|
));
|
|
$olderRepository->create(new CreateElementDto(
|
|
name: 'Second lesson',
|
|
level: $olderLevel,
|
|
parentElement: null,
|
|
));
|
|
$newerSet = $this->createSet($user, 'Newer course');
|
|
$newerLevel = $this->createLevel($newerSet, 'chapter');
|
|
app(ElementRepository::class)->create(new CreateElementDto(
|
|
name: 'Only chapter',
|
|
level: $newerLevel,
|
|
parentElement: null,
|
|
));
|
|
$this->createSession($user, 'valid-token');
|
|
$this->createSession($otherUser, 'other-token');
|
|
|
|
$this->credentialedPost('/api/schedules', [
|
|
'setId' => $olderSet->getId(),
|
|
'levelId' => $olderLevel->getId(),
|
|
'startDate' => '2026-08-14',
|
|
'targetDate' => '2026-08-14',
|
|
])->assertCreated();
|
|
$this->credentialedPost('/api/schedules', [
|
|
'setId' => $newerSet->getId(),
|
|
'levelId' => $newerLevel->getId(),
|
|
'startDate' => '2026-08-15',
|
|
'targetDate' => '2026-08-15',
|
|
])->assertCreated();
|
|
$this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'other-token',
|
|
)->postJson('/api/schedules', [
|
|
'setId' => $newerSet->getId(),
|
|
'levelId' => $newerLevel->getId(),
|
|
'startDate' => '2026-08-15',
|
|
'targetDate' => '2026-08-15',
|
|
])->assertCreated();
|
|
$this->credentialedPost('/api/schedules', [
|
|
'setId' => $olderSet->getId(),
|
|
'levelId' => $olderLevel->getId(),
|
|
'startDate' => '2026-08-16',
|
|
'targetDate' => '2026-08-16',
|
|
])->assertCreated();
|
|
|
|
$this->credentialedGet('/api/assignments?date=2026-08-15')
|
|
->assertOk()
|
|
->assertExactJson([
|
|
'date' => '2026-08-15',
|
|
'assignments' => [
|
|
[
|
|
'id' => 1,
|
|
'scheduledDate' => '2026-08-14',
|
|
'schedule' => [
|
|
'id' => 1,
|
|
'set' => [
|
|
'name' => 'Older course',
|
|
],
|
|
],
|
|
'element' => [
|
|
'name' => 'First lesson',
|
|
'kind' => 'lesson',
|
|
'path' => ['First lesson'],
|
|
],
|
|
],
|
|
[
|
|
'id' => 2,
|
|
'scheduledDate' => '2026-08-14',
|
|
'schedule' => [
|
|
'id' => 1,
|
|
'set' => [
|
|
'name' => 'Older course',
|
|
],
|
|
],
|
|
'element' => [
|
|
'name' => 'Second lesson',
|
|
'kind' => 'lesson',
|
|
'path' => ['Second lesson'],
|
|
],
|
|
],
|
|
[
|
|
'id' => 3,
|
|
'scheduledDate' => '2026-08-15',
|
|
'schedule' => [
|
|
'id' => 2,
|
|
'set' => [
|
|
'name' => 'Newer course',
|
|
],
|
|
],
|
|
'element' => [
|
|
'name' => 'Only chapter',
|
|
'kind' => 'chapter',
|
|
'path' => ['Only chapter'],
|
|
],
|
|
],
|
|
],
|
|
]);
|
|
}
|
|
|
|
public function test_it_returns_an_empty_assignment_list_for_a_date(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$this->createSession($user, 'valid-token');
|
|
|
|
$this->credentialedGet('/api/assignments?date=2026-08-15')
|
|
->assertOk()
|
|
->assertExactJson([
|
|
'date' => '2026-08-15',
|
|
'assignments' => [],
|
|
]);
|
|
}
|
|
|
|
public function test_it_rejects_invalid_assignment_dates(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$this->createSession($user, 'valid-token');
|
|
|
|
$this->credentialedGet('/api/assignments')
|
|
->assertBadRequest()
|
|
->assertExactJson(['error' => 'date is required']);
|
|
}
|
|
|
|
public function test_it_completes_and_reopens_an_assignment(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$set = $this->createSet($user, 'Course');
|
|
$lessonLevel = $this->createLevel($set, 'lesson');
|
|
$repository = app(ElementRepository::class);
|
|
$repository->create(new CreateElementDto(
|
|
name: 'First lesson',
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
$repository->create(new CreateElementDto(
|
|
name: 'Second lesson',
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
$this->createSession($user, 'valid-token');
|
|
$completedAt = new DateTimeImmutable(
|
|
'2026-08-15T12:30:45',
|
|
new DateTimeZone('UTC'),
|
|
);
|
|
$this->app->instance(Clock::class, new FakeClock($completedAt));
|
|
$this->credentialedPost('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-08-20',
|
|
'targetDate' => '2026-08-20',
|
|
])->assertCreated();
|
|
|
|
$this->credentialedPatch('/api/assignments/1', [
|
|
'completed' => true,
|
|
])->assertOk()->assertExactJson([
|
|
'assignment' => [
|
|
'id' => 1,
|
|
'completedAt' => '2026-08-15T12:30:45+00:00',
|
|
],
|
|
]);
|
|
$this->assertDatabaseHas('schedule_assignments', [
|
|
'id' => 1,
|
|
'completed_at' => '2026-08-15 12:30:45',
|
|
]);
|
|
$this->credentialedGet('/api/schedules/1')
|
|
->assertOk()
|
|
->assertJsonPath(
|
|
'schedule.days.0.assignments.0.completedAt',
|
|
'2026-08-15T12:30:45+00:00',
|
|
)
|
|
->assertJsonPath(
|
|
'schedule.days.0.assignments.1.completedAt',
|
|
null,
|
|
);
|
|
$this->credentialedGet('/api/assignments?date=2026-08-20')
|
|
->assertOk()
|
|
->assertJsonCount(1, 'assignments')
|
|
->assertJsonPath('assignments.0.id', 2);
|
|
|
|
$this->credentialedPatch('/api/assignments/1', [
|
|
'completed' => false,
|
|
])->assertOk()->assertExactJson([
|
|
'assignment' => [
|
|
'id' => 1,
|
|
'completedAt' => null,
|
|
],
|
|
]);
|
|
$this->assertDatabaseHas('schedule_assignments', [
|
|
'id' => 1,
|
|
'completed_at' => null,
|
|
]);
|
|
$this->credentialedGet('/api/assignments?date=2026-08-20')
|
|
->assertOk()
|
|
->assertJsonCount(2, 'assignments');
|
|
}
|
|
|
|
public function test_it_reschedules_only_unfinished_assignments_without_changing_start_date(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$set = $this->createSet($user, 'Course');
|
|
$lessonLevel = $this->createLevel($set, 'lesson');
|
|
$repository = app(ElementRepository::class);
|
|
foreach (range(1, 4) as $number) {
|
|
$repository->create(new CreateElementDto(
|
|
name: "Lesson {$number}",
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
}
|
|
$this->createSession($user, 'valid-token');
|
|
$completedAt = new DateTimeImmutable(
|
|
'2026-08-15T12:30:45',
|
|
new DateTimeZone('UTC'),
|
|
);
|
|
$this->app->instance(Clock::class, new FakeClock($completedAt));
|
|
$this->credentialedPost('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-08-10',
|
|
'targetDate' => '2026-08-13',
|
|
])->assertCreated();
|
|
$this->credentialedPatch('/api/assignments/1', [
|
|
'completed' => true,
|
|
])->assertOk();
|
|
|
|
$response = $this->credentialedPatch('/api/schedules/1', [
|
|
'startDate' => '2026-08-20',
|
|
'targetDate' => '2026-08-21',
|
|
'workloadPlacement' => 'end',
|
|
]);
|
|
|
|
$response->assertOk()
|
|
->assertJsonPath('schedule.startDate', '2026-08-10')
|
|
->assertJsonPath('schedule.targetDate', '2026-08-21')
|
|
->assertJsonCount(12, 'schedule.days')
|
|
->assertJsonPath('schedule.days.0.date', '2026-08-10')
|
|
->assertJsonPath(
|
|
'schedule.days.0.assignments.0.completedAt',
|
|
'2026-08-15T12:30:45+00:00',
|
|
)
|
|
->assertJsonPath('schedule.days.10.date', '2026-08-20')
|
|
->assertJsonCount(1, 'schedule.days.10.assignments')
|
|
->assertJsonPath('schedule.days.10.assignments.0.id', 2)
|
|
->assertJsonPath('schedule.days.11.date', '2026-08-21')
|
|
->assertJsonCount(2, 'schedule.days.11.assignments')
|
|
->assertJsonPath('schedule.days.11.assignments.0.id', 3)
|
|
->assertJsonPath('schedule.days.11.assignments.1.id', 4);
|
|
$this->assertDatabaseHas('schedules', [
|
|
'id' => 1,
|
|
'start_date' => '2026-08-10',
|
|
'target_date' => '2026-08-21',
|
|
]);
|
|
$this->assertDatabaseHas('schedule_assignments', [
|
|
'id' => 1,
|
|
'scheduled_date' => '2026-08-10',
|
|
'completed_at' => '2026-08-15 12:30:45',
|
|
]);
|
|
$this->assertDatabaseHas('schedule_assignments', [
|
|
'id' => 2,
|
|
'scheduled_date' => '2026-08-20',
|
|
'completed_at' => null,
|
|
]);
|
|
$this->assertDatabaseHas('schedule_assignments', [
|
|
'id' => 3,
|
|
'scheduled_date' => '2026-08-21',
|
|
'completed_at' => null,
|
|
]);
|
|
$this->assertDatabaseHas('schedule_assignments', [
|
|
'id' => 4,
|
|
'scheduled_date' => '2026-08-21',
|
|
'completed_at' => null,
|
|
]);
|
|
}
|
|
|
|
public function test_it_hides_another_users_schedule_when_rescheduling(): void
|
|
{
|
|
$owner = $this->createUser('owner@example.com');
|
|
$viewer = $this->createUser('viewer@example.com');
|
|
$set = $this->createSet($owner, 'Course');
|
|
$lessonLevel = $this->createLevel($set, 'lesson');
|
|
app(ElementRepository::class)->create(new CreateElementDto(
|
|
name: 'Welcome',
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
$this->createSession($owner, 'owner-token');
|
|
$this->createSession($viewer, 'viewer-token');
|
|
$this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'owner-token',
|
|
)->postJson('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-08-10',
|
|
'targetDate' => '2026-08-10',
|
|
])->assertCreated();
|
|
|
|
$this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'viewer-token',
|
|
)->patchJson('/api/schedules/1', [
|
|
'startDate' => '2026-08-20',
|
|
'targetDate' => '2026-08-21',
|
|
'workloadPlacement' => 'middle',
|
|
])->assertNotFound()->assertExactJson([
|
|
'error' => 'schedule not found',
|
|
]);
|
|
$this->assertDatabaseHas('schedules', [
|
|
'id' => 1,
|
|
'start_date' => '2026-08-10',
|
|
'target_date' => '2026-08-10',
|
|
]);
|
|
}
|
|
|
|
public function test_it_rejects_invalid_assignment_completion_input(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$this->createSession($user, 'valid-token');
|
|
|
|
$this->credentialedPatch('/api/assignments/1', [
|
|
'completed' => 'yes',
|
|
])->assertBadRequest()->assertExactJson([
|
|
'error' => 'completed must be a boolean',
|
|
]);
|
|
}
|
|
|
|
public function test_it_hides_another_users_assignment(): void
|
|
{
|
|
$owner = $this->createUser('owner@example.com');
|
|
$viewer = $this->createUser('viewer@example.com');
|
|
$set = $this->createSet($owner, 'Course');
|
|
$lessonLevel = $this->createLevel($set, 'lesson');
|
|
app(ElementRepository::class)->create(new CreateElementDto(
|
|
name: 'Welcome',
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
$this->createSession($owner, 'owner-token');
|
|
$this->createSession($viewer, 'viewer-token');
|
|
$this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'owner-token',
|
|
)->postJson('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-08-15',
|
|
'targetDate' => '2026-08-15',
|
|
])->assertCreated();
|
|
|
|
$this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'viewer-token',
|
|
)->patchJson('/api/assignments/1', [
|
|
'completed' => true,
|
|
])->assertNotFound()->assertExactJson([
|
|
'error' => 'assignment not found',
|
|
]);
|
|
$this->assertDatabaseHas('schedule_assignments', [
|
|
'id' => 1,
|
|
'completed_at' => null,
|
|
]);
|
|
}
|
|
|
|
public function test_it_is_stable_after_sources_change_or_are_deleted(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$set = $this->createSet($user, 'Original set');
|
|
$groupLevel = $this->createLevel($set, 'group');
|
|
$taskLevel = $this->createLevel($set, 'task');
|
|
$repository = app(ElementRepository::class);
|
|
$parent = $repository->create(new CreateElementDto(
|
|
name: 'Original parent',
|
|
level: $groupLevel,
|
|
parentElement: null,
|
|
));
|
|
$element = $repository->create(new CreateElementDto(
|
|
name: 'Original item',
|
|
level: $taskLevel,
|
|
parentElement: $parent,
|
|
));
|
|
$this->createSession($user, 'valid-token');
|
|
$createdResponse = $this->credentialedPost('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $taskLevel->getId(),
|
|
'startDate' => '2026-08-10',
|
|
'targetDate' => '2026-08-10',
|
|
])->assertCreated();
|
|
|
|
SetModel::query()->whereKey($set->getId())->update([
|
|
'name' => 'Changed set',
|
|
]);
|
|
SetLevelModel::query()->whereKey($taskLevel->getId())->update([
|
|
'kind' => 'changed-kind',
|
|
]);
|
|
ElementModel::query()->whereKey($parent->getId())->update([
|
|
'name' => 'Changed parent',
|
|
]);
|
|
ElementModel::query()->whereKey($element->getId())->update([
|
|
'name' => 'Changed item',
|
|
]);
|
|
|
|
$this->credentialedGet('/api/schedules/1')
|
|
->assertOk()
|
|
->assertExactJson($createdResponse->json());
|
|
|
|
ElementModel::query()->whereKey($element->getId())->delete();
|
|
ElementModel::query()->whereKey($parent->getId())->delete();
|
|
SetModel::query()->whereKey($set->getId())->delete();
|
|
|
|
$this->credentialedGet('/api/schedules/1')
|
|
->assertOk()
|
|
->assertExactJson($createdResponse->json());
|
|
}
|
|
|
|
public function test_it_hides_another_users_schedule(): void
|
|
{
|
|
$owner = $this->createUser('owner@example.com');
|
|
$viewer = $this->createUser('viewer@example.com');
|
|
$set = $this->createSet($owner, 'Course');
|
|
$lessonLevel = $this->createLevel($set, 'lesson');
|
|
app(ElementRepository::class)->create(new CreateElementDto(
|
|
name: 'Welcome',
|
|
level: $lessonLevel,
|
|
parentElement: null,
|
|
));
|
|
$this->createSession($owner, 'owner-token');
|
|
$this->createSession($viewer, 'viewer-token');
|
|
|
|
$this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'owner-token',
|
|
)->postJson('/api/schedules', [
|
|
'setId' => $set->getId(),
|
|
'levelId' => $lessonLevel->getId(),
|
|
'startDate' => '2026-08-01',
|
|
'targetDate' => '2026-08-01',
|
|
])->assertCreated();
|
|
|
|
$this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'viewer-token',
|
|
)->getJson('/api/schedules/1')
|
|
->assertNotFound()
|
|
->assertExactJson(['error' => 'schedule not found']);
|
|
}
|
|
|
|
public function test_it_rejects_invalid_creation_input(): void
|
|
{
|
|
$user = $this->createUser('reader@example.com');
|
|
$this->createSession($user, 'valid-token');
|
|
|
|
$this->credentialedPost('/api/schedules', [
|
|
'setId' => 999,
|
|
'levelId' => 1,
|
|
'startDate' => '2026-08-12',
|
|
'targetDate' => '2026-08-10',
|
|
])->assertNotFound()->assertExactJson([
|
|
'error' => 'set not found',
|
|
]);
|
|
}
|
|
|
|
public function test_schedule_endpoints_require_authentication(): void
|
|
{
|
|
$this->getJson('/api/assignments?date=2026-08-15')
|
|
->assertStatus(401);
|
|
$this->patchJson('/api/assignments/1', [
|
|
'completed' => true,
|
|
])->assertStatus(401);
|
|
$this->getJson('/api/schedules')->assertStatus(401);
|
|
$this->getJson('/api/schedules/1')->assertStatus(401);
|
|
$this->patchJson('/api/schedules/1', [])->assertStatus(401);
|
|
$this->postJson('/api/schedules', [])->assertStatus(401);
|
|
}
|
|
|
|
private function createUser(string $email): User
|
|
{
|
|
return app(UserRepository::class)->create(new CreateUserDto(
|
|
email: new EmailAddress($email),
|
|
passwordHash: 'hashed-password',
|
|
));
|
|
}
|
|
|
|
private function createSet(User $user, string $name): Set
|
|
{
|
|
return app(SetRepository::class)->create(new CreateSetDto(
|
|
name: $name,
|
|
creator: $user,
|
|
));
|
|
}
|
|
|
|
private function createLevel(Set $set, string $kind): SetLevel
|
|
{
|
|
return app(SetLevelRepository::class)->create(new CreateSetLevelDto(
|
|
set: $set,
|
|
kind: $kind,
|
|
));
|
|
}
|
|
|
|
private function createSession(User $user, string $token): void
|
|
{
|
|
$createdAt = new DateTimeImmutable(
|
|
'2026-08-03T12:00:00',
|
|
new DateTimeZone('UTC'),
|
|
);
|
|
app(SessionRepository::class)->create(new CreateSessionDto(
|
|
token: $token,
|
|
user: $user,
|
|
createdAt: $createdAt,
|
|
expiresAt: $createdAt->modify('+10 years'),
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $payload
|
|
*/
|
|
private function credentialedPost(
|
|
string $uri,
|
|
array $payload,
|
|
): TestResponse {
|
|
return $this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'valid-token',
|
|
)->postJson($uri, $payload);
|
|
}
|
|
|
|
private function credentialedGet(string $uri): TestResponse
|
|
{
|
|
return $this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'valid-token',
|
|
)->getJson($uri);
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $payload
|
|
*/
|
|
private function credentialedPatch(
|
|
string $uri,
|
|
array $payload,
|
|
): TestResponse {
|
|
return $this->withCredentials()
|
|
->withUnencryptedCookie(
|
|
AuthMiddleware::COOKIE_NAME,
|
|
'valid-token',
|
|
)->patchJson($uri, $payload);
|
|
}
|
|
}
|