自动化测试

在 Hyperf 里测试默认通过 phpunit 来实现，但由于 Hyperf 是一个协程框架，所以默认的 phpunit 并不能很好的工作，因此我们提供了一个 co-phpunit 脚本来进行适配，您可直接调用脚本或者使用对应的 composer 命令来运行。自动化测试没有特定的组件，但是在 Hyperf 提供的骨架包里都会有对应实现。

  1. composer require hyperf/testing
  1. "scripts": {
  2.     "test": "./test/co-phpunit -c phpunit.xml --colors=always"
  3. },

Bootstrap

Hyperf 提供了默认的 bootstrap.php 文件，它让用户在运行单元测试时，扫描并加载对应的库到内存里。

  1. <?php
  3. declare(strict_types=1);
  5. error_reporting(E_ALL);
  7. ! defined('BASE_PATH') && define('BASE_PATH', dirname(__DIR__, 1));
  9. \Swoole\Runtime::enableCoroutine(true);
  11. require BASE_PATH . '/vendor/autoload.php';
  13. require BASE_PATH . '/config/container.php';

当用户修改的代码需要重新生成代理类时，需要主动运行一下脚本。因为你单元测试运行时，并不会重置代理类。

  1. # 重新生成代理类
  2. vendor/bin/init-proxy.sh
  3. # 运行单元测试
  4. composer test

模拟 HTTP 请求

在开发接口时，我们通常需要一段自动化测试脚本来保证我们提供的接口按预期在运行，Hyperf 框架下提供了 Hyperf\Testing\Client 类，可以让您在不启动 Server 的情况下，模拟 HTTP 服务的请求：

  1. <?php
  2. use Hyperf\Testing\Client;
  4. $client = make(Client::class);
  6. $result = $client->get('/');

因为 Hyperf 支持多端口配置，除了验证默认的端口接口外，如果验证其他端口的接口呢？

  1. <?php
  3. use Hyperf\Testing\Client;
  5. $client = make(Client::class,['server' => 'adminHttp']);
  7. $result = $client->json('/user/0',[
  8.     'nickname' => 'Hyperf'
  9. ]);

示例

让我们写个小 DEMO 来测试一下。

  1. <?php
  3. declare(strict_types=1);
  5. namespace HyperfTest\Cases;
  7. use Hyperf\Testing\Client;
  8. use PHPUnit\Framework\TestCase;
  10. /**
  11.  * @internal
  12.  * @coversNothing
  13.  */
  14. class ExampleTest extends TestCase
  15. {
  16.     /**
  17.      * @var Client
  18.      */
  19.     protected $client;
  21.     public function __construct($name = null, array $data = [], $dataName = '')
  22.     {
  23.         parent::__construct($name, $data, $dataName);
  24.         $this->client = make(Client::class);
  25.     }
  27.     public function testExample()
  28.     {
  29.         $this->assertTrue(true);
  31.         $res = $this->client->get('/');
  33.         $this->assertSame(0, $res['code']);
  34.         $this->assertSame('Hello Hyperf.', $res['data']['message']);
  35.         $this->assertSame('GET', $res['data']['method']);
  36.         $this->assertSame('Hyperf', $res['data']['user']);
  38.         $res = $this->client->get('/', ['user' => 'developer']);
  40.         $this->assertSame(0, $res['code']);
  41.         $this->assertSame('developer', $res['data']['user']);
  43.         $res = $this->client->post('/', [
  44.             'user' => 'developer',
  45.         ]);
  46.         $this->assertSame('Hello Hyperf.', $res['data']['message']);
  47.         $this->assertSame('POST', $res['data']['method']);
  48.         $this->assertSame('developer', $res['data']['user']);
  50.         $res = $this->client->json('/', [
  51.             'user' => 'developer',
  52.         ]);
  53.         $this->assertSame('Hello Hyperf.', $res['data']['message']);
  54.         $this->assertSame('POST', $res['data']['method']);
  55.         $this->assertSame('developer', $res['data']['user']);
  57.         $res = $this->client->file('/', ['name' => 'file', 'file' => BASE_PATH . '/README.md']);
  59.         $this->assertSame('Hello Hyperf.', $res['data']['message']);
  60.         $this->assertSame('POST', $res['data']['method']);
  61.         $this->assertSame('README.md', $res['data']['file']);
  62.     }
  63. }

调试代码

在 FPM 场景下，我们通常改完代码，然后打开浏览器访问对应接口，所以我们通常会需要两个函数 dd 和 dump，但 Hyperf 跑在 CLI 模式下，就算提供了这两个函数，也需要在 CLI 中重启 Server，然后再到浏览器中调用对应接口查看结果。这样其实并没有简化流程，反而更麻烦了。

接下来，我来介绍如何通过配合 testing，来快速调试代码，顺便完成单元测试。

假设我们在 UserDao 中实现了一个查询用户信息的函数

  1. namespace App\Service\Dao;
  3. use App\Constants\ErrorCode;
  4. use App\Exception\BusinessException;
  5. use App\Model\User;
  7. class UserDao extends Dao
  8. {
  9.     /**
  10.      * @param $id
  11.      * @param bool $throw
  12.      * @return
  13.      */
  14.     public function first($id, $throw = true)
  15.     {
  16.         $model = User::query()->find($id);
  17.         if ($throw && empty($model)) {
  18.             throw new BusinessException(ErrorCode::USRE_NOT_EXIST);
  19.         }
  20.         return $model;
  21.     }
  22. }

