app/Member/Data/NestedGroup.php

@@ -5,6 +5,7 @@ namespace App\Member\Data;
 use App\Group;
 use Illuminate\Support\Collection;
 use Spatie\LaravelData\Data;
+use Spatie\LaravelData\DataCollection;
 
 class NestedGroup extends Data
 {
@@ -22,7 +23,7 @@ class NestedGroup extends Data
         $groups = collect([]);
 
         foreach (Group::where('parent_id', $parentId)->orderBy('name')->get()->toBase() as $group) {
-            $groups->push(['name' => str_repeat('- ', $level) . $group->name, 'id' => $group->id]);
+            $groups->push(['name' => str_repeat('- ', $level).$group->name, 'id' => $group->id]);
             $groups = $groups->merge(static::forSelect($group->id, $level + 1));
         }
 
@@ -30,10 +31,10 @@ class NestedGroup extends Data
     }
 
     /**
-     * @return Collection<int, static>
+     * @return DataCollection<int, static>
      */
-    public static function cacheForSelect(): Collection
+    public static function cacheForSelect(): DataCollection
     {
-        return static::collect(static::forSelect());
+        return static::collection(static::forSelect());
     }
 }

packages/laravel-nami

@@ -1 +1 @@
-Subproject commit 565cf2b158dc60283f3ca1daadd7b9317281d8be
+Subproject commit b735186c2d4f844f67992f86f460d6c3deaf5f28

tests/Feature/Activity/EditTest.php

@@ -5,38 +5,43 @@ namespace Tests\Feature\Activity;
 use App\Activity;
 use App\Subactivity;
 use Illuminate\Foundation\Testing\DatabaseTransactions;
+use Tests\TestCase;
 
-uses(DatabaseTransactions::class);
+class EditTest extends TestCase
+{
+    use DatabaseTransactions;
 
-it('testItEditsAnActivity', function () {
+    public function testItEditsAnActivity(): void
-    $this->login()->loginNami()->withoutExceptionHandling();
+    {
-    $activity = Activity::factory()->name('Asas')->hasAttached(Subactivity::factory()->name('Pupu')->filterable())->create();
+        $this->login()->loginNami()->withoutExceptionHandling();
+        $activity = Activity::factory()->name('Asas')->hasAttached(Subactivity::factory()->name('Pupu')->filterable())->create();
 
-    $response = $this->get(route('activity.edit', ['activity' => $activity]));
+        $response = $this->get(route('activity.edit', ['activity' => $activity]));
 
-    $this->assertInertiaHas([
+        $this->assertInertiaHas([
-        'name' => 'Asas',
+            'name' => 'Asas',
-        'is_filterable' => false,
-        'subactivities' => [$activity->subactivities->first()->id],
-        'subactivity_model' => [
-            'activities' => [$activity->id],
-            'is_age_group' => false,
             'is_filterable' => false,
-            'name' => '',
+            'subactivities' => [$activity->subactivities->first()->id],
-        ],
+            'subactivity_model' => [
-    ], $response, 'data');
+                'activities' => [$activity->id],
-    $this->assertInertiaHas([
+                'is_age_group' => false,
-        'id' => $activity->subactivities->first()->id,
+                'is_filterable' => false,
-        'name' => 'Pupu',
+                'name' => '',
-        'is_filterable' => true,
+            ],
-    ], $response, 'meta.subactivities.0');
+        ], $response, 'data');
-    $this->assertInertiaHas([
+        $this->assertInertiaHas([
-        'id' => $activity->subactivities->first()->id,
+            'id' => $activity->subactivities->first()->id,
-        'name' => 'Pupu',
+            'name' => 'Pupu',
-        'is_filterable' => true,
+            'is_filterable' => true,
-        'links' => [
+        ], $response, 'meta.subactivities.0');
-            'show' => route('api.subactivity.show', ['subactivity' => $activity->subactivities->first()->id]),
+        $this->assertInertiaHas([
-            'update' => route('api.subactivity.update', ['subactivity' => $activity->subactivities->first()->id]),
+            'id' => $activity->subactivities->first()->id,
-        ],
+            'name' => 'Pupu',
-    ], $response, 'meta.subactivities.0');
+            'is_filterable' => true,
-});
+            'links' => [
+                'show' => route('api.subactivity.show', ['subactivity' => $activity->subactivities->first()->id]),
+                'update' => route('api.subactivity.update', ['subactivity' => $activity->subactivities->first()->id]),
+            ],
+        ], $response, 'meta.subactivities.0');
+    }
+}

