JsonContext::theJsonNodeShouldExist() - Code Metrics - Inspection of "Add asserter to ensure json array contain value" - rezzza/rest-api-behat-extension - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#48)

by Timothée

created 2016-04-20 13:07 UTC

JsonContext::theJsonNodeShouldExist() A

↳ Parent: JsonContext

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	8
rs	9.4285
cc	2
eloc	5
nc	2
nop	1

<?php

namespace Rezzza\RestApiBehatExtension\Json;

use mageekguy\atoum\asserter\generator as asserter;
use Behat\Behat\Context\Context;
use Behat\Behat\Context\SnippetAcceptingContext;
use Behat\Gherkin\Node\PyStringNode;

class JsonContext implements Context, SnippetAcceptingContext
{
    private $jsonInspector;

    private $asserter;

    private $jsonSchemaBaseUrl;

    public function __construct(JsonInspector $jsonInspector, $jsonSchemaBaseUrl = null)
    {
        $this->jsonInspector = $jsonInspector;
        $this->asserter = new asserter;
        $this->jsonSchemaBaseUrl = rtrim($jsonSchemaBaseUrl, '/');
    }

    /**
     * @When /^I load JSON:$/
     */
    public function iLoadJson(PyStringNode $jsonContent)
    {
        $this->jsonInspector->writeJson((string) $jsonContent);
    }

    /**
     * @Then /^the response should be in JSON$/
     */
    public function responseShouldBeInJson()
    {
        $this->jsonInspector->readJson();
    }

    /**
     * @Then /^the JSON node "(?P<jsonNode>[^"]*)" should be equal to "(?P<expectedValue>.*)"$/
     */
    public function theJsonNodeShouldBeEqualTo($jsonNode, $expectedValue)
    {
        $realValue = $this->evaluateJsonNodeValue($jsonNode);

        $this->asserter->variable($realValue)->isEqualTo($expectedValue);
    }

    /**
     * @Then /^the JSON node "(?P<jsonNode>[^"]*)" should have (?P<expectedNth>\d+) elements?$/
     * @Then /^the JSON array node "(?P<jsonNode>[^"]*)" should have (?P<expectedNth>\d+) elements?$/
     */
    public function theJsonNodeShouldHaveElements($jsonNode, $expectedNth)
    {
        $realValue = $this->evaluateJsonNodeValue($jsonNode);

        $this->asserter->phpArray($realValue)->hasSize($expectedNth);
    }

    /**
     * @Then /^the JSON array node "(?P<jsonNode>[^"]*)" should contain "(?P<expectedValue>.*)" element$/
     */
    public function theJsonArrayNodeShouldContainElements($jsonNode, $expectedValue)
    {
        $realValue = $this->evaluateJsonNodeValue($jsonNode);

        $this->asserter->phpArray($realValue)->contains($expectedValue);
    }

    /**
     * @Then /^the JSON node "(?P<jsonNode>[^"]*)" should contain "(?P<expectedValue>.*)"$/
     */
    public function theJsonNodeShouldContain($jsonNode, $expectedValue)
    {
        $realValue = $this->evaluateJsonNodeValue($jsonNode);

        $this->asserter->string((string) $realValue)->contains($expectedValue);
    }

    /**
     * Checks, that given JSON node does not contain given value
     *
     * @Then /^the JSON node "(?P<jsonNode>[^"]*)" should not contain "(?P<unexpectedValue>.*)"$/
     */
    public function theJsonNodeShouldNotContain($jsonNode, $unexpectedValue)
    {
        $realValue = $this->evaluateJsonNodeValue($jsonNode);

        $this->asserter->string((string) $realValue)->notContains($unexpectedValue);
    }

    /**
     * Checks, that given JSON node exist
     *
     * @Given /^the JSON node "(?P<jsonNode>[^"]*)" should exist$/
     */
    public function theJsonNodeShouldExist($jsonNode)
    {
        try {
            $this->evaluateJsonNodeValue($jsonNode);
        } catch (\Exception $e) {
            throw new \Exception(sprintf("The node '%s' does not exist.", $jsonNode), 0, $e);
        }
    }

    /**
     * Checks, that given JSON node does not exist
     *
     * @Given /^the JSON node "(?P<jsonNode>[^"]*)" should not exist$/
     */
    public function theJsonNodeShouldNotExist($jsonNode)
    {
        $e = null;

        try {
            $realValue = $this->evaluateJsonNodeValue($jsonNode);
        } catch (\Exception $e) {
            // If the node does not exist an exception should be throwed
        }

        if ($e === null) {
            throw new \Exception(sprintf("The node '%s' exists and contains '%s'.", $jsonNode, json_encode($realValue)));
        }
    }