那我们编写对应的单元测试

  1. namespace HyperfTest\Cases;
  3. use HyperfTest\HttpTestCase;
  4. use App\Service\Dao\UserDao;
  5. /**
  6.  * @internal
  7.  * @coversNothing
  8.  */
  9. class UserTest extends HttpTestCase
  10. {
  11.     public function testUserDaoFirst()
  12.     {
  13.         $model = \Hyperf\Utils\ApplicationContext::getContainer()->get(UserDao::class)->first(1);
  15.         var_dump($model);
  17.         $this->assertSame(1, $model->id);
  18.     }
  19. }

然后执行我们的单测

  1. composer test -- --filter=testUserDaoFirst

测试替身

Gerard Meszaros 在 Meszaros2007 中介绍了测试替身的概念：

有时候对 被测系统(SUT) 进行测试是很困难的，因为它依赖于其他无法在测试环境中使用的组件。这有可能是因为这些组件不可用，它们不会返回测试所需要的结果，或者执行它们会有不良副作用。在其他情况下，我们的测试策略要求对被测系统的内部行为有更多控制或更多可见性。

如果在编写测试时无法使用（或选择不使用）实际的依赖组件(DOC)，可以用测试替身来代替。测试替身不需要和真正的依赖组件有完全一样的的行为方式；他只需要提供和真正的组件同样的 API 即可，这样被测系统就会以为它是真正的组件！

下面展示分别通过构造函数注入依赖、通过 @Inject 注释注入依赖的测试替身

构造函数注入依赖的测试替身

  1. <?php
  3. namespace App\Logic;
  5. use App\Api\DemoApi;
  7. class DemoLogic
  8. {
  9.     /**
  10.      * @var DemoApi $demoApi
  11.      */
  12.     private $demoApi;
  14.     public function __construct(DemoApi $demoApi)
  15.     {
  16.        $this->demoApi = $demoApi;
  17.     }
  19.     public function test()
  20.     {
  21.         $result = $this->demoApi->test();
  23.         return $result;
  24.     }
  25. }
  1. <?php
  3. namespace App\Api;
  5. class DemoApi
  6. {
  7.     public function test()
  8.     {
  9.         return [
  10.             'status' => 1
  11.         ];
  12.     }
  13. }
  1. <?php
  3. namespace HyperfTest\Cases;
  5. use App\Api\DemoApi;
  6. use App\Logic\DemoLogic;
  7. use Hyperf\Di\Container;
  8. use HyperfTest\HttpTestCase;
  9. use Mockery;
  11. class DemoLogicTest extends HttpTestCase
  12. {
  13.     public function tearDown()
  14.     {
  15.         Mockery::close();
  16.     }
  18.     public function testIndex()
  19.     {
  20.         $res = $this->getContainer()->get(DemoLogic::class)->test();
  22.         $this->assertEquals(1, $res['status']);
  23.     }
  25.     /**
  26.      * @return Container
  27.      */
  28.     protected function getContainer()
  29.     {
  30.         $container = Mockery::mock(Container::class);
  32.         $apiStub = $this->createMock(DemoApi::class);
  34.         $apiStub->method('test')->willReturn([
  35.             'status' => 1,
  36.         ]);
  38.         $container->shouldReceive('get')->with(DemoLogic::class)->andReturn(new DemoLogic($apiStub));
  40.         return $container;
  41.     }
  42. }

通过 Inject 注释注入依赖的测试替身

  1. <?php
  3. namespace App\Logic;
  5. use App\Api\DemoApi;
  6. use Hyperf\Di\Annotation\Inject;
  8. class DemoLogic
  9. {
  10.     /**
  11.      * @var DemoApi $demoApi
  12.      * @Inject()
  13.      */
  14.     private $demoApi;
  16.     public function test()
  17.     {
  18.         $result = $this->demoApi->test();
  20.         return $result;
  21.     }
  22. }
  1. <?php
  3. namespace App\Api;
  5. class DemoApi
  6. {
  7.     public function test()
  8.     {
  9.         return [
  10.             'status' => 1
  11.         ];
  12.     }
  13. }
  1. <?php
  3. namespace HyperfTest\Cases;
  5. use App\Api\DemoApi;
  6. use App\Logic\DemoLogic;
  7. use Hyperf\Di\Container;
  8. use Hyperf\Utils\ApplicationContext;
  9. use HyperfTest\HttpTestCase;
  10. use Mockery;
  12. class DemoLogicTest extends HttpTestCase
  13. {
  14.     public function tearDown()
  15.     {
  16.         Mockery::close();
  17.     }
  19.     public function testIndex()
  20.     {
  21.         $this->getContainer();
  23.         $res = $this->getContainer()->get(DemoLogic::class)->test();
  25.         $this->assertEquals(11, $res['status']);
  26.     }
  28.     /**
  29.      * @return Container
  30.      */
  31.     protected function getContainer()
  32.     {
  33.         $container = ApplicationContext::getContainer();
  35.         $apiStub = $this->createMock(DemoApi::class);
  37.         $apiStub->method('test')->willReturn([
  38.             'status' => 11
  39.         ]);
  41.         $container->getDefinitionSource()->addDefinition(DemoApi::class, function () use ($apiStub) {
  42.             return $apiStub;
  43.         });
  45.         return $container;
  46.     }
  47. }