Issues in GroupsControllerTest.php - All Issues - Inspection of "[MPFE-829] hidden Group::refName normalization. Ad..." - modera/ModeraBackendSecurityBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6ceb07...e22522 )

by Sergei

created 2016-04-26 07:58 UTC

Functional/Controller/GroupsControllerTest.php (28 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?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);
        $group->addPermission($entityPermission3);

        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 ( 6ceb07...e22522 )

Functional/Controller/GroupsControllerTest.php (28 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like