    /**
     * @Then /^the JSON should be valid according to this schema:$/
     */
    public function theJsonShouldBeValidAccordingToThisSchema(PyStringNode $jsonSchemaContent)
    {
        $this->jsonInspector->validateJson(
            new JsonSchema($jsonSchemaContent)
        );
    }

    /**
     * @Then /^the JSON should be valid according to the schema "(?P<filename>[^"]*)"$/
     */
    public function theJsonShouldBeValidAccordingToTheSchema($filename)
    {
        $filename = $this->resolveFilename($filename);

        $this->jsonInspector->validateJson(
            new JsonSchema(
                file_get_contents($filename),
                'file://' . $filename
            )
        );
    }

    /**
     * @Then /^the JSON should be equal to:$/
     */
    public function theJsonShouldBeEqualTo(PyStringNode $jsonContent)
    {
        $realJsonValue = $this->readJson();

        try {
            $expectedJsonValue = new Json($jsonContent);
        } catch (\Exception $e) {
            throw new \Exception('The expected JSON is not a valid');
        }

        $this->asserter->castToString($realJsonValue)->isEqualTo((string) $expectedJsonValue);
    }

    private function evaluateJsonNodeValue($jsonNode)
    {
        return $this->jsonInspector->readJsonNodeValue($jsonNode);
    }

    private function readJson()
    {
        return $this->jsonInspector->readJson();
    }

    private function resolveFilename($filename)
    {
        if (true === is_file($filename)) {
            return realpath($filename);
        }

        if (null === $this->jsonSchemaBaseUrl) {
            throw new \RuntimeException(sprintf(
                'The JSON schema file "%s" doesn\'t exist',
                $filename
            ));
        }

        $filename = $this->jsonSchemaBaseUrl . '/' . $filename;

        if (false === is_file($filename)) {
            throw new \RuntimeException(sprintf(
                'The JSON schema file "%s" doesn\'t exist',
                $filename
            ));
        }

        return realpath($filename);
    }
}


