Rename pact to driver

phpstan.neon

@@ -1,4 +1,4 @@
 parameters:
     excludePaths:
-        - src/PhpPact/Consumer/Model/AbstractPact.php
-        - src/PhpPact/Consumer/Model/Pact.php
+        - src/PhpPact/Consumer/Driver/AbstractDriver.php
+        - src/PhpPact/Consumer/Driver/InteractionDriver.php

src/PhpPact/Consumer/Model/AbstractPact.php → src/PhpPact/Consumer/Driver/AbstractDriver.php

@@ -1,39 +1,46 @@
 <?php
 
-namespace PhpPact\Consumer\Model;
+namespace PhpPact\Consumer\Driver;
 
 use FFI;
 use PhpPact\Standalone\Installer\Model\Scripts;
 use PhpPact\Standalone\PactConfigInterface;
 use PhpPact\Consumer\Exception\PactFileNotWroteException;
 use PhpPact\Consumer\Exception\InteractionBodyNotAddedException;
+use PhpPact\Consumer\Model\ProviderState;
 
-/**
- * Class AbstractPact.
- */
-abstract class AbstractPact
+abstract class AbstractDriver implements DriverInterface
 {
     protected FFI $ffi;
-    protected int $id;
+    protected int $pactId;
+    protected int $interactionId;
 
     public function __construct(protected PactConfigInterface $config)
     {
+        $this->ffi = FFI::cdef(\file_get_contents(Scripts::getHeader()), Scripts::getLibrary());
         $this
-            ->createFfi()
+            ->initWithLogLevel()
             ->newPact()
             ->withSpecification();
     }
 
-    private function createFfi(): self
+    private function newPact(): self
     {
-        $this->ffi = FFI::cdef(\file_get_contents(Scripts::getHeader()), Scripts::getLibrary());
+        $this->pactId = $this->ffi->pactffi_new_pact($this->config->getConsumer(), $this->config->getProvider());
 
         return $this;
     }
 
-    private function newPact(): self
+    protected function newInteraction(string $description): self
+    {
+        $this->interactionId = $this->ffi->pactffi_new_interaction($this->pactId, $description);
+
+        return $this;
+    }
+
+    private function withSpecification(): self
     {
-        $this->id = $this->ffi->pactffi_new_pact($this->config->getConsumer(), $this->config->getProvider());
+        $this->ffi->pactffi_with_specification($this->pactId, $this->getSpecification());
 
         return $this;
     }
@@ -58,27 +65,15 @@ protected function getSpecification(): int
         return $specification;
     }
 
-    private function withSpecification(): self
-    {
-        $this->ffi->pactffi_with_specification($this->id, $this->getSpecification());
-
-        return $this;
-    }
-
-    protected function newInteraction(?string $description): int
-    {
-        return $this->ffi->pactffi_new_interaction($this->id, $description);
-    }
-
     protected function cleanUp(): void
     {
-        $this->ffi->pactffi_free_pact_handle($this->id);
+        $this->ffi->pactffi_free_pact_handle($this->pactId);
     }
 
     protected function writePact(): void
     {
         $error = $this->ffi->pactffi_pact_handle_write_file(
-            $this->id,
+            $this->pactId,
             $this->config->getPactDir(),
             $this->config->getPactFileWriteMode() === PactConfigInterface::MODE_OVERWRITE
         );
@@ -87,14 +82,42 @@ protected function writePact(): void
         }
     }
 
-    protected function withBody(int $interaction, int $part, ?string $contentType = null, ?string $body = null): void
+    protected function withBody(int $part, ?string $contentType = null, ?string $body = null): void
     {
         if (is_null($body)) {
             return;
         }
-        $success = $this->ffi->pactffi_with_body($interaction, $part, $contentType, $body);
+        $success = $this->ffi->pactffi_with_body($this->interactionId, $part, $contentType, $body);
         if (!$success) {
             throw new InteractionBodyNotAddedException();
         }
     }
