Inneair\TransactionBundle\Test\Aop\TransactionalPointcutTest

Complexity

Total Complexity

12

Size/Duplication

Total Lines	142
Duplicated Lines	40.14 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	2
Bugs	1	Features	0

<?php
class TransactionalPointcutTest extends AbstractTest
{
    /**
     * Mocked service container.
     * @var PHPUnit_Framework_MockObject_MockObject
     */
    private $container;
    /**
     * Mocked logger.
     * @var PHPUnit_Framework_MockObject_MockObject
     */
    private $logger;
    /**
     * Mocked annotation reader.
     * @var PHPUnit_Framework_MockObject_MockObject
     */
    private $reader;

    /**
     * {@inheritDoc}
     */
    public function setUp()
    {
        parent::setUp();

        $this->container = $this->getMock(ContainerInterface::class);
        $this->logger = $this->getMock(LoggerInterface::class);
        $this->reader = $this->getMock(Reader::class);
    }

    public function testMatchesNonTransactionalAwareClassWithoutStrictMode()
    {
        $this->assertTrue(
            $this->buildTransactionPointcut(false)->matchesClass(
                new ReflectionClass(NonTransactionalAwareClass::class)
            )
        );
    }

    public function testMatchesNonTransactionalAwareClassWithStrictMode()
    {
        $this->assertFalse(
            $this->buildTransactionPointcut(true)->matchesClass(
                new ReflectionClass(NonTransactionalAwareClass::class)
            )
        );
    }

    public function testMatchesTransactionalAwareClassWithStrictMode()
    {
        $this->assertTrue(
            $this->buildTransactionPointcut(true)->matchesClass(
                new ReflectionClass(TransactionalAwareClass::class)
            )
        );
    }

    public function testMatchesNonPublicMethod()
    {
        $class = new ReflectionClass(TransactionalAwareClass::class);
        $this->assertFalse($this->buildTransactionPointcut(false)->matchesMethod($class->getMethod('nonPublicMethod')));
        $this->assertFalse($this->buildTransactionPointcut(true)->matchesMethod($class->getMethod('nonPublicMethod')));
    }

    public function testMatchesAnnotatedPublicMethodWithDefaultPolicy()
    {
        $this->reader->expects(static::exactly(2))->method('getMethodAnnotation')->willReturn(new Transactional());
        $this->reader->expects(static::never())->method('getClassAnnotation');

        $class = new ReflectionClass(TransactionalAwareClass::class);
        $this->assertTrue($this->buildTransactionPointcut(true)->matchesMethod($class->getMethod('publicMethod')));
        $this->assertTrue($this->buildTransactionPointcut(false)->matchesMethod($class->getMethod('publicMethod')));
    }

    public function testMatchesAnnotatedPublicMethodWithNotRequiredPolicy()
    {
        $this->reader->expects(static::once())->method('getMethodAnnotation')->willReturn(
            new Transactional(array('policy' => Transactional::NOT_REQUIRED))
        );
        $this->reader->expects(static::never())->method('getClassAnnotation');

        $class = new ReflectionClass(TransactionalAwareClass::class);
        $this->assertTrue($this->buildTransactionPointcut(false)->matchesMethod($class->getMethod('publicMethod')));
    }

    public function testMatchesAnnotatedPublicMethodWithRequiredPolicy()
    {
        $this->reader->expects(static::once())->method('getMethodAnnotation')->willReturn(
            new Transactional(array('policy' => Transactional::REQUIRED))
        );
        $this->reader->expects(static::never())->method('getClassAnnotation');

        $class = new ReflectionClass(TransactionalAwareClass::class);
        $this->assertTrue($this->buildTransactionPointcut(false)->matchesMethod($class->getMethod('publicMethod')));
    }

    public function testMatchesAnnotatedPublicMethodWithNestedPolicy()
    {
        $this->reader->expects(static::once())->method('getMethodAnnotation')->willReturn(
            new Transactional(array('policy' => Transactional::NESTED))
        );
        $this->reader->expects(static::never())->method('getClassAnnotation');

        $class = new ReflectionClass(TransactionalAwareClass::class);
        $this->assertTrue($this->buildTransactionPointcut(false)->matchesMethod($class->getMethod('publicMethod')));
    }

    public function testMatchesUnannotatedPublicMethodInAnnotatedClass()
    {
        $this->reader->expects(static::exactly(2))->method('getMethodAnnotation')->willReturn(null);
        $this->reader->expects(static::exactly(2))->method('getClassAnnotation')->willReturn(new Transactional());

        $class = new ReflectionClass(TransactionalAwareClass::class);
        $this->assertTrue($this->buildTransactionPointcut(false)->matchesMethod($class->getMethod('publicMethod')));
        $this->assertTrue($this->buildTransactionPointcut(true)->matchesMethod($class->getMethod('publicMethod')));
    }

    public function testMatchesUnannotatedPublicMethodInUnannotatedClass()
    {
        $this->reader->expects(static::exactly(2))->method('getMethodAnnotation')->willReturn(null);
        $this->reader->expects(static::exactly(2))->method('getClassAnnotation')->willReturn(null);

        $class = new ReflectionClass(TransactionalAwareClass::class);
        $this->assertFalse($this->buildTransactionPointcut(false)->matchesMethod($class->getMethod('publicMethod')));
        $this->assertFalse($this->buildTransactionPointcut(true)->matchesMethod($class->getMethod('publicMethod')));
    }

    /**
     * Builds a transactional pointcut with/without strict mode enabled.
     *
     * @param boolean $strictModeEnabled Whether strict mode is enabled.
     * @return TransactionalPointcut Pointcut.
     */
    private function buildTransactionPointcut($strictModeEnabled)
    {
        $this->container->expects(static::any())->method('getParameter')->with(
            Configuration::ROOT_NODE_NAME . '.' . Configuration::STRICT_MODE
        )->willReturn($strictModeEnabled);

        return new TransactionalPointcut($this->container, $this->reader, $this->logger);
    }
}