Add class based factory for LegacyMatch related models

database/factories/Chat/ChannelFactory.php

···
         ];
     }
 
-    public function moderated()
+    public function moderated(): static
     {
         return $this->state(['moderated' => true]);
     }
 
-    public function pm(User ...$users)
+    public function pm(User ...$users): static
     {
         if (empty($users)) {
             $users = User::factory()->count(2)->create();
···
         ])->withUsers(...$users);
     }
 
-    public function tourney()
+    public function tourney(): static
     {
-        $match = factory(LegacyMatch::class)->states('tourney')->create();
+        $match = LegacyMatch::factory()->tourney()->create();
 
         return $this->state([
             'name' => "#mp_{$match->getKey()}",
···
         ]);
     }
 
-    public function type(string $type, array $users = [])
+    public function type(string $type, array $users = []): static
     {
         if ($type === 'tourney') {
             return $this->tourney();
···
         return $this->state(['type' => Channel::TYPES[$type]])->withUsers(...$users);
     }
 
-    public function withUsers(User ...$users)
+    public function withUsers(User ...$users): static
     {
         return $this->afterCreating(function (Channel $channel) use ($users) {
             foreach ($users as $user) {

database/factories/LegacyMatch/EventFactory.php

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
 // See the LICENCE file in the repository root for full licence text.
 
+declare(strict_types=1);
+
+namespace Database\Factories\LegacyMatch;
+
 use App\Models\LegacyMatch\Event;
 use App\Models\LegacyMatch\Game;
 use App\Models\LegacyMatch\LegacyMatch;
+use App\Models\User;
+use Carbon\Carbon;
+use Database\Factories\Factory;
 
-$factory->define(Event::class, function (Faker\Generator $faker) {
-    return [
-        'match_id' => function () {
-            return factory(LegacyMatch::class)->create()->user_id;
-        },
-        'user_id' => function () {
-            return App\Models\User::factory()->create()->user_id;
-        },
-        'timestamp' => Carbon\Carbon::now(),
-    ];
-});
+class EventFactory extends Factory
+{
+    protected $model = Event::class;
 
-$factory->state(Event::class, 'create', function (Faker\Generator $faker) {
-    return [
-        'user_id' => null,
-        'text' => 'CREATE',
-    ];
-});
+    public function definition(): array
+    {
+        return [
+            'match_id' => LegacyMatch::factory(),
+            'user_id' => User::factory(),
+            'timestamp' => fn() => Carbon::now(),
+        ];
+    }
 
-$factory->state(Event::class, 'disband', function (Faker\Generator $faker) {
-    return [
-        'user_id' => null,
-        'text' => 'DISBAND',
-    ];
-});
+    public function stateCreate(): static
+    {
+        return $this->state([
+            'user_id' => null,
+            'text' => 'CREATE',
+        ]);
+    }
 
-$factory->state(Event::class, 'join', function (Faker\Generator $faker) {
-    return [
-        'text' => 'JOIN',
-    ];
-});
+    public function disband(): static
+    {
+        return $this->state([
+            'user_id' => null,
+            'text' => 'DISBAND',
+        ]);
+    }
 
-$factory->state(Event::class, 'part', function (Faker\Generator $faker) {
-    return [
-        'text' => 'PART',
-    ];
-});
+    public function join(): static
+    {
+        return $this->state(['text' => 'JOIN']);
+    }
 
-$factory->state(Event::class, 'game', function (Faker\Generator $faker) {
-    return [
-        'text' => 'test game',
-        'user_id' => null,
-        'game_id' => function () {
-            return factory(Game::class)->states('in_progress')->create()->game_id;
-        },
-    ];
-});
+    public function part(): static
+    {
+        return $this->state(['text' => 'PART']);
+    }
+
+    public function game(): static
+    {
+        return $this->state([
+            'text' => 'test game',
+            'user_id' => null,
+            'game_id' => Game::factory()->inProgress(),
+        ]);
+    }
+}

database/factories/LegacyMatch/GameFactory.php

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
 // See the LICENCE file in the repository root for full licence text.
 
+declare(strict_types=1);
+
+namespace Database\Factories\LegacyMatch;
+
+use App\Models\Beatmap;
 use App\Models\LegacyMatch\Game;
 use Carbon\Carbon;
+use Database\Factories\Factory;
 
-$factory->define(Game::class, function (Faker\Generator $faker) {
-    $beatmap = App\Models\Beatmap::inRandomOrder()->first();
+class GameFactory extends Factory
+{
+    protected $model = Game::class;
 
-    return [
-        'beatmap_id' => $beatmap->beatmap_id,
-        'start_time' => Carbon::now()->subSeconds($beatmap->total_length),
-        'play_mode' => $beatmap->playmode,
-        'scoring_type' => $faker->numberBetween(0, 3),
-        'team_type' => $faker->numberBetween(0, 3),
-    ];
-});
+    public function definition(): array
+    {
+        return [
+            'beatmap_id' => Beatmap::factory(),
+            'start_time' => fn(array $attributes) => Carbon::now()->subSeconds(Beatmap::find($attributes['beatmap_id'])->total_length),
+            'play_mode' => fn(array $attributes) => Beatmap::find($attributes['beatmap_id'])->playmode,
+            'scoring_type' => fn() => $this->faker->numberBetween(0, 3),
+            'team_type' => fn() => $this->faker->numberBetween(0, 3),
+        ];
+    }
 
-$factory->state(Game::class, 'in_progress', function (Faker\Generator $faker) {
-    return [
-        'end_time' => null,
-    ];
-});
+    public function inProgress(): static
+    {
+        return $this->state(['end_time' => null]);
+    }
 
-$factory->state(Game::class, 'complete', function (Faker\Generator $faker) {
-    return [
-        'end_time' => Carbon::now(),
-    ];
-});
+    public function complete(): static
+    {
+        return $this->state(['end_time' => fn() => Carbon::now()]);
+    }
+}

database/factories/LegacyMatch/LegacyMatchFactory.php

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
 // See the LICENCE file in the repository root for full licence text.
 
+namespace Database\Factories\LegacyMatch;
+
 use App\Models\LegacyMatch\LegacyMatch;
+use Carbon\Carbon;
+use Database\Factories\Factory;
 
-$factory->define(LegacyMatch::class, function (Faker\Generator $faker) {
-    return [
-        'name' => function () use ($faker) {
-            return $faker->sentence();
-        },
-        'start_time' => Carbon\Carbon::now(),
-        'private' => 0,
-    ];
-});
+class LegacyMatchFactory extends Factory
+{
+    protected $model = LegacyMatch::class;
 
-$factory->state(LegacyMatch::class, 'private', function (Faker\Generator $faker) {
-    return [
-        'private' => 1,
-    ];
-});
+    public function definition(): array
+    {
+        return [
+            'name' => fn() => $this->faker->sentence(),
+            'start_time' => fn() => Carbon::now(),
+            'private' => 0,
+        ];
+    }
 
-$factory->state(LegacyMatch::class, 'tourney', function (Faker\Generator $faker) {
-    return [
-        'keep_forever' => 1,
-    ];
-});
+    public function private(): static
+    {
+        return $this->state(['private' => 1]);
+    }
+
+    public function tourney(): static
+    {
+        return $this->state(['keep_forever' => 1]);
+    }
+}

tests/Browser/SanityTest.php

···
         ]);
 
         // factory for matches
-        self::$scaffolding['match'] = factory(LegacyMatch\LegacyMatch::class)->create();
-        self::$scaffolding['event'] = factory(LegacyMatch\Event::class)->states('join')->create([
+        self::$scaffolding['match'] = LegacyMatch\LegacyMatch::factory()->create();
+        self::$scaffolding['event'] = LegacyMatch\Event::factory()->join()->create([
             'match_id' => self::$scaffolding['match']->getKey(),
         ]);
 

tests/Controllers/MatchesControllerTest.php

···
 
     public function testPublicMatchLoggedInParticipated() // OK
     {
-        factory(Event::class)->states('join')->create([
+        Event::factory()->join()->create([
             'user_id' => $this->user->user_id,
             'match_id' => $this->publicMatch->match_id,
         ]);
···
 
     public function testPrivateMatchLoggedInHost() // OK
     {
-        factory(Event::class)->states('create')->create([
+        Event::factory()->stateCreate()->create([
             'user_id' => $this->user->user_id,
             'match_id' => $this->privateMatch->match_id,
         ]);
···
 
     public function testPrivateMatchLoggedInParticipated() // OK
     {
-        factory(Event::class)->states('join')->create([
+        Event::factory()->join()->create([
             'user_id' => $this->user->user_id,
             'match_id' => $this->privateMatch->match_id,
         ]);
···
 
         $this->user = User::factory()->create();
 
-        $this->publicMatch = factory(LegacyMatch::class)->create();
-        factory(Event::class)->states('create')->create([
+        $this->publicMatch = LegacyMatch::factory()->create();
+        Event::factory()->stateCreate()->create([
             'match_id' => $this->publicMatch->match_id,
         ]);
         $this->publicMatchRoute = route('matches.show', $this->publicMatch->match_id);
 
-        $this->privateMatch = factory(LegacyMatch::class)->states('private')->create();
-        factory(Event::class)->states('create')->create([
+        $this->privateMatch = LegacyMatch::factory()->private()->create();
+        Event::factory()->stateCreate()->create([
             'match_id' => $this->privateMatch->match_id,
         ]);
         $this->privateMatchRoute = route('matches.show', $this->privateMatch->match_id);