From d1f4ee3c032b7aac261e02114f82aa7115a47f84 Mon Sep 17 00:00:00 2001 From: Mike van Riel Date: Sun, 21 Jun 2015 08:38:06 +0200 Subject: [PATCH] Written test for Param tag --- src/DocBlock/Tags/Param.php | 32 +++- tests/unit/DocBlock/Tags/ParamTest.php | 227 +++++++++++++++++++++++++ 2 files changed, 255 insertions(+), 4 deletions(-) create mode 100644 tests/unit/DocBlock/Tags/ParamTest.php diff --git a/src/DocBlock/Tags/Param.php b/src/DocBlock/Tags/Param.php index 1564b35..b60faea 100644 --- a/src/DocBlock/Tags/Param.php +++ b/src/DocBlock/Tags/Param.php @@ -14,16 +14,17 @@ namespace phpDocumentor\Reflection\DocBlock\Tags; use phpDocumentor\Reflection\DocBlock\Description; use phpDocumentor\Reflection\DocBlock\DescriptionFactory; -use phpDocumentor\Reflection\DocBlock\Tag; use phpDocumentor\Reflection\Type; use phpDocumentor\Reflection\TypeResolver; use phpDocumentor\Reflection\Types\Context; +use Webmozart\Assert\Assert; /** - * Reflection class for a @param tag in a Docblock. + * Reflection class for the {@}param tag in a Docblock. */ class Param extends BaseTag { + /** @var string */ protected $name = 'param'; /** @var Type */ @@ -43,6 +44,9 @@ class Param extends BaseTag */ public function __construct($variableName, Type $type = null, $isVariadic = false, Description $description = null) { + Assert::string($variableName); + Assert::boolean($isVariadic); + $this->variableName = $variableName; $this->type = $type; $this->isVariadic = $isVariadic; @@ -59,6 +63,9 @@ class Param extends BaseTag Context $context = null ) { + Assert::stringNotEmpty($body); + Assert::allNotNull([$typeResolver, $descriptionFactory]); + $parts = preg_split('/(\s+)/Su', $body, 3, PREG_SPLIT_DELIM_CAPTURE); $type = null; $variableName = ''; @@ -100,6 +107,16 @@ class Param extends BaseTag return $this->variableName; } + /** + * Returns the variable's type or null if unknown. + * + * @return Type|null + */ + public function getType() + { + return $this->type; + } + /** * Returns whether this tag is variadic. * @@ -110,9 +127,16 @@ class Param extends BaseTag return $this->isVariadic; } + /** + * Returns a string representation for this tag. + * + * @return string + */ public function __toString() { - return $this->type . ' ' . ($this->isVariadic() ? '...' : '') . '$' . $this->variableName . ' ' - . $this->description; + return ($this->type ? $this->type . ' ' : '') + . ($this->isVariadic() ? '...' : '') + . '$' . $this->variableName + . ($this->description ? ' ' . $this->description : ''); } } diff --git a/tests/unit/DocBlock/Tags/ParamTest.php b/tests/unit/DocBlock/Tags/ParamTest.php new file mode 100644 index 0000000..d14064c --- /dev/null +++ b/tests/unit/DocBlock/Tags/ParamTest.php @@ -0,0 +1,227 @@ + + * @license http://www.opensource.org/licenses/mit-license.php MIT + * @link http://phpdoc.org + */ + +namespace phpDocumentor\Reflection\DocBlock\Tags; + +use Mockery as m; +use phpDocumentor\Reflection\DocBlock\Description; +use phpDocumentor\Reflection\DocBlock\DescriptionFactory; +use phpDocumentor\Reflection\TypeResolver; +use phpDocumentor\Reflection\Types\Context; +use phpDocumentor\Reflection\Types\String_; + +/** + * @coversDefaultClass \phpDocumentor\Reflection\DocBlock\Tags\Param + * @covers :: + */ +class ParamTest extends \PHPUnit_Framework_TestCase +{ + /** + * @uses \phpDocumentor\Reflection\DocBlock\Tags\Param::__construct + * @uses \phpDocumentor\Reflection\DocBlock\Description + * @covers \phpDocumentor\Reflection\DocBlock\Tags\BaseTag::getName + */ + public function testIfCorrectTagNameIsReturned() + { + $fixture = new Param('myParameter', null, false, new Description('Description')); + + $this->assertSame('param', $fixture->getName()); + } + + /** + * @uses \phpDocumentor\Reflection\DocBlock\Tags\Param::__construct + * @uses \phpDocumentor\Reflection\DocBlock\Tags\Param::isVariadic + * @uses \phpDocumentor\Reflection\DocBlock\Tags\Param::__toString + * @uses \phpDocumentor\Reflection\DocBlock\Tags\Formatter\PassthroughFormatter + * @uses \phpDocumentor\Reflection\DocBlock\Description + * @covers \phpDocumentor\Reflection\DocBlock\Tags\BaseTag::render + */ + public function testIfTagCanBeRenderedUsingDefaultFormatter() + { + $fixture = new Param('myParameter', new String_(), true, new Description('Description')); + $this->assertSame('string ...$myParameter Description', $fixture->render()); + + $fixture = new Param('myParameter', new String_(), false, new Description('Description')); + $this->assertSame('string $myParameter Description', $fixture->render()); + + $fixture = new Param('myParameter', null, false, new Description('Description')); + $this->assertSame('$myParameter Description', $fixture->render()); + + $fixture = new Param('myParameter'); + $this->assertSame('$myParameter', $fixture->render()); + } + + /** + * @uses \phpDocumentor\Reflection\DocBlock\Tags\Param::__construct + * @covers \phpDocumentor\Reflection\DocBlock\Tags\BaseTag::render + */ + public function testIfTagCanBeRenderedUsingSpecificFormatter() + { + $fixture = new Param('myParameter'); + + $formatter = m::mock(Formatter::class); + $formatter->shouldReceive('format')->with($fixture)->andReturn('Rendered output'); + + $this->assertSame('Rendered output', $fixture->render($formatter)); + } + + /** + * @covers ::__construct + * @covers ::getVariableName + */ + public function testHasVariableName() + { + $expected = 'myParameter'; + + $fixture = new Param($expected); + + $this->assertSame($expected, $fixture->getVariableName()); + } + + /** + * @covers ::__construct + * @covers ::getType + */ + public function testHasType() + { + $expected = new String_(); + + $fixture = new Param('myParameter', $expected); + + $this->assertSame($expected, $fixture->getType()); + } + + /** + * @covers ::__construct + * @covers ::isVariadic + */ + public function testIfParameterIsVariadic() + { + $fixture = new Param('myParameter', new String_(), false); + $this->assertFalse($fixture->isVariadic()); + + $fixture = new Param('myParameter', new String_(), true); + $this->assertTrue($fixture->isVariadic()); + } + + /** + * @covers ::__construct + * @covers \phpDocumentor\Reflection\DocBlock\Tags\BaseTag::getDescription + * @uses \phpDocumentor\Reflection\DocBlock\Description + */ + public function testHasDescription() + { + $expected = new Description('Description'); + + $fixture = new Param('1.0', null, false, $expected); + + $this->assertSame($expected, $fixture->getDescription()); + } + + /** + * @covers ::__construct + * @covers ::isVariadic + * @covers ::__toString + * @uses \phpDocumentor\Reflection\DocBlock\Description + * @uses \phpDocumentor\Reflection\Types\String_ + */ + public function testStringRepresentationIsReturned() + { + $fixture = new Param('myParameter', new String_(), true, new Description('Description')); + + $this->assertSame('string ...$myParameter Description', (string)$fixture); + } + + /** + * @covers ::create + * @uses \phpDocumentor\Reflection\DocBlock\Tags\Param:: + * @uses \phpDocumentor\Reflection\DocBlock\DescriptionFactory + * @uses \phpDocumentor\Reflection\DocBlock\Description + * @uses \phpDocumentor\Reflection\Types\Context + */ + public function testFactoryMethod() + { + $typeResolver = new TypeResolver(); + $descriptionFactory = m::mock(DescriptionFactory::class); + $context = new Context(''); + + $description = new Description('My Description'); + $descriptionFactory->shouldReceive('create')->with('My Description', $context)->andReturn($description); + + $fixture = Param::create('string ...$myParameter My Description', $typeResolver, $descriptionFactory, $context); + + $this->assertSame('string ...$myParameter My Description', (string)$fixture); + $this->assertSame('myParameter', $fixture->getVariableName()); + $this->assertInstanceOf(String_::class, $fixture->getType()); + $this->assertTrue($fixture->isVariadic()); + $this->assertSame($description, $fixture->getDescription()); + } + + /** + * @covers ::create + * @uses \phpDocumentor\Reflection\DocBlock\Tags\Param:: + * @uses \phpDocumentor\Reflection\TypeResolver + * @uses \phpDocumentor\Reflection\DocBlock\DescriptionFactory + * @expectedException \InvalidArgumentException + */ + public function testFactoryMethodFailsIfEmptyBodyIsGiven() + { + $descriptionFactory = m::mock(DescriptionFactory::class); + Param::create('', new TypeResolver(), $descriptionFactory); + } + + /** + * @covers ::create + * @expectedException \InvalidArgumentException + */ + public function testFactoryMethodFailsIfBodyIsNotString() + { + Param::create([]); + } + + /** + * @covers ::create + * @expectedException \InvalidArgumentException + */ + public function testFactoryMethodFailsIfResolverIsNull() + { + Param::create('body'); + } + + /** + * @covers ::create + * @uses \phpDocumentor\Reflection\TypeResolver + * @expectedException \InvalidArgumentException + */ + public function testFactoryMethodFailsIfDescriptionFactoryIsNull() + { + Param::create('body', new TypeResolver()); + } + + /** + * @covers ::__construct + * @expectedException \InvalidArgumentException + */ + public function testExceptionIsThrownIfVariableNameIsNotString() + { + new Param([]); + } + + /** + * @covers ::__construct + * @expectedException \InvalidArgumentException + */ + public function testExceptionIsThrownIfVariadicIsNotBoolean() + { + new Param('', null, []); + } +}