GenericEntityCreateControllerTest::shouldRejectCallWithIntegerMethod() - Code Metrics - Inspection of "factory/constructor arguments are now correctly bu..." - addiks/symfony_generics - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 5bc951...af3bd6 )

by Gerrit

created 2018-11-08 21:10 UTC

shouldRejectCallWithIntegerMethod() A

↳ Parent: GenericEntityCreateControllerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	16
rs	9.7333
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php
/**
 * Copyright (C) 2017  Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 * @license GPL-3.0
 * @author Gerrit Addiks <[email protected]>
 */

namespace Addiks\SymfonyGenerics\Tests\Unit\Controllers\API;

use PHPUnit\Framework\TestCase;
use Addiks\SymfonyGenerics\Controllers\API\GenericEntityCreateController;
use Addiks\SymfonyGenerics\Services\ArgumentCompilerInterface;
use Addiks\SymfonyGenerics\Controllers\ControllerHelperInterface;
use Symfony\Component\HttpFoundation\Request;
use Psr\Container\ContainerInterface;
use Symfony\Component\HttpFoundation\Response;
use Addiks\SymfonyGenerics\Tests\Unit\Controllers\SampleEntity;
use Webmozart\Assert\Assert;
use Serializable;
use stdClass;
use InvalidArgumentException;
use Symfony\Component\Finder\Exception\AccessDeniedException;
use ReflectionException;
use ErrorException;

final class GenericEntityCreateControllerTest extends TestCase
{

    /**
     * @var ControllerHelperInterface
     */
    private $controllerHelper;

    /**
     * @var ArgumentCompilerInterface
     */
    private $argumentBuilder;

    /**
     * @var ContainerInterface
     */
    private $container;

    public function setUp()
    {
        $this->controllerHelper = $this->createMock(ControllerHelperInterface::class);

        $this->container = $this->createMock(ContainerInterface::class);

        $this->argumentBuilder = $this->createMock(ArgumentCompilerInterface::class);

    }

