Change data provider to static method

Non-static is deprecated in phpunit 10.

Also:
- updated phpunit dusk schema
- skip creating app in provider if possible
- move base64url to its own class (helper isn't available)
- use Arr::random instead of array_rand_val
- use config in a callback
- read config file directly instead of relying on config function
- change some test class helpers to static method

app/Libraries/Base64Url.php

···
+<?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 App\Libraries;
+
+class Base64Url
+{
+    public static function decode(string $value): ?string
+    {
+        return null_if_false(base64_decode(strtr($value, '-_', '+/'), true));
+    }
+
+    public static function encode(string $value): string
+    {
+        // url safe base64
+        // reference: https://datatracker.ietf.org/doc/html/rfc4648#section-5
+        return rtrim(strtr(base64_encode($value), '+/', '-_'), '=');
+    }
+}

app/Libraries/SignedRandomString.php

···
         $key = random_bytes($randomSize);
         $hmac = static::hmac($key);
 
-        return base64url_encode($hmac.$key);
+        return Base64Url::encode($hmac.$key);
     }
 
     public static function isValid(string $input): bool
     {
-        $bin = base64url_decode($input);
+        $bin = Base64Url::decode($input);
         if ($bin === null) {
             return false;
         }

app/helpers.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.
 
+use App\Libraries\Base64Url;
 use App\Libraries\LocaleMeta;
 use App\Models\LoginAttempt;
 use Egulias\EmailValidator\EmailValidator;
···
     $url = $proxy ? proxy_media($url) : $url;
 
     return sprintf(' style="background-image:url(\'%s\');" ', e($url));
-}
-
-function base64url_decode(string $value): ?string
-{
-    return null_if_false(base64_decode(strtr($value, '-_', '+/'), true));
-}
-
-function base64url_encode(string $value): string
-{
-    // url safe base64
-    // reference: https://datatracker.ietf.org/doc/html/rfc4648#section-5
-    return rtrim(strtr(base64_encode($value), '+/', '-_'), '=');
 }
 
 function beatmap_timestamp_format($ms)
