Added unique expectations loaded via annotations (#32)

* Added unique expectations loaded via annotations

* Fixed scrutinizer comments

Author: LGouttefange

.gitignore

@@ -4,3 +4,4 @@ composer.phar
 # Commit your application's lock file http://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file
 # You may choose to ignore a library lock file http://getcomposer.org/doc/02-libraries.md#lock-file
 composer.lock
+.idea

README.md

@@ -42,7 +42,8 @@ extensions:
             logs_path: /var/log/my_app/tests/logs # defaults to codeception's tests output dir
             debug: true # defaults to false
             startDelay: 1 # default to 0
-            expectations_path: /my/expectations/path
+            expectations_path: /my/expectations/path # defaults to tests/_expectations
+            unique_expectations_path: /my/expectations/path # defaults to tests/_unique_expectations
 ```
 Note: Since Codeception version 2.2.7, extensions configuration can be added directly in the suite configuration file. That will avoid phiremock to be started for every suite. 
 
@@ -60,6 +61,7 @@ $loader = require APP_ROOT . '/vendor/autoload.php';
 * **debug:** Where to write debug data to log files
 * **startDelay:** Time to wait after Phiremock was started to start running the tests (used to give time to Phiremock to boot) 
 * **expectations_path:** Specifies a directory to search for json files defining expectations to load by default.
+* **unique_expectations_path:** Specifies a directory to search for json files defining expectations to load via annotations.
 
 ### Module
 The module allows you to connect to a Phiremock server and to interact with it in a semantic way through the codeception actor in your tests.
@@ -134,6 +136,32 @@ Retrieves all the requests received by Phiremock server matching the one specifi
     $I->grabRequestsMadeToRemoteService(A::getRequest()->andUrl(Is::equalTo('/some/url')));
 ```
 
+#### @expectation Annotations
+
+Allows you to to set up an expectation via a json file 
+
+```php
+    /**
+     * @expectation("get_client_timeout")
+     */
+    public function test(FunctionalTester $I)
+    {
+        ...
+    }
+```
+
+That will load by default the file at `tests/_unique_expectations/get_client_timeout.json`
+
+Multiple annotation formats are accepted
+
+```
+     * @expectation get_client_timeout
+     * @expectation get_client_timeout.json
+     * @expectation(get_client_timeout.json)
+     * @expectation(get_client_timeout)
+     * @expectation("get_client_timeout")
+```
+
 ## Use case
 
 ### Yii2-Curl

src/Module/Phiremock.php

@@ -20,6 +20,8 @@
 
 use Codeception\Module as CodeceptionModule;
 use Codeception\TestInterface;
+use Codeception\Util\ExpectationAnnotationParser;
+use GuzzleHttp\Client;
 use Mcustiel\Phiremock\Client\Phiremock as PhiremockClient;
 use Mcustiel\Phiremock\Client\Utils\RequestBuilder;
 use Mcustiel\Phiremock\Domain\Expectation;
@@ -51,6 +53,21 @@ public function _before(TestInterface $test)
         if ($this->config['resetBeforeEachTest']) {
             $this->haveACleanSetupInRemoteService();
         }
+        $expectations = (new ExpectationAnnotationParser())->getExpectations($test);
+        if(!empty($expectations)){
+            $client = new Client([
+                'base_uri' => "{$this->config['host']}:{$this->config['port']}",
+            ]);
+            foreach ($expectations as $expectation){
+
+                $client->post(PhiremockClient::API_EXPECTATIONS_URL, [
+                    'headers' => [
+                        'Content-Type' => 'application/json'
+                    ],
+                    'body'    => file_get_contents($expectation),
+                ]);
+            }
+        }
         parent::_before($test);
     }
 

src/Util/ExpectationAnnotationParser.php

@@ -0,0 +1,87 @@
+<?php
+
+
+namespace Codeception\Util;
+
+
+use Codeception\Configuration;
+use Codeception\Exception\ParseException;
+use Codeception\Test\Cest;
+use Codeception\TestInterface;
+
+class ExpectationAnnotationParser
+{
+    const DEFAULT_EXPECTATIONS_PATH = "tests/_unique_expectations/";
+    const PATH_CONFIG_KEY = 'unique_expectations_path';
+    /**
+     * @var array
+     */
+    private $config;
+
+    /**
+     * ExpectationAnnotationParser constructor.
+     *
+     * @param array $config
+     *
+     * @throws \Codeception\Exception\ConfigurationException
+     */
+    public function __construct($config = [])
+    {
+        if (empty($config)) {
+            $config = Configuration::config();
+        }
+        $this->config = $config;
+    }
+
+
+    /**
+     * @param TestInterface|Cest $test
+     *
+     * @return array
+     */
+    public function getExpectations(TestInterface $test)
+    {
+        if (!$test instanceof Cest) {
+            return [];
+        }
+        $expectations = Annotation::forMethod($test->getTestClass(), $test->getTestMethod())->fetchAll('expectation');
+
+        return array_map([$this, 'parseExpectation'], $expectations);
+    }
+
+    /**
+     * @param       $expectationsPath
+     *
+     * @return string
+     */
+    protected function getExpectationFullPath($path)
+    {
+        $expectationsPath = isset($this->config['paths'][self::PATH_CONFIG_KEY]) ? $this->config['paths'][self::PATH_CONFIG_KEY] : self::DEFAULT_EXPECTATIONS_PATH;
+
+        return codecept_root_dir($expectationsPath.$path);
+    }
+
+    /**
+     * @param $expectation
+     *
+     * @return string
+     * @throws ParseException
+     */
+    public function parseExpectation($expectation)
+    {
+        $matches = [];
+        $expectationRegex = '/\(?\"?(?<filePath>[a-zA-Z0-9_]+)(.json)?\"?\)?/';
+        preg_match($expectationRegex, $expectation, $matches);
+
+        if (empty($matches)) {
+            throw new ParseException("The 'expectation' annotation could not be parsed (found: '$expectation')");
+        }
+
+        $expectationPath = $this->getExpectationFullPath("{$matches['filePath']}.json");
+        if (!file_exists($expectationPath)) {
+            throw new ParseException("The expectation at $expectationPath could not be found ");
+        }
+
+        return $expectationPath;
+    }
+}

