Add additional tests for filament

app/Filament/Resources/OrganizationResource.php

@@ -40,6 +40,7 @@ use Filament\Tables\Columns\IconColumn;
 use Filament\Tables\Columns\TextColumn;
 use Filament\Tables\Table;
 use Illuminate\Support\Facades\Storage;
+use League\Flysystem\UnableToReadFile;
 
 class OrganizationResource extends Resource
 {
@@ -181,9 +182,13 @@ class OrganizationResource extends Resource
                     ->icon('heroicon-o-inbox-arrow-down')
                     ->action(function (Organization $record, array $data): void {
                         try {
-                            $file = Storage::disk(config('filament.default_filesystem_disk'))->get($data['file']);
+                            try {
+                                $file = Storage::disk(config('filament.default_filesystem_disk'))->get($data['file']);
+                            } catch (UnableToReadFile) {
+                                $file = null;
+                            }
                             if ($file === null) {
-                                throw new Exception('File not found');
+                                throw new ImportException('File not found');
                             }
                             /** @var string $timezone */
                             $timezone = $data['timezone'];

tests/Unit/Filament/Resources/OrganizationResourceTest.php

@@ -7,14 +7,25 @@ namespace Tests\Unit\Filament\Resources;
 use App\Enums\Role;
 use App\Events\OrganizationInvitationAdding;
 use App\Filament\Resources\OrganizationResource;
+use App\Filament\Resources\UserResource;
 use App\Mail\OrganizationInvitationMail;
+use App\Models\Member;
 use App\Models\Organization;
 use App\Models\OrganizationInvitation;
+use App\Models\TimeEntry;
 use App\Models\User;
 use App\Service\DeletionService;
+use App\Service\Export\ExportService;
+use App\Service\Import\Importers\ImportException;
+use App\Service\Import\Importers\ReportDto;
+use App\Service\Import\ImportService;
+use Exception;
+use Filament\Notifications\Notification;
 use Illuminate\Support\Facades\Config;
 use Illuminate\Support\Facades\Event;
 use Illuminate\Support\Facades\Mail;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Str;
 use Livewire\Livewire;
 use Mockery\MockInterface;
 use PHPUnit\Framework\Attributes\UsesClass;
@@ -81,6 +92,239 @@ class OrganizationResourceTest extends FilamentTestCase
         $response->assertSuccessful();
     }
 
+    public function test_can_delete_an_organization_from_the_table(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $this->mock(DeletionService::class, function (MockInterface $mock) use ($organization): void {
+            $mock->shouldReceive('deleteOrganization')
+                ->withArgs(fn (Organization $organizationArg) => $organizationArg->is($organization))
+                ->once();
+        });
+
+        // Act
+        $response = Livewire::test(OrganizationResource\Pages\ListOrganizations::class)
+            ->callTableAction('delete', $organization);
+
+        // Assert
+        $response->assertHasNoTableActionErrors();
+        $response->assertSuccessful();
+    }
+
+    public function test_can_export_an_organization(): void
+    {
+        // Arrange
+        Storage::fake(config('filesystems.private'));
+        Storage::disk(config('filesystems.private'))->put('exports/export.zip', 'zip-content');
+        $organization = Organization::factory()->create();
+        $this->mock(ExportService::class, function (MockInterface $mock) use ($organization): void {
+            $mock->shouldReceive('export')
+                ->withArgs(fn (Organization $organizationArg) => $organizationArg->is($organization))
+                ->once()
+                ->andReturn('exports/export.zip');
+        });
+
+        // Act
+        $response = Livewire::test(OrganizationResource\Pages\ListOrganizations::class)
+            ->callTableAction('Export', $organization);
+
+        // Assert
+        $response->assertHasNoTableActionErrors();
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->title('Export successful')
+                ->success()
+                ->persistent()
+        );
+        $response->assertFileDownloaded('export.zip');
+    }
+
+    public function test_export_organization_shows_error_notification_on_failure(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $this->mock(ExportService::class, function (MockInterface $mock): void {
+            $mock->shouldReceive('export')
+                ->once()
+                ->andThrow(new Exception('Something went wrong'));
+        });
+
+        // Act
+        $response = Livewire::test(OrganizationResource\Pages\ListOrganizations::class)
+            ->callTableAction('Export', $organization);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->title('Export failed')
+                ->danger()
+                ->body('Message: Something went wrong')
+                ->persistent()
+        );
+        $response->assertNoFileDownloaded();
+    }
+
+    public function test_can_import_into_an_organization(): void
+    {
+        // Arrange
+        Storage::fake(config('filament.default_filesystem_disk'));
+        Storage::disk(config('filament.default_filesystem_disk'))->put('imports/import.csv', 'csv-content');
+        $organization = Organization::factory()->create();
+        $this->mock(ImportService::class, function (MockInterface $mock) use ($organization): void {
+            $mock->shouldReceive('import')
+                ->withArgs(function (Organization $organizationArg, string $importerType, string $data, string $timezone) use ($organization): bool {
+                    return $organizationArg->is($organization)
+                        && $importerType === 'toggl_time_entries'
+                        && $data === 'csv-content'
+                        && $timezone === 'Europe/Vienna';
+                })
+                ->once()
+                ->andReturn(new ReportDto(
+                    clientsCreated: 1,
+                    projectsCreated: 2,
+                    tasksCreated: 3,
+                    timeEntriesCreated: 4,
+                    tagsCreated: 5,
+                    usersCreated: 6,
+                ));
+        });
+
+        // Act
+        $response = Livewire::test(OrganizationResource\Pages\ListOrganizations::class)
+            ->callTableAction('Import', $organization, data: [
+                'file' => [(string) Str::uuid() => 'imports/import.csv'],
+                'type' => 'toggl_time_entries',
+                'timezone' => 'Europe/Vienna',
+            ]);
+
+        // Assert
+        $response->assertHasNoTableActionErrors();
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->title('Import successful')
+                ->success()
+                ->body(
+                    'Imported time entries: 4<br>'.
+                    'Imported clients: 1<br>'.
+                    'Imported projects: 2<br>'.
+                    'Imported tasks: 3<br>'.
+                    'Imported tags: 5<br>'.
+                    'Imported users: 6'
+                )
+                ->persistent()
+        );
+    }
+
+    public function test_import_into_organization_shows_error_notification_on_import_exception(): void
+    {
+        // Arrange
+        Storage::fake(config('filament.default_filesystem_disk'));
+        Storage::disk(config('filament.default_filesystem_disk'))->put('imports/import.csv', 'csv-content');
+        $organization = Organization::factory()->create();
+        $this->mock(ImportService::class, function (MockInterface $mock): void {
+            $mock->shouldReceive('import')
+                ->once()
+                ->andThrow(new ImportException('Invalid CSV'));
+        });
+
+        // Act
+        $response = Livewire::test(OrganizationResource\Pages\ListOrganizations::class)
+            ->callTableAction('Import', $organization, data: [
+                'file' => [(string) Str::uuid() => 'imports/import.csv'],
+                'type' => 'toggl_time_entries',
+                'timezone' => 'Europe/Vienna',
+            ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->title('Import failed, changes rolled back')
+                ->danger()
+                ->body('Message: Invalid CSV')
+                ->persistent()
+        );
+    }
+
+    public function test_import_into_organization_shows_error_notification_if_file_is_missing(): void
+    {
+        // Arrange
+        Storage::fake(config('filament.default_filesystem_disk'));
+        $organization = Organization::factory()->create();
+        $this->mock(ImportService::class, function (MockInterface $mock): void {
+            $mock->shouldNotReceive('import');
+        });
+
+        // Act
+        $response = Livewire::test(OrganizationResource\Pages\ListOrganizations::class)
+            ->callTableAction('Import', $organization, data: [
+                'file' => [(string) Str::uuid() => 'imports/does-not-exist.csv'],
+                'type' => 'toggl_time_entries',
+                'timezone' => 'Europe/Vienna',
+            ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->title('Import failed, changes rolled back')
+                ->danger()
+                ->body('Message: File not found')
+                ->persistent()
+        );
+    }
+
+    public function test_import_into_organization_shows_error_notification_if_file_is_missing_on_non_throwing_disk(): void
+    {
+        // Arrange
+        Storage::fake(config('filament.default_filesystem_disk'), ['throw' => false]);
+        $organization = Organization::factory()->create();
+        $this->mock(ImportService::class, function (MockInterface $mock): void {
+            $mock->shouldNotReceive('import');
+        });
+
+        // Act
+        $response = Livewire::test(OrganizationResource\Pages\ListOrganizations::class)
+            ->callTableAction('Import', $organization, data: [
+                'file' => [(string) Str::uuid() => 'imports/does-not-exist.csv'],
+                'type' => 'toggl_time_entries',
+                'timezone' => 'Europe/Vienna',
+            ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->title('Import failed, changes rolled back')
+                ->danger()
+                ->body('Message: File not found')
+                ->persistent()
+        );
+    }
+
+    public function test_import_into_organization_requires_file_type_and_timezone(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $this->mock(ImportService::class, function (MockInterface $mock): void {
+            $mock->shouldNotReceive('import');
+        });
+
+        // Act
+        $response = Livewire::test(OrganizationResource\Pages\ListOrganizations::class)
+            ->callTableAction('Import', $organization, data: [
+                'file' => null,
+                'type' => null,
+                'timezone' => null,
+            ]);
+
+        // Assert
+        $response->assertHasTableActionErrors(['file', 'type', 'timezone']);
+    }
+
     public function test_can_list_related_users(): void
     {
         // Arrange
@@ -147,4 +391,238 @@ class OrganizationResourceTest extends FilamentTestCase
         Event::assertDispatched(OrganizationInvitationAdding::class);
         Mail::assertQueued(OrganizationInvitationMail::class);
     }
+
+    public function test_related_users_have_view_action_linking_to_user_resource(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $user = User::factory()->create();
+        Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Employee)->create();
+
+        // Act
+        $response = Livewire::test(OrganizationResource\RelationManagers\UsersRelationManager::class, [
+            'ownerRecord' => $organization,
+            'pageClass' => OrganizationResource\Pages\EditOrganization::class,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertTableActionHasUrl('view', UserResource::getUrl('view', [
+            'record' => $user->getKey(),
+        ]), $user);
+    }
+
+    public function test_can_attach_user_to_organization(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $user = User::factory()->create();
+
+        // Act
+        $response = Livewire::test(OrganizationResource\RelationManagers\UsersRelationManager::class, [
+            'ownerRecord' => $organization,
+            'pageClass' => OrganizationResource\Pages\EditOrganization::class,
+        ])->callTableAction('attach', data: [
+            'recordId' => $user->getKey(),
+            'role' => Role::Employee->value,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertHasNoTableActionErrors();
+        $this->assertDatabaseHas(Member::class, [
+            'organization_id' => $organization->getKey(),
+            'user_id' => $user->getKey(),
+            'role' => Role::Employee->value,
+        ]);
+    }
+
+    public function test_attach_user_to_organization_fails_with_owner_or_placeholder_role(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $user = User::factory()->create();
+
+        foreach ([Role::Owner, Role::Placeholder] as $role) {
+            // Act
+            $response = Livewire::test(OrganizationResource\RelationManagers\UsersRelationManager::class, [
+                'ownerRecord' => $organization,
+                'pageClass' => OrganizationResource\Pages\EditOrganization::class,
+            ])->callTableAction('attach', data: [
+                'recordId' => $user->getKey(),
+                'role' => $role->value,
+            ]);
+
+            // Assert
+            $response->assertHasTableActionErrors(['role']);
+        }
+        $this->assertDatabaseMissing(Member::class, [
+            'organization_id' => $organization->getKey(),
+            'user_id' => $user->getKey(),
+        ]);
+    }
+
+    public function test_can_edit_role_and_billable_rate_of_related_user(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $user = User::factory()->create();
+        $member = Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Employee)->billableRate(1000)->create();
+        $billableTimeEntry = TimeEntry::factory()->forMember($member)->billableRate(1000)->create();
+        $nonBillableTimeEntry = TimeEntry::factory()->forMember($member)->notBillable()->create();
+
+        // Act
+        $response = Livewire::test(OrganizationResource\RelationManagers\UsersRelationManager::class, [
+            'ownerRecord' => $organization,
+            'pageClass' => OrganizationResource\Pages\EditOrganization::class,
+        ])->callTableAction('edit', $user, data: [
+            'role' => Role::Admin->value,
+            'billable_rate' => 2000,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertHasNoTableActionErrors();
+        $member->refresh();
+        $this->assertSame(Role::Admin->value, $member->role);
+        $this->assertSame(2000, $member->billable_rate);
+        $this->assertSame(2000, $billableTimeEntry->refresh()->billable_rate);
+        $this->assertNull($nonBillableTimeEntry->refresh()->billable_rate);
+    }
+
+    public function test_can_make_related_user_owner_of_organization(): void
+    {
+        // Arrange
+        $owner = User::factory()->create();
+        $organization = Organization::factory()->withOwner($owner)->create();
+        $ownerMember = Member::factory()->forOrganization($organization)->forUser($owner)->role(Role::Owner)->create();
+        $user = User::factory()->create();
+        $member = Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Employee)->create();
+
+        // Act
+        $response = Livewire::test(OrganizationResource\RelationManagers\UsersRelationManager::class, [
+            'ownerRecord' => $organization,
+            'pageClass' => OrganizationResource\Pages\EditOrganization::class,
+        ])->callTableAction('edit', $user, data: [
+            'role' => Role::Owner->value,
+            'billable_rate' => null,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertHasNoTableActionErrors();
+        $this->assertSame(Role::Owner->value, $member->refresh()->role);
+        $this->assertSame(Role::Admin->value, $ownerMember->refresh()->role);
+        $this->assertSame($user->getKey(), $organization->refresh()->user_id);
+    }
+
+    public function test_edit_related_user_shows_error_notification_if_role_of_owner_is_changed(): void
+    {
+        // Arrange
+        $owner = User::factory()->create();
+        $organization = Organization::factory()->withOwner($owner)->create();
+        $ownerMember = Member::factory()->forOrganization($organization)->forUser($owner)->role(Role::Owner)->create();
+
+        // Act
+        $response = Livewire::test(OrganizationResource\RelationManagers\UsersRelationManager::class, [
+            'ownerRecord' => $organization,
+            'pageClass' => OrganizationResource\Pages\EditOrganization::class,
+        ])->callTableAction('edit', $owner, data: [
+            'role' => Role::Admin->value,
+            'billable_rate' => null,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->danger()
+                ->title('Update failed')
+                ->body(__('exceptions.api.organization_needs_at_least_one_owner'))
+                ->persistent()
+        );
+        $this->assertSame(Role::Owner->value, $ownerMember->refresh()->role);
+    }
+
+    public function test_can_detach_related_user_from_organization(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $user = User::factory()->withPersonalOrganization()->create();
+        $member = Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Employee)->create();
+
+        // Act
+        $response = Livewire::test(OrganizationResource\RelationManagers\UsersRelationManager::class, [
+            'ownerRecord' => $organization,
+            'pageClass' => OrganizationResource\Pages\EditOrganization::class,
+        ])->callTableAction('detach', $user);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertHasNoTableActionErrors();
+        $this->assertDatabaseMissing(Member::class, [
+            'id' => $member->getKey(),
+        ]);
+        $this->assertDatabaseHas(User::class, [
+            'id' => $user->getKey(),
+        ]);
+    }
+
+    public function test_detach_related_user_shows_error_notification_if_user_is_owner(): void
+    {
+        // Arrange
+        $owner = User::factory()->create();
+        $organization = Organization::factory()->withOwner($owner)->create();
+        $ownerMember = Member::factory()->forOrganization($organization)->forUser($owner)->role(Role::Owner)->create();
+
+        // Act
+        $response = Livewire::test(OrganizationResource\RelationManagers\UsersRelationManager::class, [
+            'ownerRecord' => $organization,
+            'pageClass' => OrganizationResource\Pages\EditOrganization::class,
+        ])->callTableAction('detach', $owner);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->danger()
+                ->title('Delete failed')
+                ->body(__('exceptions.api.can_not_remove_owner_from_organization'))
+                ->persistent()
+        );
+        $this->assertDatabaseHas(Member::class, [
+            'id' => $ownerMember->getKey(),
+        ]);
+    }
+
+    public function test_detach_related_user_shows_error_notification_if_user_still_has_time_entries(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $user = User::factory()->withPersonalOrganization()->create();
+        $member = Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Employee)->create();
+        TimeEntry::factory()->forMember($member)->create();
+
+        // Act
+        $response = Livewire::test(OrganizationResource\RelationManagers\UsersRelationManager::class, [
+            'ownerRecord' => $organization,
+            'pageClass' => OrganizationResource\Pages\EditOrganization::class,
+        ])->callTableAction('detach', $user);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->danger()
+                ->title('Delete failed')
+                ->body(__('exceptions.api.entity_still_in_use', [
+                    'modelToDelete' => __('validation.entities.member'),
+                    'modelInUse' => __('validation.entities.time_entry'),
+                ]))
+                ->persistent()
+        );
+        $this->assertDatabaseHas(Member::class, [
+            'id' => $member->getKey(),
+        ]);
+    }
 }

tests/Unit/Filament/Resources/ProjectMemberResourceTest.php

@@ -0,0 +1,245 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Filament\Resources;
+
+use App\Filament\Resources\ProjectMemberResource;
+use App\Models\Member;
+use App\Models\Organization;
+use App\Models\Project;
+use App\Models\ProjectMember;
+use App\Models\User;
+use Illuminate\Support\Facades\Config;
+use Livewire\Livewire;
+use PHPUnit\Framework\Attributes\UsesClass;
+use Tests\Unit\Filament\FilamentTestCase;
+
+#[UsesClass(ProjectMemberResource::class)]
+class ProjectMemberResourceTest extends FilamentTestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+        Config::set('auth.super_admins', ['admin@example.com']);
+        $user = User::factory()->withPersonalOrganization()->create([
+            'email' => 'admin@example.com',
+        ]);
+
+        $this->actingAs($user);
+    }
+
+    private function createProjectMember(?int $billableRate = null): ProjectMember
+    {
+        $organization = Organization::factory()->create();
+        $user = User::factory()->create();
+        $member = Member::factory()->forOrganization($organization)->forUser($user)->create();
+        $project = Project::factory()->forOrganization($organization)->create();
+
+        return ProjectMember::factory()
+            ->forProject($project)
+            ->forMember($member)
+            ->create($billableRate !== null ? ['billable_rate' => $billableRate] : []);
+    }
+
+    public function test_can_list_project_members(): void
+    {
+        // Arrange
+        $projectMembers = collect([
+            $this->createProjectMember(),
+            $this->createProjectMember(),
+            $this->createProjectMember(),
+        ]);
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\ListProjectMembers::class);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertCanSeeTableRecords($projectMembers);
+        $response->assertCanRenderTableColumn('project.name');
+        $response->assertCanRenderTableColumn('user.name');
+        $response->assertCanRenderTableColumn('billable_rate');
+    }
+
+    public function test_can_sort_project_members_by_billable_rate(): void
+    {
+        // Arrange
+        $projectMember1 = $this->createProjectMember(3000);
+        $projectMember2 = $this->createProjectMember(1000);
+        $projectMember3 = $this->createProjectMember(2000);
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\ListProjectMembers::class)
+            ->sortTable('billable_rate');
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertCanSeeTableRecords([$projectMember2, $projectMember3, $projectMember1], inOrder: true);
+    }
+
+    public function test_can_see_create_page_of_project_member(): void
+    {
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\CreateProjectMember::class);
+
+        // Assert
+        $response->assertSuccessful();
+    }
+
+    public function test_can_see_edit_page_of_project_member(): void
+    {
+        // Arrange
+        $projectMember = $this->createProjectMember(1500);
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\EditProjectMember::class, ['record' => $projectMember->getKey()]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertSchemaStateSet([
+            'billable_rate' => 1500,
+            'user_id' => $projectMember->user_id,
+            'member_id' => $projectMember->member_id,
+        ]);
+    }
+
+    public function test_can_see_view_page_of_project_member(): void
+    {
+        // Arrange
+        $projectMember = $this->createProjectMember();
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\ViewProjectMembers::class, ['record' => $projectMember->getKey()]);
+
+        // Assert
+        $response->assertSuccessful();
+    }
+
+    public function test_can_update_billable_rate_of_project_member(): void
+    {
+        // Arrange
+        $projectMember = $this->createProjectMember(1500);
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\EditProjectMember::class, ['record' => $projectMember->getKey()])
+            ->fillForm([
+                'billable_rate' => 2500,
+            ])
+            ->call('save');
+
+        // Assert
+        $response->assertHasNoFormErrors();
+        $response->assertSuccessful();
+        $projectMember->refresh();
+        $this->assertSame(2500, $projectMember->billable_rate);
+    }
+
+    public function test_can_remove_billable_rate_of_project_member(): void
+    {
+        // Arrange
+        $projectMember = $this->createProjectMember(1500);
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\EditProjectMember::class, ['record' => $projectMember->getKey()])
+            ->fillForm([
+                'billable_rate' => null,
+            ])
+            ->call('save');
+
+        // Assert
+        $response->assertHasNoFormErrors();
+        $response->assertSuccessful();
+        $projectMember->refresh();
+        $this->assertNull($projectMember->billable_rate);
+    }
+
+    public function test_update_project_member_fails_if_billable_rate_is_not_positive(): void
+    {
+        // Arrange
+        $projectMember = $this->createProjectMember(1500);
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\EditProjectMember::class, ['record' => $projectMember->getKey()])
+            ->fillForm([
+                'billable_rate' => 0,
+            ])
+            ->call('save');
+
+        // Assert
+        $response->assertHasFormErrors(['billable_rate']);
+        $projectMember->refresh();
+        $this->assertSame(1500, $projectMember->billable_rate);
+    }
+
+    public function test_update_project_member_fails_if_billable_rate_exceeds_maximum(): void
+    {
+        // Arrange
+        $projectMember = $this->createProjectMember(1500);
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\EditProjectMember::class, ['record' => $projectMember->getKey()])
+            ->fillForm([
+                'billable_rate' => 2147483648,
+            ])
+            ->call('save');
+
+        // Assert
+        $response->assertHasFormErrors(['billable_rate']);
+        $projectMember->refresh();
+        $this->assertSame(1500, $projectMember->billable_rate);
+    }
+
+    public function test_update_project_member_fails_if_user_or_member_is_missing(): void
+    {
+        // Arrange
+        $projectMember = $this->createProjectMember(1500);
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\EditProjectMember::class, ['record' => $projectMember->getKey()])
+            ->fillForm([
+                'user_id' => null,
+                'member_id' => null,
+            ])
+            ->call('save');
+
+        // Assert
+        $response->assertHasFormErrors(['user_id', 'member_id']);
+    }
+
+    public function test_can_delete_a_project_member(): void
+    {
+        // Arrange
+        $projectMember = $this->createProjectMember();
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\EditProjectMember::class, ['record' => $projectMember->getKey()])
+            ->callAction('delete');
+
+        // Assert
+        $response->assertHasNoActionErrors();
+        $response->assertSuccessful();
+        $this->assertDatabaseMissing(ProjectMember::class, [
+            'id' => $projectMember->getKey(),
+        ]);
+    }
+
+    public function test_can_bulk_delete_project_members(): void
+    {
+        // Arrange
+        $projectMember1 = $this->createProjectMember();
+        $projectMember2 = $this->createProjectMember();
+        $projectMember3 = $this->createProjectMember();
+
+        // Act
+        $response = Livewire::test(ProjectMemberResource\Pages\ListProjectMembers::class)
+            ->callTableBulkAction('delete', [$projectMember1, $projectMember2]);
+
+        // Assert
+        $response->assertHasNoTableBulkActionErrors();
+        $response->assertSuccessful();
+        $this->assertDatabaseMissing(ProjectMember::class, ['id' => $projectMember1->getKey()]);
+        $this->assertDatabaseMissing(ProjectMember::class, ['id' => $projectMember2->getKey()]);
+        $this->assertDatabaseHas(ProjectMember::class, ['id' => $projectMember3->getKey()]);
+    }
+}