···
 function cursor_decode($cursorString): ?array
 {
     if (is_string($cursorString) && present($cursorString)) {
-        $cursor = json_decode(base64_decode(strtr($cursorString, '-_', '+/'), true), true);
+        $cursor = json_decode(Base64Url::decode($cursorString) ?? '', true);
 
         if (is_array($cursor)) {
             return $cursor;
···
 {
     return $cursor === null
         ? null
-        : base64url_encode(json_encode($cursor));
+        : Base64Url::encode(json_encode($cursor));
 }
 
 function cursor_for_response(?array $cursor): array

phpunit.dusk.xml

···
 <?xml version="1.0" encoding="UTF-8"?>
-<phpunit backupGlobals="false"
-         backupStaticAttributes="false"
-         bootstrap="vendor/autoload.php"
-         colors="true"
-         convertErrorsToExceptions="true"
-         convertNoticesToExceptions="true"
-         convertWarningsToExceptions="true"
-         processIsolation="false"
-         stopOnFailure="false">
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    backupGlobals="false"
+    backupStaticAttributes="false"
+    bootstrap="vendor/autoload.php"
+    colors="true"
+    convertErrorsToExceptions="true"
+    convertNoticesToExceptions="true"
+    convertWarningsToExceptions="true"
+    processIsolation="false"
+    stopOnFailure="false"
+    xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd"
+>
     <extensions>
-        <extension class="Tests\SeederExtension" />
+        <extension class="Tests\SeederExtension"/>
     </extensions>
     <testsuites>
         <testsuite name="Browser Test Suite">
             <directory suffix="Test.php">./tests/Browser</directory>
         </testsuite>
     </testsuites>
-    <filter>
-        <whitelist processUncoveredFilesFromWhitelist="true">
-            <directory suffix=".php">./app</directory>
-        </whitelist>
-    </filter>
 </phpunit>

tests/BeatmapsetDisqualifyNotificationsTest.php

···
     }
     #endregion
 
-    public function booleanDataProvider()
+    public static function booleanDataProvider()
     {
         return [
             [true],

tests/BroadcastNotificationTest.php

···
         }
     }
 
-    public function notificationJobClassesDataProvider()
+    public static function notificationJobClassesDataProvider()
     {
-        $this->refreshApplication();
-
-        $path = app()->path('Jobs/Notifications');
-        $files = Finder::create()->files()->in($path)->sortByName();
+        $files = Finder::create()->files()->in(__DIR__.'/../app/Jobs/Notifications')->sortByName();
         foreach ($files as $file) {
             $baseName = $file->getBasename(".{$file->getExtension()}");
             $classes[] = ["\\App\\Jobs\\Notifications\\{$baseName}"];
···
         return $classes;
     }
 
-    public function notificationNamesDataProvider()
+    public static function notificationNamesDataProvider()
     {
         // TODO: move notification names to different class instead of filtering
         $constants = collect((new ReflectionClass(Notification::class))->getReflectionConstants())
···
         return $constants->map(fn (ReflectionClassConstant $constant) => [$constant->getValue()])->all();
     }
 
-    public function userNotificationDetailsDataProvider()
+    public static function userNotificationDetailsDataProvider()
     {
         return [
             [null], // for testing defaults.

tests/Browser/SanityTest.php

···
         }
     }
 
-    public function routesDataProvider()
+    public static function routesDataProvider()
     {
         static $bypass = [
             '__clockwork',
···
         ];
         static $types = ['user', 'guest'];
 
-        $this->refreshApplication();
+        static::createApp();
         $data = [];
 
         foreach (app()->routes->get('GET') as $uri => $route) {

tests/Commands/EsIndexScoresQueueTest.php

···
         );
     }
 
-    public function dataProviderForTestParameterValidity(): array
+    public static function dataProviderForTestParameterValidity(): array
     {
         return [
             [[], false],
···
         ];
     }
 
-    public function dataProviderForTestQueueScores(): array
+    public static function dataProviderForTestQueueScores(): array
     {
         $userId = 0;
         $setUp = function () use ($userId) {

tests/Commands/ModdingRankCommandTest.php

···
     }
 
 
-    public function rankDataProvider()
+    public static function rankDataProvider()
     {
         // 1 day ago isn't used because it might or might not be equal to the cutoff depending on how fast it runs.
         return [
···
         ];
     }
 
-    public function rankHybridDataProvider()
+    public static function rankHybridDataProvider()
     {
         return [
             // hybrid counts as ruleset with lowest enum value

tests/Controllers/AccountControllerTest.php

···
             ->assertStatus(422);
     }
 
-    public function dataProviderForUpdateCountry(): array
+    public static function dataProviderForUpdateCountry(): array
     {
         return [
             ['_A', '_A', true],

tests/Controllers/BeatmapDiscussionsControllerTest.php

···
         $this->assertSame($discussionPostCount + 3, BeatmapDiscussionPost::count());
     }
 
-    public function putVoteDataProvider()
+    public static function putVoteDataProvider()
     {
         return [
             ['graveyard', 403, 0],
···
         ];
     }
 
-    public function putVoteAgainDataProvider()
+    public static function putVoteAgainDataProvider()
     {
         return [
             'voting again has no effect' => ['1', 0],
···
         ];
     }
 
-    public function putVoteChangeToDownDataProvider()
+    public static function putVoteChangeToDownDataProvider()
     {
         return [
             'bng can change to down vote' => ['bng', 200, -2],
···
         ];
     }
 
-    public function putVoteDownDataProvider()
+    public static function putVoteDownDataProvider()
     {
         return [
             'bng can down vote' => ['bng', 200, 1, -1],

tests/Controllers/BeatmapsControllerSoloScoresTest.php

···
         }
     }
 
-    public function dataProviderForTestQuery(): array
+    public static function dataProviderForTestQuery(): array
     {
         return [
             'no parameters' => [[

tests/Controllers/BeatmapsControllerTest.php

···
         $this->assertSame($beatmapsetEventCount, BeatmapsetEvent::count());
     }
 
-    public function dataProviderForTestLookupForApi(): array
+    public static function dataProviderForTestLookupForApi(): array
     {
         return [
             'checksum' => ['checksum', fn (Beatmap $b) => $b->checksum],
···
         ];
     }
 
-    public function dataProviderForTestUpdateOwnerLoved(): array
+    public static function dataProviderForTestUpdateOwnerLoved(): array
     {
         return [
             [Beatmapset::STATES['graveyard'], true],

tests/Controllers/BeatmapsetsControllerTest.php

···
         $this->assertSame($expectedTags, $beatmapset->fresh()->tags);
     }
 
-    public function beatmapsetStatesDataProvider()
+    public static function beatmapsetStatesDataProvider()
     {
         return array_map(function ($state) {
             return [$state];
         }, array_keys(Beatmapset::STATES));
     }
 
-    public function dataProviderForTestBeatmapsetUpdateOffset(): array
+    public static function dataProviderForTestBeatmapsetUpdateOffset(): array
     {
         return [
             ['admin', true],
···
         ];
     }
 
-    public function dataProviderForTestBeatmapsetUpdateTags(): array
+    public static function dataProviderForTestBeatmapsetUpdateTags(): array
     {
         return [
             ['admin', true],
···
         ];
     }
 
-    public function dataProviderForTestBeatmapsetUpdateDescriptionAsOwner(): array
+    public static function dataProviderForTestBeatmapsetUpdateDescriptionAsOwner(): array
     {
         return [
             [false, null, true],

tests/Controllers/Chat/ChannelsControllerTest.php

···
 
     //endregion
 
-    public function dataProvider()
+    public static function dataProvider()
     {
         return [
             ['private', false],

tests/Controllers/Chat/ChatControllerTest.php

···
 
     //endregion
 
-    public function createPmWithAuthorizedGrantDataProvider()
+    public static function createPmWithAuthorizedGrantDataProvider()
     {
         return [
             [['*'], 200],
···
         ];
     }
 
-    public function createPmWithClientCredentialsDataProvider()
+    public static function createPmWithClientCredentialsDataProvider()
     {
         return [
             // TODO: need to add test that validates auth guard calls Token::validate
···
         ];
     }
 
-    public function createPmWithClientCredentialsBotGroupDataProvider()
+    public static function createPmWithClientCredentialsBotGroupDataProvider()
     {
         return [
             [['chat.write', 'delegate'], 200],

tests/Controllers/CommentsControllerTest.php

···
             ->assertUnauthorized();
     }
 
-    public function apiRequiresAuthenticationDataProvider()
+    public static function apiRequiresAuthenticationDataProvider()
     {
         return [
             ['DELETE', 'comments.vote'],
···
      * - Whether the commentable already has a pinned comment
      * - Whether pinning should be allowed
      */
-    public function pinPermissionsDataProvider(): array
+    public static function pinPermissionsDataProvider(): array
     {
         return [
             ['admin', true,  true,  true,  true,  true],

tests/Controllers/InterOp/UserGroupsControllerTest.php

···
             ->assertStatus(404);
     }
 
-    public function userGroupRoutesDataProvider(): array
+    public static function userGroupRoutesDataProvider(): array
     {
         return [
             'add' =>

tests/Controllers/LegacyApiKeyControllerTest.php

···
         $this->post(route('legacy-api-key.store'))->assertStatus(401);
     }
 
-    public function dataProviderForStoreWithInvalidParams(): array
+    public static function dataProviderForStoreWithInvalidParams(): array
     {
         return [
             [[

tests/Controllers/Multiplayer/Rooms/Playlist/ScoresControllerTest.php

···
         $this->json('PUT', $url, $bodyParams)->assertStatus($status);
     }
 
-    public function dataProviderForTestStore()
+    public static function dataProviderForTestStore()
     {
         return [
             'ok' => [true, true, 200],
···
         ];
     }
 
-    public function dataProviderForTestUpdate()
+    public static function dataProviderForTestUpdate()
     {
         static $validBodyParams = [
             'accuracy' => 1,

tests/Controllers/Multiplayer/RoomsControllerTest.php

···
 use App\Models\Multiplayer\UserScoreAggregate;
 use App\Models\OAuth\Token;
 use App\Models\User;
+use Illuminate\Support\Arr;
 use Tests\TestCase;
 
 class RoomsControllerTest extends TestCase
···
         $this->assertSame($initialUserChannelCount + 1, UserChannel::count());
     }
 
-    public function dataProviderForTestStoreWithInvalidPlayableMods(): array
+    public static function dataProviderForTestStoreWithInvalidPlayableMods(): array
     {
         $ret = [];
-        foreach ([array_rand_val(Room::REALTIME_TYPES), Room::PLAYLIST_TYPE] as $type) {
+        foreach ([Arr::random(Room::REALTIME_TYPES), Room::PLAYLIST_TYPE] as $type) {
             foreach (['allowed', 'required'] as $modType) {
                 $ret[] = [$type, $modType];
             }
···
         return $ret;
     }
 
-    public function dataProviderForTestStoreWithInvalidRealtimeAllowedMods(): array
+    public static function dataProviderForTestStoreWithInvalidRealtimeAllowedMods(): array
     {
         return [
-            [array_rand_val(Room::REALTIME_TYPES), false],
+            [Arr::random(Room::REALTIME_TYPES), false],
             [Room::PLAYLIST_TYPE, true],
         ];
     }
 
-    public function dataProviderForTestStoreWithInvalidRealtimeMods(): array
+    public static function dataProviderForTestStoreWithInvalidRealtimeMods(): array
     {
         return [
-            [array_rand_val(Room::REALTIME_TYPES), false],
+            [Arr::random(Room::REALTIME_TYPES), false],
             [Room::PLAYLIST_TYPE, true],
         ];
     }

tests/Controllers/OAuth/ClientsControllerTest.php

···
         $this->assertSame('https://nowhere.local', $this->client->redirect);
     }
 
-    public function emptyStringsTestDataProvider()
+    public static function emptyStringsTestDataProvider()
     {
         return [
             [null, 'https://nowhere.local'],

tests/Controllers/ScoreTokensControllerTest.php

···
         ]);
     }
 
-    public function dataProviderForTestStore(): array
+    public static function dataProviderForTestStore(): array
     {
         return [
             ['deleted', 404],
···
         ];
     }
 
-    public function dataProviderForTestStoreInvalidParameter(): array
+    public static function dataProviderForTestStoreInvalidParameter(): array
     {
         return [
             'invalid build hash' => ['version_hash', md5('invalid_'), 422],

tests/Controllers/UsersControllerTest.php

···
             ->assertSuccessful();
     }
 
-    public function dataProviderForStoreWebInvalidParams(): array
+    public static function dataProviderForStoreWebInvalidParams(): array
     {
         return [
             ['user1', '[e-mail]', '[e-mail]', 'short', 'short'],

tests/CreatesApplication.php

···
 
 trait CreatesApplication
 {
+    public static function createApp()
+    {
+        $app = require __DIR__.'/../bootstrap/app.php';
+        $app->make(Kernel::class)->bootstrap();
+
+        return $app;
+    }
+
     /**
      * Creates the application.
      *
···
      */
     public function createApplication()
     {
-        $app = require __DIR__.'/../bootstrap/app.php';
-        $app->make(Kernel::class)->bootstrap();
-
-        return $app;
+        return static::createApp();
     }
 }

tests/HelpersTest.php

···
         $this->assertTrue(is_sql_unique_exception($exception));
     }
 
-    public function dataForClassWithModifiers(): array
+    public static function dataForClassWithModifiers(): array
     {
         return [
             'no modifiers' =>
···
         ];
     }
 
-    public function dataForGetStringSplit(): array
+    public static function dataForGetStringSplit(): array
     {
         return [
             ["hello\nworld\n!", ['hello', 'world', '!']],

tests/Libraries/BBCodeForDBTest.php

···
         $this->assertSame($expectedOutput, $output);
     }
 
-    public function examples()
+    public static function examples()
     {
-        return $this->fileList(__DIR__.'/bbcode_examples', '.base.txt');
+        return static::fileList(__DIR__.'/bbcode_examples', '.base.txt');
     }
 
     protected function setUp(): void

tests/Libraries/BBCodeFromDBTest.php

···
         $this->assertStringEqualsFile($expectedFilePath, $text);
     }
 
-    public function examples()
+    public static function examples()
     {
-        return $this->fileList(__DIR__.'/bbcode_examples', '.db.txt');
+        return static::fileList(__DIR__.'/bbcode_examples', '.db.txt');
     }
 
-    public function removeQuoteExamples()
+    public static function removeQuoteExamples()
     {
-        return $this->fileList(__DIR__.'/bbcode_examples/remove_quotes', '.db.txt');
+        return static::fileList(__DIR__.'/bbcode_examples/remove_quotes', '.db.txt');
     }
 
     protected function setUp(): void

tests/Libraries/BeatmapsetDiscussion/DiscussionTest.php

···
     /**
      * @dataProvider minPlaysVerificationDataProvider
      */
-    public function testMinPlaysVerification(?int $minPlays, bool $verified, bool $success)
+    public function testMinPlaysVerification(\Closure $minPlays, bool $verified, bool $success)
     {
         config()->set('osu.user.post_action_verification', false);
 
-        $user = User::factory()->withPlays($minPlays)->create();
+        $user = User::factory()->withPlays($minPlays())->create();
         $beatmapset = $this->beatmapsetFactory()->create();
         $beatmapset->watches()->create(['user_id' => User::factory()->create()->getKey()]);
 
···
 
     //endregion
 
-    public function minPlaysVerificationDataProvider()
+    public static function minPlaysVerificationDataProvider()
     {
         return [
-            [config('osu.user.min_plays_for_posting') - 1, false, false],
-            [config('osu.user.min_plays_for_posting') - 1, true, true],
-            [null, false, true],
-            [null, true, true],
+            [fn () => config('osu.user.min_plays_for_posting') - 1, false, false],
+            [fn () => config('osu.user.min_plays_for_posting') - 1, true, true],
+            [fn () => null, false, true],
+            [fn () => null, true, true],
         ];
     }
 
-    public function problemOnQualifiedBeatmapsetDataProvider()
+    public static function problemOnQualifiedBeatmapsetDataProvider()
     {
         return [
             ['pending', 'Event::assertNotDispatched'],
···
         ];
     }
 
-    public function problemOnQualifiedBeatmapsetModesNotificationDataProvider()
+    public static function problemOnQualifiedBeatmapsetModesNotificationDataProvider()
     {
         return [
             'with matching notification mode' => ['osu', ['osu'], true],
···
         ];
     }
 
-    public function newDiscussionQueuesJobsDataProvider()
+    public static function newDiscussionQueuesJobsDataProvider()
     {
         return [
             [
···
         ];
     }
 
-    public function newMapperNoteByOtherUsersDataProvider()
+    public static function newMapperNoteByOtherUsersDataProvider()
     {
         return [
             ['bng', true],
···
         ];
     }
 
-    public function shouldDisqualifyOrResetNominationsDataProvider()
+    public static function shouldDisqualifyOrResetNominationsDataProvider()
     {
         return [
             ['pending', 'bng', 'problem', true],
···
         ];
     }
 
-    public function userGroupsDataProvider()
+    public static function userGroupsDataProvider()
     {
         return [
             ['admin'],

tests/Libraries/BeatmapsetDiscussion/ReplyTest.php

···
         $this->assertFalse($discussion->fresh()->resolved);
     }
 
-    public function reopeningProblemDoesNotDisqualifyOrResetNominationsDataProvider()
+    public static function reopeningProblemDoesNotDisqualifyOrResetNominationsDataProvider()
     {
         return [
             ['bng', 'pending'],
···
         ];
     }
 
-    public function replyQueuesNotificationDataProviderToStarter()
+    public static function replyQueuesNotificationDataProviderToStarter()
     {
         return [
             ['praise', false],
···
         ];
     }
 
-    public function resolveDiscussionByStarterDataProvider()
+    public static function resolveDiscussionByStarterDataProvider()
     {
         return [
             ['praise', false],
···
         ];
     }
 
-    public function resolveDiscussionByMapperDataProvider()
+    public static function resolveDiscussionByMapperDataProvider()
     {
         return [
             ['pending', true],
···
         ];
     }
 
-    public function resolveDiscussionByOtherUsersDataProvider()
+    public static function resolveDiscussionByOtherUsersDataProvider()
     {
         return [
             ['bng', false],
···
         ];
     }
 
-    public function userGroupsDataProvider()
+    public static function userGroupsDataProvider()
     {
         return [
             ['admin'],

tests/Libraries/BeatmapsetDiscussion/ReviewTest.php

···
 
     //endregion
 
-    public function dataProviderForQualifiedProblem()
+    public static function dataProviderForQualifiedProblem()
     {
         return [
             ['qualified', true],

tests/Libraries/ChatTest.php

···
         Chat::sendPrivateMessage($sender, $target, 'test message again', false);
     }
 
-    public function createAnnouncementApiDataProvider()
+    public static function createAnnouncementApiDataProvider()
     {
         return [
             [null, false, false],
···
         ];
     }
 
-    public function minPlaysDataProvider()
+    public static function minPlaysDataProvider()
     {
         return [
             'bot group with minplays' => ['bot', true, true],
···
         ];
     }
 
-    public function sendPmFriendsOnlyGroupsDataProvider()
+    public static function sendPmFriendsOnlyGroupsDataProvider()
     {
         return [
             ['admin', true],
···
         ];
     }
 
-    public function sendPmSenderFriendsOnlyGroupsDataProvider()
+    public static function sendPmSenderFriendsOnlyGroupsDataProvider()
     {
         return [
             // admin skip because OsuAuthorize skips the check when admin.
···
         ];
     }
 
-    public function verifiedDataProvider()
+    public static function verifiedDataProvider()
     {
         return [
             [false, VerificationRequiredException::class],

tests/Libraries/Fulfillments/SupporterTagFulfillmentTest.php

···
         (new SupporterTagFulfillment($this->order))->run();
     }
 
-    public function boolDataProvider()
+    public static function boolDataProvider()
     {
         return [
             [true],

tests/Libraries/Ip2AsnTest.php

···
         $this->assertSame((new Ip2Asn())->lookup($ip), $asn);
     }
 
-    public function dataProviderForLookup(): array
+    public static function dataProviderForLookup(): array
     {
         return [
             'cloudflare 1' => ['2606:4700::6810:85e5', '13335'],

tests/Libraries/Markdown/ChatMarkdownTest.php

···
         );
     }
 
-    public function chatExamples()
+    public static function chatExamples()
     {
-        return $this->fileList(__DIR__.'/chat_markdown_examples', '.md');
+        return static::fileList(__DIR__.'/chat_markdown_examples', '.md');
     }
 
     private function loadOutputTest(string $name, string $path)

tests/Libraries/Markdown/ProcessorTest.php

···
         $this->assertSame('some header', $parsed['toc']['some-header']['title']);
     }
 
-    public function htmlExamples()
+    public static function htmlExamples()
     {
-        return $this->fileList(__DIR__.'/html_markdown_examples', '.md');
+        return static::fileList(__DIR__.'/html_markdown_examples', '.md');
     }
 
-    public function indexableExamples()
+    public static function indexableExamples()
     {
-        return $this->fileList(__DIR__.'/indexable_markdown_examples', '.md');
+        return static::fileList(__DIR__.'/indexable_markdown_examples', '.md');
     }
 
     private function loadOutputTest(string $name, string $path, string $extension)

tests/Libraries/ModsTest.php

···
         }
     }
 
-    public function modCombos()
+    public static function modCombos()
     {
         return [
             // valid
···
         ];
     }
 
-    public function modComboExclusives()
+    public static function modComboExclusives()
     {
         return [
             // non-exclusive required mods and no allowed mods

tests/Libraries/Search/BeatmapsetQueryParserTest.php

···
         $this->assertSame(json_encode($expected), json_encode(BeatmapsetQueryParser::parse($query)));
     }
 
-    public function queryDataProvider()
+    public static function queryDataProvider()
     {
         return [
             // basic options

tests/Libraries/Search/BeatmapsetSearchRequestParamsTest.php

···
         $this->assertSame($expected, $searchAfter);
     }
 
-    public function cursorsDataProvider()
+    public static function cursorsDataProvider()
     {
         return [
             [null, null, false, null],
···
         ];
     }
 
-    public function cursorsGuestDataProvider()
+    public static function cursorsGuestDataProvider()
     {
         return [
             [null, null, false, null],

tests/Libraries/SignedRandomStringTest.php

···
 
 namespace Tests\Libraries;
 
+use App\Libraries\Base64Url;
 use App\Libraries\SignedRandomString;
 use Tests\TestCase;
 
···
         $this->assertFalse(SignedRandomString::isValid($value));
     }
 
-    public function dataProviderForTestIsValidInvalid(): array
+    public static function dataProviderForTestIsValidInvalid(): array
     {
         return [
             ['invalid'],
             [''],
-            [base64url_encode('test')],
+            [Base64Url::encode('test')],
         ];
     }
 }

tests/Libraries/UsernameValidationTest.php

···
      * - Beatmap or beatmapset state
      * - Whether the username should be available
      */
-    public function usernameAvailabilityWithBeatmapStateDataProvider(): array
+    public static function usernameAvailabilityWithBeatmapStateDataProvider(): array
     {
         return [
             ['graveyard', true],
···
      * - Username
      * - Whether the username should be valid
      */
-    public function usernameValidationDataProvider(): array
+    public static function usernameValidationDataProvider(): array
     {
         return [
             'alphabetic'                   => ['Username',         true],
···
      * - Whether the user lookup should have its underscores replaced with spaces
      * - Whether the user lookup should return the user
      */
-    public function usersOfUsernameLookupDataProvider(): array
+    public static function usersOfUsernameLookupDataProvider(): array
     {
         return [
             [true,  true,  false],

tests/LocaleTest.php

···
         $this->assertSame('fr', App::getLocale());
     }
 
-    public function availableLocalesProvider()
+    public static function availableLocalesProvider()
     {
-        return array_map(function ($locale) {
-            return [$locale];
-        }, config('app.available_locales'));
+        return array_map(
+            fn ($locale) => [$locale],
+            (require __DIR__.'/../config/app.php')['available_locales'],
+        );
     }
 }

tests/Middleware/RequireScopesTest.php

···
         $this->assertTrue(!oauth_token()->isClientCredentials());
     }
 
-    public function clientCredentialsTestDataProvider()
+    public static function clientCredentialsTestDataProvider()
     {
         return [
             'null is not a valid scope' => [null, MissingScopeException::class],
···
         ];
     }
 
-    public function userScopesTestDataProvider()
+    public static function userScopesTestDataProvider()
     {
         return [
             'All scopes' => [null, ['*'], null],

tests/Middleware/RouteScopesTest.php

···
         }
     }
 
-    public function routesDataProvider()
+    public static function routesDataProvider()
     {
-        // note that $this->app does not carry over to the tests.
-        $this->refreshApplication();
+        static::createApp();
 
         $data = [];
 
···
         return $data;
     }
 
-    public function routeScopesDataProvider()
+    public static function routeScopesDataProvider()
     {
-        // note that $this->app does not carry over to the tests.
-        $this->refreshApplication();
+        static::createApp();
 
-        return array_map(function ($route) {
-            return [$route];
-        }, (new RouteScopesHelper())->toArray());
+        return array_map(
+            fn ($route) => [$route],
+            (new RouteScopesHelper())->toArray(),
+        );
     }
 
     private function importExpectations()

tests/Middleware/ThrottleRequestsTest.php

···
             ->assertHeader('X-Ratelimit-Remaining', 58);
     }
 
-    public function throttleDataProvider()
+    public static function throttleDataProvider()
     {
         return [
             'throttle' => [['throttle:60,10'], 59],

tests/Models/BeatmapDiscussionTest.php

···
         $this->assertFalse($discussion->trashed());
     }
 
-    public function validBeatmapsetStatuses()
+    public static function validBeatmapsetStatuses()
     {
         return array_map(function ($status) {
             return [camel_case($status)];

tests/Models/BeatmapPackUserCompletionTest.php

···
         $this->assertSame($completed, $data['completed']);
     }
 
-    public function dataProviderForTestBasic(): array
+    public static function dataProviderForTestBasic(): array
     {
         return [
             ['convertOsu', 'osu', true],

tests/Models/BeatmapsetTest.php

···
 
     //end region
 
-    public function disqualifyOrResetNominationsDataProvider()
+    public static function disqualifyOrResetNominationsDataProvider()
     {
         return [
             ['pending', BeatmapsetResetNominations::class],
···
         ];
     }
 
-    public function dataProviderForTestRank(): array
+    public static function dataProviderForTestRank(): array
     {
         return [
             ['pending', false],
···
         ];
     }
 
-    public function rankWithOpenIssueDataProvider()
+    public static function rankWithOpenIssueDataProvider()
     {
         return [
             ['problem'],

tests/Models/ChangelogEntryTest.php

···
         $this->assertTrue(ChangelogEntry::isPrivate($data));
     }
 
-    public function dataForPublicMessageHtmlVisibility()
+    public static function dataForPublicMessageHtmlVisibility()
     {
         return [
             ['Hidden', null],

tests/Models/Chat/ChannelTest.php

···
         $this->assertEmpty($memoized);
     }
 
-    public function channelCanMessageModeratedChannelDataProvider()
+    public static function channelCanMessageModeratedChannelDataProvider()
     {
         return [
             [null, false],
···
         ];
     }
 
-    public function channelCanMessageWhenBlockedDataProvider()
+    public static function channelCanMessageWhenBlockedDataProvider()
     {
         return [
             [null, false],
···
         ];
     }
 
-    public function channelWithBlockedUserVisibilityDataProvider()
+    public static function channelWithBlockedUserVisibilityDataProvider()
     {
         return [
             [null, false],
···
         ];
     }
 
-    public function leaveChannelDataProvider()
+    public static function leaveChannelDataProvider()
     {
         return [
             ['announce', true],

tests/Models/CommentTest.php

···
         $this->assertFalse($comment->fresh()->pinned);
     }
 
-    public function commentReplyOptionDataProvider()
+    public static function commentReplyOptionDataProvider()
     {
         return [
             [null, true],
···
         ];
     }
 
-    public function dataProviderForSetCommentableInvalid()
+    public static function dataProviderForSetCommentableInvalid()
     {
         return [
             [null, null],

tests/Models/ContestTest.php

···
         $this->assertSame($result, $contest->showEntryUser());
     }
 
-    public function dataProviderForTestAssertVoteRequirementPlaylistBeatmapsets(): array
+    public static function dataProviderForTestAssertVoteRequirementPlaylistBeatmapsets(): array
     {
         return [
             // when passing is required
···
         ];
     }
 
-    public function dataProviderForTestShowEntryUser(): array
+    public static function dataProviderForTestShowEntryUser(): array
     {
         return [
             [false, null, false],

tests/Models/ModelCompositePrimaryKeysTest.php

···
         $this->assertSame($cast($check[2]), $cast($item2->fresh()->$key));
     }
 
-    public function dataProviderBase()
+    public static function dataProviderBase()
     {
         // 0: class name
         // 1: base params

tests/Models/ModelTest.php

···
         $anotherCountry->refresh();
     }
 
-    public function dataProviderForDecrementInstance(): array
+    public static function dataProviderForDecrementInstance(): array
     {
         return [
             [fn () => Country::factory()->create(), true],

tests/Models/Multiplayer/RoomTest.php

···
         (new Room())->startGame($user, $params);
     }
 
-    public function startGameDurationDataProvider()
+    public static function startGameDurationDataProvider()
     {
         static $dayMinutes = 1440;
+        static::createApp();
 
         $maxDuration = config('osu.user.max_multiplayer_duration');
         $maxDurationSupporter = config('osu.user.max_multiplayer_duration_supporter');

tests/Models/OAuth/GroupPermissionTest.php

···
         $this->assertTrue(auth()->user()->$method());
     }
 
-    public function groupsDataProvider()
+    public static function groupsDataProvider()
     {
         return [
             ['admin', 'isAdmin', false],

tests/Models/OAuth/TokenTest.php

···
         Event::assertDispatched(UserSessionEvent::class, fn (UserSessionEvent $event) => $event->action === 'logout');
     }
 
-    public function authCodeChatWriteRequiresBotGroupDataProvider()
+    public static function authCodeChatWriteRequiresBotGroupDataProvider()
     {
         return [
             [null, InvalidScopeException::class],
···
         ];
     }
 
-    public function delegationNotAllowedScopesDataProvider()
+    public static function delegationNotAllowedScopesDataProvider()
     {
         return Passport::scopes()
             ->pluck('id')
···
             ->values();
     }
 
-    public function delegationRequiredScopesDataProvider()
+    public static function delegationRequiredScopesDataProvider()
     {
         return [
             'chat.write requires delegation' => [['chat.write'], InvalidScopeException::class],
···
         ];
     }
 
-    public function delegationRequiresChatBotDataProvider()
+    public static function delegationRequiresChatBotDataProvider()
     {
         return [
             [null, InvalidScopeException::class],
···
         ];
     }
 
-    public function scopesDataProvider()
+    public static function scopesDataProvider()
     {
         return [
             'null is not a valid scope' => [null, InvalidScopeException::class],
···
         ];
     }
 
-    public function scopesClientCredentialsDataProvider()
+    public static function scopesClientCredentialsDataProvider()
     {
         return [
             'null is not a valid scope' => [null, InvalidScopeException::class],

tests/Models/Score/ModelTest.php

···
         Model::getClass($ruleset);
     }
 
-    public function dataProviderForTestGetClassInvalidRuleset(): array
+    public static function dataProviderForTestGetClassInvalidRuleset(): array
     {
         return [
             ['does'],

tests/Models/Solo/ScoreEsIndexTest.php

···
         $this->assertSame($rank, $score->userRank($params));
     }
 
-    public function dataProviderForTestUserRank(): array
+    public static function dataProviderForTestUserRank(): array
     {
         return [
             ['user', null, 4],

tests/Models/Store/OrderItemTest.php

···
         $this->assertSame($product->stock, 0);
     }
 
-    public function deleteDataProvider()
+    public static function deleteDataProvider()
     {
         return [
             ['checkout', InvariantException::class],

tests/Models/UserNotificationTest.php

···
         );
     }
 
-    public function deliveryMaskDataProvider()
+    public static function deliveryMaskDataProvider()
     {
         return [
             [0, 'mail', false],

tests/Models/UserReportTest.php

···
         $this->assertTrue(true, 'should not fail getting notification routing url');
     }
 
-    public function reportableClasses(): array
+    public static function reportableClasses(): array
     {
         $reportables = [];
 

tests/Models/UserStatistics/ModelTest.php

···
         Model::getClass($mode, $variant);
     }
 
-    public function invalidModes()
+    public static function invalidModes()
     {
         return [
             ['does', null],
···
         ];
     }
 
-    public function validModes()
+    public static function validModes()
     {
         $modes = [];
 

tests/Models/UserTest.php

···
         }
     }
 
-    public function dataProviderForAttributeTwitter(): array
+    public static function dataProviderForAttributeTwitter(): array
     {
         return [
             ['@hello', 'hello'],
···
         ];
     }
 
-    public function dataProviderValidDiscordUsername(): array
+    public static function dataProviderValidDiscordUsername(): array
     {
         return [
             ['username', true],

tests/OAuthAuthCodeRequestTest.php

···
             ->assertStatus(400);
     }
 
-    public function botClientDataProvider()
+    public static function botClientDataProvider()
     {
         return [
             'cannot request delegation with auth_code' => ['delegate', false],

tests/OAuthClientCredentialsRequestTest.php

···
             ->assertStatus($status);
     }
 
-    public function botRequestingScopeDataProvider()
+    public static function botRequestingScopeDataProvider()
     {
         return [
             '* cannot be requested' => ['*', 400],
···
         ];
     }
 
-    public function nonBotRequestingScopeDataProvider()
+    public static function nonBotRequestingScopeDataProvider()
     {
         return [
             '* cannot be requested' => ['*', 400],

tests/Providers/AuthServiceProviderTest.php

···
         }
     }
 
-    public function oauthRoutesRegisteredDataProvider()
+    public static function oauthRoutesRegisteredDataProvider()
     {
         return [
             ['oauth/authorize', 'GET', AuthorizationController::class.'@authorize'],

tests/TestCase.php

···
 
     public static function withDbAccess(callable $callback): void
     {
-        $db = (new static())->createApplication()->make('db');
+        $db = static::createApp()->make('db');
 
         $callback();
 
         static::resetAppDb($db);
+    }
+
+    protected static function fileList($path, $suffix)
+    {
+        return array_map(
+            fn ($file) => [basename($file, $suffix), $path],
+            glob("{$path}/*{$suffix}"),
+        );
     }
 
     protected static function reindexScores()
···
 
     protected array $expectedCountsCallbacks = [];
 
-    public function regularOAuthScopesDataProvider()
+    public static function regularOAuthScopesDataProvider()
     {
         $data = [];
 
···
             'expected' => $callback() + $change,
             'message' => $message,
         ];
-    }
-
-    protected function fileList($path, $suffix)
-    {
-        return array_map(function ($file) use ($path, $suffix) {
-            return [basename($file, $suffix), $path];
-        }, glob("{$path}/*{$suffix}"));
     }
 
     protected function inReceivers(Model $model, NewPrivateNotificationEvent|BroadcastNotificationBase $obj): bool

tests/Transformers/BeatmapDiscussionPostTransformerTest.php

···
         }
     }
 
-    public function groupsDataProvider()
+    public static function groupsDataProvider()
     {
         return [
             ['admin', true],

tests/Transformers/BeatmapDiscussionTransformerTest.php

···
         }
     }
 
-    public function groupsDataProvider()
+    public static function groupsDataProvider()
     {
         return [
             ['admin', true],

tests/Transformers/BeatmapTransformerTest.php

···
         }
     }
 
-    public function groupsDataProvider()
+    public static function groupsDataProvider()
     {
         return [
             ['admin', true],

tests/Transformers/BeatmapsetCompactTransformerTest.php

···
         $this->assertArrayHasKey($property, $json);
     }
 
-    public function propertyPermissionsDataProvider()
+    public static function propertyPermissionsDataProvider()
     {
         $data = [];
         $transformer = new BeatmapsetCompactTransformer();

tests/Transformers/BeatmapsetDescriptionTransformerTest.php

···
         $this->assertArrayNotHasKey('bbcode', $json);
     }
 
-    public function groupsDataProvider()
+    public static function groupsDataProvider()
     {
         return [
             ['admin', true],

tests/Transformers/BeatmapsetEventTransformerTest.php

···
         }
     }
 
-    public function dataProvider()
+    public static function dataProvider()
     {
         // one event type of each priviledge type.
         return [

tests/Transformers/BeatmapsetTransformerTest.php

···
         }
     }
 
-    public function groupsDataProvider()
+    public static function groupsDataProvider()
     {
         return [
             ['admin', true],

tests/Transformers/CommentTransformerTest.php

···
         }
     }
 
-    public function groupsDataProvider()
+    public static function groupsDataProvider()
     {
         return [
             ['admin', true],

tests/Transformers/DeclaredPermissionsTest.php

···
         $this->assertTrue(method_exists(app('OsuAuthorize'), "check{$privilege}"), "{$class} uses check{$privilege} but is not implemented.");
     }
 
-    public function transformerClassesDataProvider()
+    public static function transformerClassesDataProvider()
     {
         return array_map(
             function ($class) {
···
         );
     }
 
-    public function privilegeDataProvider()
+    public static function privilegeDataProvider()
     {
         $data = [];
 

tests/Transformers/OAuth/ClientTransformerTest.php

···
         $this->assertArrayNotHasKey('secret', $json);
     }
 
-    public function groupsDataProvider()
+    public static function groupsDataProvider()
     {
         return [
             ['admin'],

tests/Transformers/PollOptionTransformerTest.php

···
      * - Authenticated user's group identifier
      * - Whether vote count should be visible
      */
-    public function voteCountPermissionsDataProvider(): array
+    public static function voteCountPermissionsDataProvider(): array
     {
         return [
             [true,  true,  true,  'admin', true],

tests/Transformers/UserCompactTransformerTest.php

···
         $this->assertArrayHasKey($property, $json);
     }
 
-    public function groupsDataProvider()
+    public static function groupsDataProvider()
     {
         return [
             ['admin', true],
···
         ];
     }
 
-    public function propertyPermissionsDataProvider()
+    public static function propertyPermissionsDataProvider()
     {
         $data = [];
         $transformer = new UserTransformer();

tests/ZalgoTest.php

···
         ];
     }
 
-    public function zalgoExamples()
+    public static function zalgoExamples()
     {
         return [
             ['testing', 0],