Testing

Rewrite the default connection's database name for parallel testing.

Config-only — does not create connections or purge pools. Called early in CreatesApplication (after config is loaded, before defineEnvironment) so that custom connections derived from the default connection inherit the per-worker database name.

No-op when not running in parallel or when using in-memory SQLite.

Ensure the per-worker database exists, creating it if needed.

Called before Testbench database requirements and from database testing traits (RefreshDatabase, DatabaseMigrations, DatabaseTruncation, DatabaseTransactions) after the app is booted and connections are available. The config has already been rewritten by configureParallelDatabaseName().

No-op when not running in parallel or when using in-memory SQLite.

Determine if the database should be managed for parallel testing.

Get the per-worker test database name.

Determine if the test case uses the given trait, or the Testing trait by default.

Determine if the test case uses refresh-database testing concerns.

Cache and return traits used by test case.

Programmatically add a testing feature attribute.

Resolve PHPUnit method attributes for specific method.

Execute BeforeEach lifecycle attributes.

Execute AfterEach lifecycle attributes.

Load test fixtures and execute BeforeAll lifecycle attributes.

Execute AfterAll lifecycle attributes and clear caches.

Determine if the object is running as a PHPUnit test case.

Resolve the PHPUnit test class name.

Resolve the PHPUnit test method name.

Resolve and cache PHPUnit attributes for current test.

Define the setUp environment using callback.

Define the tearDown environment using callback.

Cache uses for test case before class runs.

Clear PHPUnit caches after class teardown.

Determine if the trait is used within testing using Pest.

Determine if the object implements Pest test runner.

Get Application's base path.

Ignore package discovery from.

Get package bootstrapper.

Get package providers.

Resolve application Console Kernel implementation.

Get application HTTP Kernel implementation using Workbench.

Get application HTTP exception handler using Workbench.

Get the cached Workbench configuration.

Get application bootstrap file path (if exists).

Determine if application is using a custom application kernels.

Determine if application is bootstrapped using Testbench's default skeleton.

Get the application's base path.

Get the base path for the application.

Ignore package discovery from.

Get package providers.

Get package bootstrappers.

Get application providers.

Override in test classes to filter the default provider list before registration. For example, to remove SessionServiceProvider.

Get the application timezone.

Override application providers.

Return a map of provider class names to replacements. Set a provider to false to remove it entirely, or to another class name to replace it.

Get application aliases.

Override application aliases.

Get package aliases.

Override application bindings.

Define environment setup.

Override in subclasses to modify config before providers boot. This is where test classes set database drivers, cache stores, etc.

Create the application instance.

Bootstraps the application manually step-by-step (like Orchestral Testbench's createApplication), rather than via kernel->bootstrap(), so defineEnvironment() can be called between RegisterProviders and BootProviders.

Create the default application implementation.

Resolve the application instance.

Resolve application resolving callback.

Resolve application facades implementation.

Resolve application bindings.

Resolve application HTTP exception handler.

Resolve application core environment.

Resolve application environment variables.

Make a relative COMPOSER_VENDOR_DIR from the application environment absolute.

Child processes such as the skeleton's artisan resolve a relative value against their own base path rather than the package root. Bootstrapper already exported an inherited value; rewriting a loaded one through the repository keeps its putenv setting and restoration.

Mask inherited framework APP_ENV for Testbench applications that opt out of loading env files.

The framework suite forces APP_ENV=testing globally via phpunit.xml.dist. Tests that disable environment loading should instead use the configuration defaults unless they explicitly provided APP_ENV or package-tester mode is enabled.

Determine if the current test explicitly configured an environment variable.

Resolve application HTTP kernel implementation.

Resolve application HTTP default middlewares.

Resolve application console kernel implementation.

Load configuration and register package providers/aliases.

Equivalent to Orchestral's resolveApplicationConfiguration(): loads config files, then sets app.providers and app.aliases in config BEFORE RegisterProviders reads them.

Resolve application aliases.

Resolve the route provider from application provider overrides.

Resolve the final application provider list.

Merges package providers, then applies overrides (replacements/removals) to produce the list RegisterProviders uses.

Run bootstrappers individually with defineEnvironment() inserted.

Equivalent to Orchestral's resolveApplicationBootstrappers().

Refresh route name lookups now and whenever the URL generator is resolved.

Route names set via fluent ->name() after RouteCollection::add() are not indexed until refreshNameLookups() rebuilds the lookup table. This method ensures names are refreshed both immediately and lazily — the after_resolving callback catches routes defined inside test methods (after boot) by firing whenever app('url') is resolved.

Resolve application rate limiting configuration.

Configure worker-specific cache paths for parallel testing.

When running under ParaTest, each worker gets a unique route cache path to prevent filesystem races. Without this, one worker's defineCacheRoutes() writes a shared cache file that causes other workers' routesAreCached() to return true, skipping route setup.

Get the current ParaTest worker token before the application exists.

This reads the raw runtime arrays because cached route setup may run before parent::setUp(), when no application or ParallelTesting service has been created yet.

Terminate and flush an application, returning any cleanup failure.

Mark the test as skipped when condition is not equivalent to true.

Mark the test as skipped when condition is equivalent to true.

Parse and execute test method attributes of a specific type.

Note: Attributes are already executed automatically via setUpTheTestEnvironmentUsingTestCase(). This method is for internal use by the testing infrastructure.

Setup database requirements.

Determine if using in-memory SQLite database connection.

Define database migrations.

Define database migrations after database refreshed.

Destroy database migrations.

Define database seeders.

Setup application routes.

Define routes setup.

Define web routes setup.

Define stash routes setup.

Define cache routes setup.

Synchronize Testbench routes.

Register cleanup for route files and route cache written by this test.

Get a route file path owned by this test instance.

Setup the test environment.

Teardown the test environment.

Define hooks to migrate the database before and after each test.

Determine whether migration paths should be registered for an upcoming migration.

Resolve Package Migrations Artisan command options.

Migrate Hypervel's default migrations.

Migrate all Hypervel migrations.

Resolve Hypervel Migrations Artisan command options.

Run and retain a migration processor for teardown.

Determine whether the active database concerns retain in-memory state.

Reset artisan commands for the application.

Reload the application instance.