TestCase

Register an instance in the container.

Register an instance in the container.

Mock an instance of an object in the container.

Mock a partial instance of an object in the container.

Spy an instance of an object in the container.

Instruct the container to forget a previously mocked / spied instance of an object.

Register a Vite handler that returns empty strings for all assets.

Return empty asset markup.

Return an empty result for dynamic calls.

Return empty asset markup as a string.

Ignore integrity key configuration.

Ignore build directory configuration.

Ignore hot file configuration.

Ignore entry point configuration.

Ignore script tag attributes.

Ignore style tag attributes.

Ignore preload tag attributes.

Return an empty list of preloaded assets.

Return empty React refresh markup.

Return empty asset content.

Return an empty asset URL.

Define additional headers to be sent with the request.

Add a header to be sent with the request.

Remove a header from the request.

Remove headers from the request.

Add an authorization token for the request.

Add a basic authentication header to the request with the given credentials.

Remove the authorization token from the request.

Flush all the configured headers.

Define a set of server variables to be sent with the requests.

Disable middleware for the test.

Enable the given middleware for the test.

Define additional cookies to be sent with the request.

Add a cookie to be sent with the request.

Define additional cookies that will not be encrypted before sending with the request.

Add a cookie that will not be encrypted before sending with the request.

Automatically follow any redirects returned from the response.

Include cookies and authorization headers for JSON requests.

Disable automatic encryption of cookie values.

Set the referer header and previous URL session value in order to simulate a previous request.

Set the referer header and previous URL session value from a given route in order to simulate a previous request.

Set the Precognition header to "true".

Visit the given URI with a GET request.

Visit the given URI with a GET request, expecting a JSON response.

Visit the given URI with a POST request.

Visit the given URI with a POST request, expecting a JSON response.

Visit the given URI with a PUT request.

Visit the given URI with a PUT request, expecting a JSON response.

Visit the given URI with a PATCH request.

Visit the given URI with a PATCH request, expecting a JSON response.

Visit the given URI with a DELETE request.

Visit the given URI with a DELETE request, expecting a JSON response.

Visit the given URI with an OPTIONS request.

Visit the given URI with an OPTIONS request, expecting a JSON response.

Visit the given URI with a HEAD request.

Visit the given URI with a QUERY request.

Visit the given URI with a QUERY request, expecting a JSON response.

Call the given URI with a JSON request.

Call the given URI and return the Response.

Each test request runs in a fresh coroutine via the Waiter to ensure coroutine-local Context isolation. RequestContext is seeded because tests bypass the HttpServer\Server adapter which normally does this in onRequest().

Turn the given URI into a fully-qualified URL.

Sync durable request Context state to the test coroutine.

Get a snapshot of durable session Context state for the completed request.

Get durable session Context keys.

Get the Context keys for the given session store.

Get durable authentication Context keys.

Transform headers array to array of $SERVER vars with HTTP* format.

Format the header name for the server array.

Extract the file uploads from the given data array.

If enabled, encrypt cookie values for request.

Prepare cookies for JSON requests.

Follow a redirect chain until a non-redirect is received.

Create the request instance used for testing from the given Symfony request.

Create the test response instance from the given response.

Dispatch a request lifecycle event if enabled.

Tests bypass the HttpServer\Server adapter, so lifecycle events must be dispatched here for Telescope and other watchers to work in test contexts.

Get the coroutine waiter for test requests.

Set the currently logged in user for the application.

Clear the currently logged in user for the application.

Set the currently logged in user for the application.

Assert that the user is authenticated.

Assert that the user is not authenticated.

Return true if the user is authenticated, false otherwise.

Assert that the user is authenticated as the given user.

Assert that the given credentials are valid.

Assert that the given credentials are invalid.

Return true if the credentials are valid, false otherwise.

Invoke an Artisan command and return a mocked pending command or exit code.

Invoke an Artisan command and return a mocked pending command.

Invoke an Artisan command and return the exit code.

Disable mocking the console output.

When using this with traits like DatabaseMigrations, call this in setUp() before parent::setUp() to ensure mock output is never bound.