tests/Unit/Filament/Resources/ProjectResourceTest.php

@@ -4,8 +4,12 @@ declare(strict_types=1);
 
 namespace Tests\Unit\Filament\Resources;
 
+use App\Filament\Resources\ProjectMemberResource;
 use App\Filament\Resources\ProjectResource;
+use App\Models\Member;
+use App\Models\Organization;
 use App\Models\Project;
+use App\Models\ProjectMember;
 use App\Models\User;
 use Illuminate\Support\Facades\Config;
 use Livewire\Livewire;
@@ -50,4 +54,56 @@ class ProjectResourceTest extends FilamentTestCase
         // Assert
         $response->assertSuccessful();
     }
+
+    public function test_can_list_related_project_members(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $project = Project::factory()->forOrganization($organization)->create();
+        $otherProject = Project::factory()->forOrganization($organization)->create();
+        $projectMembers = collect();
+        foreach (range(1, 3) as $i) {
+            $member = Member::factory()->forOrganization($organization)->forUser(User::factory()->create())->create();
+            $projectMembers->push(ProjectMember::factory()->forProject($project)->forMember($member)->create());
+        }
+        $otherMember = Member::factory()->forOrganization($organization)->forUser(User::factory()->create())->create();
+        $otherProjectMember = ProjectMember::factory()->forProject($otherProject)->forMember($otherMember)->create();
+
+        // Act
+        $response = Livewire::test(ProjectResource\RelationManagers\ProjectMembersRelationManager::class, [
+            'ownerRecord' => $project,
+            'pageClass' => ProjectResource\Pages\EditProject::class,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertCanSeeTableRecords($projectMembers);
+        $response->assertCanNotSeeTableRecords([$otherProjectMember]);
+        $response->assertCanRenderTableColumn('user.name');
+        $response->assertCanRenderTableColumn('billable_rate');
+    }
+
+    public function test_related_project_members_have_view_and_edit_actions_linking_to_project_member_resource(): void
+    {
+        // Arrange
+        $organization = Organization::factory()->create();
+        $project = Project::factory()->forOrganization($organization)->create();
+        $member = Member::factory()->forOrganization($organization)->forUser(User::factory()->create())->create();
+        $projectMember = ProjectMember::factory()->forProject($project)->forMember($member)->create();
+
+        // Act
+        $response = Livewire::test(ProjectResource\RelationManagers\ProjectMembersRelationManager::class, [
+            'ownerRecord' => $project,
+            'pageClass' => ProjectResource\Pages\EditProject::class,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertTableActionHasUrl('view', ProjectMemberResource::getUrl('view', [
+            'record' => $projectMember->getKey(),
+        ]), $projectMember);
+        $response->assertTableActionHasUrl('edit', ProjectMemberResource::getUrl('edit', [
+            'record' => $projectMember->getKey(),
+        ]), $projectMember);
+    }
 }

tests/Unit/Filament/Resources/UserResourceTest.php

@@ -6,12 +6,14 @@ namespace Tests\Unit\Filament\Resources;
 
 use App\Enums\Role;
 use App\Exceptions\Api\CanNotDeleteUserWhoIsOwnerOfOrganizationWithMultipleMembers;
-use App\Filament\Resources\TimeEntryResource;
+use App\Filament\Resources\OrganizationResource;
 use App\Filament\Resources\UserResource;
 use App\Models\Member;
 use App\Models\Organization;
+use App\Models\TimeEntry;
 use App\Models\User;
 use App\Service\DeletionService;
+use Filament\Notifications\Notification;
 use Illuminate\Support\Facades\Config;
 use Illuminate\Support\Facades\Hash;
 use Livewire\Livewire;
@@ -19,7 +21,7 @@ use Mockery\MockInterface;
 use PHPUnit\Framework\Attributes\UsesClass;
 use Tests\Unit\Filament\FilamentTestCase;
 
-#[UsesClass(TimeEntryResource::class)]
+#[UsesClass(UserResource::class)]
 class UserResourceTest extends FilamentTestCase
 {
     protected function setUp(): void
@@ -190,4 +192,202 @@ class UserResourceTest extends FilamentTestCase
         $response->assertCanSeeTableRecords($user->ownedOrganizations()->get());
         $response->assertCanNotSeeTableRecords([$organization]);
     }
+
+    public function test_related_organizations_have_view_action_linking_to_organization_resource(): void
+    {
+        // Arrange
+        $user = User::factory()->create();
+        $organization = Organization::factory()->create();
+        Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Employee)->create();
+
+        // Act
+        $response = Livewire::test(UserResource\RelationManagers\OrganizationsRelationManager::class, [
+            'ownerRecord' => $user,
+            'pageClass' => UserResource\Pages\EditUser::class,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertTableActionHasUrl('view', OrganizationResource::getUrl('view', [
+            'record' => $organization->getKey(),
+        ]), $organization);
+    }
+
+    public function test_can_edit_role_of_related_organization(): void
+    {
+        // Arrange
+        $user = User::factory()->create();
+        $organization = Organization::factory()->create();
+        $member = Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Employee)->create();
+
+        // Act
+        $response = Livewire::test(UserResource\RelationManagers\OrganizationsRelationManager::class, [
+            'ownerRecord' => $user,
+            'pageClass' => UserResource\Pages\EditUser::class,
+        ])->callTableAction('edit', $organization, data: [
+            'role' => Role::Admin->value,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertHasNoTableActionErrors();
+        $this->assertSame(Role::Admin->value, $member->refresh()->role);
+    }
+
+    public function test_can_make_user_owner_of_related_organization(): void
+    {
+        // Arrange
+        $owner = User::factory()->create();
+        $organization = Organization::factory()->withOwner($owner)->create();
+        $ownerMember = Member::factory()->forOrganization($organization)->forUser($owner)->role(Role::Owner)->create();
+        $user = User::factory()->create();
+        $member = Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Employee)->create();
+
+        // Act
+        $response = Livewire::test(UserResource\RelationManagers\OrganizationsRelationManager::class, [
+            'ownerRecord' => $user,
+            'pageClass' => UserResource\Pages\EditUser::class,
+        ])->callTableAction('edit', $organization, data: [
+            'role' => Role::Owner->value,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertHasNoTableActionErrors();
+        $this->assertSame(Role::Owner->value, $member->refresh()->role);
+        $this->assertSame(Role::Admin->value, $ownerMember->refresh()->role);
+        $this->assertSame($user->getKey(), $organization->refresh()->user_id);
+    }
+
+    public function test_edit_related_organization_shows_error_notification_if_role_of_owner_is_changed(): void
+    {
+        // Arrange
+        $owner = User::factory()->create();
+        $organization = Organization::factory()->withOwner($owner)->create();
+        $ownerMember = Member::factory()->forOrganization($organization)->forUser($owner)->role(Role::Owner)->create();
+
+        // Act
+        $response = Livewire::test(UserResource\RelationManagers\OrganizationsRelationManager::class, [
+            'ownerRecord' => $owner,
+            'pageClass' => UserResource\Pages\EditUser::class,
+        ])->callTableAction('edit', $organization, data: [
+            'role' => Role::Admin->value,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->danger()
+                ->title('Update failed')
+                ->body(__('exceptions.api.organization_needs_at_least_one_owner'))
+                ->persistent()
+        );
+        $this->assertSame(Role::Owner->value, $ownerMember->refresh()->role);
+    }
+
+    public function test_can_detach_related_organization_from_user(): void
+    {
+        // Arrange
+        $user = User::factory()->withPersonalOrganization()->create();
+        $organization = Organization::factory()->create();
+        $member = Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Employee)->create();
+
+        // Act
+        $response = Livewire::test(UserResource\RelationManagers\OrganizationsRelationManager::class, [
+            'ownerRecord' => $user,
+            'pageClass' => UserResource\Pages\EditUser::class,
+        ])->callTableAction('detach', $organization);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertHasNoTableActionErrors();
+        $this->assertDatabaseMissing(Member::class, [
+            'id' => $member->getKey(),
+        ]);
+        $this->assertDatabaseHas(Organization::class, [
+            'id' => $organization->getKey(),
+        ]);
+    }
+
+    public function test_detach_related_organization_shows_error_notification_if_user_is_owner(): void
+    {
+        // Arrange
+        $owner = User::factory()->create();
+        $organization = Organization::factory()->withOwner($owner)->create();
+        $ownerMember = Member::factory()->forOrganization($organization)->forUser($owner)->role(Role::Owner)->create();
+
+        // Act
+        $response = Livewire::test(UserResource\RelationManagers\OrganizationsRelationManager::class, [
+            'ownerRecord' => $owner,
+            'pageClass' => UserResource\Pages\EditUser::class,
+        ])->callTableAction('detach', $organization);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->danger()
+                ->title('Delete failed')
+                ->body(__('exceptions.api.can_not_remove_owner_from_organization'))
+                ->persistent()
+        );
+        $this->assertDatabaseHas(Member::class, [
+            'id' => $ownerMember->getKey(),
+        ]);
+    }
+
+    public function test_detach_related_organization_shows_error_notification_if_user_still_has_time_entries(): void
+    {
+        // Arrange
+        $user = User::factory()->withPersonalOrganization()->create();
+        $organization = Organization::factory()->create();
+        $member = Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Employee)->create();
+        TimeEntry::factory()->forMember($member)->create();
+
+        // Act
+        $response = Livewire::test(UserResource\RelationManagers\OrganizationsRelationManager::class, [
+            'ownerRecord' => $user,
+            'pageClass' => UserResource\Pages\EditUser::class,
+        ])->callTableAction('detach', $organization);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertNotified(
+            Notification::make()
+                ->danger()
+                ->title('Delete failed')
+                ->body(__('exceptions.api.entity_still_in_use', [
+                    'modelToDelete' => __('validation.entities.member'),
+                    'modelInUse' => __('validation.entities.time_entry'),
+                ]))
+                ->persistent()
+        );
+        $this->assertDatabaseHas(Member::class, [
+            'id' => $member->getKey(),
+        ]);
+    }
+
+    public function test_related_owned_organizations_have_view_and_edit_actions_linking_to_organization_resource(): void
+    {
+        // Arrange
+        $user = User::factory()->create();
+        $organization = Organization::factory()->withOwner($user)->create();
+        Member::factory()->forOrganization($organization)->forUser($user)->role(Role::Owner)->create();
+
+        // Act
+        $response = Livewire::test(UserResource\RelationManagers\OwnedOrganizationsRelationManager::class, [
+            'ownerRecord' => $user,
+            'pageClass' => UserResource\Pages\EditUser::class,
+        ]);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertTableActionHasUrl('view', OrganizationResource::getUrl('view', [
+            'record' => $organization->getKey(),
+        ]), $organization);
+        $response->assertTableActionHasUrl('edit', OrganizationResource::getUrl('edit', [
+            'record' => $organization->getKey(),
+        ]), $organization);
+    }
 }

tests/Unit/Filament/Widgets/ChartWidgetTestCase.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Filament\Widgets;
+
+use App\Models\User;
+use Closure;
+use Filament\Widgets\ChartWidget;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Config;
+use Livewire\Features\SupportTesting\Testable;
+use Tests\Unit\Filament\FilamentTestCase;
+
+abstract class ChartWidgetTestCase extends FilamentTestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+        Config::set('auth.super_admins', ['admin@example.com']);
+        $user = User::factory()->withPersonalOrganization()->create([
+            'email' => 'admin@example.com',
+        ]);
+
+        $this->actingAs($user);
+    }
+
+    /**
+     * Calls the protected getData() method of the chart widget of the given Livewire test.
+     *
+     * @param  Testable<ChartWidget>  $testable
+     * @return array{datasets: array<int, array{label: string, data: Collection<int, int>}>, labels: Collection<int, string>}
+     */
+    protected function getChartData(Testable $testable): array
+    {
+        /** @var ChartWidget $widget */
+        $widget = $testable->instance();
+
+        /** @var array{datasets: array<int, array{label: string, data: Collection<int, int>}>, labels: Collection<int, string>} $data */
+        $data = Closure::bind(fn (): array => $this->getData(), $widget, $widget)();
+
+        return $data;
+    }
+
+    /**
+     * @param  array{datasets: array<int, array{label: string, data: Collection<int, int>}>, labels: Collection<int, string>}  $data
+     */
+    protected function sumOfChartData(array $data): int
+    {
+        return (int) $data['datasets'][0]['data']->sum();
+    }
+}

tests/Unit/Filament/Widgets/TimeEntriesCreatedWidgetTest.php

@@ -0,0 +1,116 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Filament\Widgets;
+
+use App\Filament\Widgets\TimeEntriesCreated;
+use App\Models\TimeEntry;
+use Livewire\Livewire;
+use PHPUnit\Framework\Attributes\UsesClass;
+
+#[UsesClass(TimeEntriesCreated::class)]
+class TimeEntriesCreatedWidgetTest extends ChartWidgetTestCase
+{
+    public function test_widget_renders_with_filters(): void
+    {
+        // Act
+        $response = Livewire::test(TimeEntriesCreated::class);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertSee('Time Entries Created');
+        $response->assertSee('Last week');
+        $response->assertSee('Last month');
+        $response->assertSee('Last year');
+        $response->assertSet('filter', 'week');
+    }
+
+    public function test_counts_only_non_imported_time_entries_created_in_the_last_week_by_default(): void
+    {
+        // Arrange
+        TimeEntry::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_imported' => false],
+            ['created_at' => now()->subDays(2), 'is_imported' => false],
+            ['created_at' => now()->subDays(2), 'is_imported' => true],
+            ['created_at' => now()->subDays(10), 'is_imported' => false],
+        ]);
+
+        // Act
+        $response = Livewire::test(TimeEntriesCreated::class);
+
+        // Assert
+        $response->assertSuccessful();
+        $data = $this->getChartData($response);
+        $this->assertSame('Time Entries Created', $data['datasets'][0]['label']);
+        $this->assertSame(2, $this->sumOfChartData($data));
+        $this->assertCount(8, $data['labels']);
+        $this->assertSame(now()->subWeek()->format('Y-m-d'), $data['labels']->first());
+        $this->assertSame(now()->format('Y-m-d'), $data['labels']->last());
+    }
+
+    public function test_month_filter_counts_time_entries_created_in_the_last_month_per_day(): void
+    {
+        // Arrange
+        TimeEntry::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_imported' => false],
+            ['created_at' => now()->subDays(10), 'is_imported' => false],
+            ['created_at' => now()->subDays(10), 'is_imported' => true],
+            ['created_at' => now()->subMonths(2), 'is_imported' => false],
+        ]);
+
+        // Act
+        $response = Livewire::test(TimeEntriesCreated::class)
+            ->set('filter', 'month');
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertDispatched('updateChartData');
+        $data = $this->getChartData($response);
+        $this->assertSame(2, $this->sumOfChartData($data));
+        $this->assertSame(now()->subMonth()->format('Y-m-d'), $data['labels']->first());
+        $this->assertSame(now()->format('Y-m-d'), $data['labels']->last());
+    }
+
+    public function test_year_filter_counts_time_entries_created_in_the_last_year_per_month(): void
+    {
+        // Arrange
+        TimeEntry::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_imported' => false],
+            ['created_at' => now()->subMonths(3), 'is_imported' => false],
+            ['created_at' => now()->subMonths(3), 'is_imported' => true],
+            ['created_at' => now()->subYears(2), 'is_imported' => false],
+        ]);
+
+        // Act
+        $response = Livewire::test(TimeEntriesCreated::class)
+            ->set('filter', 'year');
+
+        // Assert
+        $response->assertSuccessful();
+        $data = $this->getChartData($response);
+        $this->assertSame(2, $this->sumOfChartData($data));
+        $this->assertCount(13, $data['labels']);
+        $this->assertSame(now()->subYear()->format('Y-m'), $data['labels']->first());
+        $this->assertSame(now()->format('Y-m'), $data['labels']->last());
+    }
+
+    public function test_unknown_filter_falls_back_to_last_week(): void
+    {
+        // Arrange
+        TimeEntry::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_imported' => false],
+            ['created_at' => now()->subDays(10), 'is_imported' => false],
+        ]);
+
+        // Act
+        $response = Livewire::test(TimeEntriesCreated::class)
+            ->set('filter', 'unknown');
+
+        // Assert
+        $response->assertSuccessful();
+        $data = $this->getChartData($response);
+        $this->assertSame(1, $this->sumOfChartData($data));
+        $this->assertCount(8, $data['labels']);
+    }
+}