tests/Feature/Activity/UpdateTest.php

@@ -3,210 +3,178 @@
 namespace Tests\Feature\Activity;
 
 use App\Activity;
-use App\Activity\Actions\ActivityUpdateAction;
 use App\Member\Member;
 use App\Member\Membership;
 use App\Subactivity;
 use Illuminate\Foundation\Testing\DatabaseTransactions;
+use Tests\TestCase;
 
-covers(ActivityUpdateAction::class);
+class UpdateTest extends TestCase
+{
+    use DatabaseTransactions;
 
-uses(DatabaseTransactions::class);
+    public function testItCannotUpdateAnActivityFromNami(): void
+    {
+        $this->login()->loginNami();
+        $activity = Activity::factory()->inNami(67)->name('abc')->create();
 
-it('testItCannotUpdateAnActivityFromNami', function () {
+        $response = $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => 'Lorem',
-    $activity = Activity::factory()->inNami(67)->name('abc')->create();
+            'is_filterable' => false,
+            'subactivities' => [],
+        ]);
 
-    $response = $this->patch(route('activity.update', ['activity' => $activity]), [
+        $response->assertSessionHasErrors(['nami_id' => 'Aktivität ist in NaMi. Update des Namens nicht möglich.']);
-        'name' => 'Lorem',
+    }
-        'is_filterable' => false,
-        'subactivities' => [],
-    ]);
 
-    $response->assertSessionHasErrors(['nami_id' => 'Aktivität ist in NaMi. Update des Namens nicht möglich.']);
+    public function testItCanUpdateSubactivitiesOfNamiActivity(): void
-});
+    {
+        $this->login()->loginNami();
+        $activity = Activity::factory()->inNami(67)->name('abc')->create();
+        $subactivity = Subactivity::factory()->create();
 
-it('testItCanUpdateSubactivitiesOfNamiActivity', function () {
+        $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => 'abc',
-    $activity = Activity::factory()->inNami(67)->name('abc')->create();
+            'is_filterable' => false,
-    $subactivity = Subactivity::factory()->create();
+            'subactivities' => [$subactivity->id],
+        ]);
 
-    $this->patch(route('activity.update', ['activity' => $activity]), [
+        $this->assertDatabaseHas('activity_subactivity', ['activity_id' => $activity->id, 'subactivity_id' => $subactivity->id]);
-        'name' => 'abc',
+    }
-        'is_filterable' => false,
-        'subactivities' => [$subactivity->id],
-    ]);
 
-    $this->assertDatabaseHas('activity_subactivity', ['activity_id' => $activity->id, 'subactivity_id' => $subactivity->id]);
+    public function testItCannotRemoveANamiSubactivityFromANamiActivity(): void
-});
+    {
+        $this->login()->loginNami();
+        $activity = Activity::factory()->inNami(67)->name('abc')->has(Subactivity::factory()->inNami(69))->create();
 
-it('testItCannotRemoveANamiSubactivityFromANamiActivity', function () {
+        $response = $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => 'abc',
-    $activity = Activity::factory()->inNami(67)->name('abc')->has(Subactivity::factory()->inNami(69))->create();
+            'is_filterable' => false,
+            'subactivities' => [],
+        ]);
 
-    $response = $this->patch(route('activity.update', ['activity' => $activity]), [
+        $response->assertSessionHasErrors(['nami_id' => 'Untertätigkeit kann nicht entfernt werden.']);
-        'name' => 'abc',
+    }
-        'is_filterable' => false,
-        'subactivities' => [],
-    ]);
 
-    $response->assertSessionHasErrors(['nami_id' => 'Untertätigkeit kann nicht entfernt werden.']);
+    public function testItCannotAddANamiSubactivityToANamiActivity(): void
-});
+    {
+        $this->login()->loginNami();
+        $activity = Activity::factory()->inNami(67)->name('abc')->create();
+        $subactivity = Subactivity::factory()->inNami(60)->create();
 
-it('testItCannotAddANamiSubactivityToANamiActivity', function () {
+        $response = $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => 'abc',
-    $activity = Activity::factory()->inNami(67)->name('abc')->create();
+            'is_filterable' => false,
-    $subactivity = Subactivity::factory()->inNami(60)->create();
+            'subactivities' => [$subactivity->id],
+        ]);
 
-    $response = $this->patch(route('activity.update', ['activity' => $activity]), [
+        $response->assertSessionHasErrors(['nami_id' => 'Untertätigkeit kann nicht hinzugefügt werden.']);
-        'name' => 'abc',
+    }
-        'is_filterable' => false,
-        'subactivities' => [$subactivity->id],
-    ]);
 
