PHPUnit does not support direct mock global functions, but can be implemented through namespace tricks or third-party libraries. 1. Use namespaces to redefine the function of the same name in the test file to overwrite the original function; 2. Use tools such as Brain Monkey or FunctionMocker to simplify the mock process; 3. The best practice is to encapsulate global functions into the class and manage it through dependency injection to improve code testability and maintainability.

In PHPUnit tests, if you need to mock a global function (such as time() , rand() , or global functions you define yourself), you will find that PHPUnit is not directly supported by native. This is because PHP's global functions cannot be easily replaced like class methods. But you can achieve this with some tips.

Use Namespace to Mock global functions

The most common and recommended way is to put the function you want to mock in a namespace and call it in your code using the "alias" technique. This can be replaced with the mock function in the test.

The steps are as follows:

• In your class or function, use use function to introduce the function you want to mock and specify an alias.
• During testing, create a temporary namespace that is the same as the original namespace and define the mock function in it.
• This way, the mock function you defined will be used first when the test is run.

 // File: App/Helper.php
namespace App;

function time() {
    return \time();
}

 // File: App/MyClass.php
namespace App;

class MyClass {
    public function getCurrentTime() {
        return time(); // The actual call is App\time()
    }
}

 // File: tests/MyClassTest.php
namespace App;

use PHPUnit\Framework\TestCase;

class MyClassTest extends TestCase {
    public function testGetCurrentTime() {
        // Define a mock function function time() {
            return 1234567890;
        }

        $myClass = new MyClass();
        $this->assertEquals(1234567890, $myClass->getCurrentTime());
    }
}

Note: In the above example, PHPUnit will look for the time() function in App namespace, and we redefined it in the test file to implement mock.

Use the tool library to simplify operations

If you don't want to manually manage namespaces and function rewrites, consider using ready-made libraries to assist:

• Brain Monkey
  This is a WordPress-based Mockery extension, but it can also be used in normal PHP projects. It can easily mock global functions, actions, and filters.

• FunctionMocker (for old projects)
  This library allows you to dynamically rewrite function behavior at runtime, suitable for some old projects or code that is inconvenient to refactor.

For example, use Brain Monkey:

 use Brain\Monkey;
use PHPUnit\Framework\TestCase;

class MyClassTest extends TestCase {
    public function setUp(): void {
        parent::setUp();
        Monkey\setUp();
    }

    public function tearDown(): void {
        Monkey\tearDown();
        parent::tearDown();
    }

    public function testTimeIsMocked() {
        Monkey\Functions\when('time')->justReturn(1234567890);

        $this->assertEquals(1234567890, time());
    }
}

This method is more intuitive and easier to maintain, and is suitable for projects with requirements for readability and development efficiency.

Avoid global function dependencies (best practice)

Although it is possible to mock global functions in various ways, from a design perspective, over-reliance on global functions makes the code difficult to test and maintain. The recommended approach is:

• Encapsulate global functions into classes for easy injection and replacement
• Use dependency injection mechanism to make external behavior controllable
• If you just want to simplify the call, you can use the facade pattern instead of directly calling the global function

Doing so will not only improve the testability of the code, but also improve the clarity of the overall structure.

Basically that's it. PHPUnit itself does not support mock global functions, but we can bypass the restrictions through namespace tricks or third-party libraries. If possible, try to avoid relying directly on global functions, so that the code written is easier to maintain and test.

The above is the detailed content of How to mock a global function for PHPUnit testing?. For more information, please follow other related articles on the PHP Chinese website!