Assert that a given where condition exists in the database.

Assert that a given where condition does not exist in the database.

Assert the count of table entries.

Assert that the given table or tables has no entries.

Assert the given record has been "soft deleted".

Assert the given record has not been "soft deleted".

Assert the given model exists in the database.

Assert the given model does not exist in the database.

Specify the number of database queries that should occur throughout the test.

Determine if the argument is a soft deletable model.

Cast a JSON string to a database compatible type.

Get the database connection.

Get the table name from the given model or string.

Get the table connection specified in the given model.

Get the table column name used for soft deletes.

Get the model entity from the given model or string.

Seed a given database connection.

Restore deprecation handling.

Disable deprecation handling for the test.

Set an environment variable for the current PHP process.

Unset an environment variable for the current PHP process.

Run a callback with a temporary environment variable value.

Run a callback with temporary environment variable values.

Get the class name of the first parameter of the given Closure.

Get the class names of the first parameter of the given Closure, including union types.

Get the class names / types of the parameters of the given Closure.

Get the class names / types of the return type of the given Closure.

Restore exception handling.

Only handle the given exceptions via the exception handler.

Only handle validation exceptions via the exception handler.

Disable exception handling for the test.

Create a new exception handler instance.

Report or log an exception.

Determine if the exception should be reported.

Render an exception into an HTTP response.

Render an exception to the console.

Determine if a given exception is being reported.

Create the context for an exception.

Register a callback to be called after an HTTP error response is rendered.

Assert route middleware runtime order.

Get resolved runtime middleware for a named route.

Set the session to the given array.

Set the session to the given array.

Start the session for the application.

Flush all of the current session data.

Freeze time.

Freeze time at the beginning of the current second.

Begin travelling to another time.

Travel to another time.

Travel back to the current time.

Set up the test environment.

Clean up the testing environment before the next test.

Reset static state between test executions.

Boot the testing helper traits.

Determine if the trait should be skipped when setting up the test environment.

Set up database-related testing traits.

Override this method to customize database trait initialization order, e.g. to process test attributes before migrations run.

Forget retained migration state when a selected in-memory database is missing.

Clean up the testing environment before the next test case.

Register a callback to be run after the application is refreshed.

The callbacks run before the test case's traits are set up, and again for each reloaded application.

Register a callback to be run after the application is created.

Register a callback to be run before the application is destroyed.

Execute the application's pre-destruction callbacks.

Preserve transaction manager context for the test coroutine.

RefreshDatabase and DatabaseTransactions store transaction state in Context. Since setUpTraits runs in a temporary coroutine (separate from the test method's coroutine), we must copy this state to non-coroutine context. The test coroutine restores the same transaction state explicitly; normal context copying omits it so child coroutines cannot inherit their parent's transactions.

Ensure callback is executed in coroutine.

Exceptions are captured and re-thrown outside the coroutine context so they propagate correctly to PHPUnit (e.g., for markTestSkipped).

Create a new TestView from the given view.

Render the contents of the given Blade template string.

Render the given view component.

Populate the shared view error bag with the given errors.

Specify a list of events that should be fired for the given operation.

These events will be mocked, so that handlers will not actually be executed.

Specify a list of events that should not be fired for the given operation.

These events will be mocked, so that handlers will not actually be executed.

Mock the event dispatcher so all events are silenced and collected.

Filter the given events against the fired events.

Filter the given classes against an array of dispatched classes.

Check if the given class exists in an array of dispatched classes.

Invoke the test method inside a Swoole coroutine container.

Uses PHPUnit 13's official extension point for customizing test method invocation. When coroutines are enabled and we're not already inside one, the test method runs inside Hypervel's coroutine container with full lifecycle management (context copying, setup/teardown hooks, cleanup).

Enforce PHPUnit's deadline while the test or its children are suspended.

Fail a test whose expected exception was followed by child coroutines reaching the time limit.

Determine whether tests run in a coroutine.

Determine if the test method should boot the framework.

Run trait and test setup hooks in the test coroutine.