tests/Unit/Filament/Widgets/TimeEntriesImportedWidgetTest.php

@@ -0,0 +1,116 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Filament\Widgets;
+
+use App\Filament\Widgets\TimeEntriesImported;
+use App\Models\TimeEntry;
+use Livewire\Livewire;
+use PHPUnit\Framework\Attributes\UsesClass;
+
+#[UsesClass(TimeEntriesImported::class)]
+class TimeEntriesImportedWidgetTest extends ChartWidgetTestCase
+{
+    public function test_widget_renders_with_filters(): void
+    {
+        // Act
+        $response = Livewire::test(TimeEntriesImported::class);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertSee('Time Entries Imported');
+        $response->assertSee('Last week');
+        $response->assertSee('Last month');
+        $response->assertSee('Last year');
+        $response->assertSet('filter', 'week');
+    }
+
+    public function test_counts_only_imported_time_entries_created_in_the_last_week_by_default(): void
+    {
+        // Arrange
+        TimeEntry::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_imported' => true],
+            ['created_at' => now()->subDays(2), 'is_imported' => true],
+            ['created_at' => now()->subDays(2), 'is_imported' => false],
+            ['created_at' => now()->subDays(10), 'is_imported' => true],
+        ]);
+
+        // Act
+        $response = Livewire::test(TimeEntriesImported::class);
+
+        // Assert
+        $response->assertSuccessful();
+        $data = $this->getChartData($response);
+        $this->assertSame('Time Entries Imported', $data['datasets'][0]['label']);
+        $this->assertSame(2, $this->sumOfChartData($data));
+        $this->assertCount(8, $data['labels']);
+        $this->assertSame(now()->subWeek()->format('Y-m-d'), $data['labels']->first());
+        $this->assertSame(now()->format('Y-m-d'), $data['labels']->last());
+    }
+
+    public function test_month_filter_counts_time_entries_created_in_the_last_month_per_day(): void
+    {
+        // Arrange
+        TimeEntry::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_imported' => true],
+            ['created_at' => now()->subDays(10), 'is_imported' => true],
+            ['created_at' => now()->subDays(10), 'is_imported' => false],
+            ['created_at' => now()->subMonths(2), 'is_imported' => true],
+        ]);
+
+        // Act
+        $response = Livewire::test(TimeEntriesImported::class)
+            ->set('filter', 'month');
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertDispatched('updateChartData');
+        $data = $this->getChartData($response);
+        $this->assertSame(2, $this->sumOfChartData($data));
+        $this->assertSame(now()->subMonth()->format('Y-m-d'), $data['labels']->first());
+        $this->assertSame(now()->format('Y-m-d'), $data['labels']->last());
+    }
+
+    public function test_year_filter_counts_time_entries_created_in_the_last_year_per_month(): void
+    {
+        // Arrange
+        TimeEntry::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_imported' => true],
+            ['created_at' => now()->subMonths(3), 'is_imported' => true],
+            ['created_at' => now()->subMonths(3), 'is_imported' => false],
+            ['created_at' => now()->subYears(2), 'is_imported' => true],
+        ]);
+
+        // Act
+        $response = Livewire::test(TimeEntriesImported::class)
+            ->set('filter', 'year');
+
+        // Assert
+        $response->assertSuccessful();
+        $data = $this->getChartData($response);
+        $this->assertSame(2, $this->sumOfChartData($data));
+        $this->assertCount(13, $data['labels']);
+        $this->assertSame(now()->subYear()->format('Y-m'), $data['labels']->first());
+        $this->assertSame(now()->format('Y-m'), $data['labels']->last());
+    }
+
+    public function test_unknown_filter_falls_back_to_last_week(): void
+    {
+        // Arrange
+        TimeEntry::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_imported' => true],
+            ['created_at' => now()->subDays(10), 'is_imported' => true],
+        ]);
+
+        // Act
+        $response = Livewire::test(TimeEntriesImported::class)
+            ->set('filter', 'unknown');
+
+        // Assert
+        $response->assertSuccessful();
+        $data = $this->getChartData($response);
+        $this->assertSame(1, $this->sumOfChartData($data));
+        $this->assertCount(8, $data['labels']);
+    }
+}

