public function setUp()
{
parent::setUp();
$this->client = new Client(['base_uri' => self::BASEURL]);
$matcherFactory = new SimpleFactory();
$this->matcher = $matcherFactory->createMatcher();
}
/**
* @param $value
* @param $pattern
* @param null $error
* @return bool
*/
public static function match($value, $pattern, &$error = null)
{
$factory = new SimpleFactory();
$matcher = $factory->createMatcher();
if (!$matcher->match($value, $pattern)) {
$error = $matcher->getError();
return false;
}
return true;
}
protected function assertJsonResponseContent($response, $filename)
{
$expectedResponse = file_get_contents(__DIR__ . sprintf('/../Tests/Responses/%s.json', $filename));
$actualResponse = $response->getContent();
$actualResponse = json_encode(json_decode($actualResponse), JSON_PRETTY_PRINT);
$factory = new SimpleFactory();
$matcher = $factory->createMatcher();
$result = $matcher->match($actualResponse, $expectedResponse);
if (!$result) {
echo $matcher->getError();
$expectedResponse = explode(PHP_EOL, (string) $expectedResponse);
$actualResponse = explode(PHP_EOL, (string) $actualResponse);
$diff = new \Diff($expectedResponse, $actualResponse, array());
$renderer = new \Diff_Renderer_Text_Unified();
echo $diff->render($renderer);
}
$this->assertTrue($result);
}
/**
* @dataProvider nullExamples
*/
public function test_null_value_in_the_json($value, $pattern)
{
$factory = new SimpleFactory();
$matcher = $factory->createMatcher();
$match = $matcher->match($value, $pattern);
$this->assertTrue($match, $matcher->getError());
}
/**
* @param string $actualResponse
* @param string $filename
* @param string $mimeType
*/
protected function assertResponseContent($actualResponse, $filename, $mimeType)
{
$responseSource = $this->getExpectedResponsesFolder();
$expectedResponse = file_get_contents(sprintf('%s/%s.%s', $responseSource, $filename, $mimeType));
$factory = new SimpleFactory();
$matcher = $factory->createMatcher();
$result = $matcher->match($actualResponse, $expectedResponse);
if (!$result) {
$difference = $matcher->getError();
$difference = $difference . PHP_EOL;
$expectedResponse = explode(PHP_EOL, (string) $expectedResponse);
$actualResponse = explode(PHP_EOL, (string) $actualResponse);
$diff = new \Diff($expectedResponse, $actualResponse, array());
$renderer = new \Diff_Renderer_Text_Unified();
$difference = $difference . $diff->render($renderer);
$this->fail($difference);
}
}
/**
* @Then /^the response JSON matches "([^"]*)"$/
*
* @param string $expectedJsonFilePath
*
* @throws \Exception
*/
public function theResponseJSONMatches($expectedJsonFilePath)
{
$factory = new PHPMatcherFactory();
$matcher = $factory->createMatcher();
$responseJson = json_encode(json_decode($this->getResponseWithAssertion()->getContent()), JSON_PRETTY_PRINT);
$expectedJson = file_get_contents($this->getFilePath($expectedJsonFilePath));
if ($matcher->match($responseJson, $expectedJson) === false) {
echo $matcher->getError();
$difference = new \Diff(explode(PHP_EOL, $expectedJson), explode(PHP_EOL, $responseJson));
echo $difference->render(new \Diff_Renderer_Text_Unified());
throw new \Exception('Response JSON did not match.');
}
}
/**
* Assert that a response matches fixture data (with wildcard patterns)
*
* This uses the matcher format for json files. See the project at
* https://github.com/coduo/php-matcher for more information.
*
* Construct a JSON fixture file with the php-matcher patterns and you can
* assert that a server response matches the spec, even if the data is
* changing.
*
* @param ResponseInterface $response psr7 response object
* @param string|resource $filename path within `$fixtureFolder`
* @param string $mimeType file extension and mime type
*
* @throws LogicException
* @throws RuntimeException
* @return void
*/
public static function assertResponseContent(ResponseInterface $response, $filename, $mimeType = 'json')
{
self::$faker = Faker\Factory::create();
$spec = self::getFixtureText($filename, $mimeType);
$actual = $response->getBody()->getContents();
// Check that the spec and actual are both valid json
$test = json_decode($spec);
if ($test === null && json_last_error() !== JSON_ERROR_NONE) {
self::fail('Invalid Specter File, unable to decode ' . $filename . '.');
}
$test = json_decode($actual);
if ($test === null && json_last_error() !== JSON_ERROR_NONE) {
self::fail('Invalid Specter File, unable to decode response.');
}
unset($test);
// Build these both into arrays for processing
$actual = json_decode($actual, true);
$spec = json_decode($spec, true);
// Convert the spec to matcher format
$matcherSpec = self::getMatcherFormat($spec);
$factory = new SimpleFactory();
$matcher = $factory->createMatcher();
// Pass this test because the matcher matched
if ($matcher->match($actual, $matcherSpec)) {
self::assertTrue(true);
return;
}
// Display the output in a better format by using a diffing tool
// We convert to strings to try to make the output more accurate
$difference = $matcher->getError() . PHP_EOL;
$specString = json_encode($spec, JSON_PRETTY_PRINT);
$specString = explode(PHP_EOL, $specString);
$actualString = json_encode($actual, JSON_PRETTY_PRINT);
$actualString = explode(PHP_EOL, $actualString);
$diffOptions = [];
$diff = new Diff($specString, $actualString, $diffOptions);
$renderer = new Diff_Renderer_Text_Unified();
self::fail($difference . $diff->render($renderer), 'Incorrect api response');
}
/**
* @Then the JSON response should match:
*/
public function theJsonResponseShouldMatch(PyStringNode $string)
{
$factory = new SimpleFactory();
$matcher = $factory->createMatcher();
$match = $matcher->match($this->response->getBody()->getContents(), $string->getRaw());
\PHPUnit_Framework_Assert::assertTrue($match, $matcher->getError());
}
public function setUp()
{
$factory = new SimpleFactory();
$this->matcher = $factory->createMatcher();
}
public function test_creating_matcher()
{
$factory = new SimpleFactory();
$this->assertInstanceOf('Coduo\\PHPMatcher\\Matcher', $factory->createMatcher());
}
/**
* @param mixed $value
* @param mixed $pattern
* @return boolean
*/
function match($value, $pattern)
{
$factory = new SimpleFactory();
$matcher = $factory->createMatcher();
return $matcher->match($value, $pattern);
}
/**
* Checks that response body contains JSON from PyString.
*
* Do not check that the response body /only/ contains the JSON from PyString,
*
* @param PyStringNode $jsonString
*
* @throws \RuntimeException
*
* @Then /^(?:the )?response should contain json:$/
*/
public function theResponseShouldContainJson(PyStringNode $jsonString)
{
$etalon = json_decode($this->replacePlaceHolder($jsonString->getRaw()), true);
$actual = $this->response->json();
if (null === $etalon) {
throw new \RuntimeException("Can not convert etalon to json:\n" . $this->replacePlaceHolder($jsonString->getRaw()));
}
$factory = new SimpleFactory();
$matcher = $factory->createMatcher();
Assertions::assertTrue($matcher->match($actual, $etalon));
}
/**
* @return Matcher
*/
private function createMatcher()
{
$factory = new SimpleFactory();
return $factory->createMatcher();
}
