How to use PHPUnit and Mockery for unit testing?

In PHP project development, unit testing is a very important task. PHPUnit and Mockery are two very popular PHP unit testing frameworks. PHPUnit is a widely used unit testing tool, while Mockery is an object simulation tool that focuses on providing a unified and concise API to create and manage object mocks.

By using PHPUnit and Mockery, developers can quickly and efficiently perform unit testing to ensure the correctness and stability of their code base. This article will introduce how to use PHPUnit and Mockery for unit testing, allowing you to conduct such testing conveniently.

1. First, we need to install PHPUnit and Mockery. Here, we will use Composer to quickly install these two tools. In the project directory where you want to use PHPUnit and Mockery, run the following command:

composer require --dev phpunit/phpunit mockery/mockery

This command will install PHPUnit and Mockery as development dependencies in your project to facilitate running unit tests.

2. Next, we will demonstrate how to use PHPUnit to create a test case. Suppose you are writing a class called "Calculator" that handles basic arithmetic operations. We will create a test case on this class and check if it is able to perform the addition operation correctly.

In your project folder, create a file called "CalculatorTest.php" and write the following code in it:

use PHPUnitFrameworkTestCase;
use MyAppCalculator;

class CalculatorTest extends TestCase
{
    public function testAddition()
    {
        $calculator = new Calculator();
        $result = $calculator->add(2, 2);
        $this->assertEquals(4, $result);
    }
}

In this test case, we First instantiate a Calculator object, and then use the add() method to perform the addition operation. Finally, we use the assertEquals() method to verify whether the result of the operation is the value we expected.

3. Next, let’s take a look at how to use Mockery to simulate an object. In many cases, we do not want to use real objects when testing, but use a mock object to replace them so that the testing is more refined and efficient. Mockery makes it easy to create and use these mock objects.

Suppose we are writing a class named "UserService" to handle user-related business logic. This class depends on another class called "UserRepository" for accessing the user data store. We can use Mockery to simulate this dependency to verify that the UserService is running normally in the test.

In your project folder, create a file called "UserServiceTest.php" and write the following code in it:

use PHPUnitFrameworkTestCase;
use MyAppUserService;
use MyAppUserRepository;
use MockeryAdapterPhpunitMockeryPHPUnitIntegration;

class UserServiceTest extends TestCase
{
    use MockeryPHPUnitIntegration;

    public function testCreateUser()
    {
        $repo = Mockery::mock(UserRepository::class);
        $repo->shouldReceive('create')
             ->once()
             ->with(['name' => 'Alice']);

        $service = new UserService($repo);
        $service->createUser('Alice');
    }
}

In this test case, we use "Mockery ::mock()" function to create a mock UserRepository object. Then, through the "shouldReceive()" method, we expect that the "create()" method of this mock object will be called once, passing an array named "'Alice'" as a parameter. Finally, we instantiate a UserService object and call the "create()" method of the mock object through its "createUser()" method.

4. Finally, let’s discuss how to run test cases in PHPUnit and Mockery. Assuming we have created the above two test cases, we can use the following command to run them:

./vendor/bin/phpunit

This command will automatically find all test cases in the project and run them. If all tests pass, PHPUnit will output a message to confirm this.

If you only want to run a specific test case, you can specify the test file or test method after the command. For example, to run the testAddition() method in "CalculatorTest.php", you can execute the following command:

./vendor/bin/phpunit tests/CalculatorTest.php --filter testAddition

With these simple steps, you can use PHPUnit and Mockery for PHP unit testing. A correct and complete test suite will help ensure the quality and stability of the PHP project code base and facilitate continuous improvement and continuous development.

The above is the detailed content of How to use PHPUnit and Mockery for unit testing?. For more information, please follow other related articles on the PHP Chinese website!