tests/Unit/Filament/Widgets/UserRegistrationsWidgetTest.php

@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\Filament\Widgets;
+
+use App\Filament\Widgets\UserRegistrations;
+use App\Models\User;
+use Livewire\Livewire;
+use PHPUnit\Framework\Attributes\UsesClass;
+
+#[UsesClass(UserRegistrations::class)]
+class UserRegistrationsWidgetTest extends ChartWidgetTestCase
+{
+    public function test_widget_renders_with_filters(): void
+    {
+        // Act
+        $response = Livewire::test(UserRegistrations::class);
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertSee('User Registrations');
+        $response->assertSee('Last week');
+        $response->assertSee('Last month');
+        $response->assertSee('Last year');
+        $response->assertSet('filter', 'week');
+    }
+
+    public function test_counts_only_non_placeholder_users_registered_in_the_last_week_by_default(): void
+    {
+        // Arrange
+        // The super admin from setUp was created just now and is therefore counted as well.
+        User::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_placeholder' => false],
+            ['created_at' => now()->subDays(2), 'is_placeholder' => false],
+            ['created_at' => now()->subDays(2), 'is_placeholder' => true],
+            ['created_at' => now()->subDays(10), 'is_placeholder' => false],
+        ]);
+
+        // Act
+        $response = Livewire::test(UserRegistrations::class);
+
+        // Assert
+        $response->assertSuccessful();
+        $data = $this->getChartData($response);
+        $this->assertSame('User Registrations', $data['datasets'][0]['label']);
+        $this->assertSame(3, $this->sumOfChartData($data));
+        $this->assertCount(8, $data['labels']);
+        $this->assertSame(now()->subWeek()->format('Y-m-d'), $data['labels']->first());
+        $this->assertSame(now()->format('Y-m-d'), $data['labels']->last());
+    }
+
+    public function test_month_filter_counts_users_registered_in_the_last_month_per_day(): void
+    {
+        // Arrange
+        User::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_placeholder' => false],
+            ['created_at' => now()->subDays(10), 'is_placeholder' => false],
+            ['created_at' => now()->subDays(10), 'is_placeholder' => true],
+            ['created_at' => now()->subMonths(2), 'is_placeholder' => false],
+        ]);
+
+        // Act
+        $response = Livewire::test(UserRegistrations::class)
+            ->set('filter', 'month');
+
+        // Assert
+        $response->assertSuccessful();
+        $response->assertDispatched('updateChartData');
+        $data = $this->getChartData($response);
+        $this->assertSame(3, $this->sumOfChartData($data));
+        $this->assertSame(now()->subMonth()->format('Y-m-d'), $data['labels']->first());
+        $this->assertSame(now()->format('Y-m-d'), $data['labels']->last());
+    }
+
+    public function test_year_filter_counts_users_registered_in_the_last_year_per_month(): void
+    {
+        // Arrange
+        User::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_placeholder' => false],
+            ['created_at' => now()->subMonths(3), 'is_placeholder' => false],
+            ['created_at' => now()->subMonths(3), 'is_placeholder' => true],
+            ['created_at' => now()->subYears(2), 'is_placeholder' => false],
+        ]);
+
+        // Act
+        $response = Livewire::test(UserRegistrations::class)
+            ->set('filter', 'year');
+
+        // Assert
+        $response->assertSuccessful();
+        $data = $this->getChartData($response);
+        $this->assertSame(3, $this->sumOfChartData($data));
+        $this->assertCount(13, $data['labels']);
+        $this->assertSame(now()->subYear()->format('Y-m'), $data['labels']->first());
+        $this->assertSame(now()->format('Y-m'), $data['labels']->last());
+    }
+
+    public function test_unknown_filter_falls_back_to_last_week(): void
+    {
+        // Arrange
+        User::factory()->createMany([
+            ['created_at' => now()->subDay(), 'is_placeholder' => false],
+            ['created_at' => now()->subDays(10), 'is_placeholder' => false],
+        ]);
+
+        // Act
+        $response = Livewire::test(UserRegistrations::class)
+            ->set('filter', 'unknown');
+
+        // Assert
+        $response->assertSuccessful();
+        $data = $this->getChartData($response);
+        $this->assertSame(2, $this->sumOfChartData($data));
+        $this->assertCount(8, $data['labels']);
+    }
+}