Ne mouillez pas ce que vous ne possédez pas

Environ. traducteur: la règle elle-même est assez ancienne, et l'exemple donné dans l'article est, à mon avis, le plus simple. Par conséquent, l'article est plus adapté aux débutants, les personnes ayant une bonne expérience dans la rédaction de tests automatiques peuvent ne rien trouver de nouveau pour elles-mêmes. UPD. Je ne pense toujours pas que l'auteur propose d'envelopper toutes les API du framework avec lequel vous travaillez avec sa propre couche (enfin, ce serait extrêmement étrange), mais il s'agit plutôt de classes à usage général faiblement structurées / typées, comme HttpRequest de l'exemple de l'article.

Les applications Web sont souvent conçues pour gérer les requêtes HTTP. Les objets sont couramment utilisés pour encapsuler les données de demande. Selon le framework, nous pourrions avoir une interface comme

interface HttpRequest
{
    public function get(string $name): string;

    // ...
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

ou même une classe spécifique comme

class HttpRequest
{
    public function get(string $name): string
    {
        // ...
    }

    // ...
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

que nous pouvons (et devrions) utiliser pour accéder aux données de la demande.

Symfony, par exemple, a Symfony \ Component \ HttpFoundation \ Request :: get (). À titre d'exemple, nous ne nous soucierons pas du type de requête HTTP que nous traitons (GET, POST ou autre). Au lieu de cela, concentrons-nous sur les API implicites comme HttpRequest :: get () et les problèmes qu'elles posent.

, , , get() , . . get():

class SomeController
{
    public function execute(HttpRequest $request): HttpResponse
    {
        $id     = $request->get('id');
        $amount = $request->get('amount');
        $price  = $request->get('price');

        // ...
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, action- (: (eng )). , HTTP-.

HttpRequest (stub) mock- SomeController , get() , : 'id', 'amount' 'price'.

, , action- .

SomeController HttpRequest (stub) unit PHPUnit :

$request = $this->createStub(HttpRequest::class);

$request->method('get')
        ->willReturnOnConsecutiveCalls(
              '1',
              '2',
              '3',
          );

$controller = new SomeController;

$controller->execute($request);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

SomeController HttpRequest, mock-, :

$request = $this->createMock(HttpRequest::class);

$request->expects($this->exactly(3))
        ->method('get')
        ->withConsecutive(
            ['id'],
            ['amount'],
            ['price']
        )
        ->willReturnOnConsecutiveCalls(
            '1',
            '2',
            '3',
        );

$controller = new SomeController;

$controller->execute($request);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , , ( . ).

, HttpRequest::get() : «id», «amount» , , «price».

SomeController::execute(), HttpRequest::get(), . , . .

, HTTP-, API, , HTTP, get(). , , , : HttpRequest , .

« , » « , ». 2009 « - »:

« , , , , , . , , , , , ».

, , ? :

« [...] , , - , , . [...], - API [...] "

:

interface SomeRequestInterface
{
    public function getId(): string;

    public function getAmount(): string;

    public function getPrice(): string;
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , value-. .

SomeRequestInterface :

$request = $this->createStub(SomeRequestInterface::class);

$request->method('getId')
        ->willReturn(1);

$request->method('getAmount')
        ->willReturn(2);

$request->method('getPrice')
        ->willReturn(3);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, HTTP- , - HTTP- . . HTTP- . . :

class SomeRequest implements SomeRequestInterface
{
    private HttpRequest $request;

    public function __construct(HttpRequest $request)
    {
        $this->request = $request;
    }

    public function getId(): string
    {
        return $this->request->get('id');
    }

    public function getAmount(): string
    {
        return $this->request->get('amount');
    }

    public function getPrice(): string
    {
        return $this->request->get('price');
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

:

class SomeController
{
    public function execute(HttpRequest $request)
    {
        return $this->executable->execute(
            new SomeRequest($request)
        )
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

SomeController , , HTTP .

Vous devrez, bien sûr, rendre votre wrapper de requête spécifique à chaque contrôleur. Votre code a-t-il besoin d'en-têtes spécifiques? Créez une méthode pour les obtenir. Votre code a-t-il besoin d'un fichier téléchargé? Créez une méthode pour obtenir exactement cela.

Une requête HTTP complète peut contenir des en-têtes, des valeurs, peut-être des fichiers téléchargés, un corps POST, etc. Mettre en place un stub de test ou une maquette pour tout cela alors que vous ne possédez pas l'interface vous empêche de faire le travail. La définition de votre propre interface simplifie grandement la tâche.