├── .gitignore
├── .travis.yml
├── CHANGES.md
├── LICENSE.txt
├── README.md
├── composer.json
├── demo
    ├── HelloWorldController.php
    └── index.php
├── phpci.yml
├── phpcs.xml
├── phpdoc.dist.xml
├── phpdox.xml
├── phpmd.xml
├── phpunit.xml.dist
├── src
    ├── Api.php
    ├── Controller.php
    ├── ControllerDocumentation.php
    ├── ControllerReflector.php
    ├── Documentation.php
    ├── Exception.php
    ├── Injector
    │   ├── ControllerReflectorInjector.php
    │   ├── LoggerInjector.php
    │   ├── RequestInjector.php
    │   ├── ResponseInjector.php
    │   ├── RouterInjector.php
    │   ├── StatusInjector.php
    │   └── WriterFactoryInjector.php
    ├── ReflectionController.php
    ├── Request.php
    ├── Response.php
    ├── Router.php
    └── Status.php
└── tests
    ├── ApiTest.php
    ├── ControllerDocumentationTest.php
    ├── ControllerReflectorTest.php
    ├── ControllerTest.php
    ├── DocumentationTest.php
    ├── ExceptionTest.php
    ├── Injector
        ├── ControllerReflectorInjectorTest.php
        ├── InjectorTestTrait.php
        ├── LoggerInjectorTest.php
        ├── RequestInjectorTest.php
        ├── ResponseInjectorTest.php
        ├── RouterInjectorTest.php
        ├── StatusInjectorTest.php
        └── WriterFactorInjectorTest.php
    ├── ReflectionControllerTest.php
    ├── RequestTest.php
    ├── ResponseTest.php
    ├── RouterTest.php
    ├── StatusTest.php
    └── TestCase.php


/.gitignore:
--------------------------------------------------------------------------------
1 | composer.lock
2 | composer.phar
3 | /vendor
4 | /bin
5 | phpunit.xml
6 | build/cache.properties
7 | /reports
8 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | php:
 3 |   - 5.5
 4 |   - 5.6
 5 |   - 7.0
 6 |   - hhvm
 7 |   - nightly
 8 | 
 9 | matrix:
10 |   fast_finish: true
11 |   allow_failures:
12 |     - php: hhvm
13 |     - php: nightly
14 | 
15 | sudo: false
16 | 
17 | before_script:
18 |   - travis_retry composer self-update
19 |   - travis_retry composer install
20 | 
21 | script:
22 |   - composer test
23 | 
24 | notifications:
25 |   slack: danielmason:mwiobPacEYneLE6a9iBAZvVB
26 | 


--------------------------------------------------------------------------------
/CHANGES.md:
--------------------------------------------------------------------------------
 1 | # Change Log
 2 | 
 3 | ## [Unreleased]
 4 | 
 5 | ## [1.0.0] - 2016-02-17
 6 | ### Changed
 7 | - Now uses Formatters 1.0.0
 8 | - My email is now listed as @ayeayeapi.com. Hopefully this will keep important Aye Aye related stuff out of the noise
 9 |   of my older inbox.
10 | - New license will be MIT
11 | - Updated badges in README
12 | 
13 | ### Removed
14 | - References to old tests had been left in composer.json
15 | - Build folder contained scripts for building in Jenkins. This has all been moved to composer.json scripts
16 | 
17 | ## [1.0.0-rc.2] - 2016-02-17
18 | ### Added
19 | - Added this file
20 | - Tests now lint first
21 | - Report script creates detailed artifacts for PHPCS, PHPLOC, PDEPEND, PHPCPD
22 | - Injector traits to help with DI while keeping things simple.
23 | - ReflectionController and ControllerReflector used to simplify Router and provide DI.
24 | - Reader Factory now decodes Request bodies
25 |  
26 | ### Changed
27 | - Higher quality PHP DocBlocks for all classes and methods
28 | - Tests no longer use TestData
29 | - Response body is now returned as an array instead of object
30 | 
31 | ### Removed
32 | - `->getData()` in Response was unnecessary, use `->getBody()` instead.
33 | - `->setStatusCode()` in Controller and Response breaks DI and was unnecessary, use `->setStatus()` instead.
34 | - Router and LoggerInterface are no longer part of the API constructor. Use the setters provided by the injectors 
35 |   instead.
36 | 
37 | ## 1.0.0-rc.1 - 2015-09-02 
38 | ### Added
39 | - 1.0.0 release candidate 
40 | 
41 | [Unreleased]: https://github.com/AyeAyeApi/Api/compare/1.0.0...HEAD
42 | [1.0.0]: https://github.com/AyeAyeApi/Api/compare/1.0.0-rc.2...1.0.0
43 | [1.0.0-rc.2]: https://github.com/AyeAyeApi/Api/compare/1.0.0-rc.1...1.0.0-rc.2
44 | 
45 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 6 | documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 7 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
 8 | persons to whom the Software is furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
