Unit tests in Laravel are used for testing isolated pieces of code like helper functions, business logic, and calculations without hitting the database or making HTTP requests. To get started, Laravel provides a built-in tests/Unit directory and supports PHPUnit natively. 1. Use php artisan make:test ExampleTest --unit to create a unit test that extends PHPUnit\Framework\TestCase. 2. Write self-contained test methods with clear assertions such as $this->assertEquals() to validate expected outcomes. 3. Mock dependencies using PHPUnit’s mocking features or Laravel’s facade mocking to isolate logic from external systems. 4. Keep tests fast, focused, and descriptive by naming them clearly and avoiding shared state. Unit testing in Laravel simplifies verifying core logic and improves maintainability when done consistently and thoughtfully.

Writing unit tests in Laravel isn’t complicated once you get the basics down. The framework comes with built-in support for PHPUnit, which makes it easy to test your application logic without relying on external services or the entire framework booting up.

Understanding What Unit Tests Are For

Unit tests focus on testing small, isolated pieces of code—like a single method or function—to ensure they behave as expected. This is different from feature tests, which simulate full user interactions.

In Laravel, unit tests are best used for:

• Testing helper functions or utility classes
• Validating business logic inside services or value objects
• Ensuring calculations or transformations work correctly

You're not hitting the database or making HTTP requests here. That’s what feature or integration tests are for.

Setting Up Your First Unit Test

Laravel includes a tests/Unit directory by default. You can create a new unit test using Artisan:

php artisan make:test ExampleTest --unit

This creates a test file under tests/Unit. You’ll notice it doesn’t extend TestCase like feature tests do—it extends PHPUnit\Framework\TestCase directly. That means faster execution since it doesn't load the whole Laravel framework.

Here’s a basic example:

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;

class ExampleTest extends TestCase
{
    public function test_basic_example()
    {
        $this->assertTrue(true);
    }
}

You can start adding methods that test individual behaviors. Each test should be self-contained and ideally fast.

Writing Meaningful Assertions

The key to good unit tests is writing clear assertions that reflect expected outcomes. Don’t just check if something runs—you want to verify behavior.

For example, say you have a simple class that calculates discounts:

class DiscountCalculator
{
    public function applyDiscount(float $price, float $discountPercentage): float
    {
        return $price - ($price * $discountPercentage / 100);
    }
}

Your test might look like this:

public function test_discount_is_applied_correctly()
{
    $calculator = new DiscountCalculator();
    $result = $calculator->applyDiscount(100, 20);

    $this->assertEquals(80, $result);
}

Some tips:

• Use descriptive test names so it's clear what's being tested
• Keep tests focused—one assertion per test when possible
• Avoid shared state between test methods
• Use data providers if you need to test multiple inputs

Mocking Dependencies When Needed

Since unit tests are supposed to be isolated, you often need to mock dependencies instead of using real instances.

Laravel provides convenient helpers for mocking, especially when working with facades. For example, if your code uses Cache::get, you can mock it like this:

Cache::shouldReceive('get')->with('key')->andReturn('value');

If you’re working with plain PHP classes and dependency injection, use PHPUnit’s mocking features:

$mock = $this->createMock(SomeDependency::class);
$mock->method('getData')->willReturn('fake-data');

$instance = new ClassUnderTest($mock);

This way, you’re testing only your code’s logic, not the actual behavior of external systems.

That's basically how unit tests work in Laravel. It's not rocket science, but it does take some practice to write clean, maintainable tests. Start small, test the core logic, and build up coverage over time.

The above is the detailed content of How do I write unit tests in Laravel?. For more information, please follow other related articles on the PHP Chinese website!