tests/ReaderTest.php

   1 <?php
   2
   3 namespace frostbane\DocBlockReader\test;
   4
   5 use function frostbane\DocBlockReader\test\model\someMethod;
   6 use PHPUnit\Framework\TestCase;
   7 use frostbane\DocBlockReader\Reader;
   8 use frostbane\DocBlockReader\test\model\SomeClass;
   9
  10 class ReaderTest extends TestCase
  11 {
  12     public function testInstance()
  13     {
  14         $someClass = new SomeClass();
  15
  16         $thisReader     = new Reader($this);
  17         $classReader    = new Reader(SomeClass::class);
  18         $instanceReader = new Reader($someClass);
  19
  20         $this->assertInstanceOf(Reader::class, $thisReader);
  21         $this->assertInstanceOf(Reader::class, $classReader);
  22         $this->assertInstanceOf(Reader::class, $instanceReader);
  23     }
  24
  25     public function testPropertyParsing()
  26     {
  27         $reader = new Reader(SomeClass::class, 'myVar', Reader::TYPE_PROPERTY);
  28         $this->commonTest($reader);
  29     }
  30
  31     public function testPropertyParsing2()
  32     {
  33         $reader = new Reader(SomeClass::class, 'myVar2', Reader::TYPE_PROPERTY);
  34         $x      = $reader->getParameter("x");
  35         $y      = $reader->getParameter("y");
  36         $this->assertSame(1, $x);
  37         $this->assertSame("yes!", $y);
  38     }
  39
  40     /**
  41      * Issue:
  42      * @see https://github.com/jan-swiecki/php-simple-annotations/issues/2
  43      *      Thanks to @KrekkieD (https://github.com/KrekkieD) for
  44      *      reporting this issue!
  45      */
  46     public function testIssue2Problem()
  47     {
  48         $reader = new Reader(SomeClass::class, 'issue2', Reader::TYPE_PROPERTY);
  49         $Lalala = $reader->getParameters()["Lalala"];
  50
  51         $this->assertSame(array("somejsonarray", "2", "anotherjsonarray", "3"), $Lalala);
  52     }
  53
  54     public function testParserMethodImplicit()
  55     {
  56         $reader = new Reader(SomeClass::class, 'parserFixture');
  57         $this->commonTest($reader);
  58     }
  59
  60     public function testParserMethodExplicit()
  61     {
  62         $reader = new Reader(SomeClass::class, 'parserFixture', Reader::TYPE_METHOD);
  63         $this->commonTest($reader);
  64     }
  65
  66     public function testParserCallable()
  67     {
  68         $someClass = new SomeClass();
  69         $reader1   = new Reader(array(SomeClass::class, "parserFixture"));
  70         $reader2   = new Reader(array($someClass, "parserFixture"));
  71
  72         $this->commonTest($reader1);
  73         $this->commonTest($reader2);
  74     }
  75
  76     public function testParserStaticCallable()
  77     {
  78         $someClass = new SomeClass();
  79         $reader1   = new Reader(array(SomeClass::class, "staticFixture"));
  80         $reader2   = new Reader(array($someClass, "staticFixture"));
  81
  82         $this->commonTest($reader1);
  83         $this->commonTest($reader2);
  84     }
  85
  86     /**
  87      * @param Reader $reader
  88      */
  89     private function commonTest($reader)
  90     {
  91         $parameters = $reader->getParameters();
  92
  93         $this->assertNotEmpty($parameters);
  94
  95         $this->assertArrayHasKey('number', $parameters);
  96         $this->assertArrayHasKey('string', $parameters);
  97         $this->assertArrayHasKey('string2', $parameters);
  98         $this->assertArrayHasKey('string3', $parameters);
  99         $this->assertArrayHasKey('string4', $parameters);
 100         $this->assertArrayHasKey('string5', $parameters);
 101         $this->assertArrayHasKey('string6', $parameters);
 102         $this->assertArrayHasKey('string7', $parameters);
 103         $this->assertArrayHasKey('array', $parameters);
 104         $this->assertArrayHasKey('object', $parameters);
 105         $this->assertArrayHasKey('nested', $parameters);
 106         $this->assertArrayHasKey('nestedArray', $parameters);
 107         $this->assertArrayHasKey('trueVar', $parameters);
 108         $this->assertArrayHasKey('null-var', $parameters);
 109         $this->assertArrayHasKey('booleanTrue', $parameters);
 110         $this->assertArrayHasKey('booleanFalse', $parameters);
 111         $this->assertArrayHasKey('booleanNull', $parameters);
 112         $this->assertArrayNotHasKey('non_existent_key', $parameters);
 113
 114         $this->assertSame(1, $parameters['number']);
 115         $this->assertSame("123", $parameters['string']);
 116         $this->assertSame("abc", $parameters['string2']);
 117         $this->assertSame(array("a", "b"), $parameters['array']);
 118         $this->assertSame(array("x" => "y"), $parameters['object']);
 119         $this->assertSame(array("x" => array("y" => "z")), $parameters['nested']);
 120         $this->assertSame(array("x" => array("y" => array("z", "p"))), $parameters['nestedArray']);
 121         $this->assertSame(true, $parameters['trueVar']);
 122         $this->assertSame(null, $parameters['null-var']);
 123
 124         $this->assertSame(true, $parameters['booleanTrue']);
 125         $this->assertSame("tRuE", $parameters['string3']);
 126         $this->assertSame("true", $parameters['string5']);
 127         $this->assertSame("false", $parameters['string6']);
 128         $this->assertSame(false, $parameters['booleanFalse']);
 129         $this->assertSame(null, $parameters['booleanNull']);
 130         $this->assertSame("null", $parameters['string4']);
 131         $this->assertSame("akane kitamoto", $parameters['string7']);
 132         $this->assertNull($reader->getParameter("non_existent_key"));
 133     }
 134
 135     public function testParserOneFromClass()
 136     {
 137         $reader     = new Reader(SomeClass::class);
 138         $parameters = $reader->getParameters();
 139
 140         $this->assertNotEmpty($parameters);
 141
 142         $this->assertArrayHasKey('number', $parameters);
 143         $this->assertArrayHasKey('string', $parameters);
 144         $this->assertArrayHasKey('array', $parameters);
 145         $this->assertArrayHasKey('object', $parameters);
 146         $this->assertArrayHasKey('nested', $parameters);
 147         $this->assertArrayHasKey('nestedArray', $parameters);
 148         $this->assertArrayHasKey('trueVar', $parameters);
 149         $this->assertArrayHasKey('null-var', $parameters);
 150         $this->assertArrayHasKey('booleanTrue', $parameters);
 151         $this->assertArrayHasKey('booleanFalse', $parameters);
 152         $this->assertArrayHasKey('booleanNull', $parameters);
 153         $this->assertArrayNotHasKey('non_existent_key', $parameters);
 154
 155         $this->assertSame(1, $parameters['number']);
 156         $this->assertSame("123", $parameters['string']);
 157         $this->assertSame("abc", $parameters['string2']);
 158         $this->assertSame(array("a", "b"), $parameters['array']);
 159         $this->assertSame(array("x" => "y"), $parameters['object']);
 160         $this->assertSame(array("x" => array("y" => "z")), $parameters['nested']);
 161         $this->assertSame(array("x" => array("y" => array("z", "p"))), $parameters['nestedArray']);
 162         $this->assertSame(true, $parameters['trueVar']);
 163         $this->assertSame(null, $parameters['null-var']);
 164
 165         $this->assertSame(true, $parameters['booleanTrue']);
 166         $this->assertSame("tRuE", $parameters['string3']);
 167         $this->assertSame(false, $parameters['booleanFalse']);
 168         $this->assertSame(null, $parameters['booleanNull']);
 169     }
 170
 171     public function testParserTwo()
 172     {
 173         $reader = new Reader(SomeClass::class, 'parserFixture');
 174
 175         $this->assertSame(1, $reader->getParameter('number'));
 176         $this->assertSame("123", $reader->getParameter('string'));
 177         $this->assertSame(array("x" => array("y" => array("z", "p"))),
 178                           $reader->getParameter('nestedArray'));
 179
 180         $this->assertSame(null, $reader->getParameter('nullVar'));
 181         $this->assertSame(null, $reader->getParameter('null-var'));
 182         $this->assertSame(null, $reader->getParameter('non-existent'));
 183     }
 184
 185     public function testParserEmpty()
 186     {
 187         $reader     = new Reader(SomeClass::class, 'parserEmptyFixture');
 188         $parameters = $reader->getParameters();
 189         $this->assertSame(array(), $parameters);
 190     }
 191
 192     public function testParserMulti()
 193     {
 194         $reader     = new Reader(SomeClass::class, 'parserMultiFixture');
 195         $parameters = $reader->getParameters();
 196
 197         $this->assertNotEmpty($parameters);
 198         $this->assertArrayHasKey('param', $parameters);
 199         $this->assertArrayHasKey('var', $parameters);
 200
 201         $this->assertSame("x", $parameters["var"]);
 202         $this->assertSame(1024, $parameters["var2"]);
 203
 204         $this->assertSame(
 205             array("string x", "integer y", "array z"),
 206             $parameters["param"]);
 207
 208     }
 209
 210     public function testParserThree()
 211     {
 212         $reader = new Reader(SomeClass::class, 'fixtureThree');
 213         // $allowedRequest = $reader->getParameter("allowedRequest");
 214
 215         $postParam = $reader->getParameter("postParam");
 216
 217         $this->assertNotEmpty($postParam);
 218     }
 219
 220     public function testParserFour()
 221     {
 222         $reader = new Reader(SomeClass::class, 'fixtureFour');
 223
 224         $this->assertSame(true, $reader->getParameter('get'));
 225         $this->assertSame(true, $reader->getParameter('post'));
 226         $this->assertSame(true, $reader->getParameter('ajax'));
 227         $this->assertSame(array("x", "y", "z"), $reader->getParameter('postParam'));
 228     }
 229
 230     public function testParserFourBis()
 231     {
 232         $reader = new Reader(SomeClass::class, 'fixtureFour');
 233
 234         $parameters = $reader->getParameters();
 235
 236         $this->assertArrayHasKey('get', $parameters);
 237         $this->assertArrayHasKey('post', $parameters);
 238         $this->assertArrayHasKey('ajax', $parameters);
 239         $this->assertArrayHasKey('postParam', $parameters);
 240
 241         $this->assertSame(true, $parameters['get']);
 242         $this->assertSame(true, $parameters['post']);
 243         $this->assertSame(true, $parameters['ajax']);
 244         $this->assertSame(array("x", "y", "z"), $parameters['postParam']);
 245
 246     }
 247
 248     public function testParseFunctionImplicit()
 249     {
 250         include_once __DIR__ . "/model/SomeMethod.php";
 251
 252         $method = "\\frostbane\\DocBlockReader\\test\\model\\someMethod";
 253
 254         $this->assertTrue(function_exists($method));
 255
 256         $reader = new Reader($method);
 257
 258         $this->commonTest($reader);
 259     }
 260
 261     public function testParseFunctionExplict()
 262     {
 263         include_once __DIR__ . "/model/SomeMethod.php";
 264
 265         $method = "\\frostbane\\DocBlockReader\\test\\model\\someMethod";
 266
 267         $this->assertTrue(function_exists($method));
 268
 269         $reader = new Reader($method, Reader::TYPE_FUNCTION);
 270
 271         $this->commonTest($reader);
 272     }
 273
 274     public function testFive()
 275     {
 276         $reader1 = new Reader(SomeClass::class, 'fixtureFive');
 277         $reader2 = new Reader(SomeClass::class, 'fixtureFive');
 278
 279         $parameters1 = $reader1->getParameters();
 280
 281         $trueVar1 = $parameters1['trueVar1'];
 282
 283         $this->assertSame(true, $trueVar1);
 284         $this->assertSame(true, $reader2->getParameter("trueVar2"));
 285
 286     }
 287
 288     public function testVariableDeclarations()
 289     {
 290         $reader       = new Reader(SomeClass::class, 'fixtureVariableDeclarations');
 291         $declarations = $reader->getVariableDeclarations("param");
 292         $this->assertNotEmpty($declarations);
 293
 294         $this->assertSame(array(
 295                               array("type" => "string", "name" => "var1"),
 296                               array("type" => "integer", "name" => "var2"),
 297                           ), $declarations);
 298     }
 299
 300     /**
 301      * @dataProvider badVariableDataProvider
 302      */
 303     public function testBadVariableDeclarations($methodName)
 304     {
 305         $this->expectException(\InvalidArgumentException::class);
 306
 307         $reader = new Reader(SomeClass::class, $methodName);
 308
 309         $reader->getVariableDeclarations("param");
 310     }
 311
 312     public function badVariableDataProvider()
 313     {
 314         return array(
 315             array('fixtureBadVariableDeclarationsOne'),
 316             array('fixtureBadVariableDeclarationsTwo'),
 317         );
 318     }
 319
 320     public function testConstantParser()
 321     {
 322         $reader = new Reader(SomeClass::class, "MY_CONST", Reader::TYPE_CONSTANT);
 323
 324         $parameters = $reader->getParameters();
 325
 326         $this->assertSame("some value", $parameters["get"]);
 327     }
 328
 329     public function testConstantParserCommon()
 330     {
 331         $reader = new Reader(SomeClass::class, "MY_OTHER_CONST", Reader::TYPE_CONSTANT);
 332
 333         $this->commonTest($reader);
 334     }
 335 }