+
+    private function initWithLogLevel(): self
+    {
+        $logLevel = $this->config->getLogLevel();
+        if ($logLevel) {
+            $this->ffi->pactffi_init_with_log_level($logLevel);
+        }
+
+        return $this;
+    }
+
+    /**
+     * @var array<ProviderState> $providerStates
+     */
+    protected function setProviderStates(array $providerStates): void
+    {
+        foreach ($providerStates as $providerState) {
+            $this->ffi->pactffi_given($this->interactionId, $providerState->getName());
+            foreach ($providerState->getParams() as $key => $value) {
+                $this->ffi->pactffi_given_with_param($this->interactionId, $providerState->getName(), $key, $value);
+            }
+        }
+    }
+
+    protected function setDescription(string $description): void
+    {
+        $this->ffi->pactffi_upon_receiving($this->interactionId, $description);
+    }
 }

src/PhpPact/Consumer/Driver/DriverInterface.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace PhpPact\Consumer\Driver;
+
+interface DriverInterface
+{
+}

src/PhpPact/Consumer/Driver/HasMockServerTrait.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace PhpPact\Consumer\Driver;
+
+use FFI;
+use PhpPact\Consumer\Exception\MockServerNotStartedException;
+use PhpPact\Standalone\MockService\MockServerConfigInterface;
+
+trait HasMockServerTrait
+{
+    protected function createMockServer(): void
+    {
+        $port = $this->ffi->pactffi_create_mock_server_for_transport(
+            $this->pactId,
+            $this->getMockServerConfig()->getHost(),
+            $this->getMockServerConfig()->getPort(),
+            $this->getMockServerTransport(),
+            null
+        );
+
+        if ($port < 0) {
+            throw new MockServerNotStartedException($port);
+        }
+        $this->getMockServerConfig()->setPort($port);
+    }
+
+    protected function mockServerMatched(): bool
+    {
+        $matched = $this->ffi->pactffi_mock_server_matched($this->getMockServerConfig()->getPort());
+
+        try {
+            if ($matched) {
+                $this->writePact();
+            }
+        } finally {
+            $this->cleanUp();
+        }
+
+        return $matched;
+    }
+
+    protected function cleanUpMockServer(): void
+    {
+        $this->ffi->pactffi_cleanup_mock_server($this->getMockServerConfig()->getPort());
+    }
+
+    abstract protected function getMockServerTransport(): string;
+
+    abstract protected function getMockServerConfig(): MockServerConfigInterface;
+}

src/PhpPact/Consumer/Driver/InteractionDriver.php