1			<?php
2
3			namespace Rezzza\RestApiBehatExtension\Json;
4
5			use mageekguy\atoum\asserter\generator as asserter;
6			use Behat\Behat\Context\Context;
7			use Behat\Behat\Context\SnippetAcceptingContext;
8			use Behat\Gherkin\Node\PyStringNode;
9
10			class JsonContext implements Context, SnippetAcceptingContext
11			{
12			private $jsonInspector;
13
14			private $asserter;
15
16			private $jsonSchemaBaseUrl;
17
18			public function __construct(JsonInspector $jsonInspector, $jsonSchemaBaseUrl = null)
19			{
20			$this->jsonInspector = $jsonInspector;
21			$this->asserter = new asserter;
22			$this->jsonSchemaBaseUrl = rtrim($jsonSchemaBaseUrl, '/');
23			}
24
25			/**
26			* @When /^I load JSON:$/
27			*/
28			public function iLoadJson(PyStringNode $jsonContent)
29			{
30			$this->jsonInspector->writeJson((string) $jsonContent);
31			}
32
33			/**
34			* @Then /^the response should be in JSON$/
35			*/
36			public function responseShouldBeInJson()
37			{
38			$this->jsonInspector->readJson();
39			}
40
41			/**
42			* @Then /^the JSON node "(?P<jsonNode>[^"])" should be equal to "(?P<expectedValue>.)"$/
43			*/
44			public function theJsonNodeShouldBeEqualTo($jsonNode, $expectedValue)
45			{
46			$realValue = $this->evaluateJsonNodeValue($jsonNode);
47
48			$this->asserter->variable($realValue)->isEqualTo($expectedValue);
49			}
50
51			/**
52			* @Then /^the JSON node "(?P<jsonNode>[^"]*)" should have (?P<expectedNth>\d+) elements?$/
53			* @Then /^the JSON array node "(?P<jsonNode>[^"]*)" should have (?P<expectedNth>\d+) elements?$/
54			*/
55			public function theJsonNodeShouldHaveElements($jsonNode, $expectedNth)
56			{
57			$realValue = $this->evaluateJsonNodeValue($jsonNode);
58
59			$this->asserter->phpArray($realValue)->hasSize($expectedNth);
60			}
61
62			/**
63			* @Then /^the JSON array node "(?P<jsonNode>[^"])" should contain "(?P<expectedValue>.)" element$/
64			*/
65			public function theJsonArrayNodeShouldContainElements($jsonNode, $expectedValue)
66			{
67			$realValue = $this->evaluateJsonNodeValue($jsonNode);
68
69			$this->asserter->phpArray($realValue)->contains($expectedValue);
70			}
71
72			/**
73			* @Then /^the JSON node "(?P<jsonNode>[^"])" should contain "(?P<expectedValue>.)"$/
74			*/
75			public function theJsonNodeShouldContain($jsonNode, $expectedValue)
76			{
77			$realValue = $this->evaluateJsonNodeValue($jsonNode);
78
79			$this->asserter->string((string) $realValue)->contains($expectedValue);
80			}
81
82			/**
83			* Checks, that given JSON node does not contain given value
84			*
85			* @Then /^the JSON node "(?P<jsonNode>[^"])" should not contain "(?P<unexpectedValue>.)"$/
86			*/
87			public function theJsonNodeShouldNotContain($jsonNode, $unexpectedValue)
88			{
89			$realValue = $this->evaluateJsonNodeValue($jsonNode);
90
91			$this->asserter->string((string) $realValue)->notContains($unexpectedValue);
92			}
93
94			/**
95			* Checks, that given JSON node exist
96			*
97			* @Given /^the JSON node "(?P<jsonNode>[^"]*)" should exist$/
98			*/
99			public function theJsonNodeShouldExist($jsonNode)
100			{
101			try {
102			$this->evaluateJsonNodeValue($jsonNode);
103			} catch (\Exception $e) {
104			throw new \Exception(sprintf("The node '%s' does not exist.", $jsonNode), 0, $e);
105			}
106			}
107
108			/**
109			* Checks, that given JSON node does not exist
110			*
111			* @Given /^the JSON node "(?P<jsonNode>[^"]*)" should not exist$/
112			*/
113			public function theJsonNodeShouldNotExist($jsonNode)
114			{
115			$e = null;
116
117			try {
118			$realValue = $this->evaluateJsonNodeValue($jsonNode);
119			} catch (\Exception $e) {
120			// If the node does not exist an exception should be throwed
121			}
122
123			if ($e === null) {
124			throw new \Exception(sprintf("The node '%s' exists and contains '%s'.", $jsonNode, json_encode($realValue)));
125			}
126			}
127
128			/**
129			* @Then /^the JSON should be valid according to this schema:$/
130			*/
131			public function theJsonShouldBeValidAccordingToThisSchema(PyStringNode $jsonSchemaContent)
132			{
133			$this->jsonInspector->validateJson(
134			new JsonSchema($jsonSchemaContent)
135			);
136			}
137
138			/**
139			* @Then /^the JSON should be valid according to the schema "(?P<filename>[^"]*)"$/
140			*/
141			public function theJsonShouldBeValidAccordingToTheSchema($filename)
142			{
143			$filename = $this->resolveFilename($filename);
144
145			$this->jsonInspector->validateJson(
146			new JsonSchema(
147			file_get_contents($filename),
148			'file://' . $filename
149			)
150			);
151			}
152
153			/**
154			* @Then /^the JSON should be equal to:$/
155			*/
156			public function theJsonShouldBeEqualTo(PyStringNode $jsonContent)
157			{
158			$realJsonValue = $this->readJson();
159
160			try {
161			$expectedJsonValue = new Json($jsonContent);
162			} catch (\Exception $e) {
163			throw new \Exception('The expected JSON is not a valid');
164			}
165
166			$this->asserter->castToString($realJsonValue)->isEqualTo((string) $expectedJsonValue);
167			}
168
169			private function evaluateJsonNodeValue($jsonNode)
170			{
171			return $this->jsonInspector->readJsonNodeValue($jsonNode);
172			}
173
174			private function readJson()
175			{
176			return $this->jsonInspector->readJson();
177			}
178
179			private function resolveFilename($filename)
180			{
181			if (true === is_file($filename)) {
182			return realpath($filename);
183			}
184
185			if (null === $this->jsonSchemaBaseUrl) {
186			throw new \RuntimeException(sprintf(
187			'The JSON schema file "%s" doesn\'t exist',
188			$filename
189			));
190			}
191
192			$filename = $this->jsonSchemaBaseUrl . '/' . $filename;
193
194			if (false === is_file($filename)) {
195			throw new \RuntimeException(sprintf(
196			'The JSON schema file "%s" doesn\'t exist',
197			$filename
198			));
199			}
200
201			return realpath($filename);
202			}
203			}
204

rezzza / rest-api-behat-extension

Pull Request — master (#48)

JsonContext::theJsonNodeShouldExist() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like