<?php
/**
 * Class MockApiConsumer
 *
 * Example consumer API.  Note that if you will need to pass in the http client you want to use
 */
class MockApiConsumer
{
    /**
     * MockApiConsumer constructor.
     *
     * @param null|\PhpPact\Mocks\MockHttpClient $httpClient
     */
    public function __construct($httpClient=null)
    {
        if ($httpClient) {
            $this->setHttpClient($httpClient);
        }
    }
    /**
     * @var \PhpPact\Mocks\MockHttpClient
     */
    private $httpClient;
    /**
     * @param \PhpPact\Mocks\MockHttpClient
     */
    public function setHttpClient($httpClient)
    {
        $this->httpClient = $httpClient;
    }
    /**
     * Mock out a basic GET
     *
     * @param $uri string
     * @return mixed
     */
    public function getBasic($url)
    {
        $uri = (new \Windwalker\Uri\PsrUri($url))
            ->withPath("/");
        $httpRequest = (new \Windwalker\Http\Request\Request())
            ->withUri($uri)
            ->withAddedHeader("Content-Type", "application/json")
            ->withMethod("get");
        $response = $this->httpClient->sendRequest($httpRequest);
        return $response;
    }
}

<?php
require_once( __DIR__ . '/MockApiConsumer.php');
use PHPUnit\Framework\TestCase;
class ConsumerTest extends TestCase
{
    /**
     * @var \PhpPact\PactBuilder
     */
    protected $_build;
    const CONSUMER_NAME = "MockApiConsumer";
    const PROVIDER_NAME = "MockApiProvider";
    /**
     * Before each test, rebuild the builder
     */
    protected function setUp()
    {
        parent::setUp();
        $this->_build = new \PhpPact\PactBuilder();
        $this->_build->serviceConsumer(self::CONSUMER_NAME)
            ->hasPactWith(self::PROVIDER_NAME);
    }
    protected function tearDown()
    {
        parent::tearDown();
        unset($this->_build);
    }
    public function testGetBasic()
    {
        // build the request
        $reqHeaders = array();
        $reqHeaders["Content-Type"] = "application/json";
        $request = new \PhpPact\Mocks\MockHttpService\Models\ProviderServiceRequest(\PhpPact\Mocks\MockHttpService\Models\HttpVerb::GET, "/", $reqHeaders);
        // build the response
        $resHeaders = array();
        $resHeaders["Content-Type"] = "application/json";
        $resHeaders["AnotherHeader"] = "my-header";
        $response = new \PhpPact\Mocks\MockHttpService\Models\ProviderServiceResponse('200', $resHeaders);
        $response->setBody("{\"msg\" : \"I am the walrus\"}");
        // build up the expected results and appropriate responses
        $mockService = $this->_build->getMockService();
        $mockService->given("Basic Get Request")
            ->uponReceiving("A GET request with a base / path and a content type of json")
            ->with($request)
            ->willRespondWith($response);
        $clientUnderTest = new MockApiConsumer($mockService->getHttpClient()); // passing in the framework's mock client
        $receivedResponse = $clientUnderTest->getBasic("https://localhost");
        // do some asserts on the return
        $this->assertEquals('200', $receivedResponse->getStatusCode(), "Let's make sure we have an OK response");
        // verify the interactions
        $hasException = false;
        try {
            $results = $mockService->verifyInteractions();
        } catch (\PhpPact\PactFailureException $e) {
            $hasException = true;
        }
        $this->assertFalse($hasException, "This basic get should verify the interactions and not throw an exception");
    }
}

<?php
// Pick your PSR client.  Guzzle should work as well.
$httpClient = new \Windwalker\Http\HttpClient();
$pactVerifier->providerState("A GET request to get types")
                ->serviceProvider("MockApiProvider", $httpClient)
                ->honoursPactWith("MockApiConsumer")
                ->pactUri('../pact/mockapiconsumer-mockapiprovider.json')
                ->verify();