-    $response->assertSessionHasErrors(['nami_id' => 'Untertätigkeit kann nicht hinzugefügt werden.']);
+    public function testItCannotRemoveANamiSubactivityFromANamiActivityAndSetAnother(): void
-});
+    {
+        $this->login()->loginNami();
+        $activity = Activity::factory()->inNami(67)->name('abc')->has(Subactivity::factory()->inNami(69))->create();
+        $otherSubactivity = Subactivity::factory()->create();
 
-it('test it cannot set subactivity to a string', function () {
+        $response = $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => 'abc',
-    $activity = Activity::factory()->create();
+            'is_filterable' => false,
+            'subactivities' => [$otherSubactivity->id],
+        ]);
 
-    $this->patch(route('activity.update', ['activity' => $activity]), [
+        $response->assertSessionHasErrors(['nami_id' => 'Untertätigkeit kann nicht entfernt werden.']);
-        'name' => 'abc',
+    }
-        'is_filterable' => false,
-        'subactivities' => ['AAA'],
-    ])->assertSessionHasErrors('subactivities.0');
-});
 
+    public function testNameIsRequired(): void
+    {
+        $this->login()->loginNami();
+        $activity = Activity::factory()->create();
 
-it('testItCannotRemoveANamiSubactivityFromANamiActivityAndSetAnother', function () {
+        $response = $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => '',
-    $activity = Activity::factory()->inNami(67)->name('abc')->has(Subactivity::factory()->inNami(69))->create();
+            'is_filterable' => true,
-    $otherSubactivity = Subactivity::factory()->create();
+        ]);
 
-    $response = $this->patch(route('activity.update', ['activity' => $activity]), [
+        $response->assertSessionHasErrors(['name' => 'Name ist erforderlich.']);
-        'name' => 'abc',
+        $response->assertSessionHasErrors(['subactivities' => 'Untergliederungen muss vorhanden sein.']);
-        'is_filterable' => false,
+    }
-        'subactivities' => [$otherSubactivity->id],
-    ]);
 
-    $response->assertSessionHasErrors(['nami_id' => 'Untertätigkeit kann nicht entfernt werden.']);
+    public function testItUpdatesName(): void
-});
+    {
+        $this->login()->loginNami();
+        $activity = Activity::factory()->name('UUU')->create();
 
-it('testNameIsRequired', function () {
+        $response = $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => 'Lorem',
-    $activity = Activity::factory()->create();
+            'is_filterable' => true,
+            'subactivities' => [],
+        ]);
 
-    $response = $this->patch(route('activity.update', ['activity' => $activity]), [
+        $response->assertRedirect('/activity');
-        'name' => '',
+        $this->assertDatabaseHas('activities', ['name' => 'Lorem', 'is_filterable' => true]);
-        'is_filterable' => true,
+    }
-    ]);
 
-    $response->assertSessionHasErrors(['name' => 'Name ist erforderlich.']);
+    public function testItSetsSubactivities(): void
-    $response->assertSessionHasErrors(['subactivities' => 'Untergliederungen muss vorhanden sein.']);
+    {
-});
+        $this->login()->loginNami();
+        $activity = Activity::factory()->create();
+        $subactivity = Subactivity::factory()->create();
 
-it('testItUpdatesName', function () {
+        $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => 'Lorem',
-    $activity = Activity::factory()->name('UUU')->create();
+            'is_filterable' => false,
+            'subactivities' => [$subactivity->id],
+        ]);
 
-    $response = $this->patch(route('activity.update', ['activity' => $activity]), [
+        $this->assertDatabaseHas('activity_subactivity', ['activity_id' => $activity->id, 'subactivity_id' => $subactivity->id]);
-        'name' => 'Lorem',
+    }
-        'is_filterable' => true,
-        'subactivities' => [],
-    ]);
 
-    $response->assertRedirect('/activity');
+    public function testItCannotSetNamiId(): void
-    $this->assertDatabaseHas('activities', ['name' => 'Lorem', 'is_filterable' => true]);
+    {
-});
+        $this->login()->loginNami();
+        $activity = Activity::factory()->create();
 
