The functional testing of the Laravel controller can be achieved through the following steps: 1. Use PHPUnit and Laravel test base classes to simulate HTTP requests and assert the response results; 2. Use actingAs() to simulate authenticating users and control the middleware's enablement status; 3. Submit form data and verify database changes during POST requests; 4. Use assertJson and other methods to verify the return structure for the JSON interface. Through these steps, the logic correctness and interface stability of the controller can be effectively ensured.

It is actually not difficult to write functional tests of Laravel controllers. The key is to understand its structure and goals. Functional testing mainly simulates user behavior, such as accessing a certain route, submitting forms, uploading files, etc., and then asserting whether the return result meets expectations. Laravel provides very convenient testing tools that allow you to quickly write clear and reliable test cases.

1. Test base classes using PHPUnit and Laravel

Laravel has built-in support for PHPUnit and provides Tests\TestCase base class to simplify controller testing. You only need to inherit this class and you can use $this->get() , $this->post() and other methods to simulate HTTP requests.

For example, suppose you have a controller method that shows the details of the article:

 public function show($id)
{
    $article = Article::findOrFail($id);
    return view('articles.show', compact('article'));
}

You can write a test like this:

 public function test_article_show_page_displays_correct_content()
{
    $article = Article::factory()->create();

    $response = $this->get("/articles/{$article->id}");

    $response->assertStatus(200);
    $response->assertSee($article->title);
}

The key point here is: first create data (you can use the model factory), then send a request, and finally make an assertion.

2. Simulate authenticated user and middleware behavior

Many controllers require users to log in before accessing. At this time, you can use actingAs() method provided by Laravel to simulate logged-in users:

 $user = User::factory()->create();
$this->actingAs($user);

$response = $this->get('/dashboard');
$response->assertStatus(200);

If you use custom middleware, such as permission control, you can turn on or off the middleware in the test to avoid interfering with the test logic. For example, set in TestCase :

 protected function setUp(): void
{
    parent::setUp();
    $this->withoutMiddleware();
}

Of course, if you want to test the behavior of the middleware itself, you should keep it and write a test specifically to verify that the middleware is in effect.

3. Test POST requests and form submissions

POST requests are usually used to process form submissions, such as creating resources. When testing such requests, in addition to checking the response status code, you should also verify that the database is updated correctly.

For example, the controller method for creating an article:

 public function store(Request $request)
{
    $validated = $request->validate([
        'title' => 'required',
        'content' => 'required'
    ]);

    Article::create($validated);

    return redirect('/articles');
}

The corresponding test might be like this:

 public function test_can_create_article_via_post_request()
{
    $user = User::factory()->create();
    $this->actingAs($user);

    $data = [
        'title' => 'Test Article',
        'content' => 'This is a test article content.',
    ];

    $response = $this->post('/articles', $data);

    $response->assertRedirect('/articles');
    $this->assertDatabaseHas('articles', $data);
}

A few points to note:

• To make sure the user is logged in (if required)
• The form field name must be consistent with the verification rules in the controller
• It is best to use assertDatabaseHas to confirm that the data is really inserted

4. Handle JSON interface testing

If you are writing APIs, the controller may return data in JSON format. At this time, you can use assertJson or assertExactJson to verify the output format.

for example:

 public function test_api_returns_json_for_articles_index()
{
    Article::factory()->count(3)->create();

    $response = $this->getJson('/api/articles');

    $response->assertStatus(200);
    $response->assertJsonCount(3, 'data');
}

If you return JSON data with a specific structure, you can also use assertJsonStructure() :

 $response->assertJsonStructure([
    'data' => [
        '*' => ['id', 'title', 'content']
    ]
]);

This method is suitable for front-end and back-end separation projects and can effectively ensure interface stability.

Basically that's it. The most important thing about writing functional tests is to have clear ideas: simulate requests → verify responses → check for side effects (such as database changes). Laravel provides a very complete tool chain. As long as you master the basic routines, you can quickly write reliable test cases.

The above is the detailed content of Writing Feature Tests for Laravel Controllers?. For more information, please follow other related articles on the PHP Chinese website!