<?php
require_once( __DIR__ . '/MockApiConsumer.php');
use PHPUnit\Framework\TestCase;
class ProviderTest extends TestCase
{
    public function testPactProviderStateSetupTearDown() 
    {
        
        $httpClient = new \Windwalker\Http\HttpClient();
        
        // whatever your URL of choice is
        $uri = WEB_SERVER_HOST . ':' . WEB_SERVER_PORT;
        $pactVerifier = new \PhpPact\PactVerifier($uri);
        $setUpFunction = function() {
            $fileName = "mock.json";
            $currentDir = dirname(__FILE__);
            $absolutePath = realpath($currentDir . '/../site/' );
            $absolutePath .= '/' . $fileName;
            $type = new \stdClass();
            $type->id = 700;
            $type->name = "mock";
            $types = array( $type );
            $body = new \stdClass();
            $body->types = $types;
            $output = \json_encode($body, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
            file_put_contents($absolutePath, $output);
        };
        $tearDownFunction = function() {
            $fileName = "mock.json";
            $currentDir = dirname(__FILE__);
            $absolutePath = realpath($currentDir . '/../site/' );
            $absolutePath .= '/' . $fileName;
            unlink($absolutePath);
        };
        // wherever your PACT file is
        // you may want to leverage PactBrokerConnector to pull this
        $json = 'mockapiconsumer-mockapiprovider.json';
        $pactVerifier->providerState("A GET request for a setup", $setUpFunction, $tearDownFunction)
            ->serviceProvider("MockApiProvider", $httpClient)
            ->honoursPactWith("MockApiConsumer")
            ->pactUri($json)
            ->verify(); // note that this should test all as we can run setup and tear down
        
    }         
}

<?php
// declare your state
$testState = "There is something to POST to";
// Pick your PSR client.  Guzzle should work as well.
$httpClient = new \Windwalker\Http\HttpClient();
$pactVerifier->providerState("Test State")
    ->serviceProvider("MockApiProvider", $httpClient)
    ->honoursPactWith("MockApiConsumer")
    ->pactUri($json)
    ->verify(null, $testState);
  

<?php 
$resHeaders = array();
$resHeaders["Content-Type"] = "application/json";
$resHeaders["AnotherHeader"] = "my-header";
$response = new ProviderServiceResponse('200', $resHeaders);
$response->setBody("{\"msg\" : \"I am almost a walrus\"}");
$resMatchers = array();
$resMatchers['$.body.msg'] = new MatchingRule('$.body.msg', array(
    MatcherRuleTypes::RULE_TYPE => MatcherRuleTypes::REGEX_TYPE,
    MatcherRuleTypes::REGEX_PATTERN => 'walrus')
);
$resMatchers['$.body.*'] = new MatchingRule('$.body.*', array(
    MatcherRuleTypes::RULE_TYPE => MatcherRuleTypes::OBJECT_TYPE)
);
$response->setMatchingRules($resMatchers);

<?php
// create your options
$uriOptions = new \PhpPact\PactUriOptions("https://your-pact-broker" );
$connector = new \PhpPact\PactBrokerConnector($uriOptions);
// Use the appropriate function to read from a file, JSON string, or ProviderServicePactFile object
$file = __DIR__ . '/../example/pact/mockapiconsumer-mockapiprovider.json';
$statusCode = $connector->publishFile($file, '1.0.3');

<?php
// create your options
$uriOptions = new \PhpPact\PactUriOptions("https://your-pact-broker" );
$connector = new \PhpPact\PactBrokerConnector($uriOptions);
// particular version
$pact = $connector->retrievePact("MockApiProvider", "MockApiConsumer", "1.0.2");
error_log(\json_encode($pact,JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES));
// get all pacts for this provider
$pacts = $connector->retrieveLatestProviderPacts("MockApiProvider");
$pact = array_pop($pacts);
error_log(\json_encode($pact,JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES));

<?php
$uriOptions = new \PhpPact\PactUriOptions("https://your-pact-broker" );
$connector = new \PhpPact\PactBrokerConnector($uriOptions);
$connector->verify(true, "https://your-ci-builder/api/pact-example-api/job/master/42/", "MockProvider", '0.0.42', 'MockConsumer', 'latest');