GroupsControllerTest::testUpdateAction() - Code Metrics - Inspection of "Merge branch '2.x'" - modera/ModeraBackendSecurityBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 29f90c...6ceb07 )

by Sergei

created 2016-04-20 05:40 UTC

GroupsControllerTest::testUpdateAction() B

↳ Parent: GroupsControllerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	25
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	25
rs	8.8571
cc	1
eloc	16
nc	1
nop	1

<?php

namespace Modera\BackendSecurityBundle\Tests\Functional\Controller;

use Doctrine\ORM\Tools\SchemaTool;
use Modera\BackendSecurityBundle\Controller\GroupsController;
use Modera\FoundationBundle\Testing\FunctionalTestCase;
use Modera\SecurityBundle\Entity\Group;
use Modera\SecurityBundle\Entity\Permission;
use Modera\SecurityBundle\Entity\PermissionCategory;
use Modera\SecurityBundle\Entity\User;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;

/**
 * @author    Alex Plaksin <[email protected]>
 * @copyright 2016 Modera Foundation
 */
class GroupsControllerTest extends FunctionalTestCase
{
    /**
     * @var SchemaTool
     */
    private static $schemaTool;

    private static $encoder;

    /**
     * @var User
     */
    private static $user;

    /**
     * @var GroupsController
     */
    private static $controller;

    /**
     * {@inheritdoc}
     */
    public static function doSetUpBeforeClass()
    {
        static::$schemaTool = new SchemaTool(static::$em);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        static::$schemaTool->dropSchema(static::getTablesMetadata());
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        static::$schemaTool->createSchema(static::getTablesMetadata());
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        static::$encoder = static::$container->get('security.encoder_factory');
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        static::$user = new User();
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        static::$user->setEmail('[email protected]');
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        static::$user->setPassword(
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            static::$encoder->getEncoder(static::$user)->encodePassword('1234', static::$user->getSalt())
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        );
        static::$user->setUsername('testUser');
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        $entityPermissionCategory = new PermissionCategory();
        $entityPermissionCategory->setName('backend_user');
        $entityPermissionCategory->setTechnicalName('backend_user');
        static::$em->persist($entityPermissionCategory);

        $entityPermission = new Permission();
        $entityPermission->setRoleName('IS_AUTHENTICATED_FULLY');
        $entityPermission->setDescription('IS_AUTHENTICATED_FULLY');
        $entityPermission->setName('IS_AUTHENTICATED_FULLY');
        $entityPermission->setCategory($entityPermissionCategory);

        $entityPermission2 = new Permission();
        $entityPermission2->setRoleName('ROLE_MANAGE_PERMISSIONS');
        $entityPermission2->setDescription('ROLE_MANAGE_PERMISSIONS');
        $entityPermission2->setName('ROLE_MANAGE_PERMISSIONS');
        $entityPermission2->setCategory($entityPermissionCategory);

        $entityPermission3 = new Permission();
        $entityPermission3->setRoleName('ROLE_ACCESS_BACKEND_TOOLS_SECURITY_SECTION');
        $entityPermission3->setDescription('ROLE_ACCESS_BACKEND_TOOLS_SECURITY_SECTION');
        $entityPermission3->setName('ROLE_ACCESS_BACKEND_TOOLS_SECURITY_SECTION');
        $entityPermission3->setCategory($entityPermissionCategory);

        static::$em->persist($entityPermission);
        static::$em->persist($entityPermission2);
        static::$em->persist($entityPermission3);
        static::$em->flush();

        $group = new Group();
        $group->setRefName('backend-user');
        $group->setName('backend-user');
        $group->addPermission($entityPermission);
        $group->addPermission($entityPermission2);

        static::$user->addToGroup($group);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        static::$em->persist($group);
        static::$em->persist(static::$user);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        static::$em->flush();

        static::$controller = new GroupsController();
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        static::$controller->setContainer(static::$container);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }

    public function doSetUp()
    {
        $token = new UsernamePasswordToken(static::$user, '1234', 'secured_area');
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        static::$container->get('security.token_storage')->setToken($token);
    }

    /**
     * {@inheritdoc}
     */
    public static function doTearDownAfterClass()
    {
        static::$schemaTool->dropSchema(static::getTablesMetadata());
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }

    /**
     * Simple correct behavior group create.
     *
     * @return null|object
     */
    public function testCreateAction()
    {
        $beforeGroupsCount = count(static::$em->getRepository(Group::clazz())->findAll());

        $params = array(
            'record' => array(
                'id' => '',
                'name' => 'testName',
                'refName' => 'testRefName',
            ),
        );

        $result = static::$controller->createAction($params);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        $this->assertArrayHasKey('success', $result);
        $this->assertTrue($result['success']);
        $this->assertArrayHasKey('created_models', $result);
        $this->assertArrayHasKey('modera.security_bundle.group', $result['created_models']);
        $this->assertCount(1, $result['created_models']['modera.security_bundle.group']);

        $afterGroupsCount = count(static::$em->getRepository(Group::clazz())->findAll());
        $this->assertEquals($beforeGroupsCount + 1, $afterGroupsCount);

        $createdGroup = static::$em->getRepository(Group::clazz())->find($result['created_models']['modera.security_bundle.group'][0]);

        $this->assertEquals('testName', $createdGroup->getName());
        $this->assertEquals('testRefName', $createdGroup->getRefName());

        return $createdGroup;
    }

    /**
     * @depends testCreateAction
     */
    public function testCreateAction_EmptyName()

    {
        $params = array(
            'record' => array(
                'id' => '',
                'name' => '',
                'refName' => '',
            ),
        );

        $result = static::$controller->createAction($params);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        $this->assertArrayHasKey('success', $result);
        $this->assertFalse($result['success']);
        $this->assertArrayHasKey('field_errors', $result);
        $this->assertCount(1, $result['field_errors']);
        $this->assertArrayHasKey('name', $result['field_errors']);
    }