-it('testItSetsSubactivities', function () {
+        $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => 'Lorem',
-    $activity = Activity::factory()->create();
+            'nami_id' => 66,
-    $subactivity = Subactivity::factory()->create();
+            'is_filterable' => false,
+            'subactivities' => [],
+        ]);
 
-    $this->patch(route('activity.update', ['activity' => $activity]), [
+        $this->assertDatabaseHas('activities', ['nami_id' => null]);
-        'name' => 'Lorem',
+    }
-        'is_filterable' => false,
-        'subactivities' => [$subactivity->id],
-    ]);
 
-    $this->assertDatabaseHas('activity_subactivity', ['activity_id' => $activity->id, 'subactivity_id' => $subactivity->id]);
+    public function testItUnsetsSubactivities(): void
-});
+    {
+        $this->login()->loginNami();
+        $activity = Activity::factory()
+            ->hasAttached(Subactivity::factory())
+            ->create();
 
-it('testItCannotSetNamiId', function () {
+        $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => 'Lorem',
-    $activity = Activity::factory()->create();
+            'is_filterable' => false,
+            'subactivities' => [],
+        ]);
 
-    $this->patch(route('activity.update', ['activity' => $activity]), [
+        $this->assertDatabaseEmpty('activity_subactivity');
-        'name' => 'Lorem',
+    }
-        'nami_id' => 66,
-        'is_filterable' => false,
-        'subactivities' => [],
-    ]);
 
-    $this->assertDatabaseHas('activities', ['nami_id' => null]);
+    public function testItCannotSetSubactivityIfItStillHasMembers(): void
-});
+    {
+        $this->login()->loginNami();
+        $activity = Activity::factory()->create();
+        $subactivity = Subactivity::factory()->hasAttached($activity)->create();
+        $newSubactivity = Subactivity::factory()->create();
+        Member::factory()->defaults()->has(Membership::factory()->for($activity)->for($subactivity))->create();
 
-it('testItUnsetsSubactivities', function () {
+        $response = $this->patch(route('activity.update', ['activity' => $activity]), [
-    $this->login()->loginNami();
+            'name' => 'abc',
-    $activity = Activity::factory()
+            'is_filterable' => false,
-        ->hasAttached(Subactivity::factory())
+            'subactivities' => [$newSubactivity->id],
-        ->create();
+        ]);
 
-    $this->patch(route('activity.update', ['activity' => $activity]), [
+        $response->assertSessionHasErrors(['subactivities' => 'Untergliederung hat noch Mitglieder.']);
-        'name' => 'Lorem',
+    }
-        'is_filterable' => false,
+}
-        'subactivities' => [],
-    ]);
-
-    $this->assertDatabaseEmpty('activity_subactivity');
-});
-
-it('testItCannotSetSubactivityIfItStillHasMembers', function () {
-    $this->login()->loginNami();
-    $activity = Activity::factory()
-        ->hasAttached(Subactivity::factory())
-        ->create();
-    Member::factory()->defaults()->has(Membership::factory()->for($activity)->for($activity->subactivities->first()))->create();
-
-    $response = $this->patch(route('activity.update', ['activity' => $activity]), [
-        'name' => 'abc',
-        'is_filterable' => false,
-        'subactivities' => [],
-    ]);
-
-    $response->assertSessionHasErrors(['subactivities' => 'Untergliederung hat noch Mitglieder.']);
-});
-
-it('test it succeeds when membership is not of removing subactivity', function () {
-    $this->login()->loginNami();
-    $activity = Activity::factory()
-        ->hasAttached(Subactivity::factory())
-        ->create();
-    Member::factory()->defaults()->has(Membership::factory()->for($activity)->for(Subactivity::factory()))->create();
-
-    $response = $this->patch(route('activity.update', ['activity' => $activity]), [
-        'name' => 'abc',
-        'is_filterable' => false,
-        'subactivities' => [],
-    ]);
-
-    $response->assertSessionDoesntHaveErrors();
-});
-
-it('test it succeeds when membership is not of removing activity', function () {
-    $this->login()->loginNami();
-    $activity = Activity::factory()
-        ->hasAttached(Subactivity::factory())
-        ->create();
-    Member::factory()->defaults()->has(Membership::factory()->for(Activity::factory())->for($activity->subactivities->first()))->create();
-
-    $response = $this->patch(route('activity.update', ['activity' => $activity]), [
-        'name' => 'abc',
-        'is_filterable' => false,
-        'subactivities' => [],
-    ]);
-
-    $response->assertSessionDoesntHaveErrors();
-});