    /**
     * @test
     */
    public function shouldCreateAnEntity()
    {
        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class
            ]
        );

        $this->controllerHelper->expects($this->once())->method('flushORM');

        $this->controllerHelper->expects($this->once())->method('persistEntity')->with(

            $this->equalTo(new SampleEntity())
        );

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var Response $response */
        $response = $controller->createEntity($request);

        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function shouldRejectNonExistingEntityClass()
    {
        $this->expectException(InvalidArgumentException::class);

        $controller = new GenericEntityCreateController(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => "\\ClassDoes\\NotExist"
            ]
        );
    }

    /**
     * @test
     */
    public function shouldRejectMissingEntityClass()
    {
        $this->expectException(InvalidArgumentException::class);

        $controller = new GenericEntityCreateController(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
            ]
        );
    }

    /**
     * @test
     */
    public function shouldRejectControllerCalledAgain()
    {
        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class
            ]
        );

        $this->expectException(InvalidArgumentException::class);

        $controller->__construct(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class
            ]
        );
    }

    /**
     * @test
     */
    public function shouldProvideConstructArguments()
    {
        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'arguments' => [
                    'foo' => 'bar'
                ]
            ]
        );

        /** @var SampleEntity|null $persistedEntity */
        $persistedEntity = null;

        $this->controllerHelper->expects($this->once())->method('flushORM');

        $this->controllerHelper->method('persistEntity')->will($this->returnCallback(

            function (SampleEntity $entity) use (&$persistedEntity) {
                $persistedEntity = $entity;
            }
        ));

        $this->argumentBuilder->method('buildCallArguments')->willReturn([

            'bar'
        ]);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var Response $response */
        $response = $controller->createEntity($request);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        $this->assertEquals('bar', $persistedEntity->constructArgument);
    }

    /**
     * @test
     */
    public function shouldExecuteACall()
    {
        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'calls' => [
                    'doFoo' => []
                ]
            ]
        );

        /** @var SampleEntity|null $persistedEntity */
        $persistedEntity = null;

        $this->controllerHelper->method('persistEntity')->will($this->returnCallback(

            function (SampleEntity $entity) use (&$persistedEntity) {
                $persistedEntity = $entity;
            }
        ));

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $this->assertNull($persistedEntity);

        $controller->createEntity($request);

        $this->assertTrue($persistedEntity instanceof SampleEntity);
        $this->assertTrue($persistedEntity->fooCalled);
    }

    /**
     * @test
     */
    public function shouldRejectCallToNonExistingMethod()
    {
        $this->expectException(InvalidArgumentException::class);

        $controller = new GenericEntityCreateController(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'calls' => [
                    'doNonExistingThing' => []
                ]
            ]
        );
    }

    /**
     * @test
     */
    public function shouldRejectCallWithNonArrayParameters()
    {
        $this->expectException(InvalidArgumentException::class);

        $controller = new GenericEntityCreateController(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'calls' => [
                    'doFoo' => "notAnArray"
                ]
            ]
        );
    }

    /**
     * @test
     */
    public function shouldRejectCallWithIntegerMethod()
    {
        $this->expectException(InvalidArgumentException::class);

        $controller = new GenericEntityCreateController(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'calls' => [
                    0 => []
                ]
            ]
        );
    }

    /**
     * @test
     */
    public function shouldUseFactoryObject()
    {
        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'factory' => '@some_factory_service::serialize'
            ]
        );

        $expectedEntity = new SampleEntity();

        /** @var SampleEntity|null $actualEntity */
        $actualEntity = null;

        /** @var Serializable $factoryMock */
        $factoryMock = $this->createMock(Serializable::class);
        $factoryMock->method("serialize")->willReturn($expectedEntity);

        $this->container->expects($this->once())->method('get')->with(

            $this->equalTo('some_factory_service')
        )->willReturn($factoryMock);

        $this->controllerHelper->method('persistEntity')->will($this->returnCallback(

            function (SampleEntity $entity) use (&$actualEntity) {
                $actualEntity = $entity;
            }
        ));

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $controller->createEntity($request);

        $this->assertSame($expectedEntity, $actualEntity);
    }

    /**
     * @test
     */
    public function shouldRejectWrongEntityCreated()
    {
        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'factory' => '@some_factory_service::serialize'
            ]
        );

        /** @var Serializable $factoryMock */
        $factoryMock = $this->createMock(Serializable::class);
        $factoryMock->method("serialize")->willReturn(new stdClass());

        $this->container->expects($this->once())->method('get')->with(

            $this->equalTo('some_factory_service')
        )->willReturn($factoryMock);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $this->expectException(InvalidArgumentException::class);

        $controller->createEntity($request);
    }

    /**
     * @test
     */
    public function shouldRejectNonExistingFactory()

    {
        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'factory' => '@some_factory_service::serialize'
            ]
        );

        $this->container->expects($this->once())->method('get')->with(

            $this->equalTo('some_factory_service')
        )->willReturn(null);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage("Did not find service 'some_factory_service'!");

        $controller->createEntity($request);
    }

    /**
     * @test
     */
    public function shouldRejectInvalidFactory()
    {
        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'factory' => '::serialize'
            ]
        );

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $this->expectException(ErrorException::class);

        $controller->createEntity($request);
    }

    /**
     * @test
     */
    public function shouldRejectNonExistingFactoryMethod()

    {
        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'factory' => '@some_factory_service::MethodDoesNotExist'
            ]
        );

        /** @var Serializable $factoryMock */
        $factoryMock = $this->createMock(Serializable::class);

        $this->container->expects($this->once())->method('get')->with(

            $this->equalTo('some_factory_service')
        )->willReturn($factoryMock);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $this->expectException(ReflectionException::class);

        $controller->createEntity($request);
    }

    /**
     * @test
     */
    public function shouldCorrectlyDetectFactoryMethod()
    {
        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'factory' => '@some_factory_service::serialize::thisShouldCauseAnError'
            ]
        );

        /** @var Serializable $factoryMock */
        $factoryMock = $this->createMock(Serializable::class);
        $factoryMock->method("serialize")->willReturn(new SampleEntity());

        $this->container->expects($this->once())->method('get')->with(

            $this->equalTo('some_factory_service')
        )->willReturn($factoryMock);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $this->expectException(ReflectionException::class);

        $controller->createEntity($request);
    }

    /**
     * @test
     */
    public function shouldCheckIfAccessIsGranted()
    {
        $this->expectException(AccessDeniedException::class);

        $this->controllerHelper->expects($this->exactly(2))->method('denyAccessUnlessGranted')->will($this->returnCallback(

            function ($attribute, $object) {
                if ($object instanceof SampleEntity) {
                    throw new AccessDeniedException('Lorem ipsum!');
                }
            }
        ));

        /** @var Serializable $factoryMock */
        $factoryMock = $this->createMock(Serializable::class);
        $factoryMock->method("serialize")->willReturn(new SampleEntity());

        $this->container->expects($this->once())->method('get')->with(

            $this->equalTo('some_factory_service')
        )->willReturn($factoryMock);

        $controller = new GenericEntityCreateController(
            $this->controllerHelper,
            $this->argumentBuilder,
            $this->container,
            [
                'entity-class' => SampleEntity::class,
                'factory' => '@some_factory_service::serialize',
                'authorization-attribute' => 'some-attribute',
            ]
        );

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $controller->createEntity($request);
    }

}


1			<?php
2			/**
3			* Copyright (C) 2017 Gerrit Addiks.
4			* This package (including this file) was released under the terms of the GPL-3.0.
5			* You should have received a copy of the GNU General Public License along with this program.
6			* If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
7			* @license GPL-3.0
8			* @author Gerrit Addiks <[email protected]>
9			*/
10
11			namespace Addiks\SymfonyGenerics\Tests\Unit\Controllers\API;
12
13			use PHPUnit\Framework\TestCase;
14			use Addiks\SymfonyGenerics\Controllers\API\GenericEntityCreateController;
15			use Addiks\SymfonyGenerics\Services\ArgumentCompilerInterface;
16			use Addiks\SymfonyGenerics\Controllers\ControllerHelperInterface;
17			use Symfony\Component\HttpFoundation\Request;
18			use Psr\Container\ContainerInterface;
19			use Symfony\Component\HttpFoundation\Response;
20			use Addiks\SymfonyGenerics\Tests\Unit\Controllers\SampleEntity;
21			use Webmozart\Assert\Assert;
22			use Serializable;
23			use stdClass;
24			use InvalidArgumentException;
25			use Symfony\Component\Finder\Exception\AccessDeniedException;
26			use ReflectionException;
27			use ErrorException;
28
29			final class GenericEntityCreateControllerTest extends TestCase
30			{
31
32			/**
33			* @var ControllerHelperInterface
34			*/
35			private $controllerHelper;
36
37			/**
38			* @var ArgumentCompilerInterface
39			*/
40			private $argumentBuilder;

addiks / symfony_generics

Push — master ( 5bc951...af3bd6 )

shouldRejectCallWithIntegerMethod() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like