    /**
     * @depends testCreateAction
     */
    public function testCreateAction_DuplicatedRefName()

    {
        $params = array(
            'record' => array(
                'id' => '',
                'name' => 'testName2',
                'refName' => 'testRefName',
            ),
        );

        $result = static::$controller->createAction($params);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        $this->assertArrayHasKey('success', $result);
        $this->assertFalse($result['success']);
        $this->assertArrayHasKey('field_errors', $result);
        $this->assertCount(1, $result['field_errors']);
        $this->assertArrayHasKey('refName', $result['field_errors']);
    }

    /**
     * @depends testCreateAction
     */
    public function testUpdateAction(Group $group)
    {
        $params = array(
            'record' => array(
                'id' => $group->getId(),
                'name' => 'testNameUpdated',
                'refName' => 'testRefNameUpdated',
            ),
        );

        $result = static::$controller->updateAction($params);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        $this->assertArrayHasKey('success', $result);
        $this->assertTrue($result['success']);
        $this->assertArrayHasKey('updated_models', $result);
        $this->assertArrayHasKey('modera.security_bundle.group', $result['updated_models']);
        $this->assertCount(1, $result['updated_models']['modera.security_bundle.group']);
        $this->assertEquals($group->getId(), $result['updated_models']['modera.security_bundle.group'][0]);

        /** @var Group $groupFromDb */
        $groupFromDb = static::$em->find(Group::clazz(), $group->getId());

        $this->assertEquals('testNameUpdated', $groupFromDb->getName());
        $this->assertEquals('testRefNameUpdated', $groupFromDb->getRefName());
    }

    /**
     * @depends testCreateAction
     * @depends testUpdateAction
     *
     * @param Group $group
     *
     * @return Group
     */
    public function testUpdateAction_SameRefName(Group $group)
    {
        $this->assertEquals('testRefNameUpdated', $group->getRefName());

        $params = array(
            'record' => array(
                'id' => $group->getId(),
                'name' => 'newTestName',
                'refName' => 'testRefNameUpdated',
            ),
        );

        $result = static::$controller->updateAction($params);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        $this->assertArrayHasKey('success', $result);
        $this->assertTrue($result['success']);
        $this->assertArrayHasKey('updated_models', $result);
        $this->assertArrayHasKey('modera.security_bundle.group', $result['updated_models']);
        $this->assertCount(1, $result['updated_models']['modera.security_bundle.group']);
        $this->assertEquals($group->getId(), $result['updated_models']['modera.security_bundle.group'][0]);

        /** @var Group $groupFromDb */
        $groupFromDb = static::$em->find(Group::clazz(), $group->getId());

        $this->assertEquals('newTestName', $groupFromDb->getName());
        $this->assertEquals('testRefNameUpdated', $groupFromDb->getRefName());

        return $groupFromDb;
    }

    /**
     * @depends testUpdateAction_SameRefName
     *
     * @param Group $group
     */
    public function testUpdateAction_ExistingRefNameUse(Group $group)
    {
        $newGroup = new Group();
        $newGroup->setName('brandNewGroup');
        $newGroup->setRefName('brandNewRefName');

        static::$em->persist($newGroup);
        static::$em->flush();

        $this->assertEquals('testRefNameUpdated', $group->getRefName());

        $params = array(
            'record' => array(
                'id' => $group->getId(),
                'name' => 'newTestNameExistingRef',
                'refName' => 'brandNewRefName',
            ),
        );

        $result = static::$controller->updateAction($params);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        $this->assertArrayHasKey('success', $result);
        $this->assertFalse($result['success']);
        $this->assertArrayHasKey('field_errors', $result);
        $this->assertCount(1, $result['field_errors']);
        $this->assertArrayHasKey('refName', $result['field_errors']);
    }

    /**
     * @return array
     */
    private static function getTablesClasses()
    {
        return array(
            Permission::clazz(),
            PermissionCategory::clazz(),
            User::clazz(),
            Group::clazz(),
        );
    }

    private static function getTablesMetadata()
    {
        $metaData = array();

        foreach (static::getTablesClasses() as $class) {
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            $metaData[] = static::$em->getClassMetadata($class);
        }

        return $metaData;
    }

    /**
     * {@inheritdoc}
     */
    protected static function getIsolationLevel()
    {
        return self::IM_CLASS;
    }
}


1			<?php
2
3			namespace Modera\BackendSecurityBundle\Tests\Functional\Controller;
4
5			use Doctrine\ORM\Tools\SchemaTool;
6			use Modera\BackendSecurityBundle\Controller\GroupsController;
7			use Modera\FoundationBundle\Testing\FunctionalTestCase;
8			use Modera\SecurityBundle\Entity\Group;
9			use Modera\SecurityBundle\Entity\Permission;
10			use Modera\SecurityBundle\Entity\PermissionCategory;
11			use Modera\SecurityBundle\Entity\User;
12			use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
13
14			/**
15			* @author Alex Plaksin <[email protected]>
16			* @copyright 2016 Modera Foundation
17			*/
18			class GroupsControllerTest extends FunctionalTestCase
19			{
20			/**
21			* @var SchemaTool
22			*/
23			private static $schemaTool;
24
25			private static $encoder;
26
27			/**
28			* @var User
29			*/
30			private static $user;
31
32			/**
33			* @var GroupsController
34			*/
35			private static $controller;
36
37			/**
38			* {@inheritdoc}
39			*/
40			public static function doSetUpBeforeClass()

modera / ModeraBackendSecurityBundle

Push — master ( 29f90c...6ceb07 )

GroupsControllerTest::testUpdateAction() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like