@@ -0,0 +1,103 @@
+<?php
+
+namespace PhpPact\Consumer\Driver;
+
+use PhpPact\Consumer\Model\Interaction;
+use PhpPact\Standalone\MockService\MockServerConfigInterface;
+
+class InteractionDriver extends AbstractDriver implements InteractionDriverInterface
+{
+    use HasMockServerTrait;
+
+    public function __construct(MockServerConfigInterface $config)
+    {
+        parent::__construct($config);
+    }
+
+    protected function getMockServerTransport(): string
+    {
+        return $this->config->isSecure() ? 'https' : 'http';
+    }
+
+    protected function getMockServerConfig(): MockServerConfigInterface
+    {
+        return $this->config;
+    }
+
+    public function verifyInteractions(): bool
+    {
+        return $this->mockServerMatched();
+    }
+
+    protected function cleanUp(): void
+    {
+        $this->cleanUpMockServer();
+        parent::cleanUp();
+    }
+
+    public function registerInteraction(Interaction $interaction): bool
+    {
+        $this
+            ->newInteraction($interaction->getDescription())
+            ->given($interaction)
+            ->uponReceiving($interaction)
+            ->with($interaction)
+            ->willRespondWith($interaction)
+            ->createMockServer();
+
+        return true;
+    }
+
+    private function given(Interaction $interaction): self
+    {
+        $this->setProviderStates($interaction->getProviderStates());
+
+        return $this;
+    }
+
+    private function uponReceiving(Interaction $interaction): self
+    {
+        $this->setDescription($interaction->getDescription());
+
+        return $this;
+    }
+
+    private function with(Interaction $interaction): self
+    {
+        $request = $interaction->getRequest();
+        $this->ffi->pactffi_with_request($this->interactionId, $request->getMethod(), $request->getPath());
+        $this->withHeaders($this->ffi->InteractionPart_Request, $request->getHeaders());
+        $this->withQuery($request->getQuery());
+        $this->withBody($this->ffi->InteractionPart_Request, null, $request->getBody());
+
+        return $this;
+    }
+
+    private function willRespondWith(Interaction $interaction): self
+    {
+        $response = $interaction->getResponse();
+        $this->ffi->pactffi_response_status($this->interactionId, $response->getStatus());
+        $this->withHeaders($this->ffi->InteractionPart_Response, $response->getHeaders());
+        $this->withBody($this->ffi->InteractionPart_Response, null, $response->getBody());
+
+        return $this;
+    }
+
+    private function withHeaders(int $part, array $headers): void
+    {
+        foreach ($headers as $header => $values) {
+            foreach (array_values($values) as $index => $value) {
+                $this->ffi->pactffi_with_header_v2($this->interactionId, $part, (string) $header, (int) $index, (string) $value);
+            }
+        }
+    }
+
+    private function withQuery(array $query): void
+    {
+        foreach ($query as $key => $values) {
+            foreach (array_values($values) as $index => $value) {
+                $this->ffi->pactffi_with_query_parameter_v2($this->interactionId, (string) $key, (int) $index, (string) $value);
+            }
+        }
+    }
+}

src/PhpPact/Consumer/Driver/InteractionDriverInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace PhpPact\Consumer\Driver;
+
+use PhpPact\Consumer\Model\Interaction;
+
+interface InteractionDriverInterface extends DriverInterface
+{
+    public function verifyInteractions(): bool;
+
+    public function registerInteraction(Interaction $interaction): bool;
+}

src/PhpPact/Consumer/InteractionBuilder.php

@@ -2,9 +2,10 @@
 
 namespace PhpPact\Consumer;
 
+use PhpPact\Consumer\Driver\InteractionDriver;
+use PhpPact\Consumer\Driver\InteractionDriverInterface;
 use PhpPact\Consumer\Model\ConsumerRequest;
 use PhpPact\Consumer\Model\Interaction;
-use PhpPact\Consumer\Model\Pact;
 use PhpPact\Consumer\Model\ProviderResponse;
 use PhpPact\Standalone\MockService\MockServerConfigInterface;
 
@@ -17,8 +18,8 @@ class InteractionBuilder implements BuilderInterface
     /** @var Interaction */
     protected Interaction $interaction;
 
-    /** @var Pact */
-    protected Pact $pact;
+    /** @var InteractionDriverInterface */
+    protected InteractionDriverInterface $driver;
 
     /**
      * InteractionBuilder constructor.
@@ -28,7 +29,7 @@ class InteractionBuilder implements BuilderInterface
     public function __construct(MockServerConfigInterface $config)
     {
         $this->interaction           = new Interaction();
-        $this->pact                  = new Pact($config);
+        $this->driver                = new InteractionDriver($config);
     }
 
     /**
@@ -78,14 +79,14 @@ public function willRespondWith(ProviderResponse $response): bool
     {
         $this->interaction->setResponse($response);
 
-        return $this->pact->registerInteraction($this->interaction);
+        return $this->driver->registerInteraction($this->interaction);
     }
 
     /**
      * {@inheritdoc}
      */
     public function verify(): bool
     {
-        return $this->pact->verifyInteractions();
+        return $this->driver->verifyInteractions();
     }
 }