tests/tests/_unique_expectations/test_first_get.json

@@ -0,0 +1,15 @@
+{
+  "request": {
+    "method": "GET",
+    "url": {
+      "isEqualTo" : "/expectation/1"
+    }
+  },
+  "response": {
+    "statusCode": 200,
+    "body": "response",
+    "headers": {
+      "Content-Type": "application/json"
+    }
+  }
+}

tests/tests/_unique_expectations/test_second_get.json

@@ -0,0 +1,17 @@
+{
+  "request": {
+    "method": "GET",
+    "url": {
+      "isEqualTo" : "/expectation/2"
+    }
+  },
+  "response": {
+    "statusCode": 200,
+    "body": {
+      "id": "id"
+    },
+    "headers": {
+      "Content-Type": "application/json"
+    }
+  }
+}

tests/tests/acceptance/BasicTestCest.php

@@ -11,11 +11,11 @@ class BasicTestCest
 {
     public function _before(AcceptanceTester $I)
     {
-        $I->haveACleanSetupInRemoteService();
     }
 
     public function _after(AcceptanceTester $I)
     {
+        $I->haveACleanSetupInRemoteService();
     }
 
     // tests
@@ -127,4 +127,46 @@ public function testGrabRequestsMadeToRemoteService(AcceptanceTester $I)
             $I->assertSame($value, $headers[$key]);
         }
     }
+
+    /**
+     * @param AcceptanceTester $I
+     * @expectation("test_first_get")
+     */
+    public function testAnnotationExpectationIsLoaded(AcceptanceTester $I)
+    {
+        $requestBuilder = A::getRequest()->andUrl(Is::equalTo('/expectation/1'));
+        $response = file_get_contents('http://localhost:18080/expectation/1');
+
+        $requests = $I->grabRequestsMadeToRemoteService($requestBuilder);
+        $I->assertCount(1, $requests);
+
+        $I->assertEquals("response", $response);
+    }
+
+    /**
+     * @param AcceptanceTester $I
+     * @expectation("test_first_get")
+     * @expectation("test_second_get")
+     */
+    public function testMultipleAnnotationsAreLoaded(AcceptanceTester $I)
+    {
+        $requestBuilder = A::getRequest()->andUrl(Is::matching('/\\/expectation\\/\\d+/'));
+        file_get_contents('http://localhost:18080/expectation/1');
+        file_get_contents('http://localhost:18080/expectation/2');
+        $requests = $I->grabRequestsMadeToRemoteService($requestBuilder);
+        $I->assertCount(2, $requests);
+    }
+
+    /**
+     * @param AcceptanceTester $I
+     *
+     * @expectation test_first_get
+     * @expectation test_first_get.json
+     * @expectation(test_first_get.json)
+     * @expectation(test_first_get)
+     * @expectation("test_first_get")
+     */
+    public function testAnnotationFormats(AcceptanceTester $I)
+    {
+    }
 }

tests/tests/unit.suite.yml

@@ -0,0 +1,5 @@
+actor: UnitTester
+modules:
+    enabled:
+        - \Helper\Unit
+        - Asserts

tests/tests/unit/ExpectationParserTestCest.php

@@ -0,0 +1,28 @@
+<?php
+
+use Codeception\Exception\ParseException;
+use Codeception\Util\ExpectationAnnotationParser;
+
+class ExpectationParserTestCest
+{
+    /** @var ExpectationAnnotationParser */
+    private $parser;
+
+    public function _before()
+    {
+        $this->parser = new ExpectationAnnotationParser();
+    }
+
+    public function jsonExtensionIsOptional()
+    {
+        $this->parser->parseExpectation("test_first_get");
+        $this->parser->parseExpectation("test_first_get.json");
+    }
+
+    public function expectationNotFoundThrowsParseError(UnitTester $I)
+    {
+        $I->expectException(ParseException::class,function(){
+            $this->parser->parseExpectation("random.expectation");
+        });
+    }
+}

tests/tests/unit/_bootstrap.php

@@ -0,0 +1 @@
+<?php