tests/Feature/Initialize/InitializeActivitiesTest.php

@@ -55,7 +55,7 @@ class InitializeActivitiesTest extends TestCase
         ]);
     }
 
-    public static function activityDataProvider(): Generator
+    public function activityDataProvider(): Generator
     {
         yield [
             fn (ActivityFake $fake) => $fake->fetches(1000, [

tests/Feature/Member/PreventionTest.php

@@ -109,7 +109,7 @@ class PreventionTest extends TestCase
         $this->assertNotNull($participant->fresh()->last_remembered_at);
     }
 
-    public static function attributes(): Generator
+    protected function attributes(): Generator
     {
         yield [
             'attrs' => ['has_vk' => true, 'efz' => null, 'ps_at' => now()],
@@ -172,12 +172,12 @@ class PreventionTest extends TestCase
      * @param array<string, mixed> $memberAttributes
      */
     #[DataProvider('attributes')]
-    public function testItRemembersMember(array $attrs, array $preventions): void
+    public function testItRemembersMember(array $memberAttributes, array $preventions): void
     {
         Mail::fake();
         $form = $this->createForm();
         $participant = $this->createParticipant($form);
-        $participant->member->update($attrs);
+        $participant->member->update($memberAttributes);
 
         PreventionRememberAction::run();
 

tests/Feature/Member/ShowTest.php

@@ -171,7 +171,7 @@ class ShowTest extends TestCase
         ], $response, 'data');
     }
 
-    public static function membershipDataProvider(): Generator
+    public function membershipDataProvider(): Generator
     {
         yield [now()->subMonths(2), null, true];
         yield [now()->subMonths(2), now()->subDay(), false];

tests/Feature/Membership/IndexTest.php

@@ -46,7 +46,7 @@ class IndexTest extends TestCase
             ->assertJsonPath('meta.links.store', route('member.membership.store', ['member' => $member]));
     }
 
-    public static function membershipDataProvider(): Generator
+    public function membershipDataProvider(): Generator
     {
         yield [now()->subMonths(2), null, true];
         yield [now()->subMonths(2), now()->subDay(), false];

tests/Unit/Mailman/ServiceTest.php

@@ -52,7 +52,7 @@ class ServiceTest extends TestCase
             ]), 200),
         ]);
 
-        $result = app(MailmanService::class)->setCredentials('http://mailman.test/api/', 'user', 'secret')->members(MailingList::toFactory()->id('listid')->toData())->first();
+        $result = app(MailmanService::class)->setCredentials('http://mailman.test/api/', 'user', 'secret')->members(MailingList::factory()->id('listid')->toData())->first();
 
         $this->assertEquals(994, $result->memberId);
         $this->assertEquals('test@example.com', $result->email);
@@ -67,7 +67,7 @@ class ServiceTest extends TestCase
             'http://mailman.test/api/lists/listid/roster/member?page=1&count=10' => Http::response('', 401),
         ]);
 
-        app(MailmanService::class)->setCredentials('http://mailman.test/api/', 'user', 'secret')->members(MailingList::toFactory()->id('listid')->toData())->first();
+        app(MailmanService::class)->setCredentials('http://mailman.test/api/', 'user', 'secret')->members(MailingList::factory()->id('listid')->toData())->first();
     }
 
     public function testItCanGetLists(): void
@@ -90,7 +90,7 @@ class ServiceTest extends TestCase
         $this->assertEquals('Eltern', $lists[0]->displayName);
     }
 
-    public static function listDataProvider(): Generator
+    public function listDataProvider(): Generator
     {
         foreach (range(3, 40) as $i) {
             yield [
@@ -114,7 +114,7 @@ class ServiceTest extends TestCase
             ]);
         }
 
-        $result = app(MailmanService::class)->setCredentials('http://mailman.test/api/', 'user', 'secret')->members(MailingList::toFactory()->id('listid')->toData());
+        $result = app(MailmanService::class)->setCredentials('http://mailman.test/api/', 'user', 'secret')->members(MailingList::factory()->id('listid')->toData());
 
         $this->assertCount($totals->count(), $result->toArray());
         Http::assertSentCount($totals->chunk(10)->count());