11 | Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
14 | WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
15 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
16 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
17 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Aye Aye API
  2 | 
  3 | [![PHP >= 5.5](https://img.shields.io/badge/php-%3E%3D%205.5-8892BF.svg)]
  4 | (https://php.net/)
  5 | [![License: MIT](https://img.shields.io/packagist/l/ayeaye/api.svg)]
  6 | (https://raw.githubusercontent.com/AyeAyeApi/Api/master/LICENSE.txt)
  7 | [![Version](https://img.shields.io/packagist/v/ayeaye/api.svg)]
  8 | (https://packagist.org/packages/ayeaye/api)
  9 | [![Build Status](https://img.shields.io/travis/AyeAyeApi/Api/master.svg)]
 10 | (https://travis-ci.org/AyeAyeApi/Api/branches)
 11 | 
 12 | Aye Aye API is a micro framework for building API's written in PHP. It's designed to be easy to use, fast to
 13 | develop with and to scale from tiny micro-services to world devouring titans.
 14 | 
 15 | ## Installation
 16 | 
 17 | Create a project and include Aye Aye.
 18 | 
 19 | ```bash
 20 | composer init --require="ayeaye/api ^1.0.0" -n
 21 | composer install
 22 | ```
 23 | 
 24 | ## Quick Start Guide
 25 | 
 26 | When working with Aye Aye, you will do almost all of your work in Controller classes.
 27 | 
 28 | Here's our ubiquitous Hello World controller:
 29 | 
 30 | ```php
 31 | <?php
 32 | // HelloWorldController.php
 33 | 
 34 | use AyeAye\Api\Controller;
 35 | 
 36 | class HelloWorldController extends Controller
 37 | {
 38 |     /**
 39 |      * Yo ho ho
 40 |      * @param string $name Optional, defaults to 'Captain'
 41 |      * @return string
 42 |      */
 43 |     public function getAyeAyeEndpoint($name = 'Captain')
 44 |     {
 45 |         return "Aye Aye $name";
 46 |     }
 47 | }
 48 | ```
 49 | 
 50 | Controllers contain endpoints and child controllers. The above controller has a single endpoint `hello` that will 
 51 | respond to HTTP GET requests. This is reflected in the name which takes the form `[verb][Name]Endpoint`.
 52 | 
 53 | The endpoint takes one parameter, `name`, which will default to `'Captain'` if not otherwise provided. The return is
 54 | a string.
 55 | 
 56 | The API needs an entry point, which will put in index.php
 57 | 
 58 | ```php
 59 | <?php
 60 | // index.php
 61 | 
 62 | require_once '../vendor/autoload.php';
 63 | require_once 'HelloWorldController.php';
 64 | 
 65 | use AyeAye\Api\Api;
 66 | 
 67 | $initialController = new HelloWorldController();
 68 | $api = new Api($initialController);
 69 | 
 70 | $api->go()->respond();
 71 | ```
 72 | 
 73 | First we grab composer's autoloader, and our controller (which we haven't added to the autoloader). We instantiate our
 74 | HelloWorldController, and pass it into the constructor of our Api object. This becomes our initialController, and it's
 75 | the only one Aye Aye needs to know about, we'll come onto why later.
 76 | 
 77 | Finally the `->go()` method produces a Response object, with which we can `->respond()`.
 78 | 
 79 | We can test this using PHP's build in server:
 80 | 
 81 | ```bash
 82 | $ php -S localhost:8000 index.php &
 83 | 
 84 | $ curl localhost:8000/aye-aye                 # {"data":"Aye Aye Captain"}
 85 | $ curl localhost:8000/aye-aye?name=Sandwiches # {"data":"Aye Aye Sandwiches"}
 86 | ```
 87 | 
 88 | Notice how the string has been converted into a serialised object (JSON by default but the format can be selected with
 89 | an `Accept` header or a file suffix).
 90 | 
 91 | That tests our endpoint, but what happens if you just query the root of the Api.
 92 | 
 93 | ```bash
 94 | $ curl localhost:8000 # {"data":{"controllers":[],"endpoints":{"get":{"aye-aye":{"summary":"Yo ho ho","parameters":{"name":{"type":"string","description":"Optional, defaults to 'Captain'"}},"returnType":["string"]}}}}} 
 95 | ```
 96 | 
 97 | Lets take take a closer look at that returned string. 
 98 | 
 99 | ```json
100 | {
101 |   "data": {
102 |     "controllers": [],
103 |     "endpoints": {
104 |       "get": {
105 |         "aye-aye": {
106 |           "summary": "Yo ho ho",
107 |           "parameters": {
108 |             "name": {
109 |               "type": "string",
110 |               "description": "Optional, defaults to 'Captain'"
111 |             }
112 |           },
113 |           "returnType": [
114 |             "string"
115 |           ]
116 |         }
117 |       }
118 |     }
119 |   }
120 | }
121 | ```
122 | As you can see, it is an explanation of how our controller is structured. We didn't write anything more than what was
123 | expected of us, and it makes sense to both the back end developers, and the consumers of your Api.
124 | 
125 | Don't forget to close the server down when you're done.
126 | 
127 | ```bash
128 | $ fg
129 | ^C
130 | ```
131 | 
132 | ## Why should you use it?
133 | 
134 | Developing in Aye Aye is simple, clean and logical. Aye Aye processes requests and gives them to the appropriate
135 | endpoint on the appropriate controller. That endpoint is simply a method, that takes a set of parameters and returns
136 | some data. Aye Aye will work out where to find those parameters in the request, and it will format the data on return. 
137 | It even supports multiple data formats and will automatically switch based on what the user requests.
138 | 
139 | There's no fluff. You don't need to learn new database tools, or logging interfaces (assuming you know [PSR-3]
140 | (https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md), and you should) or
141 | authentication methods. Aye Aye only provides routing, request parsing and response handling. You can use whatever
142 | you like for the rest.
143 | 
144 | If you follow [PSR-4](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md), then
145 | your API will look a lot like your directory structure, making maintenance a breeze.
146 | 
147 | Aye Aye knows about itself. It knows what endpoints and what sub-controllers are available on any given controller, and
148 | by reading the documentation in the doc-block comments, it can tell users what those end points do. You only need to 
149 | write your documentation once, and Aye Aye will read it and tell your users what those end points do, and what
150 | parameters they take.
151 | 
152 | By default it can read and write data as json (the default) and xml, though more formats can easily be added. It also
153 | reads GET, POST and HEADER, and parametrises url slugs. Data from these sources is passed into your methods for you.
154 | 
155 | ## Quick Start explained
156 | 
157 | The most important and powerful feature of Aye Aye is it's controllers. Controllers do two things. They provide
158 | endpoints, and access to other controllers.
159 | 
160 | Controllers are classes that extend `AyeAye\Api\Controller`
161 | 
162 | Endpoints are methods on the controllers that are named in this way `[verb][name]Endpoint(...)`
163 | 
164 | - The `[verb]` is the http verb, the endpoint is waiting for.
165 | - The `[name]` is the name of the endpoint.
166 | - `Endpoint` is literally the word "Endpoint". It helps us know what we're dealing with.
167 | 
168 | You can define any parameters you like for the method, and Aye Aye will automatically populate them for you.
169 | 
170 | Controllers can also reference other controllers with methods named like this `[name]Controller()`
171 | 
172 | These should return a controller object, and it's how Aye Aye navigates the Api.
173 | 
174 | ### The hello world controller
175 | 
176 | Above we wrote a controller to say hello.
177 | 
178 | ```php
179 | <?php
180 | // HelloWorldController.php
181 | 
182 | use AyeAye\Api\Controller;
183 | 
184 | class HelloWorldController extends Controller
185 | {
186 |     /**
187 |      * Yo ho ho
188 |      * @param string $name Optional, defaults to 'Captain'
189 |      * @return string
190 |      */
191 |     public function getAyeAyeEndpoint($name = 'Captain')
192 |     {
193 |         return "Aye Aye $name";
194 |     }
195 | }
196 | ```
197 | 
198 | The one method in this controller tells you everything you need to know.
199 |  * It will respond to a GET request send to the hello endpoint. 
200 |  * It takes one parameter, 'name', which will default to Captain
201 |  * It returns a string
202 |  
203 | So how did we go from that, to sending and receiving the data with curl?
204 | 
205 | When we created the Api object, we passed it a HelloWorldController object as a parameter, this tells the Api this is 
206 | our starting point. The Aye Aye identifies getAyeEndpoint as an endpoint called "aye" that is triggered with a GET
207 | request.
208 | 
209 | You'll notice that we used a PHP Doc Block to explain what the method does. This is _really_ important. Not only does
210 | it tell other developers what this end point does... it tells your API's users too, and they'll be using it in just the
211 | same way.
212 | 
213 | In the quick start guide we queryied "/", and you will have seen that the Api tells you it has one GET endpoint,
214 | called 'aye, that it takes one parameter, as string called name, and it described all of these things with the 
215 | documentation you made for the method!
216 | 
217 | ### Child Controllers
218 | 
219 | Obviously just having one controller is pretty useless. To go from one controller to the next, we create a
220 | `[name]Controller()` method. This method should return another object that extends Controller. To demonstrate that in
221 | our application quick start application, we can just return `$this`.
222 |  
223 | ```php
224 | <?php
225 | // HelloWorldController.php
226 | 
227 | use AyeAye\Api\Controller;
228 |  
229 | class HelloWorldController extends Controller
230 | {
231 |     /**
232 |      * Yo ho ho
233 |      * @param string $name Optional, defaults to 'Captain'
234 |      * @returns string
235 |      */
236 |     public function getAyeAyeEndpoint($name = 'Captain')
237 |     {
238 |         return "Aye Aye $name";
239 |     }
240 |     
241 |     /**
242 |      * lol...
243 |      * @returns $this
244 |      */
245 |     public function ayeController()
246 |     {
247 |         return $this;
248 |     }
249 | }
250 | ```
251 |  
252 | Now when we start our application and the fun begins!
253 | 
254 | ```bash
255 | $ php -S localhost:8000 public/index.php &
256 | curl localhost:8000/aye/aye/aye/aye/aye-aye?name=Aye%20Aye # {"data":"Aye Aye Aye Aye"}
257 | ```
258 | 
259 | ## Contributing
260 | 
261 | Aye Aye is an Open Source project and contributions are very welcome.
262 | 
263 | ### Issues
264 | 
265 | To report problems, please open an Issue on the [GitHub Issue Tracker](https://github.com/AyeAyeApi/Api/issues).
266 | 
267 | ### Changes
268 | 
269 | Send me pull requests. Send me lots of them.
270 | 
271 | We follow the [PSR-1](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md) and
272 | [PSR-2](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md) coding standards.
273 | PHPMD and PHPCS, and their rule files will help guide you in this.
274 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "ayeaye/api",
 3 |     "type": "library",
 4 |     "description": "A simple but powerful API framework",
 5 |     "homepage": "https://ayeayeapi.com",
 6 |     "keywords": [ "api", "framework", "rest" ],
 7 |     "minimum-stability": "stable",
 8 |     "license" : "MIT",
 9 |     "authors": [
10 |         {
11 |             "name": "Daniel Mason",
12 |             "email": "daniel@ayeayeapi.com",
13 |             "homepage": "http://danielmason.com",
14 |             "role": "Lead developer"
15 |         }
16 |     ],
17 |     "require": {
18 |         "php": "^5.5 || ^7.0",
19 |         "ayeaye/formatters": "^1.0.0",
20 |         "psr/log": "^1.0.0"
21 |     },
22 |     "require-dev": {
23 |         "phpunit/phpunit": "^4.5",
24 |         "squizlabs/php_codesniffer": "^2.2",
25 |         "phploc/phploc": "^2.0",
26 |         "pdepend/pdepend": "^2.0",
27 |         "phpmd/phpmd": "^2.2",
28 |         "sebastian/phpcpd": "^2.0",
29 |         "phpdocumentor/phpdocumentor": "^2.8",
30 |         "nikic/php-parser": "^1.0"
31 |     },
32 |     "autoload": {
33 |         "psr-4": {
34 |             "AyeAye\\Api\\": "src/"
35 |         }
36 |     },
37 |     "autoload-dev": {
38 |         "psr-4": {
39 |             "AyeAye\\Api\\Tests\\": "tests/"
40 |         }
41 |     },
42 |     "config": {
43 |         "github-protocols": ["https"]
44 |     },
45 |     "scripts" : {
46 |       "lint" : [
47 |         "find -L src tests -name '*.php' -print0 | xargs -0 -n 1 -P 4 php -l"
48 |       ],
49 |       "test" : [
50 |         "@lint",
51 |         "vendor/bin/phpunit"
52 |       ],
53 |       "quality" : [
54 |         "vendor/bin/phpcpd src",
55 |         "vendor/bin/phpcs --standard=phpcs.xml src",
56 |         "vendor/bin/phpmd src text phpmd.xml"
57 |       ],
58 |       "quality-fix" : [
59 |         "vendor/bin/phpcbf --standard=phpcs.xml src"
60 |       ],
61 |       "report" : [
62 |         "vendor/bin/phploc --count-tests --log-csv reports/logs/phploc.csv --log-xml reports/logs/phploc.xml src tests",
63 |         "vendor/bin/pdepend --jdepend-xml=reports/logs/jdepend.xml --jdepend-chart=reports/dependencies.svg --overview-pyramid=reports/overview-pyramid.svg src",
64 |         "# vendor/bin/phpmd src xml tests reports/logs/pmd.xml",
65 |         "vendor/bin/phpcs --report=checkstyle --report-file=reports/logs/checkstyle.xml --standard=phpcs.xml src",
66 |         "vendor/bin/phpcpd --log-pmd reports/logs/pmd-cpd.xml src"
67 |       ],
68 |       "doc" : [
69 |         "vendor/bin/phpdoc"
70 |       ]
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/demo/HelloWorldController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | // HelloWorldController.php
 3 | 
 4 | use AyeAye\Api\Controller;
 5 | 
 6 | class HelloWorldController extends Controller
 7 | {
 8 |     /**
 9 |      * Yo ho ho
10 |      * @param string $name Optional, defaults to 'Captain'
11 |      * @return string
12 |      */
13 |     public function getAyeAyeEndpoint($name = 'Captain')
14 |     {
15 |         return "Aye Aye $name";
16 |     }
17 | 
18 |     /**
19 |      * lol...
20 |      * @return $this
21 |      */
22 |     public function ayeController()
23 |     {
24 |         return $this;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/demo/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | // index.php
 3 | 
 4 | require_once '../vendor/autoload.php';
 5 | require_once 'HelloWorldController.php';
 6 | 
 7 | use AyeAye\Api\Api;
 8 | use Psr\Log\AbstractLogger;
 9 | 
10 | class EchoLogger extends AbstractLogger
11 | {
12 |     public function log($level, $message, array $context = array())
13 |     {
14 |         echo $message.PHP_EOL;
15 |         $this->logArray($context);
16 |     }
17 | 
18 |     public function logArray($array, $indent = '  ')
19 |     {
20 |         foreach($array as $key => $value) {
21 |             if(!is_scalar($value)) {
22 |                 echo $indent.$key.':'.PHP_EOL;
23 |                 $this->logArray($value, $indent.'  ');
24 |                 continue;
25 |             }
26 |             echo $indent.$key.': '.$value;
27 |         }
28 |     }
29 | }
30 | 
31 | $initialController = new HelloWorldController();
32 | $api = new Api($initialController);
33 | $api->setLogger(new EchoLogger);
34 | 
35 | $api->go()->respond();
36 | 
37 | 


--------------------------------------------------------------------------------
/phpci.yml:
--------------------------------------------------------------------------------
 1 | setup:
 2 |   composer:
 3 |     action: "install"
 4 | 
 5 | test:
 6 |   php_unit:
 7 |     coverage: "reports/html"
 8 |   php_loc:
 9 |     directory: "src"
10 |   php_mess_detector:
11 |     path: "src"
12 |     rules:
13 |       - "codesize"
14 |       - "design"
15 |       - "cleancode"
16 |       - "naming"
17 |       - "unusedcode"
18 |     allow_failures: true
19 |     zero_config: true
20 | 


--------------------------------------------------------------------------------
/phpcs.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <ruleset name="Rules for PHPCS">
 3 |     <description>Used for maintaining standards in Aye Aye Api</description>
 4 | 
 5 |     <file>./src</file>
 6 |     <file>./tests</file>
 7 | 
 8 |     <rule ref="PSR1"/>
 9 |     <rule ref="PSR2"/>
10 | </ruleset>
11 | 


--------------------------------------------------------------------------------
/phpdoc.dist.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" ?>
 2 | <phpdoc>
 3 |     <parser>
 4 |         <target>reports/documentation</target>
 5 |         <encoding>utf8</encoding>
 6 |         <markers>
 7 |             <item>TODO</item>
 8 |             <item>FIXME</item>
 9 |         </markers>
10 |     </parser>
11 |     <transformer>
12 |         <target>reports/documentation</target>
13 |     </transformer>
14 |     <transformations>
15 |         <template name="responsive-twig" />
16 |     </transformations>
17 |     <files>
18 |         <directory>src</directory>
19 |         <directory>tests</directory>
20 |         <directory>vendor/ayeaye/formatters/src</directory>
21 |         <directory>vendor/ayeaye/formatters/tests</directory>
22 |     </files>
23 | </phpdoc>
24 | 


--------------------------------------------------------------------------------
/phpdox.xml:
--------------------------------------------------------------------------------
 1 | <phpdox xmlns="http://phpdox.net/config">
 2 |     <project name="AyeAye/Api" source="src" workdir="reports/phpdox">
 3 |         <collector publiconly="false">
 4 |             <include mask="*.php" />
 5 |         </collector>
 6 | 
 7 |         <generator output="reports">
 8 |             <build engine="html" enabled="true" output="api">
 9 |                 <file extension="html" />
10 |             </build>
11 |         </generator>
12 |     </project>
13 | </phpdox>
14 | 


--------------------------------------------------------------------------------
/phpmd.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <ruleset name="My first PHPMD rule set"
 3 |          xmlns="http://pmd.sf.net/ruleset/1.0.0"
 4 |          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5 |          xsi:schemaLocation="http://pmd.sf.net/ruleset/1.0.0
 6 |                      http://pmd.sf.net/ruleset_xml_schema.xsd"
 7 |          xsi:noNamespaceSchemaLocation="
 8 |                      http://pmd.sf.net/ruleset_xml_schema.xsd">
 9 |     <description>
10 |         Rulesets to check against Aye Aye
11 |     </description>
12 | 
13 |     <!-- Import the entire unused code rule set -->
14 |     <rule ref="rulesets/cleancode.xml" />
15 |     <rule ref="rulesets/codesize.xml" />
16 |     <rule ref="rulesets/controversial.xml" />
17 |     <rule ref="rulesets/design.xml" />
18 |     <rule ref="rulesets/naming.xml" />
19 |     <rule ref="rulesets/unusedcode.xml" />
20 | </ruleset>
21 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" ?>
 2 | <phpunit bootstrap="vendor/autoload.php"
 3 |          colors="true"
 4 |          convertErrorsToExceptions="true"
 5 |          convertNoticesToExceptions="true"
 6 |          convertWarningsToExceptions="true"
 7 |          beStrictAboutTestsThatDoNotTestAnything="true"
 8 |          checkForUnintentionallyCoveredCode="true"
 9 |          beStrictAboutOutputDuringTests="true"
10 |          beStrictAboutTestSize="true"
11 |          beStrictAboutChangesToGlobalState="true"
12 |          verbose="true"
13 |         >
14 |     <testsuites>
15 |         <testsuite name="ApiTests">
16 |             <directory>./tests</directory>
17 |         </testsuite>
18 |     </testsuites>
19 |     <logging>
20 |         <log type="coverage-html" target="reports/coverage"/>
21 |         <log type="coverage-clover" target="reports/logs/clover.xml"/>
22 |         <log type="coverage-crap4j" target="reports/logs/crap4j.xml"/>
23 |         <log type="junit" target="reports/logs/junit.xml" logIncompleteSkipped="false"/>
24 |     </logging>
25 |     <filter>
26 |         <whitelist processUncoveredFilesFromWhitelist="true">
27 |             <directory suffix=".php">src</directory>
28 |         </whitelist>
29 |     </filter>
30 | </phpunit>
31 | 


--------------------------------------------------------------------------------
/src/Api.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Api.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api;
 11 | 
 12 | use AyeAye\Api\Exception as AyeAyeException;
 13 | use AyeAye\Api\Injector\LoggerInjector;
 14 | use AyeAye\Api\Injector\RequestInjector;
 15 | use AyeAye\Api\Injector\ResponseInjector;
 16 | use AyeAye\Api\Injector\RouterInjector;
 17 | use AyeAye\Api\Injector\WriterFactoryInjector;
 18 | use AyeAye\Formatter\Writer\Json;
 19 | use Psr\Log\LoggerAwareInterface;
 20 | use Psr\Log\LogLevel;
 21 | 
 22 | /**
 23 |  * Class Api
 24 |  * Quick start your API with this class
 25 |  * @package AyeAye/Api
 26 |  * @see     https://github.com/AyeAyeApi/Api
 27 |  */
 28 | class Api implements LoggerAwareInterface
 29 | {
 30 |     use LoggerInjector;
 31 |     use RequestInjector;
 32 |     use ResponseInjector;
 33 |     use RouterInjector;
 34 |     use WriterFactoryInjector;
 35 | 
 36 |     /**
 37 |      * The starting controller for the Api
 38 |      * @var Controller
 39 |      */
 40 |     protected $controller;
 41 | 
 42 |     /**
 43 |      * Set up the API
 44 |      *
 45 |      * Initialise the API with a controller that forms the starting point of
 46 |      * routing information.
 47 |      *
 48 |      * @param Controller      $initialController The starting point for the Api
 49 |      */
 50 |     public function __construct(Controller $initialController)
 51 |     {
 52 |         $this->controller = $initialController;
 53 |     }
 54 | 
 55 |     /**
 56 |      * Write to the logger.
 57 |      *
 58 |      * Implementing the PSR LogAware interface.
 59 |      *
 60 |      * @param integer $level
 61 |      * @param string  $message
 62 |      * @param array   $context
 63 |      * @return $this
 64 |      */
 65 |     protected function log($level, $message, array $context = array())
 66 |     {
 67 |         $this->getLogger()->log($level, $message, $context);
 68 |         return $this;
 69 |     }
 70 | 
 71 |     /**
 72 |      * Process the request, get a response and return it.
 73 |      *
 74 |      * Exceptions thrown in most places will be handled here.
 75 |      * Currently there's no nice way to handle exceptions in Response::respond
 76 |      *
 77 |      * @return Response
 78 |      * @SuppressWarnings(PHPMD.ShortMethodName)
 79 |      */
 80 |     public function go()
 81 |     {
 82 |         $response = $this->getResponse();
 83 | 
 84 |         try {
 85 |             $request = $this->getRequest();
 86 |             $response->setWriterFactory(
 87 |                 $this->getWriterFactory()
 88 |             );
 89 |             $response->setRequest(
 90 |                 $request
 91 |             );
 92 |             $response->setBodyData(
 93 |                 $this->getRouter()->processRequest(
 94 |                     $this->getRequest(),
 95 |                     $this->controller
 96 |                 )
 97 |             );
 98 |             $response->setStatus(
 99 |                 $this->controller->getStatus()
100 |             );
101 |         } catch (AyeAyeException $e) {
102 |             $this->log(LogLevel::INFO, $e->getPublicMessage());
103 |             $this->log(LogLevel::ERROR, $e->getMessage(), ['exception' => $e]);
104 |             $response->setBodyData($e->getPublicMessage());
105 |             $response->setStatus(new Status($e->getCode()));
106 |         } catch (\Exception $e) {
107 |             $status = new Status(500);
108 |             $this->log(LogLevel::CRITICAL, $e->getMessage(), ['exception' => $e]);
109 |             $response->setBodyData($status->getMessage());
110 |             $response->setStatus($status);
111 |         }
112 | 
113 |         // Ultimate fail safe
114 |         try {
115 |             $response->prepareResponse();
116 |         } catch (\Exception $e) {
117 |             $this->log(LogLevel::CRITICAL, $e->getMessage(), ['exception' => $e]);
118 |             return $this->createFailSafeResponse();
119 |         }
120 | 
121 |         return $response;
122 |     }
123 | 
124 |     /**
125 |      * Returns a standardised 500 error.
126 |      *
127 |      * To be used in the event of a catastrophic failure, this method creates
128 |      * all new objects, ignoring dependency injection and returns in JSON.
129 |      *
130 |      * This will be problematic for users expecting a response in a format
131 |      * other than JSON and should only be called if the format they are
132 |      * actually expecting can not be provided when using
133 |      * Response::prepareResponse.
134 |      *
135 |      * @return Response
136 |      */
137 |     protected function createFailSafeResponse()
138 |     {
139 |         $status = new Status(500);
140 |         $response = new Response();
141 |         $response->setRequest(new Request());
142 |         $response->setWriter(new Json());
143 |         $response->setStatus($status);
144 |         $response->setBodyData($status->getMessage());
145 |         return $response;
146 |     }
147 | }
148 | 


--------------------------------------------------------------------------------
/src/Controller.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Controller.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api;
11 | 
12 | use AyeAye\Api\Injector\StatusInjector;
13 | 
14 | /**
15 |  * Class Controller
16 |  * Describes endpoints and child controllers
17 |  * @package AyeAye/Api
18 |  * @see     https://github.com/AyeAyeApi/Api
19 |  */
20 | class Controller
21 | {
22 |     use StatusInjector;
23 | 
24 |     /**
25 |      * Methods (controllers and endpoints) that should not be publicly listed.
26 |      * @var string[]
27 |      */
28 |     private $hiddenMethods = [
29 |         'getIndexEndpoint' => true, // Value not used
30 |     ];
31 | 
32 |     /**
33 |      * Hide a method
34 |      *
35 |      * When a controller or endpoint method is hidden, it will no longer be
36 |      * automatically listed in the controllers index. It will, however, still
37 |      * be accessible.
38 |      *
39 |      * @param $methodName
40 |      * @return $this
41 |      * @throws Exception
42 |      */
43 |     protected function hideMethod($methodName)
44 |     {
45 |         if (!method_exists($this, $methodName)) {
46 |             throw new Exception(500, "The method '$methodName' does not exist in ".get_called_class());
47 |         }
48 |         $this->hiddenMethods[$methodName] = true;
49 |         return $this;
50 |     }
51 | 
52 |     /**
53 |      * Is a method currently hidden.
54 |      *
55 |      * This is used to determine if it should be indexed or not.
56 |      *
57 |      * @param $methodName
58 |      * @return bool
59 |      * @throws Exception
60 |      */
61 |     public function isMethodHidden($methodName)
62 |     {
63 |         if (!method_exists($this, $methodName)) {
64 |             throw new Exception(500, "The method '$methodName' does not exist in ".get_called_class());
65 |         }
66 |         return isset($this->hiddenMethods[$methodName]);
67 |     }
68 | 
69 |     /**
70 |      * Show a hidden method.
71 |      *
72 |      * This reveals what would otherwise be a hidden method, allowing it to be
73 |      * indexed. If the named method does not exist, it will throw an exception
74 |      * via isMethodHidden.
75 |      *
76 |      * If the method exists but is not hidden this will not do anything.
77 |      *
78 |      * @param $methodName
79 |      * @return $this
80 |      * @throws Exception
81 |      */
82 |     protected function showMethod($methodName)
83 |     {
84 |         if ($this->isMethodHidden($methodName)) {
85 |             unset($this->hiddenMethods[$methodName]);
86 |         }
87 |         return $this;
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/src/ControllerDocumentation.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * ControllerDocumentation.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api;
 11 | 
 12 | use AyeAye\Formatter\Serializable;
 13 | 
 14 | /**
 15 |  * Class ControllerDocumentation
 16 |  *
 17 |  * Parses the relevant child controller and endpoint methods of a Controller
 18 |  * object through a Documentation object and returns the result as an array.
 19 |  * This is used to provide API documentation to end users.
 20 |  *
 21 |  * @package AyeAye/Api
 22 |  * @see     https://github.com/AyeAyeApi/Api
 23 |  */
 24 | class ControllerDocumentation implements Serializable
 25 | {
 26 |     /**
 27 |      * @var Controller
 28 |      */
 29 |     protected $controller;
 30 | 
 31 |     /**
 32 |      * @var \ReflectionObject
 33 |      */
 34 |     protected $reflectedController;
 35 | 
 36 |     /**
 37 |      * @var Documentation
 38 |      */
 39 |     protected $documentation;
 40 | 
 41 |     /**
 42 |      * Multi dimensional array of endpoint information
 43 |      * @var array[]
 44 |      */
 45 |     protected $endpointsCache;
 46 | 
 47 |     /**
 48 |      * A list of child controllers
 49 |      * @var string[]
 50 |      */
 51 |     protected $controllersCache;
 52 | 
 53 |     /**
 54 |      * ControllerDocumentation constructor.
 55 |      *
 56 |      * The reflection object must contain a valid controller class.
 57 |      *
 58 |      * @param Controller $controller
 59 |      * @param \ReflectionObject $reflectionController
 60 |      * @throws \InvalidArgumentException
 61 |      */
 62 |     public function __construct(Controller $controller, \ReflectionObject $reflectionController = null)
 63 |     {
 64 |         $this->controller = $controller;
 65 |         $this->reflectedController = $reflectionController;
 66 |         if(!$this->reflectedController) {
 67 |             $this->reflectedController = new \ReflectionObject($this->controller);
 68 |         }
 69 |         if(!$this->reflectedController->isInstance($controller)) {
 70 |             throw new \InvalidArgumentException(
 71 |                 'Controller did not match ReflectionObject'
 72 |             );
 73 |         }
 74 |         $this->documentation = new Documentation();
 75 |     }
 76 | 
 77 |     /**
 78 |      * List the endpoints the controller provides.
 79 |      *
 80 |      * It is the endpoint name, not the method name that is given. Endpoints
 81 |      * are grouped by http verb and will have their documentation listed. If
 82 |      * the endpoint has been "hidden" by the controller, it will not be listed.
 83 |      *
 84 |      * @return array
 85 |      */
 86 |     protected function getEndpoints()
 87 |     {
 88 |         if (!$this->endpointsCache) {
 89 |             $isHidden = $this->getControllerMethod('isMethodHidden');
 90 |             $endpoints = [];
 91 |             $parts = [];
 92 |             $methods = $this->reflectedController->getMethods(\ReflectionMethod::IS_PUBLIC);
 93 |             foreach ($methods as $method) {
 94 |                 if (preg_match('/([a-z]+)([A-Z]\w+)Endpoint$/', $method->getName(), $parts)) {
 95 |                     if (!$isHidden($method->getName())) {
 96 |                         $httpVerb = strtolower($parts[1]);
 97 |                         $endpoint = $this->camelcaseToHyphenated($parts[2]);
 98 |                         if (!array_key_exists($httpVerb, $endpoints)) {
 99 |                             $endpoints[$httpVerb] = array();
100 |                         }
101 |                         $endpoints[$httpVerb][$endpoint] = $this->documentation->getMethodDocumentation($method);
102 |                     }
103 |                 }
104 |             }
105 |             $this->endpointsCache = $endpoints;
106 |         }
107 |         return $this->endpointsCache;
108 |     }
109 | 
110 |     /**
111 |      * Lists child controllers the controller provides.
112 |      *
113 |      * It is the controller name, not the method name that is given. If the
114 |      * controller has been "hidden" by the controller, it will not be listed.
115 |      *
116 |      * @return array
117 |      */
118 |     protected function getControllers()
119 |     {
120 |         if (!$this->controllersCache) {
121 |             $isHidden = $this->getControllerMethod('isMethodHidden');
122 |             $methods = $this->reflectedController->getMethods(\ReflectionMethod::IS_PUBLIC);
123 |             $controllers = [];
124 |             foreach ($methods as $method) {
125 |                 if (preg_match('/(\w+)Controller$/', $method->getName(), $parts)) {
126 |                     if (!$isHidden($method->getName())) {
127 |                         $controllers[] = $this->camelcaseToHyphenated($parts[1]);
128 |                     }
129 |                 }
130 |             }
131 |             $this->controllersCache = $controllers;
132 |         }
133 |         return $this->controllersCache;
134 |     }
135 | 
136 |     /**
137 |      * Turns camel case strings into lowercase hyphenated strings.
138 |      *
139 |      * Hyphenated strings are more useful for breaking up words in urls.
140 |      *
141 |      * @param string $camelcaseString
142 |      * @return string Hyphenated string for urls
143 |      */
144 |     protected function camelcaseToHyphenated($camelcaseString)
145 |     {
146 |         return strtolower(preg_replace('/([a-z])([A-Z])/s', '$1-$2', $camelcaseString));
147 |     }
148 | 
149 |     /**
150 |      * Gets a callable method from the original controller.
151 |      *
152 |      * Given a method name in the controller, this method will return a
153 |      * callable function that will invoke the method with any arguments you
154 |      * provide.
155 |      *
156 |      * @param string $methodName
157 |      * @return \Closure
158 |      */
159 |     protected function getControllerMethod($methodName)
160 |     {
161 |         $reflectionMethod = $this->reflectedController->getMethod($methodName);
162 |         $reflectionMethod->setAccessible(true);
163 |         return function () use ($reflectionMethod) {
164 |             return $reflectionMethod->invokeArgs($this->controller, func_get_args());
165 |         };
166 |     }
167 | 
168 |     /**
169 |      * Returns the documentation of the controller.
170 |      *
171 |      * Returns an array containing bother child controllers and endpoints with
172 |      * their respective documentation. This can be given to an end user so that
173 |      * they can understand how this controller deals with requests.
174 |      *
175 |      * @return array
176 |      */
177 |     public function getDocumentation()
178 |     {
179 |         return [
180 |             'controllers' => $this->getControllers(),
181 |             'endpoints' => $this->getEndpoints(),
182 |         ];
183 |     }
184 | 
185 |     /**
186 |      * Returns the documentation of the controller.
187 |      *
188 |      * @see ::getDocumentation
189 |      * @return array
190 |      */
191 |     public function ayeAyeSerialize()
192 |     {
193 |         return $this->getDocumentation();
194 |     }
195 | }
196 | 


--------------------------------------------------------------------------------
/src/ControllerReflector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * ControllerReflector.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api;
11 | 
12 | /**
13 |  * Class ControllerReflector
14 |  *
15 |  * Takes a Controller and turns it into a ReflectionController.
16 |  *
17 |  * This class exists purely for dependency injection. Use ControllerReflectorInjector to replace it in order to
18 |  * replace ReflectionController.
19 |  *
20 |  * @package AyeAye/Api
21 |  * @see     https://github.com/AyeAyeApi/Api
22 |  */
23 | class ControllerReflector
24 | {
25 |     /**
26 |      * Reflects a given controller.
27 |      *
28 |      * Exists purely for Dependency Injection.
29 |      *
30 |      * @param Controller $controller
31 |      * @return ReflectionController
32 |      */
33 |     public function reflectController(Controller $controller)
34 |     {
35 |         return new ReflectionController($controller);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Documentation.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Documentation.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api;
 11 | 
 12 | /**
 13 |  * Class Documentation
 14 |  *
 15 |  * Parses PHP DocBlocks of methods based on PSR-5.
 16 |  *
 17 |  * @package AyeAye/Api
 18 |  * @see     https://github.com/AyeAyeApi/Api
 19 |  */
 20 | class Documentation
 21 | {
 22 |     /**
 23 |      * Breaks the doc block of the given method into its component parts
 24 |      *
 25 |      * Takes a Reflection method and returns an array containing the summary,
 26 |      * and description (if they exist), as well as parameters and return type.
 27 |      *
 28 |      * @param \ReflectionMethod $method
 29 |      * @return array
 30 |      */
 31 |     public function getMethodDocumentation(\ReflectionMethod $method)
 32 |     {
 33 |         $comment = $this->getMethodComment($method);
 34 | 
 35 |         $summary     = $this->getSummary($comment);
 36 |         $parameters  = $this->getParameters($comment);
 37 |         $returnType  = $this->getReturnType($comment);
 38 | 
 39 |         $documentation = [];
 40 |         if ($summary) {
 41 |             $documentation['summary'] = $summary;
 42 |             // If there is no Summary, there CAN NOT be a Description
 43 |             $description = $this->getDescription($comment);
 44 |             if ($description) {
 45 |                 $documentation['description'] = $description;
 46 |             }
 47 |         }
 48 | 
 49 |         // These should always show even if they're empty
 50 |         $documentation['parameters'] = $parameters;
 51 |         $documentation['returnType'] = $returnType;
 52 | 
 53 |         return $documentation;
 54 |     }
 55 | 
 56 |     /**
 57 |      * Get a cleaned up version of the method comment.
 58 |      *
 59 |      * Reflection methods return the doc block with the surrounding stars still
 60 |      * in the string. This method breaks the continuous string into individual
 61 |      * lines, removes the starting asterisks, and trims the line. Finally the
 62 |      * first and last lines of the comment are removed if they are empty.
 63 |      *
 64 |      * @param \ReflectionMethod $method
 65 |      * @return string[]
 66 |      */
 67 |     protected function getMethodComment(\ReflectionMethod $method)
 68 |     {
 69 |         $lines = preg_split("/((\r?\n)|(\r\n?))/", $method->getDocComment());
 70 |         $count = count($lines);
 71 |         foreach ($lines as $i => $line) {
 72 |             $line = preg_replace('/^\s*(\/\*\*|\*\/?)\s*/', '', $line);
 73 |             $line = trim($line);
 74 |             $lines[$i] = $line;
 75 |             if (!$line && ($i == 0 || $i == $count - 1)) { // If first or last lines are blank
 76 |                 unset($lines[$i]);
 77 |             }
 78 |         }
 79 | 
 80 |         return array_values($lines);
 81 | 
 82 |     }
 83 | 
 84 |     /**
 85 |      * Gets the summary of a method.
 86 |      *
 87 |      * Starting from the beginning of the doc block, this method extracts text
 88 |      * until it reaches a full stop at the end of a line, a blank line, or a
 89 |      * line beginning with an @ symbol.
 90 |      *
 91 |      * @param string[] $lines
 92 |      * @return string
 93 |      */
 94 |     protected function getSummary(array $lines)
 95 |     {
 96 |         $summary = '';
 97 |         foreach ($lines as $line) {
 98 |             // Check for blank line
 99 |             if (!$line) {
100 |                 // If summary exists break out
101 |                 if ($summary) {
102 |                     break;
103 |                 }
104 |                 continue;
105 |             }
106 | 
107 |             // Check for tag
108 |             if ($line[0] == '@') {
109 |                 break;
110 |             }
111 | 
112 |             // Otherwise we're good for summary
113 |             $summary .= $line . "\n";
114 |             if (substr($line, -1) == '.') {
115 |                 break;
116 |             }
117 |         }
118 | 
119 |         return trim($summary);
120 |     }
121 | 
122 |     /**
123 |      * Gets a methods description.
124 |      *
125 |      * Skips over the summary (as described above), then if there are further
126 |      * lines before the first line that begins with an @, then this will
127 |      * extract them as the description.
128 |      *
129 |      * This line and the paragraph above would all be extracted as description.
130 |      *
131 |      * @param string[] $lines
132 |      * @return string
133 |      */
134 |     protected function getDescription(array $lines)
135 |     {
136 |         $description = '';
137 |         $summaryFound = false;
138 |         $summaryPassed = false;
139 | 
140 |         foreach ($lines as $line) {
141 |             if ($line && !$summaryPassed) {
142 |                 $summaryFound = true;
143 |                 if (substr(trim($line), -1) == '.') {
144 |                     $summaryPassed = true;
145 |                 }
146 |                 continue;
147 |             }
148 |             if (!$line && $summaryFound && !$summaryPassed) {
149 |                 $summaryPassed = true;
150 |                 continue;
151 |             }
152 |             if ($line && $line[0] == '@') {
153 |                 break;
154 |             }
155 |             if ($line && $summaryPassed) {
156 |                 $description .= $line . "\n";
157 |             }
158 |         }
159 |         return trim($description);
160 |     }
161 | 
162 |     /**
163 |      * Gets the parameters of a method.
164 |      *
165 |      * Returns a keyed array with parameter name as the key, containing
166 |      * another array with 'type' and 'description'.
167 |      *
168 |      * @param string[] $lines
169 |      * @return array
170 |      */
171 |     protected function getParameters(array $lines)
172 |     {
173 |         $comment = implode("\n", $lines);
174 |         preg_match_all('/@param\s([\s\S]+?(?=@))/', $comment, $paramsDoc);
175 | 
176 |         $params = [];
177 |         if (isset($paramsDoc[1])) {
178 |             foreach ($paramsDoc[1] as $paramDoc) {
179 |                 // Break up the documentation into 3 parts:
180 |                 // @param type $name description
181 |                 // 1. The type
182 |                 // 2. The name
183 |                 // 3. The description
184 |                 $documentation = [];
185 |                 preg_match('/([^$]+)?\$(\w+)(.+)?/s', $paramDoc, $documentation);
186 |                 list(/*ignore*/, $type, $name, $description) = $documentation;
187 | 
188 | 
189 |                 // Clean up description
190 |                 $lines = preg_split("/((\r?\n)|(\r\n?))/", $description);
191 |                 foreach ($lines as $key => $value) {
192 |                     $value = preg_replace('/\r/', '', $value);
193 |                     $value = preg_replace('/^\s+\*/', '', $value);
194 |                     $value = trim($value);
195 |                     $lines[$key] = $value;
196 |                 }
197 |                 $description = implode("\n", $lines);
198 | 
199 |                 // Sort out the values
200 |                 $params[$name] = [
201 |                     'type' => trim($type),
202 |                     'description' => trim($description),
203 |                 ];
204 |             }
205 |         }
206 | 
207 |         return $params;
208 |     }
209 | 
210 |     /**
211 |      * Gets the return types from a method or function's comment.
212 |      *
213 |      * This method will always return an array to allow for the possibility of
214 |      * multiple return types split with | pipe. It will also replace '$this'
215 |      * with 'self' to (somewhat) hide internals.
216 |      *
217 |      * @param array $lines
218 |      * @return string[]
219 |      */
220 |     protected function getReturnType(array $lines)
221 |     {
222 |         foreach ($lines as $line) {
223 |             if (strpos($line, '@return') === 0) {
224 |                 $type = trim(str_replace('@return', '', $line));
225 |                 $type = str_replace('$this', 'self', $type);
226 |                 $type = explode('|', $type);
227 |                 return $type;
228 |             }
229 |         }
230 |         return [];
231 |     }
232 | }
233 | 


--------------------------------------------------------------------------------
/src/Exception.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Exception.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api;
 11 | 
 12 | /**
 13 |  * Class Exception
 14 |  *
 15 |  * An exception specifically designed to be thrown back to the API end user. It
 16 |  * provides a public message and HTTP status code.
 17 |  *
 18 |  * @package AyeAye/Api
 19 |  * @see     https://github.com/AyeAyeApi/Api
 20 |  */
 21 | class Exception extends \Exception implements \JsonSerializable
 22 | {
 23 |     const DEFAULT_ERROR_CODE = 500;
 24 |     const DEFAULT_MESSAGE = 'Internal Server Error';
 25 | 
 26 |     /**
 27 |      * A message to show the client if available
 28 |      * @var string
 29 |      */
 30 |     public $publicMessage;
 31 | 
 32 |     /**
 33 |      * Exception constructor.
 34 |      *
 35 |      * Include information to pass to the client.
 36 |      *
 37 |      * @param string $publicMessage Message to show the user if not caught. Optional
 38 |      * @param int $code HTTP Status code to send to the user
 39 |      * @param string $systemMessage Message to show the enter into the log if different from the public message
 40 |      * @param \Exception $previous Any previous Exception
 41 |      * @SuppressWarnings(PHPMD.StaticAccess)
 42 |      */
 43 |     public function __construct($publicMessage = '', $code = 500, $systemMessage = '', \Exception $previous = null)
 44 |     {
 45 |         // Shift all parameters along if the first parameter is a string
 46 |         if (is_int($publicMessage)) {
 47 |             if (is_string($code)) {
 48 |                 if ($systemMessage instanceof \Exception) {
 49 |                     $previous = $systemMessage;
 50 |                 }
 51 |                 $systemMessage = $code;
 52 |             }
 53 |             $code = $publicMessage;
 54 |             $publicMessage = null;
 55 |         }
 56 | 
 57 |         // If a public message wasn't specified, get it from the code
 58 |         if (!$publicMessage) {
 59 |             $publicMessage = Status::getMessageForCode($code);
 60 |             if (!$publicMessage) {
 61 |                 $publicMessage = static::DEFAULT_MESSAGE;
 62 |             }
 63 |         }
 64 | 
 65 |         // If the system message wasn't specified, use the public message
 66 |         if (!$systemMessage) {
 67 |             $systemMessage = $publicMessage;
 68 |         }
 69 | 
 70 |         $this->publicMessage = $publicMessage;
 71 | 
 72 |         parent::__construct($systemMessage, $code, $previous);
 73 |     }
 74 | 
 75 |     /**
 76 |      * Get the message to tell the client.
 77 |      *
 78 |      * This message should only ever contain information that is useful to the
 79 |      * client and will not compromise the condition of the server.
 80 |      *
 81 |      * @return string
 82 |      */
 83 |     public function getPublicMessage()
 84 |     {
 85 |         return $this->publicMessage;
 86 |     }
 87 | 
 88 |     /**
 89 |      * Return data to be serialised into Json.
 90 |      *
 91 |      * The returned data contains the public message and exception code (which
 92 |      * is likely to be the HTTP status code). It will also include any previous
 93 |      * Aye Aye Exceptions.
 94 |      *
 95 |      * @return array
 96 |      */
 97 |     public function jsonSerialize()
 98 |     {
 99 |         $serialized = [
100 |             'message' => $this->getPublicMessage(),
101 |             'code' => $this->getCode(),
102 |         ];
103 |         if ($this->getPrevious() instanceof $this) {
104 |             /** @var static $previous */
105 |             $previous = $this->getPrevious();
106 |             $serialized['previous'] = $previous->jsonSerialize();
107 |         }
108 |         return $serialized;
109 |     }
110 | }
111 | 


--------------------------------------------------------------------------------
/src/Injector/ControllerReflectorInjector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * ControllerReflectorInjector.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Injector;
11 | 
12 | use AyeAye\Api\ControllerReflector;
13 | 
14 | /**
15 |  * Trait ControllerReflectorInjector
16 |  * Allows the injection and management of a ControllerReflector object. Provides a default if one isn't set.
17 |  * @package AyeAye/Api
18 |  * @see     https://github.com/AyeAyeApi/Api
19 |  */
20 | trait ControllerReflectorInjector
21 | {
22 |     /**
23 |      * @var ControllerReflector
24 |      */
25 |     private $controllerReflector;
26 | 
27 |     /**
28 |      * Get the controller reflector.
29 |      *
30 |      * If a controller reflector has not been set, a default is set and then
31 |      * returned.
32 |      *
33 |      * @return ControllerReflector
34 |      */
35 |     public function getControllerReflector()
36 |     {
37 |         if (!$this->controllerReflector) {
38 |             $this->controllerReflector = new ControllerReflector();
39 |         }
40 |         return $this->controllerReflector;
41 |     }
42 | 
43 |     /**
44 |      * Set a controller reflector object.
45 |      *
46 |      * This allows Dependency Injection.
47 |      *
48 |      * @param ControllerReflector $controllerReflector
49 |      * @return $this
50 |      */
51 |     public function setControllerReflector($controllerReflector)
52 |     {
53 |         $this->controllerReflector = $controllerReflector;
54 |         return $this;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Injector/LoggerInjector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * LoggerInjector.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Injector;
11 | 
12 | use Psr\Log\LoggerInterface;
13 | use Psr\Log\NullLogger;
14 | 
15 | /**
16 |  * Trait LoggerInjector
17 |  * Allows the injection and management of a Psr/LoggerInterface object. Provides a NullLogger if one isn't set.
18 |  * @package AyeAye/Api
19 |  * @see     https://github.com/AyeAyeApi/Api
20 |  */
21 | trait LoggerInjector
22 | {
23 |     /**
24 |      * @var LoggerInterface
25 |      */
26 |     private $logger;
27 | 
28 |     /**
29 |      * Set a PSR logger.
30 |      *
31 |      * @param LoggerInterface $logger
32 |      * @return $this
33 |      */
34 |     public function setLogger(LoggerInterface $logger)
35 |     {
36 |         $this->logger = $logger;
37 |         return $this;
38 |     }
39 | 
40 |     /**
41 |      * Get the previously set PSR logger.
42 |      *
43 |      * If a logger has not been set, the PSR NullLogger will be returned. This
44 |      * can be used like any other logger but won't have any effect.
45 |      *
46 |      * @return NullLogger
47 |      */
48 |     public function getLogger()
49 |     {
50 |         if (!$this->logger) {
51 |             $this->logger = new NullLogger();
52 |         }
53 |         return $this->logger;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Injector/RequestInjector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * RequestInjector.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Injector;
11 | 
12 | use AyeAye\Api\Request;
13 | 
14 | /**
15 |  * Trait RequestInjector
16 |  * Allows the injection and management of a Request object. Provides a default if one isn't set.
17 |  * @package AyeAye/Api
18 |  * @see     https://github.com/AyeAyeApi/Api
19 |  */
20 | trait RequestInjector
21 | {
22 |     /**
23 |      * The request object to use for this call
24 |      * @var Request
25 |      */
26 |     private $request;
27 | 
28 |     /**
29 |      * Set the request object.
30 |      *
31 |      * Use for injecting or overriding the actual request from the client.
32 |      *
33 |      * @param Request $request
34 |      * @return $this;
35 |      */
36 |     public function setRequest(Request $request)
37 |     {
38 |         $this->request = $request;
39 |         return $this;
40 |     }
41 | 
42 |     /**
43 |      * Get the request object.
44 |      *
45 |      * If none is set it will create a default Request object that makes
46 |      * available all of the parameters Aye Aye can find in the actual request
47 |      * from the user.
48 |      *
49 |      * @return Request
50 |      */
51 |     public function getRequest()
52 |     {
53 |         if (!$this->request) {
54 |             $this->request = new Request();
55 |         }
56 |         return $this->request;
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Injector/ResponseInjector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * ResponseInjector.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Injector;
11 | 
12 | use AyeAye\Api\Response;
13 | 
14 | /**
15 |  * Trait ResponseInjector
16 |  * Allows the injection and management of a Response object. Provides a default if one isn't set.
17 |  * @package AyeAye/Api
18 |  * @see     https://github.com/AyeAyeApi/Api
19 |  */
20 | trait ResponseInjector
21 | {
22 |     /**
23 |      * The response object to return for this call
24 |      * @var Response
25 |      */
26 |     private $response;
27 | 
28 |     /**
29 |      * Set the response object.
30 |      *
31 |      * Use for dependency injection.
32 |      *
33 |      * @param Response $response
34 |      * @returns $this
35 |      */
36 |     public function setResponse(Response $response)
37 |     {
38 |         $this->response = $response;
39 |         return $this;
40 |     }
41 | 
42 |     /**
43 |      * Get the response object.
44 |      *
45 |      * If none is set it will create a default Response object.
46 |      *
47 |      * @return Response
48 |      */
49 |     public function getResponse()
50 |     {
51 |         if (!$this->response) {
52 |             $this->response = new Response();
53 |         }
54 |         return $this->response;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Injector/RouterInjector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * RouterInjector.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Injector;
11 | 
12 | use AyeAye\Api\Router;
13 | 
14 | /**
15 |  * Trait RouterInjector
16 |  * Allows the injection and management of a Router object. Provides a default if one isn't set.
17 |  * @package AyeAye/Api
18 |  * @see     https://github.com/AyeAyeApi/Api
19 |  */
20 | trait RouterInjector
21 | {
22 |     /**
23 |      * The router that will direct the request
24 |      * @var Router
25 |      */
26 |     private $router;
27 | 
28 |     /**
29 |      * Set the router to be used when go is called.
30 |      *
31 |      * Use this for dependency injection.
32 |      *
33 |      * @param Router $router
34 |      * @return $this;
35 |      */
36 |     public function setRouter(Router $router)
37 |     {
38 |         $this->router = $router;
39 |         return $this;
40 |     }
41 | 
42 |     /**
43 |      * Get the router.
44 |      *
45 |      * If no router has been set, the default will be used.
46 |      *
47 |      * @return Router
48 |      */
49 |     public function getRouter()
50 |     {
51 |         if (!$this->router) {
52 |             $this->router = new Router();
53 |         }
54 |         return $this->router;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Injector/StatusInjector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * StatusInjector.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Injector;
11 | 
12 | use AyeAye\Api\Status;
13 | 
14 | /**
15 |  * Trait StatusInjector
16 |  * Allows the injection and management of a Status object. Provides a default if one isn't set.
17 |  * Note: The default status is "200 OK". If an error occurred the status must be updated.
18 |  * @package AyeAye/Api
19 |  * @see     https://github.com/AyeAyeApi/Api
20 |  */
21 | trait StatusInjector
22 | {
23 |     /**
24 |      * @var Status
25 |      */
26 |     private $status;
27 | 
28 |     /**
29 |      * Get the status from the current object.
30 |      *
31 |      * If a status has not been set, a default "200 OK" status is returned.
32 |      *
33 |      * @return Status
34 |      */
35 |     public function getStatus()
36 |     {
37 |         if (!$this->status) {
38 |             $this->status = new Status();
39 |         }
40 |         return $this->status;
41 |     }
42 | 
43 |     /**
44 |      * Set the status for the current object.
45 |      *
46 |      * Use any time the status of the request changes. Avoid setting to 200 as
47 |      * this will be the default and it would be undesirable to change a bad
48 |      * status to OK.
49 |      *
50 |      * @param Status $status
51 |      * @return $this
52 |      */
53 |     public function setStatus(Status $status)
54 |     {
55 |         $this->status = $status;
56 |         return $this;
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Injector/WriterFactoryInjector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * WriterFactoryInjector.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Injector;
11 | 
12 | use AyeAye\Formatter\WriterFactory;
13 | use AyeAye\Formatter\Writer\Json;
14 | use AyeAye\Formatter\Writer\Xml;
15 | 
16 | /**
17 |  * Trait WriterFactoryInjector
18 |  * Allows the injection and management of a WriterFactory object. Provides a default if one isn't set.
19 |  * Note: The default WriterFactory provides writers for Json and XML
20 |  * @package AyeAye/Api
21 |  * @see     https://github.com/AyeAyeApi/Api
22 |  */
23 | trait WriterFactoryInjector
24 | {
25 |     /**
26 |      * A collection of writers available
27 |      * @var WriterFactory
28 |      */
29 |     private $writerFactory;
30 | 
31 |     /**
32 |      * Sets the writer factory.
33 |      *
34 |      * Use for dependency injection.
35 |      *
36 |      * @param WriterFactory $writerFactory
37 |      * @returns $this
38 |      */
39 |     public function setWriterFactory(WriterFactory $writerFactory)
40 |     {
41 |         $this->writerFactory = $writerFactory;
42 |         return $this;
43 |     }
44 | 
45 |     /**
46 |      * Get the writer factory.
47 |      *
48 |      * If none is set it will create a default format factory for xml and json
49 |      *
50 |      * @return WriterFactory
51 |      */
52 |     public function getWriterFactory()
53 |     {
54 |         if (!$this->writerFactory) {
55 |             $xmlFormatter = new Xml();
56 |             $jsonFormatter = new Json();
57 |             $this->writerFactory = new WriterFactory([
58 |                 // xml
59 |                 'xml' => $xmlFormatter,
60 |                 'text/xml' => $xmlFormatter,
61 |                 'application/xml' => $xmlFormatter,
62 |                 // json
63 |                 'json' => $jsonFormatter,
64 |                 'application/json' => $jsonFormatter,
65 |             ]);
66 |         }
67 |         return $this->writerFactory;
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/ReflectionController.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * ReflectionController.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api;
 11 | 
 12 | use AyeAye\Formatter\Deserializable;
 13 | 
 14 | /**
 15 |  * Class ReflectionController
 16 |  *
 17 |  * Provides functionality similar to ReflectionObject (which is what is used underneath) to provide Controller specific
 18 |  * code reflection.
 19 |  *
 20 |  * @package AyeAye/Api
 21 |  * @see     https://github.com/AyeAyeApi/Api
 22 |  */
 23 | class ReflectionController
 24 | {
 25 |     /**
 26 |      * @var Controller
 27 |      */
 28 |     protected $controller;
 29 | 
 30 |     /**
 31 |      * @var \ReflectionObject
 32 |      */
 33 |     protected $reflection;
 34 | 
 35 |     /**
 36 |      * ReflectionController constructor.
 37 |      *
 38 |      * Initialise a ReflectionController with a valid controller. It will be
 39 |      * reflected into a reflection object that will allow us to analyse its
 40 |      * features.
 41 |      *
 42 |      * @param Controller $controller
 43 |      */
 44 |     public function __construct(Controller $controller)
 45 |     {
 46 |         $this->controller = $controller;
 47 |         $this->reflection = new \ReflectionObject($controller);
 48 |     }
 49 | 
 50 |     /**
 51 |      * Check for a particular endpoint.
 52 |      *
 53 |      * Takes the request method (http verb) and endpoint name and checks for a
 54 |      * matching class method.
 55 |      *
 56 |      * @param $method
 57 |      * @param $endpointName
 58 |      * @return bool
 59 |      */
 60 |     public function hasEndpoint($method, $endpointName)
 61 |     {
 62 |         $methodName = $this->parseEndpointName($method, $endpointName);
 63 |         return $this->reflection->hasMethod($methodName);
 64 |     }
 65 | 
 66 |     /**
 67 |      * Call an endpoint and get the result.
 68 |      *
 69 |      * This method will parse the request into the endpoint methods parameters
 70 |      * so the writer of an endpoint need only describe the information they
 71 |      * need in the method declaration.
 72 |      *
 73 |      * @param $method
 74 |      * @param $endpointName
 75 |      * @param Request $request
 76 |      * @return mixed
 77 |      */
 78 |     public function getEndpointResult($method, $endpointName, Request $request)
 79 |     {
 80 |         $methodName = $this->parseEndpointName($method, $endpointName);
 81 |         if (!$this->reflection->hasMethod($methodName)) {
 82 |             throw new \RuntimeException("{$this->reflection->getName()}::{$methodName} does not exist");
 83 |         }
 84 | 
 85 |         $reflectionMethod = $this->reflection->getMethod($methodName);
 86 |         return $reflectionMethod->invokeArgs(
 87 |             $this->controller,
 88 |             $this->mapRequestToArguments($reflectionMethod, $request)
 89 |         );
 90 |     }
 91 | 
 92 |     /**
 93 |      * Creates an array of parameters with which to call a method.
 94 |      *
 95 |      * Matches the parameters in a given method to the values available in the
 96 |      * given request. For absent values, either the default, or null, will be
 97 |      * used.
 98 |      *
 99 |      * @param \ReflectionMethod $method
100 |      * @param Request $request
101 |      * @return array
102 |      */
103 |     protected function mapRequestToArguments(\ReflectionMethod $method, Request $request)
104 |     {
105 |         $map = [];
106 |         foreach ($method->getParameters() as $parameter) {
107 |             $value = $request->getParameter(
108 |                 $parameter->getName(),
109 |                 $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null
110 |             );
111 |             if ($parameter->getClass() &&
112 |                 $parameter->getClass()->implementsInterface(Deserializable::class)
113 |             ) {
114 |                 /** @var Deserializable $deserializable */
115 |                 $value = $parameter->getClass()
116 |                     ->newInstanceWithoutConstructor()
117 |                     ->ayeAyeDeserialize($value);
118 |                 $className = $parameter->getClass()->getName();
119 |                 if (!is_object($value) || get_class($value) !== $className) {
120 |                     throw new \RuntimeException("$className::ayeAyeDeserialize did not return an instance of itself");
121 |                 }
122 |             }
123 |             $map[$parameter->getName()] = $value;
124 |         }
125 |         return $map;
126 |     }
127 | 
128 |     /**
129 |      * Construct the method name for an endpoint.
130 |      *
131 |      * Endpoint methods are constructed like this [method][name]Endpoint. The
132 |      * method name is lower cased, the endpoint name is upper camel cased, and
133 |      * the class method name ends with the word "Endpoint".
134 |      *
135 |      * @example GET hello-world => getHelloWorldEndpoint
136 |      *
137 |      * @param string $method
138 |      * @param string $endpoint
139 |      * @return string
140 |      */
141 |     protected function parseEndpointName($method, $endpoint)
142 |     {
143 |         $endpoint = str_replace(' ', '', ucwords(str_replace(['-', '+', '%20'], ' ', $endpoint)));
144 |         $method = strtolower($method);
145 |         return $method . $endpoint . 'Endpoint';
146 |     }
147 | 
148 |     /**
149 |      * Check if the named controller exists as a child of this controller.
150 |      *
151 |      * Takes the requested child controller name and checks for a corresponding
152 |      * class method name. (Note: The class method will end with the word
153 |      * Controller)
154 |      *
155 |      * @param $controllerName
156 |      * @return bool
157 |      */
158 |     public function hasChildController($controllerName)
159 |     {
160 |         $methodName = $this->parseControllerName($controllerName);
161 |         return $this->reflection->hasMethod($methodName);
162 |     }
163 | 
164 |     /**
165 |      * Get the child controller object.
166 |      *
167 |      * Gets the new child controller object from the child controller class
168 |      * method. If the method does not exist, or the returned value is not a
169 |      * controller object, a \RuntimeException is thrown.
170 |      *
171 |      * @throws \RuntimeException
172 |      * @param $controllerName
173 |      * @return Controller
174 |      */
175 |     public function getChildController($controllerName)
176 |     {
177 |         $methodName = $this->parseControllerName($controllerName);
178 |         if (!$this->reflection->hasMethod($methodName)) {
179 |             throw new \RuntimeException("{$this->reflection->getName()}::{$methodName} does not exist");
180 |         }
181 | 
182 |         $controller = $this->reflection->getMethod($methodName)->invokeArgs($this->controller, []);
183 |         if (!is_object($controller) || !$controller instanceof Controller) {
184 |             throw new \RuntimeException("{$this->reflection->getName()}::{$methodName} did not return a Controller");
185 |         }
186 |         return $controller;
187 |     }
188 | 
189 |     /**
190 |      * Construct the method name for a controller
191 |      *
192 |      * The methods for child controllers are simple named [name]Controller
193 |      * where [name] is lower camel cased.
194 |      *
195 |      * @example hello-world => helloWorldController
196 |      *
197 |      * @param string $controller
198 |      * @return string
199 |      */
200 |     protected function parseControllerName($controller)
201 |     {
202 |         $controller = str_replace(' ', '', lcfirst(ucwords(str_replace(['-', '+', '%20'], ' ', $controller))));
203 |         return $controller . 'Controller';
204 |     }
205 | 
206 |     /**
207 |      * Get the status of the controller.
208 |      *
209 |      * This is a simple wrapper function.
210 |      *
211 |      * @return Status
212 |      */
213 |     public function getStatus()
214 |     {
215 |         return $this->controller->getStatus();
216 |     }
217 | 
218 |     /**
219 |      * Get the documentation for a controller.
220 |      *
221 |      * Creates a documentation object from the reflected controller.
222 |      *
223 |      * @return ControllerDocumentation
224 |      */
225 |     public function getDocumentation()
226 |     {
227 |         return new ControllerDocumentation($this->controller, $this->reflection);
228 |     }
229 | }
230 | 


--------------------------------------------------------------------------------
/src/Request.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Request.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api;
 11 | 
 12 | use AyeAye\Formatter\Reader\Json;
 13 | use AyeAye\Formatter\Reader\Xml;
 14 | use AyeAye\Formatter\ReaderFactory;
 15 | 
 16 | /**
 17 |  * Class Request.
 18 |  *
 19 |  * Describes the details of a request from the client.
 20 |  *
 21 |  * @package AyeAye/Api
 22 |  * @see     https://github.com/AyeAyeApi/Api
 23 |  */
 24 | class Request implements \JsonSerializable
 25 | {
 26 |     // HTTP verbs as defined in http://www.ietf.org/rfc/rfc2616
 27 |     const METHOD_GET = 'GET';
 28 |     const METHOD_HEAD = 'HEAD';
 29 |     const METHOD_POST = 'POST';
 30 |     const METHOD_PUT = 'PUT';
 31 |     const METHOD_DELETE = 'DELETE';
 32 |     const METHOD_TRACE = 'TRACE';
 33 |     const METHOD_OPTIONS = 'OPTIONS';
 34 |     const METHOD_CONNECT = 'CONNECT';
 35 |     const METHOD_PATCH = 'PATCH';
 36 | 
 37 |     const DEFAULT_FORMAT = 'json';
 38 | 
 39 |     /**
 40 |      * A list of accepted HTTP verbs. By default everything is accepted
 41 |      * however, you could extend Request and provide a different list.
 42 |      * @var array
 43 |      */
 44 |     public $allowedMethods = [
 45 |         self::METHOD_GET,
 46 |         self::METHOD_HEAD,
 47 |         self::METHOD_POST,
 48 |         self::METHOD_PUT,
 49 |         self::METHOD_DELETE,
 50 |         self::METHOD_TRACE,
 51 |         self::METHOD_OPTIONS,
 52 |         self::METHOD_CONNECT,
 53 |         self::METHOD_PATCH,
 54 |     ];
 55 | 
 56 |     /**
 57 |      * The method of request
 58 |      * @var string
 59 |      */
 60 |     protected $requestMethod = null;
 61 | 
 62 |     /**
 63 |      * What uri did the client request
 64 |      * @var string
 65 |      */
 66 |     protected $requestedUri = '';
 67 | 
 68 |     /**
 69 |      * The requested uri as an array.
 70 |      * @var array
 71 |      */
 72 |     protected $requestChain = null;
 73 | 
 74 |     /**
 75 |      * An amalgamation of all parameters sent in any way.
 76 |      * @var array
 77 |      */
 78 |     protected $parameters = [];
 79 | 
 80 |     /**
 81 |      * The reader factory contains readers that might be able to read the body
 82 |      * @var ReaderFactory
 83 |      */
 84 |     protected $readerFactory;
 85 | 
 86 |     /**
 87 |      * Request constructor.
 88 |      *
 89 |      * To take the request as is from PHP, instantiate this class without
 90 |      * specifying and arguments. The constructor can be used to immediately
 91 |      * override any part of the request or even be used to arbitrarily define
 92 |      * request parameters.
 93 |      *
 94 |      * Note: If any parameters are defined, this will block the actual request
 95 |      * parameters from being used.
 96 |      *
 97 |      * @param string $requestedMethod
 98 |      * @param string $requestedUri
 99 |      * @param ReaderFactory $readerFactory
100 |      * @param array|object ...$parameters Any number of arrays or objects containing request parameters such as _GET,
101 |      *                                   _POST. This will override the defaults which will otherwise be taken from the
102 |      *                                   url and _REQUEST global variable.
103 |      */
104 |     public function __construct(
105 |         $requestedMethod = null,
106 |         $requestedUri = null,
107 |         ReaderFactory $readerFactory = null
108 |     ) {
109 |         $this->readerFactory = $readerFactory;
110 | 
111 |         $parameters = array_slice(func_get_args(), 3);
112 |         foreach ($parameters as $parameterGroup) {
113 |             $this->setParameters($parameterGroup);
114 |         }
115 | 
116 |         $this->requestMethod = $requestedMethod ?: $this->getRequestMethod();
117 |         $this->requestedUri  = $requestedUri    ?: $this->getRequestedUri();
118 |         if (!$this->parameters) {
119 |             $this->parameters = $this->useActualParameters();
120 |         }
121 |     }
122 | 
123 |     /**
124 |      * Get the reader factory.
125 |      *
126 |      * If none is set, then create one, set it and return it. By default it
127 |      * will only be able to read Xml and Json.
128 |      *
129 |      * @return ReaderFactory
130 |      */
131 |     protected function getReaderFactory()
132 |     {
133 |         if (!$this->readerFactory) {
134 |             $this->readerFactory = new ReaderFactory([
135 |                 new Json(),
136 |                 new Xml(),
137 |             ]);
138 |         }
139 |         return $this->readerFactory;
140 |     }
141 | 
142 |     /**
143 |      * Get the HTTP verb for this request.
144 |      *
145 |      * The actual verb can be overridden simply by setting it in the
146 |      * constructor. If no verb is set, and for some reason it can not be found
147 |      * in the _SERVER global variable, a default of 'GET' will be returned.
148 |      *
149 |      * @SuppressWarnings(PHPMD.Superglobals)
150 |      * @return string
151 |      */
152 |     protected function getRequestMethod()
153 |     {
154 |         if ($this->requestMethod) {
155 |             return $this->requestMethod;
156 |         }
157 |         if (array_key_exists('REQUEST_METHOD', $_SERVER)) {
158 |             return $_SERVER['REQUEST_METHOD'];
159 |         }
160 |         return static::METHOD_GET;
161 |     }
162 | 
163 |     /**
164 |      * Get the requested uri.
165 |      *
166 |      * The actual uri can be overridden simply by setting it in the
167 |      * constructor. If no uri is set, and for some reason it can not be found
168 |      * in the _SERVER global variable, a default of '' will be returned.
169 |      *
170 |      * @SuppressWarnings(PHPMD.Superglobals)
171 |      * @return string
172 |      */
173 |     protected function getRequestedUri()
174 |     {
175 |         if ($this->requestedUri) {
176 |             return $this->requestedUri;
177 |         }
178 |         if (array_key_exists('REQUEST_URI', $_SERVER)) {
179 |             return $_SERVER['REQUEST_URI'];
180 |         }
181 |         return '';
182 |     }
183 | 
184 |     /**
185 |      * Get parameters associated with this request.
186 |      *
187 |      * Starts the url itself, then the _REQUEST super global, adds headers,
188 |      * then body, overriding in that order (i.e. if a body variable overrides
189 |      * a header, the body will be used instead).
190 |      *
191 |      * @return array
192 |      * @SuppressWarnings(PHPMD.Superglobals)
193 |      */
194 |     protected function useActualParameters()
195 |     {
196 |         $this->setParameters($this->urlToParameters($this->getRequestedUri()));
197 |         $this->setParameters($_REQUEST);
198 |         $this->setParameters($this->parseHeader($_SERVER));
199 |         $this->setParameters($this->stringToArray($this->readBody()));
200 |         return $this->getParameters();
201 |     }
202 | 
203 |     /**
204 |      * Parse headers.
205 |      *
206 |      * This method should be passed the _SERVER global array. Most http headers
207 |      * in PHP are prefixed with HTTP_ however, there are two values prefixed
208 |      * with CONTENT_. All other values in the array will be ignored.
209 |      *
210 |      * @param string[] $headers
211 |      * @return string
212 |      */
213 |     protected function parseHeader(array $headers = [])
214 |     {
215 |         $processedHeaders = array();
216 |         foreach ($headers as $key => $value) {
217 |             if (substr($key, 0, 5) == 'HTTP_') {
218 |                 $name = str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($key, 5)))));
219 |                 $processedHeaders[$name] = $value;
220 |             } elseif ($key == 'CONTENT_TYPE') {
221 |                 $processedHeaders['Content-Type'] = $value;
222 |             } elseif ($key == 'CONTENT_LENGTH') {
223 |                 $processedHeaders['Content-Length'] = $value;
224 |             }
225 |         }
226 |         return $processedHeaders;
227 |     }
228 | 
229 |     /**
230 |      * Reads in the body of the request.
231 |      *
232 |      * Uses php streams to get the body of a request.
233 |      *
234 |      * @return string
235 |      */
236 |     protected function readBody()
237 |     {
238 |         return file_get_contents('php://input');
239 |     }
240 | 
241 |     /**
242 |      * Turns a url string into an array of parameters.
243 |      *
244 |      * This can be a little bit confusing but it allows people to create
245 |      * pretty uri's for an API. This array simply parametrises the uri
246 |      * by assuming each slug is the key for the following one.
247 |      *
248 |      * @example 'here/is/an/example' => ['here' => 'is', 'is' => 'an', 'an' => 'example']
249 |      *
250 |      * @param string $url
251 |      * @return array
252 |      * @SuppressWarnings(PHPMD.Superglobals)
253 |      */
254 |     protected function urlToParameters($url)
255 |     {
256 |         $urlParameters = [];
257 |         $url = parse_url($url, PHP_URL_PATH);
258 |         $urlParts = explode('/', $url);
259 |         reset($urlParts); // Note, the first entry will always be blank
260 |         $key = next($urlParts);
261 |         while (($value = next($urlParts)) !== false) {
262 |             $urlParameters[$key] = $value;
263 |             $key = $value;
264 |         }
265 |         return $urlParameters;
266 |     }
267 | 
268 |     /**
269 |      * Tries to turn a string of data into an array.
270 |      *
271 |      * This method uses a ReaderFactory that will attempt to read the sting
272 |      * as a number of predefined strings, accepting the first one that returns
273 |      * something. Failing all else, if there was a string it will return an
274 |      * array with the text attached to a 'text' key
275 |      * eg. $this->stringToArray('fail')['body'] == 'fail'
276 |      *
277 |      * @param string $string
278 |      * @return array
279 |      */
280 |     protected function stringToArray($string)
281 |     {
282 |         if (!$string || !is_string($string)) {
283 |             return [];
284 |         }
285 | 
286 |         $result = $this->getReaderFactory()->read($string);
287 |         if ($result) {
288 |             return $result;
289 |         }
290 | 
291 |         $array = [];
292 |         $array['text'] = $string;
293 |         return $array;
294 |     }
295 | 
296 |     /**
297 |      * The http method being used.
298 |      *
299 |      * Get the http verb used for the request.
300 |      *
301 |      * @return string
302 |      */
303 |     public function getMethod()
304 |     {
305 |         return $this->requestMethod;
306 |     }
307 | 
308 |     /**
309 |      * Look up the value of a requested parameter.
310 |      *
311 |      * A default can be specified. If the parameter is not found the default
312 |      * will be returned. The 'default' defaults to null.
313 |      *
314 |      * @param string $key
315 |      * @param bool $default
316 |      * @return mixed
317 |      */
318 |     public function getParameter($key, $default = null)
319 |     {
320 |         // Request _should_ contain get, post and cookies
321 |         if (array_key_exists($key, $this->parameters)) {
322 |             return $this->parameters[$key];
323 |         }
324 |         // We can also flatten out the variable names to see if they exist
325 |         $flatKey = $this->flatten($key);
326 |         foreach ($this->parameters as $index => $value) {
327 |             if ($flatKey == $this->flatten($index)) {
328 |                 return $value;
329 |             }
330 |         }
331 |         return $default;
332 |     }
333 | 
334 |     /**
335 |      * Flatten a variable name.
336 |      *
337 |      * Simply removes all non alpha numeric characters (except hyphen and
338 |      * underscore) and makes it lower case.
339 |      *
340 |      * @param $name
341 |      * @return string
342 |      */
343 |     protected function flatten($name)
344 |     {
345 |         return strtolower(preg_replace('/[\W_-]/', '', $name));
346 |     }
347 | 
348 |     /**
349 |      * Returns all parameters.
350 |      *
351 |      * This method should only be used for debugging.
352 |      *
353 |      * @return array
354 |      */
355 |     public function getParameters()
356 |     {
357 |         return $this->parameters;
358 |     }
359 | 
360 |     /**
361 |      * Get the requested route.
362 |      *
363 |      * Breaks the uri into an array that can be used by the router to determine
364 |      * which controller and endpoint should be called.
365 |      *
366 |      * @return string[]
367 |      */
368 |     public function getRequestChain()
369 |     {
370 |         if (is_null($this->requestChain)) {
371 |             $this->requestChain = $this->getRequestChainFromUri($this->requestedUri);
372 |         }
373 |         return $this->requestChain;
374 |     }
375 | 
376 |     /**
377 |      * Returns an array of possible formats.
378 |      *
379 |      * The request could specify the desired response format in a number of
380 |      * ways, this method returns them all including a final default fallback.
381 |      *
382 |      * @return string
383 |      */
384 |     public function getFormats()
385 |     {
386 |         return [
387 |             'header' => $this->getParameter('Accept'),
388 |             'suffix' => $this->getFormatFromUri($this->requestedUri),
389 |             'default' => static::DEFAULT_FORMAT,
390 |         ];
391 |     }
392 | 
393 |     /**
394 |      * Used by PHP to get json object.
395 |      *
396 |      * This method is useful for debugging incoming requests. It should not
397 |      * reveal anything the sender does not know, but might help explain how
398 |      * the request has been processed.
399 |      *
400 |      * @return array|mixed
401 |      */
402 |     public function jsonSerialize()
403 |     {
404 |         return [
405 |             'method' => $this->getMethod(),
406 |             'requestedUri' => $this->requestedUri,
407 |             'parameters' => $this->getParameters()
408 |         ];
409 |     }
410 | 
411 |     /**
412 |      * Get the format from the url.
413 |      *
414 |      * If the request had a suffix in the url, this method will discover it and
415 |      * return it.
416 |      *
417 |      * @example /hello-world.json => json
418 |      * @example /hello-world.xml => xml
419 |      * @example /hello-world => null
420 |      *
421 |      * @param $requestedUri
422 |      * @return string|null
423 |      */
424 |     protected function getFormatFromUri($requestedUri)
425 |     {
426 |         $uriParts = explode('?', $requestedUri, 2);
427 |         $uriWithoutGet = reset($uriParts);
428 |         $uriAndFormat = explode('.', $uriWithoutGet);
429 |         if (count($uriAndFormat) >= 2) {
430 |             return end($uriAndFormat);
431 |         }
432 |         return null;
433 |     }
434 | 
435 |     /**
436 |      * Breaks up the uri.
437 |      *
438 |      * Breaks the uri into slugs used to work out the route.
439 |      *
440 |      * @param string $requestedUri
441 |      * @return string[]
442 |      */
443 |     protected function getRequestChainFromUri($requestedUri)
444 |     {
445 |         // Trim any get variables and the requested format, eg: /requested/uri.format?get=variables
446 |         $requestedUri = preg_replace('/[\?\.].*$/', '', $requestedUri);
447 |         // Clear the base url
448 | 
449 |         $requestChain = explode('/', $requestedUri);
450 | 
451 |         if (!$requestChain[0]) {
452 |             unset($requestChain[0]);
453 |         }
454 | 
455 |         return array_values($requestChain);
456 |     }
457 | 
458 |     /**
459 |      * Add a set of parameters to the Request.
460 |      *
461 |      * This method is for internal use only. It allows setting of key => value
462 |      * parameters, including for string objects (assuming a Reader has been set
463 |      * up for them).
464 |      *
465 |      * @param array|object $newParameters
466 |      * @throws \Exception
467 |      * @returns $this
468 |      */
469 |     protected function setParameters($newParameters)
470 |     {
471 |         if (is_scalar($newParameters)) {
472 |             if (!is_string($newParameters)) {
473 |                 throw new \Exception('newParameters can not be scalar');
474 |             }
475 |             $newParameters = $this->stringToArray($newParameters);
476 |         }
477 |         foreach ($newParameters as $field => $value) {
478 |             $this->setParameter($field, $value);
479 |         }
480 |         return $this;
481 |     }
482 | 
483 |     /**
484 |      * Add a parameter
485 |      *
486 |      * Adds a single parameter, checking the parameter name is scalar.
487 |      *
488 |      * @param $name
489 |      * @param $value
490 |      * @return bool Returns true of value was set
491 |      * @throws \Exception
492 |      */
493 |     protected function setParameter($name, $value)
494 |     {
495 |         if (!is_scalar($name)) {
496 |             throw new \Exception('Parameter name must be scalar');
497 |         }
498 |         $this->parameters[$name] = $value;
499 |         return $this;
500 |     }
501 | }
502 | 


--------------------------------------------------------------------------------
/src/Response.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Response.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api;
 11 | 
 12 | use AyeAye\Api\Injector\RequestInjector;
 13 | use AyeAye\Api\Injector\StatusInjector;
 14 | use AyeAye\Formatter\WriterFactory;
 15 | use AyeAye\Formatter\Writer;
 16 | 
 17 | /**
 18 |  * Class Response.
 19 |  *
 20 |  * Contains a payload of information to return to the client.
 21 |  *
 22 |  * @package AyeAye/Api
 23 |  * @see     https://github.com/AyeAyeApi/Api
 24 |  */
 25 | class Response
 26 | {
 27 |     use StatusInjector;
 28 |     use RequestInjector;
 29 | 
 30 |     const DEFAULT_DATA_NAME = 'data';
 31 | 
 32 |     /**
 33 |      * The name of the object that is returned to the user where appropriate.
 34 |      *
 35 |      * @var string
 36 |      */
 37 |     protected $responseName = 'response';
 38 | 
 39 |     /**
 40 |      * The writer factory to use when the response is to be formatted
 41 |      * @var WriterFactory
 42 |      */
 43 |     protected $writerFactory;
 44 | 
 45 |     /**
 46 |      * The specific writer that will be used to format this response
 47 |      * @var Writer
 48 |      */
 49 |     protected $writer;
 50 | 
 51 |     /**
 52 |      * The data you wish to return in the response.
 53 |      * @var mixed
 54 |      */
 55 |     protected $body = [];
 56 | 
 57 |     /**
 58 |      * The formatted response.
 59 |      * We can prepare a response earlier to take advantage of the main API
 60 |      * class' error handling.
 61 |      * @var string
 62 |      */
 63 |     protected $preparedResponse;
 64 | 
 65 | 
 66 |     /**
 67 |      * Get all data that is being returned.
 68 |      *
 69 |      * This will return an array. Unless otherwise stated, data will usually be
 70 |      * attached to the 'data' key of this array.
 71 |      *
 72 |      * @return array
 73 |      */
 74 |     public function getBody()
 75 |     {
 76 |         return $this->body;
 77 |     }
 78 | 
 79 |     /**
 80 |      * Set the data that is to be returned.
 81 |      *
 82 |      * If data is directly returned from an endpoint, it will be attached to
 83 |      * the default data name (usually "data").
 84 |      *
 85 |      * @example
 86 |      *   return 'hello world'; becomes { "data" => "hello world" }
 87 |      *
 88 |      * However, if a Generator is returned, the keys returned will be used
 89 |      * instead.
 90 |      *
 91 |      * @example
 92 |      *   yield 'hello' => 'world'; becomes { "hello" => "world" }
 93 |      *
 94 |      * If no key is given, the default will still be used. This is useful to
 95 |      * provide uniformity in response while adding additional data such as
 96 |      * HATEOAS.
 97 |      *
 98 |      * @example
 99 |      *   yield 'hello';
100 |      *   yield 'links' => $this->generateLinks();
101 |      *
102 |      * @param \Generator|mixed $data
103 |      * @return $this
104 |      */
105 |     public function setBodyData($data)
106 |     {
107 |         if (!$data instanceof \Generator) {
108 |             $this->body[static::DEFAULT_DATA_NAME] = $data;
109 |             return $this;
110 |         }
111 |         foreach ($data as $key => $value) {
112 |             $actualKey = $key ?: static::DEFAULT_DATA_NAME;
113 |             $this->body[$actualKey] = $value;
114 |         }
115 |         return $this;
116 |     }
117 | 
118 |     /**
119 |      * Set the writer factory.
120 |      *
121 |      * This will be choose a writer to format the data based on the request.
122 |      *
123 |      * @param WriterFactory $writerFactory
124 |      * @return $this
125 |      */
126 |     public function setWriterFactory(WriterFactory $writerFactory)
127 |     {
128 |         $this->writerFactory = $writerFactory;
129 |         return $this;
130 |     }
131 | 
132 |     /**
133 |      * Set the writer.
134 |      *
135 |      * This overrides any choice that might otherwise be made by the writer
136 |      * factory and should therefore be avoided.
137 |      *
138 |      * @param Writer $writer
139 |      * @return $this
140 |      */
141 |     public function setWriter(Writer $writer)
142 |     {
143 |         $this->writer = $writer;
144 |         return $this;
145 |     }
146 | 
147 |     /**
148 |      * Prepare the response.
149 |      *
150 |      * This selects a writer from the writer factory and prepares serialises
151 |      * the data into a string. This is done early to allow exceptions and
152 |      * errors to be caught and handled earlier.
153 |      *
154 |      * @return $this
155 |      */
156 |     public function prepareResponse()
157 |     {
158 |         if (!$this->writer) {
159 |             $this->writer = $this->writerFactory->getWriterFor(
160 |                 $this->request->getFormats()
161 |             );
162 |         }
163 |         $this->preparedResponse = $this->writer->format($this->getBody(), $this->responseName);
164 |         return $this;
165 |     }
166 | 
167 |     /**
168 |      * Send the response.
169 |      *
170 |      * This method sends headers and writes the data to the output stream.
171 |      *
172 |      * If the response has not yet been prepared, this method will prepare it
173 |      * first. This method should be the last thing that happens before the
174 |      * script ends.
175 |      *
176 |      * @return $this
177 |      */
178 |     public function respond()
179 |     {
180 |         if (is_null($this->preparedResponse)) {
181 |             $this->prepareResponse();
182 |         }
183 | 
184 |         if ($this->status instanceof Status) {
185 |             header($this->status->getHttpHeader());
186 |         }
187 | 
188 |         header("Content-Type: {$this->writer->getContentType()}");
189 |         echo $this->preparedResponse;
190 | 
191 |         return $this;
192 |     }
193 | }
194 | 


--------------------------------------------------------------------------------
/src/Router.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Router.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api;
11 | 
12 | use AyeAye\Api\Injector\ControllerReflectorInjector;
13 | use AyeAye\Api\Injector\StatusInjector;
14 | 
15 | /**
16 |  * Class Router
17 |  * Finds the correct endpoint to process a request
18 |  * @package AyeAye/Api
19 |  * @see     https://github.com/AyeAyeApi/Api
20 |  */
21 | class Router
22 | {
23 |     use ControllerReflectorInjector;
24 |     use StatusInjector;
25 | 
26 |     /**
27 |      * Look at a request and work out what to do next.
28 |      *
29 |      * Looks at the request chain, takes the first part off, if there is a
30 |      * matching controller, it will load the controller and recurse. If there
31 |      * is a matching endpoint it will call the endpoint passing in the
32 |      * request data.
33 |      *
34 |      * @param Request $request
35 |      * @param Controller $controller
36 |      * @param array $requestChain
37 |      * @return mixed
38 |      * @throws Exception
39 |      */
40 |     public function processRequest(Request $request, Controller $controller, array $requestChain = null)
41 |     {
42 | 
43 |         $reflectionController = $this->getControllerReflector()->reflectController($controller);
44 | 
45 |         // If the request chain is null as apposed to empty, we can get it from the request
46 |         if (is_null($requestChain)) {
47 |             $requestChain = $request->getRequestChain();
48 |         }
49 | 
50 |         // Get the next element of the front of the chain
51 |         $nextLink = array_shift($requestChain);
52 |         if ($nextLink) {
53 |             // If the next element represents a controller, recurse with the new controller and remaining chain
54 |             if ($reflectionController->hasChildController($nextLink)) {
55 |                 return $this->processRequest(
56 |                     $request,
57 |                     $reflectionController->getChildController($nextLink),
58 |                     $requestChain
59 |                 );
60 |             }
61 | 
62 |             // If the next element represents an endpoint, call it, passing in the request data
63 |             if ($reflectionController->hasEndpoint($request->getMethod(), $nextLink)) {
64 |                 $data = $reflectionController->getEndpointResult($request->getMethod(), $nextLink, $request);
65 |                 $this->setStatus($reflectionController->getStatus());
66 |                 return $data;
67 |             }
68 | 
69 |             // If we had another element but it doesn't represent anything, throw an exception.
70 |             $message = "Could not find controller or endpoint matching '$nextLink'";
71 |             throw new Exception($message, 404);
72 |         }
73 | 
74 |         // If there were no more links in the chain, call the index endpoint if there is one.
75 |         // Index endpoints will prevent automated automatic documentation, which may be undesirable. See below.
76 |         if ($reflectionController->hasEndpoint($request->getMethod(), 'index')) {
77 |             $data = $reflectionController->getEndpointResult($request->getMethod(), 'index', $request);
78 |             $this->setStatus($reflectionController->getStatus());
79 |             return $data;
80 |         }
81 | 
82 |         // Generate documentation for the current controller and return it.
83 |         return $reflectionController->getDocumentation();
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Status.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Api.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api;
 11 | 
 12 | /**
 13 |  * Class Status
 14 |  * Represents an HTTP status, used to provide appropriate response
 15 |  * @package AyeAye/Api
 16 |  * @see     https://github.com/AyeAyeApi/Api
 17 |  */
 18 | class Status implements \JsonSerializable
 19 | {
 20 |     /**
 21 |      * A list of common HTTP status codes and their associated messages
 22 |      * @var array
 23 |      */
 24 |     public static $statusCodes = [
 25 |         // Informational
 26 |         // If a request has both a header and a body you can break it in two with this
 27 |         100 => 'Continue',
 28 |         // Let the client know you're switching protocols (not really necessary)
 29 |         101 => 'Switching Protocols',
 30 |         // Taken from WebDAV, used for requests that take a long time and might get queued
 31 |         102 => 'Processing',
 32 | 
 33 |         // Success
 34 |         // Hopefully you'll see this a lot
 35 |         200 => 'OK',
 36 |         // A new record was successfully created
 37 |         201 => 'Created',
 38 |         // The request has been accepted but NOT yet processed
 39 |         202 => 'Accepted',
 40 |         // Returned information might be from another source
 41 |         203 => 'Non-Authoritative Information (since HTTP/1.1)',
 42 |         // Requested processed but isn't returning any content
 43 |         204 => 'No Content',
 44 |         // Request processed but isn't returning any content, request user reset the document view
 45 |         205 => 'Reset Content',
 46 |         // Request contains partial content (if request larger than range requested by client)
 47 |         206 => 'Partial Content',
 48 |         // 207 => 'Multi-Status', // WebDAV, lets just avoid this for now, it's a mess
 49 |         // Taken from WebDAV. Could be use for an already implemented request
 50 |         208 => 'Already Reported',
 51 |         // o.O
 52 |         226 => 'IM Used',
 53 | 
 54 |         // Redirect
 55 |         // Multiple choices means the client must provide more information
 56 |         300 => 'Multiple Choices',
 57 |         // And don't come back!
 58 |         301 => 'Moved Permanently',
 59 |         // Sometimes used to mean Moved Temporarily, however it's implemented link 'See Other'
 60 |         // If that's not desired 307 should be used instead
 61 |         302 => 'Found',
 62 |         // Like Moved Temporarily except the resource should be hit with GET regardless of method used here
 63 |         303 => 'See Other',
 64 |         // Can be used to respond to the headers If-Modified-Since or If-Match
 65 |         304 => 'Not Modified',
 66 |         // Provides the address of a proxy through with the request needs to be passed (eg, for security)
 67 |         305 => 'Use Proxy',
 68 |         // 306 => 'Switch Proxy', // No longer used, see above
 69 |         // Moved to a different location but uses the same verb
 70 |         307 => 'Temporary Redirect',
 71 |         // Like 301 but the redirect MUST use the same method. Not really used
 72 |         308 => 'Permanent Redirect',
 73 | 
 74 |         // Client Error
 75 |         // Request is syntactically wrong
 76 |         400 => 'Bad Request',
 77 |         // Not yet authorized
 78 |         401 => 'Unauthorized',
 79 |         // Could be used to mean monetary, but could also mean a CAPTCHA
 80 |         402 => 'Payment Required',
 81 |         // Authorized but still don't have permission
 82 |         403 => 'Forbidden',
 83 |         // I don't think I need to describe this... are you sure you're in the right business?
 84 |         404 => 'Not Found',
 85 |         // Using GET instead of PUT for example
 86 |         405 => 'Method Not Allowed',
 87 |         // Response available but not appropriate based on the clients request headers
 88 |         406 => 'Not Acceptable',
 89 |         // Authenticate with proxy first
 90 |         407 => 'Proxy Authentication Required',
 91 |         // Server took too long
 92 |         408 => 'Request Timeout',
 93 |         // Conflicting information in the request
 94 |         409 => 'Conflict',
 95 |         // Requested resource is no longer available and will not be made available again
 96 |         410 => 'Gone',
 97 |         // Request must specify the length of it's content (probably not useful in PHP)
 98 |         411 => 'Length Required',
 99 |         // The server does not meet a precondition of the request
100 |         412 => 'Precondition Failed',
101 |         // Request is larger than the server is willing to deal with
102 |         413 => 'Request Entity Too Large',
103 |         // Uri is too long (probably not useful in PHP)
104 |         414 => 'Request-URI Too Long',
105 |         // The server does not support the requested response format (eg contact-list.png)
106 |         415 => 'Unsupported Media Type',
107 |         // For example, the client requested more data than is available
108 |         416 => 'Requested Range Not Satisfiable',
109 |         // Expect header requirements can't be et
110 |         417 => 'Expectation Failed',
111 |         // Can not make coffee
112 |         418 => 'I\'m a teapot',
113 |         // Authentication has expired
114 |         419 => 'Authentication Timeout',
115 |         // Taken from WebDAV, syntactically correct but semantically wrong request
116 |         422 => 'Unprocessable Entity',
117 |         // Taken from WebDAV, the resource has been locked (could be used like 410 Gone, but try again later)
118 |         423 => 'Locked',
119 |         // Taken from WebDAV, this request failed due to an earlier one
120 |         424 => 'Failed Dependency',
121 |         // Use a newer protocol (probably not useful in PHP, but could mean client out of date)
122 |         426 => 'Upgrade Required',
123 |         // Ugh, not sure
124 |         428 => 'Precondition Required',
125 |         // For rate limiting
126 |         429 => 'Too Many Requests',
127 |         // For
128 |         431 => 'Request Header Fields Too Large',
129 |         // Taken from Microsoft, concise.
130 |         440 => 'Login Timeout',
131 |         // Taken from Nginx, like 204 No Content, except it might be the clients fault
132 |         444 => 'No Response',
133 |         // Taken from Microsoft, can be used to specify missing parameters
134 |         449 => 'Retry With',
135 |         // Re-purposed from Microsoft.
136 |         450 => 'Inappropriate content',
137 |         // I get it :)
138 |         451 => 'Unavailable For Legal Reasons',
139 |         // Taken from Nginx and re worded. Useful for certificate authentication
140 |         495 => 'Certificate Error',
141 |         // Taken from Nginx and re worded. Useful for certificate authentication
142 |         496 => 'Certificate Required',
143 |         // Taken from Esri. useful for OAuth or similar
144 |         498 => 'Token expired/invalid',
145 |         // Taken from Esri. useful for OAuth or similar
146 |         499 => 'Token required',
147 | 
148 |         // Server Error
149 |         // Generic "something went wrong on our end"
150 |         500 => 'Internal Server Error',
151 |         // Request method not implemented but might be in the future
152 |         501 => 'Not Implemented',
153 |         // Server was acting as a gateway but received an invalid response from upstream
154 |         502 => 'Bad Gateway',
155 |         // Out to lunch, back soon
156 |         503 => 'Service Unavailable',
157 |         // Server was acting as a gateway but did not receive a timely response from upstream
158 |         504 => 'Gateway Timeout',
159 |         // Probably not useful in an PHP
160 |         505 => 'HTTP Version Not Supported',
161 |         // o.O
162 |         506 => 'Variant Also Negotiates',
163 |         // Taken from WebDAV. Ran out of space
164 |         507 => 'Insufficient Storage',
165 |         // Taken from WebDAV. Like 208 but server has detected an infinite loop
166 |         508 => 'Loop Detected',
167 |         // Taken from Apache Bandwidth limit extension, but could be useful for throttling
168 |         509 => 'Bandwidth Limit Exceeded',
169 |         // More extensions to request required?
170 |         510 => 'Not Extended',
171 |         // Not going to be useful in PHP as you're already at the server, see 401
172 |         511 => 'Network Authentication Required',
173 |         // Taken from CloudFlare. Resource provider sent an error. Use 502 instead
174 |         520 => 'Origin Error',
175 |         // Taken from CloudFlare. Can't connect to resource provider Use 503 instead
176 |         521 => 'Web server is down',
177 |         // Taken from CloudFlare. Connection to resource provider timed out. Use 504 instead
178 |         522 => 'Connection timed out',
179 |         // Taken from CloudFlare. Resource has been blocked. Use 401 or 403 instead
180 |         523 => 'Proxy Declined Request',
181 |         // Taken from CloudFlare. Connection to proxy timed out. Use 504 instead
182 |         524 => 'A timeout occurred',
183 |         // Taken from Microsoft. Connection to proxy timed out. Use 504 instead
184 |         598 => 'Network read timeout error',
185 |         // Taken from Microsoft. Connection to proxy timed out. Use 504 instead
186 |         599 => 'Network connect timeout error',
187 |     ];
188 | 
189 |     /**
190 |      * HTTP code for status
191 |      * @var int
192 |      */
193 |     protected $code;
194 | 
195 |     /**
196 |      * The message associated with the code
197 |      * @var string
198 |      */
199 |     protected $message;
200 | 
201 |     /**
202 |      * Status constructor.
203 |      *
204 |      * Construct with the numeric HTTP status code (defaults to 200).
205 |      *
206 |      * @param int $code Default 200
207 |      * @throws \Exception If invalid code
208 |      */
209 |     public function __construct($code = 200)
210 |     {
211 |         if (!array_key_exists($code, static::$statusCodes)) {
212 |             throw new \Exception("Status '$code' does not exist");
213 |         }
214 |         $this->code = $code;
215 |         $this->message = static::getMessageForCode($code);
216 |     }
217 | 
218 |     /**
219 |      * HTTP code for status
220 |      * @return int
221 |      */
222 |     public function getCode()
223 |     {
224 |         return $this->code;
225 |     }
226 | 
227 |     /**
228 |      * HTTP message for status
229 |      * @return int
230 |      */
231 |     public function getMessage()
232 |     {
233 |         return $this->message;
234 |     }
235 | 
236 |     /**
237 |      * Returns data that is to be serialised by json
238 |      * @return array
239 |      */
240 |     public function jsonSerialize()
241 |     {
242 |         return [
243 |             'code' => $this->getCode(),
244 |             'message' => $this->getMessage(),
245 |         ];
246 |     }
247 | 
248 |     /**
249 |      * Returns the appropriate message for a given code
250 |      * @param int $code
251 |      * @return null
252 |      */
253 |     public static function getMessageForCode($code)
254 |     {
255 |         if (array_key_exists($code, static::$statusCodes)) {
256 |             return static::$statusCodes[$code];
257 |         }
258 |         return null;
259 |     }
260 | 
261 |     /**
262 |      * Send the header
263 |      * @return $this
264 |      */
265 |     public function getHttpHeader()
266 |     {
267 |         return "HTTP/1.1 {$this->getCode()} {$this::getMessageForCode($this->getCode())}";
268 |     }
269 | }
270 | 


--------------------------------------------------------------------------------
/tests/ApiTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * ApiTest.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api\Tests;
 11 | 
 12 | use AyeAye\Api\Api;
 13 | use AyeAye\Api\Response;
 14 | use AyeAye\Api\Status;
 15 | use AyeAye\Api\Tests\Injector\RequestInjectorTest;
 16 | use AyeAye\Api\Tests\Injector\ResponseInjectorTest;
 17 | use AyeAye\Api\Tests\Injector\RouterInjectorTest;
 18 | use AyeAye\Api\Tests\Injector\WriterFactorInjectorTest;
 19 | use AyeAye\Api\Tests\Injector\LoggerInjectorTest;
 20 | use Psr\Log\LogLevel;
 21 | 
 22 | /**
 23 |  * Class ApiTest
 24 |  * @package AyeAye\Api\Tests
 25 |  * @see     https://github.com/AyeAyeApi/Api
 26 |  * @coversDefaultClass \AyeAye\Api\Api
 27 |  */
 28 | class ApiTest extends TestCase
 29 | {
 30 | 
 31 |     use LoggerInjectorTest;
 32 |     use RequestInjectorTest;
 33 |     use ResponseInjectorTest;
 34 |     use RouterInjectorTest;
 35 |     use WriterFactorInjectorTest;
 36 | 
 37 |     /**
 38 |      * @return Api
 39 |      */
 40 |     protected function getTestSubject()
 41 |     {
 42 |         $controller    = $this->getMockController();
 43 |         return new Api($controller);
 44 |     }
 45 | 
 46 |     /**
 47 |      * @test
 48 |      * @covers ::__construct
 49 |      */
 50 |     public function testConstruct()
 51 |     {
 52 |         // Mocks
 53 |         $controller = $this->getMockController();
 54 | 
 55 |         // Tests
 56 |         $api = new Api($controller);
 57 | 
 58 |         $this->assertSame(
 59 |             $controller,
 60 |             $this->getObjectAttribute($api, 'controller')
 61 |         );
 62 |     }
 63 | 
 64 |     /**
 65 |      * @test
 66 |      * @covers ::log
 67 |      * @uses \AyeAye\Api\Api::__construct
 68 |      * @uses \AyeAye\Api\Injector\LoggerInjector
 69 |      */
 70 |     public function testLog()
 71 |     {
 72 | 
 73 |         // Data
 74 |         $level0 = 'level0';
 75 |         $message0 = 'message0';
 76 | 
 77 |         $level1 = 'level1';
 78 |         $message1 = 'message1';
 79 |         $context1 = ['context' => '1'];
 80 | 
 81 |         $level2 = 'level2';
 82 |         $message2 = 'message2';
 83 | 
 84 |         // Mocks
 85 |         $controller = $this->getMockController();
 86 |         $logger = $this->getMockLogger();
 87 | 
 88 |         $logger
 89 |             ->expects($this->at(0))
 90 |             ->method('log')
 91 |             ->with($level1, $message1, $context1);
 92 |         $logger
 93 |             ->expects($this->at(1))
 94 |             ->method('log')
 95 |             ->with($level2, $message2);
 96 | 
 97 |         // Tests
 98 |         $api = new Api($controller);
 99 |         $log = $this->getObjectMethod($api, 'log');
100 | 
101 |         // Not logged
102 |         $this->assertSame(
103 |             $api,
104 |             $log($level0, $message0)
105 |         );
106 | 
107 |         // Set Logger
108 |         $this->assertSame(
109 |             $api,
110 |             $api->setLogger($logger)
111 |         );
112 | 
113 |         // Log twice
114 |         $this->assertSame(
115 |             $api,
116 |             $log($level1, $message1, $context1)
117 |         );
118 | 
119 |         $this->assertSame(
120 |             $api,
121 |             $log($level2, $message2)
122 |         );
123 |     }
124 | 
125 |     /**
126 |      * @test
127 |      * @covers ::go
128 |      * @uses \AyeAye\Api\Api::__construct
129 |      * @uses \AyeAye\Api\Injector\LoggerInjector
130 |      * @uses \AyeAye\Api\Injector\RouterInjector
131 |      * @uses \AyeAye\Api\Injector\ResponseInjector
132 |      * @uses \AyeAye\Api\Injector\RequestInjector
133 |      * @uses \AyeAye\Api\Injector\WriterFactoryInjector
134 |      */
135 |     public function testGo()
136 |     {
137 |         // Test Data
138 |         $data = 'data';
139 | 
140 |         // Mocks
141 |         $controller = $this->getMockController();
142 |         $request = $this->getMockRequest();
143 |         $response = $this->getMockResponse();
144 |         $router = $this->getMockRouter();
145 |         $logger = $this->getMockLogger();
146 |         $writerFactory = $this->getMockWriterFactory();
147 |         $status = $this->getMockStatus();
148 | 
149 |         $response
150 |             ->expects($this->once())
151 |             ->method('setWriterFactory')
152 |             ->with($writerFactory);
153 |         $response
154 |             ->expects($this->once())
155 |             ->method('setRequest')
156 |             ->with($request);
157 |         $response
158 |             ->expects($this->once())
159 |             ->method('setBodyData')
160 |             ->with($data);
161 |         $response
162 |             ->expects($this->once())
163 |             ->method('setStatus')
164 |             ->with($status);
165 |         $response
166 |             ->expects($this->once())
167 |             ->method('prepareResponse');
168 | 
169 |         $router
170 |             ->expects($this->once())
171 |             ->method('processRequest')
172 |             ->with($request, $controller)
173 |             ->will($this->returnValue($data));
174 | 
175 |         $controller
176 |             ->expects($this->once())
177 |             ->method('getStatus')
178 |             ->will($this->returnValue($status));
179 | 
180 |         // Tests
181 |         $api = new Api($controller);
182 |         $api->setRouter($router)
183 |             ->setLogger($logger)
184 |             ->setRequest($request)
185 |             ->setResponse($response)
186 |             ->setWriterFactory($writerFactory);
187 | 
188 |         $this->assertSame(
189 |             $response,
190 |             $api->go()
191 |         );
192 |     }
193 | 
194 |     /**
195 |      * @test
196 |      * @covers ::go
197 |      * @uses \AyeAye\Api\Api::__construct
198 |      * @uses \AyeAye\Api\Api::log
199 |      * @uses \AyeAye\Api\Status
200 |      * @uses \AyeAye\Api\Injector\LoggerInjector
201 |      * @uses \AyeAye\Api\Injector\ResponseInjector
202 |      * @uses \AyeAye\Api\Injector\RequestInjector
203 |      * @uses \AyeAye\Api\Injector\WriterFactoryInjector
204 |      */
205 |     public function testGoAyeAyeException()
206 |     {
207 |         // Test Data
208 |         $code = 500;
209 |         $publicMessage = 'public message';
210 |         $privateMessage = 'private message';
211 | 
212 | 
213 |         // Mocks
214 |         $controller = $this->getMockController();
215 |         $request = $this->getMockRequest();
216 |         $response = $this->getMockResponse();
217 |         $logger = $this->getMockLogger();
218 |         $writerFactory = $this->getMockWriterFactory();
219 |         $exception = $this->getMockAyeAyeException();
220 | 
221 |         $exception
222 |             ->expects($this->exactly(2))
223 |             ->method('getPublicMessage')
224 |             ->will($this->returnValue($publicMessage));
225 |         $this->setObjectAttribute($exception, 'message', $privateMessage);
226 |         $this->setObjectAttribute($exception, 'code', $code);
227 | 
228 |         $response
229 |             ->expects($this->once())
230 |             ->method('setWriterFactory')
231 |             ->with($writerFactory)
232 |             ->willThrowException($exception);
233 |         $response
234 |             ->expects($this->once())
235 |             ->method('setStatus')
236 |             ->with($this->isInstanceOf(Status::class));
237 |         $response
238 |             ->expects($this->once())
239 |             ->method('prepareResponse');
240 |         $response
241 |             ->expects($this->once())
242 |             ->method('setBodyData')
243 |             ->with($publicMessage);
244 | 
245 |         $logger
246 |             ->expects($this->at(0))
247 |             ->method('log')
248 |             ->with(LogLevel::INFO, $publicMessage);
249 |         $logger
250 |             ->expects($this->at(1))
251 |             ->method('log')
252 |             ->with(LogLevel::ERROR, $privateMessage, ['exception' => $exception]);
253 | 
254 | 
255 |         // Tests
256 |         $api = new Api($controller);
257 |         $api->setLogger($logger)
258 |             ->setRequest($request)
259 |             ->setResponse($response)
260 |             ->setWriterFactory($writerFactory);
261 | 
262 |         $this->assertSame(
263 |             $response,
264 |             $api->go()
265 |         );
266 |     }
267 | 
268 |     /**
269 |      * @test
270 |      * @covers ::go
271 |      * @uses \AyeAye\Api\Api::__construct
272 |      * @uses \AyeAye\Api\Api::log
273 |      * @uses \AyeAye\Api\Injector\LoggerInjector
274 |      * @uses \AyeAye\Api\Injector\ResponseInjector
275 |      * @uses \AyeAye\Api\Injector\RequestInjector
276 |      * @uses \AyeAye\Api\Injector\WriterFactoryInjector
277 |      * @uses \AyeAye\Api\Status
278 |      */
279 |     public function testGoException()
280 |     {
281 |         // Test Data
282 |         $message = 'message';
283 |         $exception = new \Exception($message);
284 | 
285 |         // Mocks
286 |         $controller = $this->getMockController();
287 |         $request = $this->getMockRequest();
288 |         $response = $this->getMockResponse();
289 |         $logger = $this->getMockLogger();
290 |         $writerFactory = $this->getMockWriterFactory();
291 | 
292 |         $response
293 |             ->expects($this->once())
294 |             ->method('setWriterFactory')
295 |             ->with($writerFactory)
296 |             ->willThrowException($exception);
297 |         $response
298 |             ->expects($this->once())
299 |             ->method('setStatus')
300 |             ->with($this->isInstanceOf(Status::class));
301 |         $response
302 |             ->expects($this->once())
303 |             ->method('prepareResponse');
304 |         $response
305 |             ->expects($this->once())
306 |             ->method('setBodyData')
307 |             ->with('Internal Server Error');
308 | 
309 |         $logger
310 |             ->expects($this->once())
311 |             ->method('log')
312 |             ->with(LogLevel::CRITICAL, $message, ['exception' => $exception]);
313 | 
314 | 
315 |         // Tests
316 |         $api = new Api($controller);
317 |         $api->setLogger($logger)
318 |             ->setRequest($request)
319 |             ->setResponse($response)
320 |             ->setWriterFactory($writerFactory);
321 | 
322 |         $this->assertSame(
323 |             $response,
324 |             $api->go()
325 |         );
326 |     }
327 | 
328 |     /**
329 |      * @test
330 |      * @covers ::go
331 |      * @uses \AyeAye\Api\Api::__construct
332 |      * @uses \AyeAye\Api\Api::createFailSafeResponse
333 |      * @uses \AyeAye\Api\Api::log
334 |      * @uses \AyeAye\Api\Injector\LoggerInjector
335 |      * @uses \AyeAye\Api\Injector\ResponseInjector
336 |      * @uses \AyeAye\Api\Injector\RequestInjector
337 |      * @uses \AyeAye\Api\Injector\RouterInjector
338 |      * @uses \AyeAye\Api\Injector\StatusInjector
339 |      * @uses \AyeAye\Api\Injector\WriterFactoryInjector
340 |      * @uses \AyeAye\Api\Status
341 |      * @uses \AyeAye\Api\Response
342 |      * @uses \AyeAye\Api\Request
343 |      * @uses \AyeAye\Formatter\Writer\Json
344 |      */
345 |     public function testGoFailSafe()
346 |     {
347 |         // Test Data
348 |         $data = 'data';
349 |         $message = 'message';
350 |         $exception = new \Exception($message);
351 | 
352 |         // Mocks
353 |         $controller = $this->getMockController();
354 |         $request = $this->getMockRequest();
355 |         $response = $this->getMockResponse();
356 |         $router = $this->getMockRouter();
357 |         $logger = $this->getMockLogger();
358 |         $writerFactory = $this->getMockWriterFactory();
359 |         $status = $this->getMockStatus();
360 | 
361 |         $response
362 |             ->expects($this->once())
363 |             ->method('setWriterFactory')
364 |             ->with($writerFactory);
365 |         $response
366 |             ->expects($this->once())
367 |             ->method('setRequest')
368 |             ->with($request);
369 |         $response
370 |             ->expects($this->once())
371 |             ->method('setBodyData')
372 |             ->with($data);
373 |         $response
374 |             ->expects($this->once())
375 |             ->method('setStatus')
376 |             ->with($status);
377 |         $response
378 |             ->expects($this->once())
379 |             ->method('prepareResponse')
380 |             ->willThrowException($exception);
381 | 
382 |         $router
383 |             ->expects($this->once())
384 |             ->method('processRequest')
385 |             ->with($request, $controller)
386 |             ->will($this->returnValue($data));
387 | 
388 |         $controller
389 |             ->expects($this->once())
390 |             ->method('getStatus')
391 |             ->will($this->returnValue($status));
392 | 
393 |         $logger
394 |             ->expects($this->once())
395 |             ->method('log')
396 |             ->with(LogLevel::CRITICAL, $message, ['exception' => $exception]);
397 | 
398 |         // Tests
399 |         $api = new Api($controller);
400 |         $api->setRouter($router)
401 |             ->setLogger($logger)
402 |             ->setRequest($request)
403 |             ->setResponse($response)
404 |             ->setWriterFactory($writerFactory);
405 | 
406 |         $this->assertNotSame(
407 |             $response,
408 |             $api->go()
409 |         );
410 |     }
411 | 
412 |     /**
413 |      * @test
414 |      * @covers ::createFailSafeResponse
415 |      * @uses \AyeAye\Api\Api::__construct
416 |      * @uses \AyeAye\Api\Status
417 |      * @uses \AyeAye\Api\Response
418 |      * @uses \AyeAye\Api\Request
419 |      * @uses \AyeAye\Api\Injector\StatusInjector
420 |      * @uses \AyeAye\Api\Injector\RequestInjector
421 |      * @uses \AyeAye\Formatter\Writer\Json
422 |      */
423 |     public function testCreateFailSafeResponse()
424 |     {
425 |         // Mocks
426 |         $controller = $this->getMockController();
427 | 
428 |         // Tests
429 |         $api = new Api($controller);
430 | 
431 |         $createFailSafeResponse = $this->getObjectMethod($api, 'createFailSafeResponse');
432 | 
433 |         /** @var Response $response */
434 |         $response = $createFailSafeResponse();
435 | 
436 |         $this->assertSame(
437 |             500,
438 |             $response->getStatus()->getCode()
439 |         );
440 |         $this->assertSame(
441 |             Status::getMessageForCode(500),
442 |             $response->getBody()['data']
443 |         );
444 |     }
445 | 
446 | }
447 | 


--------------------------------------------------------------------------------
/tests/ControllerDocumentationTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * ControllerDocumentationTest.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api\Tests;
 11 | 
 12 | use AyeAye\Api\Controller;
 13 | use AyeAye\Api\ControllerDocumentation;
 14 | 
 15 | /**
 16 |  * Class ControllerDocumentationTest
 17 |  * @package AyeAye\Api\Tests
 18 |  * @see     https://github.com/AyeAyeApi/Api
 19 |  * @coversDefaultClass AyeAye\Api\ControllerDocumentation
 20 |  */
 21 | class ControllerDocumentationTest extends TestCase
 22 | {
 23 | 
 24 |     /**
 25 |      * @return \ReflectionObject|\PHPUnit_Framework_MockObject_MockObject
 26 |      */
 27 |     protected function getMockReflectedController()
 28 |     {
 29 |         $mockReflection = $this->getMockReflectionObject();
 30 |         $mockReflection
 31 |             ->expects($this->once())
 32 |             ->method('isInstance')
 33 |             ->will($this->returnValue(true));
 34 |         return $mockReflection;
 35 |     }
 36 | 
 37 |     /**
 38 |      * @test
 39 |      * @covers ::__construct
 40 |      */
 41 |     public function testConstruct()
 42 |     {
 43 |         $mockController = $this->getMockController();
 44 | 
 45 |         $controllerDocumentation = new ControllerDocumentation($mockController);
 46 | 
 47 |         $this->assertSame(
 48 |             $mockController,
 49 |             $this->getObjectAttribute($controllerDocumentation, 'controller')
 50 |         );
 51 |     }
 52 | 
 53 |     /**
 54 |      * @test
 55 |      * @covers ::__construct
 56 |      * @expectedException \InvalidArgumentException
 57 |      * @expectedExceptionMessage Controller did not match ReflectionObject
 58 |      */
 59 |     public function testConstructException()
 60 |     {
 61 |         $mockController =$this->getMockController();
 62 | 
 63 |         /** @var \ReflectionObject|\PHPUnit_Framework_MockObject_MockObject $mockReflection */
 64 |         $mockReflection = $this
 65 |             ->getMockBuilder('\ReflectionObject')
 66 |             ->disableOriginalConstructor()
 67 |             ->getMock();
 68 |         $mockReflection
 69 |             ->expects($this->once())
 70 |             ->method('isInstance')
 71 |             ->with($mockController)
 72 |             ->will($this->returnValue(false));
 73 | 
 74 |         new ControllerDocumentation($mockController, $mockReflection);
 75 |     }
 76 | 
 77 |     /**
 78 |      * @test
 79 |      * @covers ::getEndpoints
 80 |      * @uses \AyeAye\Api\ControllerDocumentation::__construct
 81 |      * @uses \AyeAye\Api\ControllerDocumentation::getControllerMethod
 82 |      * @uses \AyeAye\Api\ControllerDocumentation::camelcaseToHyphenated
 83 |      */
 84 |     public function testGetEndpoints()
 85 |     {
 86 |         // Test the actual generation
 87 |         $methodName1 = 'getFirstEndpoint';
 88 |         $methodName2 = 'getSecondEndpoint';
 89 |         $methodName3 = 'postComplexlyNamedEndpoint';
 90 |         $methodName4 = 'postHiddenEndpoint';
 91 | 
 92 |         $reflectedMethod = $this->getMockReflectionMethod();
 93 |         $reflectedMethod
 94 |             ->expects($this->any())
 95 |             ->method('invokeArgs')
 96 |             ->will($this->returnCallback(function($controller, $inputArray) {
 97 |                 return reset($inputArray) == 'postHiddenEndpoint';
 98 |             }));
 99 | 
100 |         $method1 = $this->getMockReflectionMethod();
101 |         $method1
102 |             ->expects($this->any())
103 |             ->method('getName')
104 |             ->will($this->returnValue($methodName1));
105 |         $method2 = $this->getMockReflectionMethod();
106 |         $method2
107 |             ->expects($this->any())
108 |             ->method('getName')
109 |             ->will($this->returnValue($methodName2));
110 |         $method3 = $this->getMockReflectionMethod();
111 |         $method3
112 |             ->expects($this->any())
113 |             ->method('getName')
114 |             ->will($this->returnValue($methodName3));
115 |         $method4 = $this->getMockReflectionMethod();
116 |         $method4
117 |             ->expects($this->any())
118 |             ->method('getName')
119 |             ->will($this->returnValue($methodName4));
120 | 
121 |         $mockController = $this->getMockController();
122 | 
123 |         $mockReflection = $this->getMockReflectedController();
124 |         $mockReflection
125 |             ->expects($this->once())
126 |             ->method('getMethods')
127 |             ->with(\ReflectionMethod::IS_PUBLIC)
128 |             ->will($this->returnValue([
129 |                 $method1,
130 |                 $method2,
131 |                 $method3,
132 |                 $method4,
133 |             ]));
134 | 
135 |         $mockReflection
136 |             ->expects($this->once())
137 |             ->method('getMethod')
138 |             ->with('isMethodHidden')
139 |             ->will($this->returnValue($reflectedMethod));
140 | 
141 |         $documentation = $this->getMockDocumentation();
142 |         $documentation
143 |             ->expects($this->any())
144 |             ->method('getMethodDocumentation')
145 |             ->will($this->returnValue([]));
146 | 
147 |         $controllerDocumentation = new ControllerDocumentation($mockController, $mockReflection);
148 |         $this->setObjectAttribute($controllerDocumentation, 'documentation', $documentation);
149 | 
150 |         $getEndpoints = $this->getObjectMethod($controllerDocumentation, 'getEndpoints');
151 | 
152 |         $this->assertSame(
153 |             [
154 |                 'get' => [
155 |                     'first' => [],
156 |                     'second' => [],
157 |                 ],
158 |                 'post' => [
159 |                     'complexly-named' => [],
160 |                 ]
161 | 
162 |             ],
163 |             $getEndpoints()
164 |         );
165 |     }
166 | 
167 |     /**
168 |      * @test
169 |      * @covers ::getEndpoints
170 |      * @uses \AyeAye\Api\ControllerDocumentation::__construct
171 |      */
172 |     public function testGetEndpointsSimple()
173 |     {
174 |         // Quick check
175 |         $endpoints = new \stdClass();
176 | 
177 |         $mockController = $this->getMockController();
178 |         $mockReflection = $this->getMockReflectedController();
179 | 
180 |         $controllerDocumentation = new ControllerDocumentation($mockController, $mockReflection);
181 |         $this->setObjectAttribute($controllerDocumentation, 'endpointsCache', $endpoints);
182 |         $getEndpoints = $this->getObjectMethod($controllerDocumentation, 'getEndpoints');
183 | 
184 |         $this->assertSame(
185 |             $endpoints,
186 |             $getEndpoints()
187 |         );
188 |     }
189 | 
190 |     /**
191 |      * @test
192 |      * @covers ::getControllers
193 |      * @uses \AyeAye\Api\ControllerDocumentation::__construct
194 |      * @uses \AyeAye\Api\ControllerDocumentation::getControllerMethod
195 |      * @uses \AyeAye\Api\ControllerDocumentation::camelcaseToHyphenated
196 |      */
197 |     public function testGetControllers()
198 |     {
199 |         // Test the actual generation
200 |         $methodName1 = 'simpleController';
201 |         $methodName2 = 'complexlyNamedController';
202 |         $methodName3 = 'hiddenController';
203 |         $methodName4 = 'controllerNope';
204 | 
205 |         $reflectedMethod = $this->getMockReflectionMethod();
206 |         $reflectedMethod
207 |             ->expects($this->any())
208 |             ->method('invokeArgs')
209 |             ->will($this->returnCallback(function($controller, $inputArray) {
210 |                 return reset($inputArray) == 'hiddenController';
211 |             }));
212 | 
213 |         $method1 = $this->getMockReflectionMethod();
214 |         $method1
215 |             ->expects($this->any())
216 |             ->method('getName')
217 |             ->will($this->returnValue($methodName1));
218 |         $method2 = $this->getMockReflectionMethod();
219 |         $method2
220 |             ->expects($this->any())
221 |             ->method('getName')
222 |             ->will($this->returnValue($methodName2));
223 |         $method3 = $this->getMockReflectionMethod();
224 |         $method3
225 |             ->expects($this->any())
226 |             ->method('getName')
227 |             ->will($this->returnValue($methodName3));
228 |         $method4 = $this->getMockReflectionMethod();
229 |         $method4
230 |             ->expects($this->any())
231 |             ->method('getName')
232 |             ->will($this->returnValue($methodName4));
233 | 
234 |         $mockReflection = $this->getMockReflectedController();
235 |         $mockReflection
236 |             ->expects($this->once())
237 |             ->method('getMethods')
238 |             ->with(\ReflectionMethod::IS_PUBLIC)
239 |             ->will($this->returnValue([
240 |                 $method1,
241 |                 $method2,
242 |                 $method3,
243 |                 $method4,
244 |             ]));
245 |         $mockReflection
246 |             ->expects($this->once())
247 |             ->method('getMethod')
248 |             ->with('isMethodHidden')
249 |             ->will($this->returnValue($reflectedMethod));
250 | 
251 |         $mockController = $this->getMockController();
252 | 
253 |         $controllerDocumentation = new ControllerDocumentation($mockController, $mockReflection);
254 | 
255 |         $getControllers = $this->getObjectMethod($controllerDocumentation, 'getControllers');
256 | 
257 |         $this->assertSame(
258 |             [
259 |                 'simple',
260 |                 'complexly-named',
261 |             ],
262 |             $getControllers()
263 |         );
264 |     }
265 | 
266 |     /**
267 |      * @test
268 |      * @covers ::getControllers
269 |      * @uses \AyeAye\Api\ControllerDocumentation::__construct
270 |      */
271 |     public function testGetControllersSimple()
272 |     {
273 |         // Easy to track
274 |         $controllers = new \stdClass();
275 | 
276 |         $mockController = $this->getMockController();
277 |         $mockReflection = $this->getMockReflectedController();
278 | 
279 |         $controllerDocumentation = new ControllerDocumentation($mockController, $mockReflection);
280 |         $this->setObjectAttribute($controllerDocumentation, 'controllersCache', $controllers);
281 |         $getControllers = $this->getObjectMethod($controllerDocumentation, 'getControllers');
282 | 
283 |         $this->assertSame(
284 |             $controllers,
285 |             $getControllers()
286 |         );
287 |     }
288 | 
289 |     /**
290 |      * @test
291 |      * @covers ::camelcaseToHyphenated
292 |      * @uses \AyeAye\Api\ControllerDocumentation::__construct
293 |      */
294 |     public function testCamelcaseToHyphenated()
295 |     {
296 |         $mockController = $this->getMockController();
297 |         $mockReflection = $this->getMockReflectedController();
298 | 
299 |         $controllerDocumentation = new ControllerDocumentation($mockController, $mockReflection);
300 | 
301 |         $camelcaseToHyphenated = $this->getObjectMethod($controllerDocumentation, 'camelcaseToHyphenated');
302 | 
303 |         $this->assertSame(
304 |             'camelcase-to-hyphenated',
305 |             $camelcaseToHyphenated('camelcaseToHyphenated')
306 |         );
307 |     }
308 | 
309 |     /**
310 |      * @test
311 |      * @covers ::getControllerMethod
312 |      * @uses \AyeAye\Api\ControllerDocumentation::__construct
313 |      */
314 |     public function testGetControllerMethod()
315 |     {
316 |         $param1 = 'param 1';
317 |         $param2 = 'param 2';
318 |         $methodName = 'methodName';
319 | 
320 |         $mockReflectedObject = $this->getMockReflectedController();
321 | 
322 |         $mockController = $this->getMockController();
323 | 
324 |         /** @var \ReflectionMethod|\PHPUnit_Framework_MockObject_MockObject $mockReflectedMethod */
325 |         $mockReflectedMethod = $this->getMockReflectionMethod();
326 |         $mockReflectedMethod
327 |             ->expects($this->once())
328 |             ->method('setAccessible')
329 |             ->with(true)
330 |             ->will($this->returnValue(null));
331 |         $mockReflectedMethod
332 |             ->expects($this->once())
333 |             ->method('invokeArgs')
334 |             ->with($mockController, [$param1, $param2])
335 |             ->will($this->returnValue(true));
336 | 
337 |         $mockReflectedObject
338 |             ->expects($this->once())
339 |             ->method('getMethod')
340 |             ->with($methodName)
341 |             ->will($this->returnValue($mockReflectedMethod));
342 | 
343 |         $controllerDocumentation = new ControllerDocumentation($mockController, $mockReflectedObject);
344 | 
345 |         $getControllerMethod = $this->getObjectMethod($controllerDocumentation, 'getControllerMethod');
346 | 
347 |         $controllerMethod = $getControllerMethod($methodName);
348 | 
349 |         $this->assertTrue(
350 |             $controllerMethod($param1, $param2)
351 |         );
352 |     }
353 | 
354 |     /**
355 |      * @test
356 |      * @covers ::getDocumentation
357 |      * @uses \AyeAye\Api\ControllerDocumentation::__construct
358 |      * @uses \AyeAye\Api\ControllerDocumentation::getControllers
359 |      * @uses \AyeAye\Api\ControllerDocumentation::getEndpoints
360 |      */
361 |     public function testGetDocumentation()
362 |     {
363 |         // Easy to track
364 |         $endpoints = new \stdClass();
365 |         $controllers = new \stdClass();
366 | 
367 |         $mockController = $this->getMockController();
368 |         $mockReflection = $this->getMockReflectedController();
369 | 
370 |         $controllerDocumentation = new ControllerDocumentation($mockController, $mockReflection);
371 | 
372 |         $this->setObjectAttribute($controllerDocumentation, 'endpointsCache', $endpoints);
373 |         $this->setObjectAttribute($controllerDocumentation, 'controllersCache', $controllers);
374 | 
375 |         $this->assertSame(
376 |             [
377 |                 'controllers' => $controllers,
378 |                 'endpoints' => $endpoints,
379 |             ],
380 |             $controllerDocumentation->getDocumentation()
381 |         );
382 |     }
383 | 
384 |     /**
385 |      * @test
386 |      * @covers ::ayeAyeSerialize
387 |      * @uses \AyeAye\Api\ControllerDocumentation::__construct
388 |      * @uses \AyeAye\Api\ControllerDocumentation::getControllers
389 |      * @uses \AyeAye\Api\ControllerDocumentation::getEndpoints
390 |      * @uses \AyeAye\Api\ControllerDocumentation::getDocumentation
391 |      */
392 |     public function testAyeAyeSerialize()
393 |     {
394 |         // Easy to track
395 |         $endpoints = new \stdClass();
396 |         $controllers = new \stdClass();
397 | 
398 |         $mockController = $this->getMockController();
399 |         $mockReflection = $this->getMockReflectedController();
400 | 
401 |         $controllerDocumentation = new ControllerDocumentation($mockController, $mockReflection);
402 | 
403 |         $this->setObjectAttribute($controllerDocumentation, 'endpointsCache', $endpoints);
404 |         $this->setObjectAttribute($controllerDocumentation, 'controllersCache', $controllers);
405 | 
406 |         $this->assertSame(
407 |             [
408 |                 'controllers' => $controllers,
409 |                 'endpoints' => $endpoints,
410 |             ],
411 |             $controllerDocumentation->ayeAyeSerialize()
412 |         );
413 |     }
414 | 
415 | }
416 | 


--------------------------------------------------------------------------------
/tests/ControllerReflectorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * ControllerReflectorTest.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Tests;
11 | 
12 | use AyeAye\Api\ControllerReflector;
13 | use AyeAye\Api\ReflectionController;
14 | 
15 | /**
16 |  * Class ControllerReflectorTest
17 |  * @package AyeAye\Api\Tests
18 |  * @coversDefaultClass \AyeAye\Api\ControllerReflector
19 |  */
20 | class ControllerReflectorTest extends TestCase
21 | {
22 |     /**
23 |      * @test
24 |      * @covers ::reflectController
25 |      * @uses \AyeAye\Api\ReflectionController
26 |      */
27 |     public function testReflectController()
28 |     {
29 |         $controller = $this->getMockController();
30 |         $controllerReflector = new ControllerReflector();
31 | 
32 |         $reflectionController = $controllerReflector->reflectController($controller);
33 | 
34 |         $this->assertInstanceOf(
35 |             ReflectionController::class,
36 |             $reflectionController
37 |         );
38 |         $this->assertSame(
39 |             $controller,
40 |             $this->getObjectAttribute($reflectionController, 'controller')
41 |         );
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/ControllerTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * ApiTest.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api\Tests;
 11 | 
 12 | use AyeAye\Api\Controller;
 13 | use AyeAye\Api\Tests\Injector\StatusInjectorTest;
 14 | 
 15 | 
 16 | /**
 17 |  * Class ControllerTest
 18 |  * @package AyeAye\Api\Tests
 19 |  * @see     https://github.com/AyeAyeApi/Api
 20 |  * @coversDefaultClass \AyeAye\Api\Controller
 21 |  */
 22 | class ControllerTest extends TestCase
 23 | {
 24 |     use StatusInjectorTest;
 25 | 
 26 |     /**
 27 |      * @return Controller
 28 |      */
 29 |     protected function getTestSubject()
 30 |     {
 31 |         return new Controller();
 32 |     }
 33 | 
 34 |     /**
 35 |      * @test
 36 |      * @covers ::hideMethod
 37 |      * @return void
 38 |      */
 39 |     public function testHideMethod()
 40 |     {
 41 |         // Test Data
 42 |         $method = 'hideMethod';
 43 | 
 44 |         // Tests
 45 |         $controller = new Controller();
 46 | 
 47 |         $hiddenMethods = $this->getObjectAttribute($controller, 'hiddenMethods');
 48 | 
 49 |         $this->assertCount(
 50 |             1,
 51 |             $hiddenMethods
 52 |         );
 53 | 
 54 |         $this->assertArrayHasKey(
 55 |             'getIndexEndpoint',
 56 |             $hiddenMethods
 57 |         );
 58 | 
 59 |         $hideMethod = $this->getObjectMethod($controller, 'hideMethod');
 60 |         $hideMethod($method);
 61 | 
 62 |         $hiddenMethods = $this->getObjectAttribute($controller, 'hiddenMethods');
 63 | 
 64 |         $this->assertCount(
 65 |             2,
 66 |             $hiddenMethods
 67 |         );
 68 | 
 69 |         $this->assertArrayHasKey(
 70 |             $method,
 71 |             $hiddenMethods
 72 |         );
 73 |     }
 74 | 
 75 | 
 76 |     /**
 77 |      * @test
 78 |      * @covers ::hideMethod
 79 |      * @uses \AyeAye\Api\Exception
 80 |      * @uses \AyeAye\Api\Status
 81 |      * @expectedException \AyeAye\Api\Exception
 82 |      * @expectedExceptionCode 500
 83 |      * @expectedExceptionMessage The method 'notARealMethod' does not exist in AyeAye\Api\Controller
 84 |      * @return void
 85 |      */
 86 |     public function testHideMethodException()
 87 |     {
 88 |         // Test Data
 89 |         $method = 'notARealMethod';
 90 | 
 91 |         // Tests
 92 |         $controller = new Controller();
 93 | 
 94 |         $hideMethod = $this->getObjectMethod($controller, 'hideMethod');
 95 |         $hideMethod($method);
 96 |     }
 97 | 
 98 |     /**
 99 |      * @test
100 |      * @covers ::isMethodHidden
101 |      * @return void
102 |      */
103 |     public function testIsMethodHidden()
104 |     {
105 |         // Test Data
106 |         $method = 'hideMethod';
107 | 
108 |         // Tests
109 |         $controller = new Controller();
110 | 
111 |         $isMethodHidden = $this->getObjectMethod($controller, 'isMethodHidden');
112 | 
113 |         $this->assertFalse(
114 |             $isMethodHidden($method)
115 |         );
116 | 
117 |         $this->setObjectAttribute($controller, 'hiddenMethods', [$method => true]);
118 | 
119 |         $this->assertTrue(
120 |             $isMethodHidden($method)
121 |         );
122 |     }
123 | 
124 |     /**
125 |      * @test
126 |      * @covers ::isMethodHidden
127 |      * @uses \AyeAye\Api\Exception
128 |      * @uses \AyeAye\Api\Status
129 |      * @expectedException \AyeAye\Api\Exception
130 |      * @expectedExceptionCode 500
131 |      * @expectedExceptionMessage The method 'notARealMethod' does not exist in AyeAye\Api\Controller
132 |      * @return void
133 |      */
134 |     public function testIsMethodHiddenException()
135 |     {
136 |         // Test Data
137 |         $method = 'notARealMethod';
138 | 
139 |         // Tests
140 |         $controller = new Controller();
141 | 
142 |         $isMethodHidden = $this->getObjectMethod($controller, 'isMethodHidden');
143 |         $isMethodHidden($method);
144 |     }
145 | 
146 |     /**
147 |      * @test
148 |      * @covers ::showMethod
149 |      * @uses \AyeAye\Api\Controller::isMethodHidden
150 |      * @return void
151 |      */
152 |     public function testShowMethod()
153 |     {
154 |         // Test Data
155 |         $hiddenMethod = 'hideMethod';
156 |         $visibleMethod = 'showMethod';
157 | 
158 |         // Tests
159 |         $controller = new Controller();
160 | 
161 |         $hiddenMethods = [$hiddenMethod => true];
162 |         $this->setObjectAttribute($controller, 'hiddenMethods', $hiddenMethods);
163 | 
164 |         $showMethod = $this->getObjectMethod($controller, 'showMethod');
165 | 
166 |         // Method is not hidden, nothing should happen
167 |         $this->assertSame(
168 |             $controller,
169 |             $showMethod($visibleMethod)
170 |         );
171 | 
172 |         $this->assertSame(
173 |             $hiddenMethods,
174 |             $this->getObjectAttribute($controller, 'hiddenMethods')
175 |         );
176 | 
177 |         // Method is not hidden, nothing should happen
178 |         $this->assertSame(
179 |             $controller,
180 |             $showMethod($hiddenMethod)
181 |         );
182 | 
183 |         $this->assertNotSame(
184 |             $hiddenMethods,
185 |             $this->getObjectAttribute($controller, 'hiddenMethods')
186 |         );
187 | 
188 |         $this->assertEmpty(
189 |             $this->getObjectAttribute($controller, 'hiddenMethods')
190 |         );
191 |     }
192 | }
193 | 


--------------------------------------------------------------------------------
/tests/DocumentationTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * DocumentationTest.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api\Tests;
 11 | 
 12 | use AyeAye\Api\Documentation;
 13 | 
 14 | /**
 15 |  * Class DocumentationTest
 16 |  * @package AyeAye\Api\Tests
 17 |  * @see     https://github.com/AyeAyeApi/Api
 18 |  * @coversDefaultClass \AyeAye\Api\Documentation
 19 |  */
 20 | class DocumentationTest extends TestCase
 21 | {
 22 | 
 23 |     /**
 24 |      * @param string $documentation
 25 |      * @return \ReflectionMethod|\PHPUnit_Framework_MockObject_MockObject
 26 |      */
 27 |     protected function createMethodWithDocBlock($documentation = '')
 28 |     {
 29 |         $reflectionMethod = $this
 30 |             ->getMockBuilder('ReflectionMethod')
 31 |             ->disableOriginalConstructor()
 32 |             ->getMock();
 33 |         $reflectionMethod
 34 |             ->method('getDocComment')
 35 |             ->with()
 36 |             ->will($this->returnValue($documentation));
 37 |         return $reflectionMethod;
 38 |     }
 39 | 
 40 |     /**
 41 |      * @return \PHPUnit_Framework_MockObject_MockObject|\ReflectionMethod
 42 |      */
 43 |     protected function createDocBlock()
 44 |     {
 45 |         return $this->createMethodWithDocBlock('/**
 46 |              * Test Summary
 47 |              * on two lines.
 48 |              * Test Description
 49 |              * on
 50 |              * three lines.
 51 |              * @param        $incomplete
 52 |              * @param int    $integer    Test integer
 53 |              * @param string $string     Test string
 54 |              * Second line
 55 |              * @return string
 56 |              */');
 57 |     }
 58 | 
 59 |     /**
 60 |      * @return \PHPUnit_Framework_MockObject_MockObject|\ReflectionMethod
 61 |      */
 62 |     protected function createDocBlockWithLineBreak()
 63 |     {
 64 |         return $this->createMethodWithDocBlock('/**
 65 |              *
 66 |              * This is a
 67 |              * three line summary
 68 |              * with a break
 69 |              *
 70 |              * This is a one line description
 71 |              * @return $this
 72 |              */');
 73 |     }
 74 | 
 75 |     /**
 76 |      * @return \PHPUnit_Framework_MockObject_MockObject|\ReflectionMethod
 77 |      */
 78 |     protected function createDocBlockNoDescriptionMultiReturnType()
 79 |     {
 80 |         return $this->createMethodWithDocBlock('/**
 81 |              * This is a summary. There is no description
 82 |              * @return null|mixed
 83 |              */');
 84 |     }
 85 | 
 86 |     /**
 87 |      * @return \PHPUnit_Framework_MockObject_MockObject|\ReflectionMethod
 88 |      */
 89 |     protected function createEmptyDocBlock()
 90 |     {
 91 |         return $this->createMethodWithDocBlock('');
 92 |     }
 93 | 
 94 |     /**
 95 |      * @test
 96 |      * @covers ::getMethodDocumentation
 97 |      * @uses \AyeAye\Api\Documentation
 98 |      */
 99 |     public function testGetMethodDocumentation()
100 |     {
101 |         $documentation = new Documentation();
102 | 
103 |         $method = $this->createDocBlock();
104 |         $expected = [
105 |             'summary' => "Test Summary\non two lines.",
106 |             'description' => "Test Description\non\nthree lines.",
107 |             'parameters' => [
108 |                 'incomplete' => [
109 |                     'type' => '',
110 |                     'description' => '',
111 |                 ],
112 |                 'integer' => [
113 |                     'type' => 'int',
114 |                     'description' => 'Test integer',
115 |                 ],
116 |                 'string' => [
117 |                     'type' => 'string',
118 |                     'description' => "Test string\nSecond line",
119 |                 ],
120 |             ],
121 |             'returnType' => ['string']
122 | 
123 |         ];
124 |         $this->assertSame(
125 |             $expected,
126 |             $documentation->getMethodDocumentation($method)
127 |         );
128 | 
129 |         $method = $this->createDocBlockWithLineBreak();
130 |         $expected = [
131 |             'summary' => "This is a\nthree line summary\nwith a break",
132 |             'description' => "This is a one line description",
133 |             'parameters' => [],
134 |             'returnType' => ['self']
135 | 
136 |         ];
137 |         $this->assertSame(
138 |             $expected,
139 |             $documentation->getMethodDocumentation($method)
140 |         );
141 | 
142 |         $method = $this->createDocBlockNoDescriptionMultiReturnType();
143 |         $expected = [
144 |             'summary' => "This is a summary. There is no description",
145 |             'parameters' => [],
146 |             'returnType' => ['null', 'mixed']
147 | 
148 |         ];
149 |         $this->assertSame(
150 |             $expected,
151 |             $documentation->getMethodDocumentation($method)
152 |         );
153 | 
154 |         $method = $this->createEmptyDocBlock();
155 |         $expected = [
156 |             'parameters' => [],
157 |             'returnType' => []
158 | 
159 |         ];
160 |         $this->assertSame(
161 |             $expected,
162 |             $documentation->getMethodDocumentation($method)
163 |         );
164 |     }
165 | 
166 |     /**
167 |      * @test
168 |      * @covers ::getMethodComment
169 |      */
170 |     public function testGetMethodComment()
171 |     {
172 |         $documentation = new Documentation();
173 |         $getMethodComment = $this->getObjectMethod($documentation, 'getMethodComment');
174 | 
175 |         $method = $this->createDocBlock();
176 |         $expected = [
177 |             'Test Summary',
178 |             'on two lines.',
179 |             'Test Description',
180 |             'on',
181 |             'three lines.',
182 |             '@param        $incomplete',
183 |             '@param int    $integer    Test integer',
184 |             '@param string $string     Test string',
185 |             'Second line',
186 |             '@return string'
187 |         ];
188 |         $this->assertSame(
189 |             $expected,
190 |             $getMethodComment($method)
191 |         );
192 | 
193 |         $method = $this->createDocBlockWithLineBreak();
194 |         $expected = [
195 |             '',
196 |             'This is a',
197 |             'three line summary',
198 |             'with a break',
199 |             '',
200 |             'This is a one line description',
201 |             '@return $this'
202 |         ];
203 |         $this->assertSame(
204 |             $expected,
205 |             $getMethodComment($method)
206 |         );
207 | 
208 |         $method = $this->createDocBlockNoDescriptionMultiReturnType();
209 |         $expected = [
210 |             'This is a summary. There is no description',
211 |             '@return null|mixed',
212 |         ];
213 |         $this->assertSame(
214 |             $expected,
215 |             $getMethodComment($method)
216 |         );
217 | 
218 |         $method = $this->createEmptyDocBlock();
219 |         $expected = [];
220 |         $this->assertSame(
221 |             $expected,
222 |             $getMethodComment($method)
223 |         );
224 |     }
225 | 
226 |     /**
227 |      * @test
228 |      * @covers ::getSummary
229 |      * @uses \AyeAye\Api\Documentation::getMethodComment
230 |      */
231 |     public function testgetSummary()
232 |     {
233 |         $documentation = new Documentation();
234 | 
235 |         $getMethodComment = $this->getObjectMethod($documentation, 'getMethodComment');
236 |         $getSummary = $this->getObjectMethod($documentation, 'getSummary');
237 | 
238 |         $method = $this->createDocBlock();
239 |         $comment = $getMethodComment($method);
240 |         $this->assertSame(
241 |             "Test Summary\non two lines.",
242 |             $getSummary($comment)
243 |         );
244 | 
245 |         $method = $this->createDocBlockWithLineBreak();
246 |         $comment = $getMethodComment($method);
247 |         $this->assertSame(
248 |             "This is a\nthree line summary\nwith a break",
249 |             $getSummary($comment)
250 |         );
251 | 
252 |         $method = $this->createDocBlockNoDescriptionMultiReturnType();
253 |         $comment = $getMethodComment($method);
254 |         $this->assertSame(
255 |             'This is a summary. There is no description',
256 |             $getSummary($comment)
257 |         );
258 | 
259 |         $method = $this->createEmptyDocBlock();
260 |         $comment = $getMethodComment($method);
261 |         $this->assertSame(
262 |             '',
263 |             $getSummary($comment)
264 |         );
265 |     }
266 | 
267 |     /**
268 |      * @test
269 |      * @covers ::getDescription
270 |      * @uses \AyeAye\Api\Documentation::getMethodComment
271 |      */
272 |     public function testGetDescription()
273 |     {
274 |         $documentation = new Documentation();
275 | 
276 |         $getMethodComment = $this->getObjectMethod($documentation, 'getMethodComment');
277 |         $getDescription = $this->getObjectMethod($documentation, 'getDescription');
278 | 
279 |         $method = $this->createDocBlock();
280 |         $comment = $getMethodComment($method);
281 |         $this->assertSame(
282 |             "Test Description\non\nthree lines.",
283 |             $getDescription($comment)
284 |         );
285 | 
286 |         $method = $this->createDocBlockWithLineBreak();
287 |         $comment = $getMethodComment($method);
288 |         $this->assertSame(
289 |             'This is a one line description',
290 |             $getDescription($comment)
291 |         );
292 | 
293 |         $method = $this->createDocBlockNoDescriptionMultiReturnType();
294 |         $comment = $getMethodComment($method);
295 |         $this->assertSame(
296 |             '',
297 |             $getDescription($comment)
298 |         );
299 | 
300 |         $method = $this->createEmptyDocBlock();
301 |         $comment = $getMethodComment($method);
302 |         $this->assertSame(
303 |             '',
304 |             $getDescription($comment)
305 |         );
306 |     }
307 | 
308 |     /**
309 |      * @test
310 |      * @covers ::getParameters
311 |      * @uses \AyeAye\Api\Documentation::getMethodComment
312 |      */
313 |     public function testGetParameters()
314 |     {
315 |         $documentation = new Documentation();
316 | 
317 |         $getMethodComment = $this->getObjectMethod($documentation, 'getMethodComment');
318 |         $getParameters = $this->getObjectMethod($documentation, 'getParameters');
319 | 
320 |         $method = $this->createDocBlock();
321 |         $expected = [
322 |             'incomplete' => [
323 |                 'type' => '',
324 |                 'description' => '',
325 |             ],
326 |             'integer' => [
327 |                 'type' => 'int',
328 |                 'description' => 'Test integer',
329 |             ],
330 |             'string' => [
331 |                 'type' => 'string',
332 |                 'description' => "Test string\nSecond line",
333 |             ],
334 |         ];
335 |         $comment = $getMethodComment($method);
336 |         $this->assertSame(
337 |             $expected,
338 |             $getParameters($comment)
339 |         );
340 | 
341 |         $method = $this->createDocBlockWithLineBreak();
342 |         $comment = $getMethodComment($method);
343 |         $this->assertSame(
344 |             [],
345 |             $getParameters($comment)
346 |         );
347 | 
348 |         $method = $this->createDocBlockNoDescriptionMultiReturnType();
349 |         $comment = $getMethodComment($method);
350 |         $this->assertSame(
351 |             [],
352 |             $getParameters($comment)
353 |         );
354 | 
355 |         $method = $this->createEmptyDocBlock();
356 |         $comment = $getMethodComment($method);
357 |         $this->assertSame(
358 |             [],
359 |             $getParameters($comment)
360 |         );
361 |     }
362 | 
363 |     /**
364 |      * @test
365 |      * @covers ::getReturnType()
366 |      * @uses \AyeAye\Api\Documentation::getMethodComment
367 |      */
368 |     public function testGetReturnType()
369 |     {
370 |         $documentation = new Documentation();
371 | 
372 |         $getMethodComment = $this->getObjectMethod($documentation, 'getMethodComment');
373 |         $getReturnType = $this->getObjectMethod($documentation, 'getReturnType');
374 | 
375 |         $method = $this->createDocBlock();
376 |         $comment = $getMethodComment($method);
377 | 
378 |         $this->assertSame(
379 |             ['string'],
380 |             $getReturnType($comment, $method->getDeclaringClass())
381 |         );
382 | 
383 |         $method = $this->createDocBlockWithLineBreak();
384 |         $comment = $getMethodComment($method);
385 |         $this->assertSame(
386 |             ['self'],
387 |             $getReturnType($comment, $method->getDeclaringClass())
388 |         );
389 | 
390 |         $method = $this->createDocBlockNoDescriptionMultiReturnType();
391 |         $comment = $getMethodComment($method);
392 |         $this->assertSame(
393 |             ['null', 'mixed'],
394 |             $getReturnType($comment)
395 |         );
396 | 
397 |         $method = $this->createEmptyDocBlock();
398 |         $comment = $getMethodComment($method);
399 |         $this->assertSame(
400 |             [],
401 |             $getReturnType($comment)
402 |         );
403 |     }
404 | }
405 | 


--------------------------------------------------------------------------------
/tests/ExceptionTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * ExceptionTest.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api\Tests;
 11 | 
 12 | use AyeAye\Api\Exception;
 13 | 
 14 | /**
 15 |  * Class ExceptionTest
 16 |  * @package AyeAye\Api\Tests
 17 |  * @see     https://github.com/AyeAyeApi/Api
 18 |  * @coversDefaultClass \AyeAye\Api\Exception
 19 |  */
 20 | class ExceptionTest extends TestCase
 21 | {
 22 | 
 23 |     /**
 24 |      * @test
 25 |      * @covers ::__construct
 26 |      */
 27 |     public function testContructStandard()
 28 |     {
 29 |         $publicMessage = 'Public Message';
 30 |         $code = 418;
 31 |         $systemMessage = 'System Message';
 32 |         $previousException = new \Exception();
 33 |         $exception = new Exception(
 34 |             $publicMessage,
 35 |             $code,
 36 |             $systemMessage,
 37 |             $previousException
 38 |         );
 39 | 
 40 |         $this->assertSame(
 41 |             $publicMessage,
 42 |             $this->getObjectAttribute($exception, 'publicMessage')
 43 |         );
 44 |         $this->assertSame(
 45 |             $systemMessage,
 46 |             $this->getObjectAttribute($exception, 'message')
 47 |         );
 48 |         $this->assertSame(
 49 |             $code,
 50 |             $this->getObjectAttribute($exception, 'code')
 51 |         );
 52 |         $this->assertSame(
 53 |             $previousException,
 54 |             $this->getObjectAttribute($exception, 'previous')
 55 |         );
 56 |     }
 57 | 
 58 |     /**
 59 |      * @test
 60 |      * @covers ::__construct
 61 |      * @uses AyeAye\Api\Status
 62 |      */
 63 |     public function testContructShifted()
 64 |     {
 65 |         $code = 418;
 66 |         $systemMessage = 'System Message';
 67 |         $previousException = new \Exception();
 68 |         $exception = new Exception(
 69 |             $code,
 70 |             $systemMessage,
 71 |             $previousException
 72 |         );
 73 | 
 74 |         $this->assertSame(
 75 |             'I\'m a teapot',
 76 |             $this->getObjectAttribute($exception, 'publicMessage')
 77 |         );
 78 |         $this->assertSame(
 79 |             $systemMessage,
 80 |             $this->getObjectAttribute($exception, 'message')
 81 |         );
 82 |         $this->assertSame(
 83 |             $code,
 84 |             $this->getObjectAttribute($exception, 'code')
 85 |         );
 86 |         $this->assertSame(
 87 |             $previousException,
 88 |             $this->getObjectAttribute($exception, 'previous')
 89 |         );
 90 |     }
 91 | 
 92 |     /**
 93 |      * @test
 94 |      * @covers ::__construct
 95 |      * @uses AyeAye\Api\Status
 96 |      */
 97 |     public function testContructSimplified()
 98 |     {
 99 |         $exception = new Exception(999);
100 |         $this->assertSame(
101 |             'Internal Server Error',
102 |             $this->getObjectAttribute($exception, 'publicMessage')
103 |         );
104 |         $this->assertSame(
105 |             'Internal Server Error',
106 |             $this->getObjectAttribute($exception, 'message')
107 |         );
108 |         $this->assertSame(
109 |             999,
110 |             $this->getObjectAttribute($exception, 'code')
111 |         );
112 |         $this->assertNull(
113 |             $this->getObjectAttribute($exception, 'previous')
114 |         );
115 |     }
116 | 
117 |     /**
118 |      * @test
119 |      * @covers ::getPublicMessage
120 |      * @uses AyeAye\Api\Status
121 |      * @uses AyeAye\Api\Exception::__construct
122 |      */
123 |     public function testGetPublicMessage()
124 |     {
125 |         $exception = new Exception();
126 |         $this->assertSame(
127 |             'Internal Server Error',
128 |             $exception->getPublicMessage()
129 |         );
130 | 
131 |         $exception = new Exception('Test');
132 |         $this->assertSame(
133 |             'Test',
134 |             $exception->getPublicMessage()
135 |         );
136 |     }
137 | 
138 |     /**
139 |      * @test
140 |      * @covers ::jsonSerialize
141 |      * @uses AyeAye\Api\Exception::__construct
142 |      * @uses AyeAye\Api\Exception::getPublicMessage
143 |      */
144 |     public function testJsonSerialize()
145 |     {
146 |         $publicMessage = 'Public Message';
147 |         $code = 418;
148 |         $systemMessage = 'System Message';
149 |         $previousException = new \Exception();
150 |         $exception = new Exception(
151 |             $publicMessage,
152 |             $code,
153 |             $systemMessage,
154 |             $previousException
155 |         );
156 | 
157 |         $this->assertSame(
158 |             [
159 |                 'message' => $publicMessage,
160 |                 'code' => $code
161 |             ],
162 |             $exception->jsonSerialize()
163 |         );
164 | 
165 |         $newPublicMessage = 'Public Message';
166 |         $newCode = 418;
167 |         $newSystemMessage = 'System Message';
168 |         $newException = new Exception(
169 |             $newPublicMessage,
170 |             $newCode,
171 |             $newSystemMessage,
172 |             $exception
173 |         );
174 | 
175 |         $this->assertSame(
176 |             [
177 |                 'message' => $newPublicMessage,
178 |                 'code' => $newCode,
179 |                 'previous' => [
180 |                     'message' => $publicMessage,
181 |                     'code' => $code
182 |                 ]
183 |             ],
184 |             $newException->jsonSerialize()
185 |         );
186 |     }
187 | }
188 | 


--------------------------------------------------------------------------------
/tests/Injector/ControllerReflectorInjectorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * ControllerReflectorInjectorTest.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Tests\Injector;
11 | 
12 | use AyeAye\Api\ControllerReflector;
13 | 
14 | /**
15 |  * Trait ControllerReflectorInjectorTest
16 |  * Add to the test class for any class that uses the ControllerReflectorInjector trait
17 |  * @package AyeAye/Api
18 |  * @see     https://github.com/AyeAyeApi/Api
19 |  */
20 | trait ControllerReflectorInjectorTest
21 | {
22 |     use InjectorTestTrait;
23 | 
24 |     /**
25 |      * @test
26 |      * @covers ::getControllerReflector
27 |      * @uses \AyeAye\Api\Api
28 |      * @uses \AyeAye\Api\Injector\ControllerReflectorInjector::setControllerReflector
29 |      */
30 |     public function testGetControllerReflector()
31 |     {
32 |         // Mocks
33 |         $controllerReflector = $this->getMockControllerReflector();
34 | 
35 |         // Tests
36 |         $testSubject = $this->getTestSubject();
37 | 
38 |         $this->assertInstanceOf(
39 |             ControllerReflector::class,
40 |             $testSubject->getControllerReflector()
41 |         );
42 | 
43 |         $this->assertSame(
44 |             $testSubject,
45 |             $testSubject->setControllerReflector($controllerReflector)
46 |         );
47 | 
48 |         $this->assertSame(
49 |             $controllerReflector,
50 |             $testSubject->getControllerReflector($testSubject, 'controllerReflector')
51 |         );
52 |     }
53 | 
54 |     /**
55 |      * @test
56 |      * @covers ::setControllerReflector
57 |      * @uses \AyeAye\Api\Api
58 |      */
59 |     public function testSetControllerReflector()
60 |     {
61 |         // Mocks
62 |         $controllerReflector = $this->getMockControllerReflector();
63 | 
64 |         // Tests
65 |         $testSubject = $this->getTestSubject();
66 | 
67 |         $this->assertNull(
68 |             $this->getObjectAttribute($testSubject, 'controllerReflector')
69 |         );
70 | 
71 |         $this->assertSame(
72 |             $testSubject,
73 |             $testSubject->setControllerReflector($controllerReflector)
74 |         );
75 | 
76 |         $this->assertSame(
77 |             $controllerReflector,
78 |             $this->getObjectAttribute($testSubject, 'controllerReflector')
79 |         );
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/tests/Injector/InjectorTestTrait.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * InjectorTestTrait.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api\Tests\Injector;
 11 | 
 12 | use AyeAye\Api\ControllerReflector;
 13 | use AyeAye\Api\Request;
 14 | use AyeAye\Api\Response;
 15 | use AyeAye\Api\Router;
 16 | use AyeAye\Api\Status;
 17 | use AyeAye\Formatter\WriterFactory;
 18 | use Psr\Log\LoggerInterface;
 19 | 
 20 | /**
 21 |  * Trait InjectorTestTrait
 22 |  * Add to the any injected test to provide information on functionality of our TestCase.
 23 |  * Note: This class may need to be updated if the signatures of our TestCase methods change
 24 |  * @package AyeAye/Api
 25 |  * @see     https://github.com/AyeAyeApi/Api
 26 |  */
 27 | trait InjectorTestTrait
 28 | {
 29 |     /**
 30 |      * @return mixed
 31 |      */
 32 |     abstract protected function getTestSubject();
 33 | 
 34 |     /**
 35 |      * @return LoggerInterface|\PHPUnit_Framework_MockObject_MockObject
 36 |      */
 37 |     abstract protected function getMockLogger();
 38 | 
 39 |     /**
 40 |      * @return Request|\PHPUnit_Framework_MockObject_MockObject
 41 |      */
 42 |     abstract protected function getMockRequest();
 43 | 
 44 |     /**
 45 |      * @return Response|\PHPUnit_Framework_MockObject_MockObject
 46 |      */
 47 |     abstract protected function getMockResponse();
 48 | 
 49 |     /**
 50 |      * @return Router|\PHPUnit_Framework_MockObject_MockObject
 51 |      */
 52 |     abstract protected function getMockRouter();
 53 | 
 54 |     /**
 55 |      * @return Status|\PHPUnit_Framework_MockObject_MockObject
 56 |      */
 57 |     abstract protected function getMockStatus();
 58 | 
 59 |     /**
 60 |      * @return WriterFactory|\PHPUnit_Framework_MockObject_MockObject
 61 |      */
 62 |     abstract protected function getMockWriterFactory();
 63 | 
 64 |     /**
 65 |      * @return ControllerReflector|\PHPUnit_Framework_MockObject_MockObject
 66 |      */
 67 |     abstract protected function getMockControllerReflector();
 68 | 
 69 | 
 70 |     /**
 71 |      * Asserts that two variables have the same type and value.
 72 |      * Used on objects, it asserts that two variables reference
 73 |      * the same object.
 74 |      *
 75 |      * @param mixed  $expected
 76 |      * @param mixed  $actual
 77 |      * @param string $message
 78 |      */
 79 |     abstract public function assertSame($expected, $actual, $message = '');
 80 | 
 81 |     /**
 82 |      * Asserts that a variable is null.
 83 |      *
 84 |      * @param mixed  $actual
 85 |      * @param string $message
 86 |      */
 87 |     abstract public function assertNull($actual, $message = '');
 88 | 
 89 |     /**
 90 |      * Returns the value of an object's attribute.
 91 |      * This also works for attributes that are declared protected or private.
 92 |      *
 93 |      * @param object $object
 94 |      * @param string $attributeName
 95 |      *
 96 |      * @return mixed
 97 |      *
 98 |      * @throws \PHPUnit_Framework_Exception
 99 |      *
100 |      * @since  Method available since Release 4.0.0
101 |      */
102 |     abstract public function getObjectAttribute($object, $attributeName);
103 | 
104 |     /**
105 |      * Asserts that two variables do not have the same type and value.
106 |      * Used on objects, it asserts that two variables do not reference
107 |      * the same object.
108 |      *
109 |      * @param mixed  $expected
110 |      * @param mixed  $actual
111 |      * @param string $message
112 |      */
113 |     abstract public function assertNotSame($expected, $actual, $message = '');
114 | 
115 |     /**
116 |      * Asserts that a variable is of a given type.
117 |      *
118 |      * @param string $expected
119 |      * @param mixed  $actual
120 |      * @param string $message
121 |      *
122 |      * @since Method available since Release 3.5.0
123 |      */
124 |     abstract public function assertInstanceOf($expected, $actual, $message = '');
125 | }
126 | 


--------------------------------------------------------------------------------
/tests/Injector/LoggerInjectorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * LoggerInjectorTest.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Tests\Injector;
11 | 
12 | use Psr\Log\NullLogger;
13 | 
14 | /**
15 |  * Trait LoggerInjectorTest
16 |  * Add to the test class for any class that uses the LoggerInjector trait
17 |  * @package AyeAye/Api
18 |  * @see     https://github.com/AyeAyeApi/Api
19 |  */
20 | trait LoggerInjectorTest
21 | {
22 |     use InjectorTestTrait;
23 | 
24 |     /**
25 |      * @test
26 |      * @covers ::getLogger
27 |      * @uses \AyeAye\Api\Api
28 |      * @uses \AyeAye\Api\Injector\LoggerInjector::setLogger
29 |      */
30 |     public function testGetLogger()
31 |     {
32 |         // Mocks
33 |         $logger = $this->getMockLogger();
34 | 
35 |         // Tests
36 |         $testSubject = $this->getTestSubject();
37 | 
38 |         $this->assertInstanceOf(
39 |             NullLogger::class,
40 |             $testSubject->getLogger()
41 |         );
42 | 
43 |         $this->assertSame(
44 |             $testSubject,
45 |             $testSubject->setLogger($logger)
46 |         );
47 | 
48 |         $this->assertSame(
49 |             $logger,
50 |             $testSubject->getLogger($testSubject, 'logger')
51 |         );
52 |     }
53 | 
54 |     /**
55 |      * @test
56 |      * @covers ::setLogger
57 |      * @uses \AyeAye\Api\Api
58 |      */
59 |     public function testSetLogger()
60 |     {
61 |         // Mocks
62 |         $logger = $this->getMockLogger();
63 | 
64 |         // Tests
65 |         $testSubject = $this->getTestSubject();
66 | 
67 |         $this->assertNull(
68 |             $this->getObjectAttribute($testSubject, 'logger')
69 |         );
70 | 
71 |         $this->assertSame(
72 |             $testSubject,
73 |             $testSubject->setLogger($logger)
74 |         );
75 | 
76 |         $this->assertSame(
77 |             $logger,
78 |             $this->getObjectAttribute($testSubject, 'logger')
79 |         );
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/tests/Injector/RequestInjectorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * RequestInjectorTest.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Tests\Injector;
11 | 
12 | /**
13 |  * Trait RequestInjectorTest
14 |  * Add to the test class for any class that uses the RequestInjector trait
15 |  * @package AyeAye/Api
16 |  * @see     https://github.com/AyeAyeApi/Api
17 |  */
18 | trait RequestInjectorTest
19 | {
20 |     use InjectorTestTrait;
21 | 
22 |     /**
23 |      * @test
24 |      * @covers ::setRequest
25 |      * @uses \AyeAye\Api\Api
26 |      */
27 |     public function testSetRequest()
28 |     {
29 |         // Mocks
30 |         $request = $this->getMockRequest();
31 | 
32 |         // Tests
33 |         $testSubject = $this->getTestSubject();
34 | 
35 |         $this->assertNull(
36 |             $this->getObjectAttribute($testSubject, 'request')
37 |         );
38 | 
39 |         $this->assertSame(
40 |             $testSubject,
41 |             $testSubject->setRequest($request)
42 |         );
43 | 
44 |         $this->assertSame(
45 |             $request,
46 |             $this->getObjectAttribute($testSubject, 'request')
47 |         );
48 |     }
49 | 
50 |     /**
51 |      * @test
52 |      * @covers ::getRequest
53 |      * @uses \AyeAye\Api\Api
54 |      * @uses \AyeAye\Api\Injector\RequestInjector::setRequest
55 |      * @uses \AyeAye\Api\Request
56 |      */
57 |     public function testGetRequest()
58 |     {
59 |         // Mocks
60 |         $request = $this->getMockRequest();
61 | 
62 |         // Tests
63 |         $testSubject = $this->getTestSubject();
64 | 
65 |         $this->assertNotSame(
66 |             $request,
67 |             $testSubject->getRequest()
68 |         );
69 | 
70 |         $this->assertSame(
71 |             $testSubject,
72 |             $testSubject->setRequest($request)
73 |         );
74 | 
75 |         $this->assertSame(
76 |             $request,
77 |             $testSubject->getRequest()
78 |         );
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/tests/Injector/ResponseInjectorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * ResponseInjectorTest.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Tests\Injector;
11 | 
12 | /**
13 |  * Trait ResponseInjectorTest
14 |  * Add to the test class for any class that uses the ResponseInjector trait
15 |  * @package AyeAye/Api
16 |  * @see     https://github.com/AyeAyeApi/Api
17 |  */
18 | trait ResponseInjectorTest
19 | {
20 |     use InjectorTestTrait;
21 | 
22 |     /**
23 |      * @test
24 |      * @covers ::setResponse
25 |      * @uses \AyeAye\Api\Api
26 |      */
27 |     public function testSetResponse()
28 |     {
29 |         // Mocks
30 |         $response = $this->getMockResponse();
31 | 
32 |         // Tests
33 |         $testSubject = $this->getTestSubject();
34 | 
35 |         $this->assertNull(
36 |             $this->getObjectAttribute($testSubject, 'response')
37 |         );
38 | 
39 |         $this->assertSame(
40 |             $testSubject,
41 |             $testSubject->setResponse($response)
42 |         );
43 | 
44 |         $this->assertSame(
45 |             $response,
46 |             $this->getObjectAttribute($testSubject, 'response')
47 |         );
48 |     }
49 | 
50 |     /**
51 |      * @test
52 |      * @covers ::getResponse
53 |      * @uses \AyeAye\Api\Api
54 |      * @uses \AyeAye\Api\Injector\ResponseInjector::setResponse
55 |      * @uses \AyeAye\Api\Response
56 |      */
57 |     public function testGetResponse()
58 |     {
59 |         // Mocks
60 |         $response = $this->getMockResponse();
61 | 
62 |         // Tests
63 |         $testSubject = $this->getTestSubject();
64 | 
65 |         $this->assertNotSame(
66 |             $response,
67 |             $testSubject->getResponse()
68 |         );
69 | 
70 |         $this->assertSame(
71 |             $testSubject,
72 |             $testSubject->setResponse($response)
73 |         );
74 | 
75 |         $this->assertSame(
76 |             $response,
77 |             $testSubject->getResponse()
78 |         );
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/tests/Injector/RouterInjectorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * RouterInjectorTest.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Tests\Injector;
11 | 
12 | /**
13 |  * Trait RouterInjectorTest
14 |  * Add to the test class for any class that uses the RouterInjector trait
15 |  * @package AyeAye/Api
16 |  * @see     https://github.com/AyeAyeApi/Api
17 |  */
18 | trait RouterInjectorTest
19 | {
20 |     use InjectorTestTrait;
21 | 
22 |     /**
23 |      * @test
24 |      * @covers ::setRouter
25 |      * @uses \AyeAye\Api\Api
26 |      */
27 |     public function testSetRouter()
28 |     {
29 |         // Mocks
30 |         $router = $this->getMockRouter();
31 | 
32 |         // Tests
33 |         $testSubject = $this->getTestSubject();
34 | 
35 |         $this->assertNull(
36 |             $this->getObjectAttribute($testSubject, 'router')
37 |         );
38 | 
39 |         $this->assertSame(
40 |             $testSubject,
41 |             $testSubject->setRouter($router)
42 |         );
43 | 
44 |         $this->assertSame(
45 |             $router,
46 |             $this->getObjectAttribute($testSubject, 'router')
47 |         );
48 |     }
49 | 
50 |     /**
51 |      * @test
52 |      * @covers ::getRouter
53 |      * @uses \AyeAye\Api\Api
54 |      * @uses \AyeAye\Api\Injector\RouterInjector::setRouter
55 |      */
56 |     public function testGetRouter()
57 |     {
58 |         // Mocks
59 |         $router = $this->getMockRouter();
60 | 
61 |         // Tests
62 |         $testSubject = $this->getTestSubject();
63 | 
64 |         $this->assertNotSame(
65 |             $router,
66 |             $testSubject->getRouter()
67 |         );
68 | 
69 |         $this->assertSame(
70 |             $testSubject,
71 |             $testSubject->setRouter($router)
72 |         );
73 | 
74 |         $this->assertSame(
75 |             $router,
76 |             $testSubject->getRouter()
77 |         );
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/tests/Injector/StatusInjectorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * StatusInjectorTest.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Tests\Injector;
11 | 
12 | use AyeAye\Api\Router;
13 | 
14 | /**
15 |  * Trait StatusInjectorTest
16 |  * Add to the test class for any class that uses the StatusInjector trait
17 |  * @package AyeAye/Api
18 |  * @see     https://github.com/AyeAyeApi/Api
19 |  */
20 | trait StatusInjectorTest
21 | {
22 |     use InjectorTestTrait;
23 | 
24 |     /**
25 |      * @test
26 |      * @covers ::getStatus
27 |      * @uses \AyeAye\Api\Status
28 |      * @uses \AyeAye\Api\Injector\StatusInjector::setStatus
29 |      */
30 |     public function testGetStatus()
31 |     {
32 |         $router = new Router();
33 |         $status = $this->getMockStatus();
34 | 
35 |         $this->assertInstanceOf(
36 |             'AyeAye\Api\Status',
37 |             $router->getStatus()
38 |         );
39 |         $this->assertNotSame(
40 |             $status,
41 |             $router->getStatus()
42 |         );
43 | 
44 |         $router->setStatus($status);
45 |         $this->assertInstanceOf(
46 |             'AyeAye\Api\Status',
47 |             $router->getStatus()
48 |         );
49 |         $this->assertSame(
50 |             $status,
51 |             $router->getStatus()
52 |         );
53 |     }
54 | 
55 |     /**
56 |      * @test
57 |      * @covers ::setStatus
58 |      */
59 |     public function testSetStatus()
60 |     {
61 |         $status = $this->getMockStatus();
62 |         $testSubject = $this->getTestSubject();
63 | 
64 |         $testSubject->setStatus($status);
65 |         $this->assertSame(
66 |             $status,
67 |             $this->getObjectAttribute($testSubject, 'status')
68 |         );
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/tests/Injector/WriterFactorInjectorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * WriterFactorInjectorTest.php
 4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
 5 |  * @copyright (c) 2016 Daniel Mason <daniel@ayeayeapi.com>
 6 |  * @license   MIT
 7 |  * @see       https://github.com/AyeAyeApi/Api
 8 |  */
 9 | 
10 | namespace AyeAye\Api\Tests\Injector;
11 | 
12 | /**
13 |  * Trait WriterFactorInjectorTest
14 |  * Add to the test class for any class that uses the WriterFactorInjector trait
15 |  * @package AyeAye/Api
16 |  * @see     https://github.com/AyeAyeApi/Api
17 |  */
18 | trait WriterFactorInjectorTest
19 | {
20 |     use InjectorTestTrait;
21 | 
22 |     /**
23 |      * @test
24 |      * @covers ::setWriterFactory
25 |      * @uses \AyeAye\Api\Api
26 |      */
27 |     public function testSetWriterFactory()
28 |     {
29 |         // Mocks
30 |         $writerFactory = $this->getMockWriterFactory();
31 | 
32 |         // Tests
33 |         $testSubject = $this->getTestSubject();
34 | 
35 |         $this->assertNull(
36 |             $this->getObjectAttribute($testSubject, 'writerFactory')
37 |         );
38 | 
39 |         $this->assertSame(
40 |             $testSubject,
41 |             $testSubject->setWriterFactory($writerFactory)
42 |         );
43 | 
44 |         $this->assertSame(
45 |             $writerFactory,
46 |             $this->getObjectAttribute($testSubject, 'writerFactory')
47 |         );
48 |     }
49 | 
50 |     /**
51 |      * @test
52 |      * @covers ::getWriterFactory
53 |      * @uses \AyeAye\Api\Injector\WriterFactoryInjector::setWriterFactory
54 |      * @uses \AyeAye\Api\Api
55 |      * @uses \AyeAye\Formatter\WriterFactory
56 |      */
57 |     public function testGetWriterFactory()
58 |     {
59 |         // Test Data
60 |         $requiredFormats = [
61 |             'xml',
62 |             'text/xml',
63 |             'application/xml',
64 |             'json',
65 |             'application/json',
66 |         ];
67 | 
68 |         // Mocks
69 |         $writerFactory = $this->getMockWriterFactory();
70 | 
71 |         // Tests
72 |         $testSubject = $this->getTestSubject();
73 | 
74 |         $this->assertNotSame(
75 |             $writerFactory,
76 |             $testSubject->getWriterFactory()
77 |         );
78 | 
79 |         // Test the factory was constructed correctly
80 |         $formats = $this->getObjectAttribute($testSubject->getWriterFactory(), 'formats');
81 |         foreach($requiredFormats as $format) {
82 |             $this->assertArrayHasKey(
83 |                 $format,
84 |                 $formats
85 |             );
86 |         }
87 | 
88 |         $this->assertSame(
89 |             $testSubject,
90 |             $testSubject->setWriterFactory($writerFactory)
91 |         );
92 | 
93 |         $this->assertSame(
94 |             $writerFactory,
95 |             $testSubject->getWriterFactory()
96 |         );
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/tests/ResponseTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * ResponseTest.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api\Tests;
 11 | 
 12 | use AyeAye\Api\Injector\RequestInjector;
 13 | use AyeAye\Api\Request;
 14 | use AyeAye\Api\Response;
 15 | use AyeAye\Api\Status;
 16 | use AyeAye\Api\Tests\Injector\StatusInjectorTest;
 17 | use AyeAye\Formatter\WriterFactory;
 18 | use AyeAye\Formatter\Writer;
 19 | use AyeAye\Formatter\Writer\Json;
 20 | 
 21 | /**
 22 |  * Class ResponseTest
 23 |  * @package AyeAye\Api\Tests
 24 |  * @see     https://github.com/AyeAyeApi/Api
 25 |  * @coversDefaultClass \AyeAye\Api\Response
 26 |  */
 27 | class ResponseTest extends TestCase
 28 | {
 29 | 
 30 |     use StatusInjectorTest;
 31 |     use RequestInjector;
 32 | 
 33 |     /**
 34 |      * @return Response
 35 |      */
 36 |     protected function getTestSubject()
 37 |     {
 38 |         return new Response();
 39 |     }
 40 | 
 41 |     /**
 42 |      * @test
 43 |      * @covers ::setBodyData
 44 |      * @covers ::getBody
 45 |      */
 46 |     public function testBody()
 47 |     {
 48 |         $response = new Response();
 49 |         $this->assertEmpty(
 50 |             $response->getBody()
 51 |         );
 52 | 
 53 |         $object = new \stdClass(); // Good for tracking reference
 54 |         $this->assertSame(
 55 |             $response,
 56 |             $response->setBodyData($object)
 57 |         );
 58 |         $this->assertArrayHasKey(
 59 |             'data',
 60 |             $response->getBody()
 61 |         );
 62 |         $this->assertSame(
 63 |             $object,
 64 |             $response->getBody()['data']
 65 |         );
 66 |     }
 67 | 
 68 |     /**
 69 |      * @test
 70 |      * @covers ::setBodyData
 71 |      * @covers ::getBody
 72 |      * @requires PHP 5.5
 73 |      */
 74 |     public function testBodyGenerator()
 75 |     {
 76 |         $generator = function() {
 77 |             yield 'data' => 'data';
 78 |             yield 'string' => 'string';
 79 |             yield 'integer' => 42;
 80 |         };
 81 | 
 82 |         $response = new Response();
 83 | 
 84 |         $this->assertSame(
 85 |             $response,
 86 |             $response->setBodyData(
 87 |                 $generator()
 88 |             )
 89 |         );
 90 | 
 91 |         $this->assertSame(
 92 |             [
 93 |                 'data' => 'data',
 94 |                 'string' => 'string',
 95 |                 'integer' => 42,
 96 |             ],
 97 |             $response->getBody()
 98 |         );
 99 |     }
100 | 
101 |     /**
102 |      * @test
103 |      * @covers ::setWriterFactory
104 |      * @uses \AyeAye\Formatter\WriterFactory
105 |      */
106 |     public function testWriterFactory()
107 |     {
108 |         $expectedWriterFactory = new WriterFactory([]);
109 |         $response = new Response();
110 | 
111 |         $this->assertSame(
112 |             $response,
113 |             $response->setWriterFactory($expectedWriterFactory)
114 |         );
115 | 
116 |         $actualWriterFactory = $this->getObjectAttribute($response, 'writerFactory');
117 | 
118 |         $this->assertSame(
119 |             $expectedWriterFactory,
120 |             $actualWriterFactory
121 |         );
122 |     }
123 | 
124 |     /**
125 |      * @test
126 |      * @covers ::setWriter
127 |      * @uses \AyeAye\Formatter\Writer\Json
128 |      */
129 |     public function testWriter()
130 |     {
131 |         $expectedWriter = new Json();
132 |         $response = new Response();
133 | 
134 |         $this->assertSame(
135 |             $response,
136 |             $response->setWriter($expectedWriter)
137 |         );
138 | 
139 |         $actualWriter = $this->getObjectAttribute($response, 'writer');
140 | 
141 |         $this->assertSame(
142 |             $expectedWriter,
143 |             $actualWriter
144 |         );
145 |     }
146 | 
147 |     /**
148 |      * @test
149 |      * @covers ::prepareResponse
150 |      * @uses \AyeAye\Api\Request
151 |      * @uses \AyeAye\Api\Response::setWriterFactory
152 |      * @uses \AyeAye\Api\Response::setRequest
153 |      * @uses \AyeAye\Api\Response::getBody
154 |      * @uses \AyeAye\Api\Response::setBodyData
155 |      */
156 |     public function testPrepareResponse()
157 |     {
158 |         $response = new Response();
159 |         $writers = [
160 |             'testWriter'
161 |         ];
162 |         $data = 'data';
163 |         $expectedBody = [
164 |             'data' => $data
165 |         ];
166 |         $response->setBodyData($data);
167 | 
168 |         /** @var Request|\PHPUnit_Framework_MockObject_MockObject $request */
169 |         $request = $this->getMockRequest();
170 |         $request
171 |             ->expects($this->once())
172 |             ->method('getFormats')
173 |             ->with()
174 |             ->will($this->returnValue($writers));
175 | 
176 |         $writer = $this->getMockWriter();
177 |         $writer
178 |             ->expects($this->once())
179 |             ->method('format')
180 |             ->with($expectedBody, 'response')
181 |             ->will($this->returnValue(json_encode($expectedBody)));
182 | 
183 |         /** @var WriterFactory|\PHPUnit_Framework_MockObject_MockObject $writerFactory */
184 |         $writerFactory = $this->getMockWriterFactory();
185 |         $writerFactory
186 |             ->expects($this->once())
187 |             ->method('getWriterFor')
188 |             ->with($writers)
189 |             ->will($this->returnValue($writer));
190 | 
191 |         $response
192 |             ->setWriterFactory($writerFactory)
193 |             ->setRequest($request);
194 | 
195 |         $this->assertSame(
196 |             $response,
197 |             $response->prepareResponse()
198 |         );
199 | 
200 |         $this->assertJsonStringEqualsJsonString(
201 |             json_encode($expectedBody),
202 |             $this->getObjectAttribute($response, 'preparedResponse')
203 |         );
204 | 
205 |         return $response;
206 |     }
207 | 
208 |     /**
209 |      * @test
210 |      * @runInSeparateProcess
211 |      * @depends testPrepareResponse
212 |      * @param Response $response
213 |      * @covers ::respond
214 |      * @uses \AyeAye\Api\Request
215 |      */
216 |     public function testRespond(Response $response)
217 |     {
218 |         /** @var Writer|\PHPUnit_Framework_MockObject_MockObject $writer */
219 |         $writer = $this->getMockWriter();
220 |         $writer
221 |             ->expects($this->exactly(2))
222 |             ->method('getContentType')
223 |             ->with()
224 |             ->will($this->returnValue(''));
225 | 
226 |         /** @var Status|\PHPUnit_Framework_MockObject_MockObject $status */
227 |         $status = $this->getMockStatus();
228 |         $status
229 |             ->expects($this->once())
230 |             ->method('getHttpHeader')
231 |             ->with()
232 |             ->will($this->returnValue(null));
233 | 
234 |         $response->setWriter($writer);
235 | 
236 |         ob_start();
237 |         $this->assertSame(
238 |             $response,
239 |             $response->respond()
240 |         );
241 | 
242 |         $this->assertJsonStringEqualsJsonString(
243 |             json_encode(['data'=>'data']),
244 |             ob_get_clean()
245 |         );
246 | 
247 | 
248 |         ob_start();
249 |         $response->setStatus($status);
250 |         $this->assertSame(
251 |             $response,
252 |             $response->respond()
253 |         );
254 | 
255 |         $this->assertJsonStringEqualsJsonString(
256 |             json_encode(['data'=>'data']),
257 |             ob_get_clean()
258 |         );
259 |     }
260 | 
261 |     /**
262 |      * @test
263 |      * @runInSeparateProcess
264 |      * @covers ::respond
265 |      * @uses \AyeAye\Api\Request
266 |      * @uses \AyeAye\Api\Response::setWriterFactory
267 |      * @uses \AyeAye\Api\Response::setRequest
268 |      * @uses \AyeAye\Api\Response::getBody
269 |      * @uses \AyeAye\Api\Response::setBodyData
270 |      * @uses \AyeAye\Api\Response::prepareResponse
271 |      */
272 |     public function testRespondFull()
273 |     {
274 |         $response = new Response();
275 |         $writers = [
276 |             'testWriter'
277 |         ];
278 |         $data = 'data';
279 |         $expectedBody = [
280 |             'data' => $data
281 |         ];
282 |         $response->setBodyData($data);
283 | 
284 |         /** @var Request|\PHPUnit_Framework_MockObject_MockObject $request */
285 |         $request = $this->getMockRequest();
286 |         $request->expects($this->once())
287 |             ->method('getFormats')
288 |             ->with()
289 |             ->will($this->returnValue($writers));
290 | 
291 |         $writer = $this->getMockWriter();
292 |         $writer
293 |             ->expects($this->once())
294 |             ->method('format')
295 |             ->with($expectedBody, 'response')
296 |             ->will($this->returnValue(json_encode($expectedBody)));
297 |         $writer
298 |             ->expects($this->once())
299 |             ->method('getContentType')
300 |             ->with()
301 |             ->will($this->returnValue(''));
302 | 
303 |         /** @var WriterFactory|\PHPUnit_Framework_MockObject_MockObject $writerFactory */
304 |         $writerFactory = $this->getMockWriterFactory();
305 |         $writerFactory
306 |             ->expects($this->once())
307 |             ->method('getWriterFor')
308 |             ->with($writers)
309 |             ->will($this->returnValue($writer));
310 | 
311 |         /** @var Status|\PHPUnit_Framework_MockObject_MockObject $status */
312 |         $status = $this->getMockStatus();
313 |         $status
314 |             ->expects($this->once())
315 |             ->method('getHttpHeader')
316 |             ->with()
317 |             ->will($this->returnValue(null));
318 | 
319 |         $response
320 |             ->setWriterFactory($writerFactory)
321 |             ->setRequest($request)
322 |             ->setStatus($status);
323 | 
324 |         ob_start();
325 |         $this->assertSame(
326 |             $response,
327 |             $response->respond()
328 |         );
329 | 
330 |         $this->assertJsonStringEqualsJsonString(
331 |             json_encode(['data'=>'data']),
332 |             ob_get_clean()
333 |         );
334 |     }
335 | }
336 | 


--------------------------------------------------------------------------------
/tests/RouterTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * RouterTest.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api\Tests;
 11 | 
 12 | use AyeAye\Api\Router;
 13 | use AyeAye\Api\Tests\Injector\ControllerReflectorInjectorTest;
 14 | 
 15 | /**
 16 |  * Class RouterTest
 17 |  * @package AyeAye\Api\Tests
 18 |  * @see     https://github.com/AyeAyeApi/Api
 19 |  * @coversDefaultClass AyeAye\Api\Router
 20 |  */
 21 | class RouterTest extends TestCase
 22 | {
 23 |     use ControllerReflectorInjectorTest;
 24 | 
 25 |     /**
 26 |      * @return Router
 27 |      */
 28 |     protected function getTestSubject()
 29 |     {
 30 |         return new Router();
 31 |     }
 32 | 
 33 |     /**
 34 |      * @test
 35 |      * @covers ::processRequest
 36 |      * @uses \AyeAye\Api\Injector\ControllerReflectorInjector
 37 |      */
 38 |     public function testProcessRequestNoRoute()
 39 |     {
 40 |         $method = 'get';
 41 |         $index = 'index';
 42 |         $documentation = $this->getMockControllerDocumentation();
 43 | 
 44 |         $controller = $this->getMockController();
 45 | 
 46 |         $request = $this->getMockRequest();
 47 |         $request
 48 |             ->expects($this->once())
 49 |             ->method('getMethod')
 50 |             ->with()
 51 |             ->will($this->returnValue($method));
 52 |         $request
 53 |             ->expects($this->once())
 54 |             ->method('getRequestChain')
 55 |             ->with()
 56 |             ->will($this->returnValue([]));
 57 | 
 58 |         $reflectionController = $this->getMockReflectionController();
 59 | 
 60 |         $reflectionController
 61 |             ->expects($this->once())
 62 |             ->method('hasEndpoint')
 63 |             ->with($method, $index)
 64 |             ->will($this->returnValue(false));
 65 |         $reflectionController
 66 |             ->expects($this->once())
 67 |             ->method('getDocumentation')
 68 |             ->with()
 69 |             ->will($this->returnValue($documentation));
 70 | 
 71 |         $controllerReflector = $this->getMockControllerReflector();
 72 |         $controllerReflector
 73 |             ->expects($this->once())
 74 |             ->method('reflectController')
 75 |             ->with($controller)
 76 |             ->will($this->returnValue($reflectionController));
 77 | 
 78 |         $router = new Router();
 79 |         $router->setControllerReflector($controllerReflector);
 80 | 
 81 |         $this->assertSame(
 82 |             $documentation,
 83 |             $router->processRequest($request, $controller)
 84 |         );
 85 |     }
 86 | 
 87 |     /**
 88 |      * @test
 89 |      * @covers ::processRequest
 90 |      * @uses \AyeAye\Api\Router::setStatus
 91 |      * @uses \AyeAye\Api\Injector\ControllerReflectorInjector
 92 |      */
 93 |     public function testProcessRequestIndexOverride()
 94 |     {
 95 |         $method = 'post';
 96 |         $index = 'index';
 97 |         $requestChain = [];
 98 |         $data = new \stdClass();
 99 | 
100 |         $status = $this->getMockStatus();
101 | 
102 |         $controller = $this->getMockController();
103 | 
104 |         $request = $this->getMockRequest();
105 |         $request
106 |             ->expects($this->exactly(2))
107 |             ->method('getMethod')
108 |             ->with()
109 |             ->will($this->returnValue($method));
110 | 
111 |         $reflectionController = $this->getMockReflectionController();
112 |         $reflectionController
113 |             ->expects($this->never())
114 |             ->method('hasChildController');
115 |         $reflectionController
116 |             ->expects($this->once())
117 |             ->method('hasEndpoint')
118 |             ->with($method, $index)
119 |             ->will($this->returnValue(true));
120 |         $reflectionController
121 |             ->expects($this->once())
122 |             ->method('getEndpointResult')
123 |             ->with($method, $index, $request)
124 |             ->will($this->returnValue($data));
125 |         $reflectionController
126 |             ->expects($this->once())
127 |             ->method('getStatus')
128 |             ->with()
129 |             ->will($this->returnValue($status));
130 | 
131 |         $controllerReflector = $this->getMockControllerReflector();
132 |         $controllerReflector
133 |             ->expects($this->once())
134 |             ->method('reflectController')
135 |             ->with($controller)
136 |             ->will($this->returnValue($reflectionController));
137 | 
138 |         $router = new Router();
139 |         $router->setControllerReflector($controllerReflector);
140 | 
141 |         $this->assertSame(
142 |             $data,
143 |             $router->processRequest($request, $controller, $requestChain)
144 |         );
145 |     }
146 | 
147 |     /**
148 |      * @test
149 |      * @covers ::processRequest
150 |      * @uses \AyeAye\Api\Router::setStatus
151 |      * @uses \AyeAye\Api\Injector\ControllerReflectorInjector
152 |      */
153 |     public function testProcessRequestSingleEndpoint()
154 |     {
155 |         $method = 'get';
156 |         $endpointName = 'test';
157 |         $requestChain = [$endpointName];
158 |         $data = new \stdClass();
159 | 
160 |         $status = $this->getMockStatus();
161 | 
162 |         $controller = $this->getMockController();
163 | 
164 |         $request = $this->getMockRequest();
165 |         $request
166 |             ->expects($this->exactly(2))
167 |             ->method('getMethod')
168 |             ->with()
169 |             ->will($this->returnValue($method));
170 | 
171 |         $reflectionController = $this->getMockReflectionController();
172 |         $reflectionController
173 |             ->expects($this->once())
174 |             ->method('hasChildController')
175 |             ->with($endpointName)
176 |             ->will($this->returnValue(false));
177 |         $reflectionController
178 |             ->expects($this->once())
179 |             ->method('hasEndpoint')
180 |             ->with($method, $endpointName)
181 |             ->will($this->returnValue(true));
182 |         $reflectionController
183 |             ->expects($this->once())
184 |             ->method('getEndpointResult')
185 |             ->with($method, $endpointName, $request)
186 |             ->will($this->returnValue($data));
187 |         $reflectionController
188 |             ->expects($this->once())
189 |             ->method('getStatus')
190 |             ->with()
191 |             ->will($this->returnValue($status));
192 | 
193 |         $controllerReflector = $this->getMockControllerReflector();
194 |         $controllerReflector
195 |             ->expects($this->once())
196 |             ->method('reflectController')
197 |             ->with($controller)
198 |             ->will($this->returnValue($reflectionController));
199 | 
200 |         $router = new Router();
201 |         $router->setControllerReflector($controllerReflector);
202 | 
203 |         $this->assertSame(
204 |             $data,
205 |             $router->processRequest($request, $controller, $requestChain)
206 |         );
207 |     }
208 | 
209 |     /**
210 |      * @test
211 |      * @covers ::processRequest
212 |      * @uses \AyeAye\Api\Router::setStatus
213 |      * @uses \AyeAye\Api\Injector\ControllerReflectorInjector
214 |      */
215 |     public function testProcessRequestControllerRoutedEndpoint()
216 |     {
217 |         $method = 'get';
218 |         $controller1 = 'controller-one';
219 |         $controller2 = 'controller-two';
220 |         $endpointName = 'test';
221 |         $requestChain = [$controller1, $controller2, $endpointName];
222 |         $data = new \stdClass();
223 | 
224 |         $status = $this->getMockStatus();
225 | 
226 |         $controller = $this->getMockController();
227 | 
228 |         $request = $this->getMockRequest();
229 |         $request
230 |             ->expects($this->exactly(2))
231 |             ->method('getMethod')
232 |             ->with()
233 |             ->will($this->returnValue($method));
234 | 
235 |         $reflectionController = $this->getMockReflectionController();
236 |         $reflectionController
237 |             ->expects($this->at(0))
238 |             ->method('hasChildController')
239 |             ->with($controller1)
240 |             ->will($this->returnValue(true));
241 |         $reflectionController
242 |             ->expects($this->at(1))
243 |             ->method('getChildController')
244 |             ->with($controller1)
245 |             ->will($this->returnValue($controller));
246 |         $reflectionController
247 |             ->expects($this->at(2))
248 |             ->method('hasChildController')
249 |             ->with($controller2)
250 |             ->will($this->returnValue(true));
251 |         $reflectionController
252 |             ->expects($this->at(3))
253 |             ->method('getChildController')
254 |             ->with($controller2)
255 |             ->will($this->returnValue($controller));
256 |         $reflectionController
257 |             ->expects($this->at(4))
258 |             ->method('hasChildController')
259 |             ->with($endpointName)
260 |             ->will($this->returnValue(false));
261 |         $reflectionController
262 |             ->expects($this->once())
263 |             ->method('hasEndpoint')
264 |             ->with($method, $endpointName)
265 |             ->will($this->returnValue(true));
266 |         $reflectionController
267 |             ->expects($this->once())
268 |             ->method('getEndpointResult')
269 |             ->with($method, $endpointName, $request)
270 |             ->will($this->returnValue($data));
271 |         $reflectionController
272 |             ->expects($this->once())
273 |             ->method('getStatus')
274 |             ->with()
275 |             ->will($this->returnValue($status));
276 | 
277 |         $controllerReflector = $this->getMockControllerReflector();
278 |         $controllerReflector
279 |             ->expects($this->any())
280 |             ->method('reflectController')
281 |             ->with($controller)
282 |             ->will($this->returnValue($reflectionController));
283 | 
284 |         $router = new Router();
285 |         $router->setControllerReflector($controllerReflector);
286 | 
287 |         $this->assertSame(
288 |             $data,
289 |             $router->processRequest($request, $controller, $requestChain)
290 |         );
291 |     }
292 | 
293 |     /**
294 |      * @test
295 |      * @covers ::processRequest
296 |      * @uses \AyeAye\Api\Router::setStatus
297 |      * @uses \AyeAye\Api\Exception
298 |      * @uses \AyeAye\Api\Injector\ControllerReflectorInjector
299 |      * @expectedException \AyeAye\Api\Exception
300 |      * @expectedExceptionCode 404
301 |      * @expectedExceptionMessage Could not find controller or endpoint matching 'test'
302 |      */
303 |     public function testProcessRequestUnknownEndpoint()
304 |     {
305 |         $method = 'get';
306 |         $endpointName = 'test';
307 |         $requestChain = [$endpointName];
308 |         $data = new \stdClass();
309 | 
310 |         $controller = $this->getMockController();
311 | 
312 |         $request = $this->getMockRequest();
313 |         $request
314 |             ->expects($this->once())
315 |             ->method('getMethod')
316 |             ->with()
317 |             ->will($this->returnValue($method));
318 | 
319 |         $reflectionController = $this->getMockReflectionController();
320 |         $reflectionController
321 |             ->expects($this->once())
322 |             ->method('hasChildController')
323 |             ->with($endpointName)
324 |             ->will($this->returnValue(false));
325 |         $reflectionController
326 |             ->expects($this->once())
327 |             ->method('hasEndpoint')
328 |             ->with($method, $endpointName)
329 |             ->will($this->returnValue(false));
330 | 
331 |         $controllerReflector = $this->getMockControllerReflector();
332 |         $controllerReflector
333 |             ->expects($this->once())
334 |             ->method('reflectController')
335 |             ->with($controller)
336 |             ->will($this->returnValue($reflectionController));
337 | 
338 |         $router = new Router();
339 |         $router->setControllerReflector($controllerReflector);
340 | 
341 |         $this->assertSame(
342 |             $data,
343 |             $router->processRequest($request, $controller, $requestChain)
344 |         );
345 |     }
346 | }
347 | 


--------------------------------------------------------------------------------
/tests/StatusTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * StatusTest.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api\Tests;
 11 | 
 12 | use AyeAye\Api\Status;
 13 | 
 14 | /**
 15 |  * Class StatusTest
 16 |  * @package AyeAye\Api\Tests
 17 |  * @see     https://github.com/AyeAyeApi/Api
 18 |  * @coversDefaultClass AyeAye\Api\Status
 19 |  */
 20 | class StatusTest extends TestCase
 21 | {
 22 | 
 23 |     /**
 24 |      * @test
 25 |      * @covers ::__construct
 26 |      * @expectedException        \Exception
 27 |      * @expectedExceptionMessage Status '9001' does not exist
 28 |      */
 29 |     public function testInvalidStatusCode()
 30 |     {
 31 |         new Status(9001);
 32 |     }
 33 | 
 34 |     /**
 35 |      * @test
 36 |      * @covers ::__construct
 37 |      * @uses AyeAye\Api\Status::getCode
 38 |      * @uses AyeAye\Api\Status::getMessage
 39 |      * @uses AyeAye\Api\Status::getMessageForCode
 40 |      */
 41 |     public function testConstruct()
 42 |     {
 43 |         $status = new Status();
 44 |         $this->assertSame(
 45 |             200,
 46 |             $status->getCode()
 47 |         );
 48 |         $this->assertSame(
 49 |             'OK',
 50 |             $status->getMessage()
 51 |         );
 52 |     }
 53 | 
 54 |     /**
 55 |      * @test
 56 |      * @covers ::getCode
 57 |      * @uses AyeAye\Api\Status::__construct
 58 |      * @uses AyeAye\Api\Status::getMessageForCode
 59 |      */
 60 |     public function testGetCode()
 61 |     {
 62 |         $status = new Status();
 63 |         $this->assertSame(
 64 |             200,
 65 |             $status->getCode()
 66 |         );
 67 | 
 68 |         $status = new Status(500);
 69 |         $this->assertSame(
 70 |             500,
 71 |             $status->getCode()
 72 |         );
 73 |     }
 74 | 
 75 |     /**
 76 |      * @test
 77 |      * @covers ::getMessage
 78 |      * @uses AyeAye\Api\Status::__construct
 79 |      * @uses AyeAye\Api\Status::getMessageForCode
 80 |      */
 81 |     public function testGetMessage()
 82 |     {
 83 |         $status = new Status();
 84 |         $this->assertSame(
 85 |             'OK',
 86 |             $status->getMessage()
 87 |         );
 88 | 
 89 |         $status = new Status(500);
 90 |         $this->assertSame(
 91 |             'Internal Server Error',
 92 |             $status->getMessage()
 93 |         );
 94 |     }
 95 | 
 96 |     /**
 97 |      * @test
 98 |      * @covers ::getMessageForCode
 99 |      * @uses AyeAye\Api\Status::__construct
100 |      */
101 |     public function testGetMessageForCode()
102 |     {
103 |         $this->assertSame(
104 |             'OK',
105 |             Status::getMessageForCode(200)
106 |         );
107 | 
108 |         $this->assertSame(
109 |             'Internal Server Error',
110 |             Status::getMessageForCode(500)
111 |         );
112 | 
113 |         $this->assertNull(
114 |             Status::getMessageForCode(9001)
115 |         );
116 |     }
117 | 
118 |     /**
119 |      * @test
120 |      * @covers ::getHttpHeader
121 |      * @uses AyeAye\Api\Status::getCode
122 |      * @uses AyeAye\Api\Status::__construct
123 |      * @uses AyeAye\Api\Status::getMessageForCode
124 |      */
125 |     public function testGetHttpHeader()
126 |     {
127 |         $status = new Status();
128 |         $this->assertSame(
129 |             'HTTP/1.1 200 OK',
130 |             $status->getHttpHeader()
131 |         );
132 | 
133 |         $status = new Status(500);
134 |         $this->assertSame(
135 |             'HTTP/1.1 500 Internal Server Error',
136 |             $status->getHttpHeader()
137 |         );
138 |     }
139 | 
140 |     /**
141 |      * @test
142 |      * @covers ::jsonSerialize
143 |      * @uses AyeAye\Api\Status::__construct
144 |      * @uses AyeAye\Api\Status::getMessageForCode
145 |      * @uses AyeAye\Api\Status::getCode
146 |      * @uses AyeAye\Api\Status::getMessage
147 |      */
148 |     public function testJsonSerialize()
149 |     {
150 |         $status = new Status();
151 |         $this->assertJsonStringEqualsJsonString(
152 |             json_encode([
153 |                 'code' => 200,
154 |                 'message' => 'OK',
155 |             ]),
156 |             json_encode($status)
157 |         );
158 | 
159 |         $status = new Status(500);
160 |         $this->assertSame(
161 |             json_encode([
162 |                 'code' => 500,
163 |                 'message' => 'Internal Server Error',
164 |             ]),
165 |             json_encode($status)
166 |         );
167 |     }
168 | }
169 | 


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * TestCase.php
  4 |  * @author    Daniel Mason <daniel@ayeayeapi.com>
  5 |  * @copyright (c) 2015 - 2016 Daniel Mason <daniel@ayeayeapi.com>
  6 |  * @license   MIT
  7 |  * @see       https://github.com/AyeAyeApi/Api
  8 |  */
  9 | 
 10 | namespace AyeAye\Api\Tests;
 11 | 
 12 | use AyeAye\Api\Controller;
 13 | use AyeAye\Api\ControllerDocumentation;
 14 | use AyeAye\Api\ControllerReflector;
 15 | use AyeAye\Api\Documentation;
 16 | use AyeAye\Api\Exception as AyeAyeException;
 17 | use AyeAye\Api\Exception;
 18 | use AyeAye\Api\ReflectionController;
 19 | use AyeAye\Api\Request;
 20 | use AyeAye\Api\Response;
 21 | use AyeAye\Api\Router;
 22 | use AyeAye\Formatter\Writer;
 23 | use AyeAye\Formatter\WriterFactory;
 24 | use AyeAye\Api\Status;
 25 | use Psr\Log\AbstractLogger;
 26 | 
 27 | /**
 28 |  * Class TestCase
 29 |  * Abstract Testing class to provide additional utilities
 30 |  * @abstract
 31 |  * @package AyeAye\Api\Tests
 32 |  * @see     https://github.com/AyeAyeApi/Api
 33 |  */
 34 | abstract class TestCase extends \PHPUnit_Framework_TestCase
 35 | {
 36 |     /**
 37 |      * Get an otherwise inaccessible method
 38 |      * @param object $object
 39 |      * @param $methodName
 40 |      * @return callable
 41 |      */
 42 |     protected function getObjectMethod($object, $methodName)
 43 |     {
 44 |         if (!is_object($object)) {
 45 |             throw new \InvalidArgumentException('Can not get method of non object');
 46 |         }
 47 |         $reflectionMethod = new \ReflectionMethod($object, $methodName);
 48 |         $reflectionMethod->setAccessible(true);
 49 |         return function () use ($object, $reflectionMethod) {
 50 |             return $reflectionMethod->invokeArgs($object, func_get_args());
 51 |         };
 52 |     }
 53 | 
 54 |     /**
 55 |      * @param object $object        The object to update
 56 |      * @param string $attributeName The attribute to change
 57 |      * @param mixed  $value         The value to change it to
 58 |      */
 59 |     protected function setObjectAttribute($object, $attributeName, $value)
 60 |     {
 61 |         $reflection = new \ReflectionObject($object);
 62 |         $property = $reflection->getProperty($attributeName);
 63 |         $property->setAccessible(true);
 64 |         $property->setValue($object, $value);
 65 |     }
 66 | 
 67 |     /**
 68 |      * @return \ReflectionMethod|\PHPUnit_Framework_MockObject_MockObject
 69 |      */
 70 |     protected function getMockReflectionMethod()
 71 |     {
 72 |         $mockReflection = $this
 73 |             ->getMockBuilder(\ReflectionMethod::class)
 74 |             ->disableOriginalConstructor()
 75 |             ->getMock();
 76 |         return $mockReflection;
 77 |     }
 78 | 
 79 |     /**
 80 |      * @return \ReflectionObject|\PHPUnit_Framework_MockObject_MockObject
 81 |      */
 82 |     protected function getMockReflectionObject()
 83 |     {
 84 |         $mockReflection = $this
 85 |             ->getMockBuilder(\ReflectionObject::class)
 86 |             ->disableOriginalConstructor()
 87 |             ->getMock();
 88 |         return $mockReflection;
 89 |     }
 90 | 
 91 |     /**
 92 |      * @return \ReflectionObject|\PHPUnit_Framework_MockObject_MockObject
 93 |      */
 94 |     protected function getMockReflectionParameter()
 95 |     {
 96 |         $mockReflection = $this
 97 |             ->getMockBuilder(\ReflectionParameter::class)
 98 |             ->disableOriginalConstructor()
 99 |             ->getMock();
100 |         return $mockReflection;
101 |     }
102 | 
103 |     /**
104 |      * @return Controller|\PHPUnit_Framework_MockObject_MockObject
105 |      */
106 |     protected function getMockController()
107 |     {
108 |         return $this->getMock(Controller::class);
109 |     }
110 | 
111 |     protected function getMockControllerDocumentation()
112 |     {
113 |         return $this
114 |             ->getMockBuilder(ControllerDocumentation::class)
115 |             ->disableOriginalConstructor()
116 |             ->getMock();
117 |     }
118 | 
119 |     /**
120 |      * @return ControllerReflector|\PHPUnit_Framework_MockObject_MockObject
121 |      */
122 |     protected function getMockControllerReflector()
123 |     {
124 |         return $this->getMock(ControllerReflector::class);
125 |     }
126 | 
127 |     /**
128 |      * @return ReflectionController|\PHPUnit_Framework_MockObject_MockObject
129 |      */
130 |     protected function getMockReflectionController()
131 |     {
132 |         return $this
133 |             ->getMockBuilder(ReflectionController::class)
134 |             ->disableOriginalConstructor()
135 |             ->getMock();
136 |     }
137 | 
138 |     /**
139 |      * @return Documentation|\PHPUnit_Framework_MockObject_MockObject
140 |      */
141 |     protected function getMockDocumentation()
142 |     {
143 |         return $this->getMock(Documentation::class);
144 |     }
145 | 
146 |     /**
147 |      * @return Request|\PHPUnit_Framework_MockObject_MockObject
148 |      */
149 |     protected function getMockRequest()
150 |     {
151 |         return $this
152 |             ->getMockBuilder(Request::class)
153 |             ->disableOriginalConstructor()
154 |             ->getMock();
155 |     }
156 | 
157 |     /**
158 |      * @return Response|\PHPUnit_Framework_MockObject_MockObject
159 |      */
160 |     protected function getMockResponse()
161 |     {
162 |         return $this
163 |             ->getMockBuilder(Response::class)
164 |             ->disableOriginalConstructor()
165 |             ->getMock();
166 |     }
167 | 
168 |     /**
169 |      * @return Router|\PHPUnit_Framework_MockObject_MockObject
170 |      */
171 |     protected function getMockRouter()
172 |     {
173 |         return $this->getMock(Router::class);
174 |     }
175 | 
176 |     /**
177 |      * @return Status|\PHPUnit_Framework_MockObject_MockObject
178 |      */
179 |     protected function getMockStatus()
180 |     {
181 |         return $this
182 |             ->getMockBuilder(Status::class)
183 |             ->disableOriginalConstructor()
184 |             ->getMock();
185 |     }
186 | 
187 |     /**
188 |      * @return WriterFactory|\PHPUnit_Framework_MockObject_MockObject
189 |      */
190 |     protected function getMockWriterFactory()
191 |     {
192 |         return $this
193 |             ->getMockBuilder(WriterFactory::class)
194 |             ->disableOriginalConstructor()
195 |             ->getMock();
196 |     }
197 | 
198 |     /**
199 |      * @return Writer|\PHPUnit_Framework_MockObject_MockObject
200 |      */
201 |     protected function getMockWriter()
202 |     {
203 |         return $this->getMock(Writer::class);
204 |     }
205 | 
206 |     /**
207 |      * @return AbstractLogger|\PHPUnit_Framework_MockObject_MockObject
208 |      */
209 |     protected function getMockLogger()
210 |     {
211 |         return $this->getMockForAbstractClass(AbstractLogger::class);
212 |     }
213 | 
214 |     /**
215 |      * @return AyeAyeException|\PHPUnit_Framework_MockObject_MockObject
216 |      */
217 |     protected function getMockAyeAyeException()
218 |     {
219 |         return $this
220 |             ->getMockBuilder(Exception::class)
221 |             ->disableOriginalConstructor()
222 |             ->getMock();
223 |     }
224 | }
225 | 


--------------------------------------------------------------------------------