UsersControllerTest::getTablesClasses() - Code Metrics - Inspection of "Now UIs provided by bundle can be more easily exte..." - modera/ModeraBackendSecurityBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e22522...ee64fa )

by Sergei

created 2016-05-10 13:06 UTC

UsersControllerTest::getTablesClasses() A

↳ Parent: UsersControllerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	10
rs	9.4285
cc	1
eloc	7
nc	1
nop	0

<?php

namespace Modera\BackendSecurityBundle\Tests\Functional\Controller;

use Doctrine\ORM\Tools\SchemaTool;
use Modera\ActivityLoggerBundle\Entity\Activity;
use Modera\BackendSecurityBundle\Controller\UsersController;
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 UsersControllerTest extends FunctionalTestCase
{
    /**
     * @var SchemaTool
     */
    private static $schemaTool;

    private static $encoder;

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

    /**
     * {@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);

        $entityPermission4 = new Permission();
        $entityPermission4->setRoleName('ROLE_MANAGE_USER_PROFILES');
        $entityPermission4->setDescription('ROLE_MANAGE_USER_PROFILES');
        $entityPermission4->setName('ROLE_MANAGE_USER_PROFILES');
        $entityPermission4->setCategory($entityPermissionCategory);

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

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

        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();
    }

    public function testMainFormHydration()
    {
        $this->assertNotNull(static::$user);
class YourClass
{
    private static $someVariable;

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

        $user = static::$em->find(User::clazz(), static::$user->getId());
class YourClass
{
    private static $someVariable;

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

        $this->assertNotNull($user);

        $this->assertEquals(static::$user, $user);
class YourClass
{
    private static $someVariable;

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

        $userMeta = array('rootElement' => array('subElement' => 'subElementValue', 'subElement2' => 'subElementValue2'),
        );
        static::$user->setMeta($userMeta);
class YourClass
{
    private static $someVariable;

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

        static::$em->flush();

        $controller = $this->getController();

        $response = $controller->listAction(
            array(
                'hydration' => array('profile' => 'list'),
                'page' => 1,
                'start' => 0,
                'limit' => 25,
            )
        );

        $this->assertArrayHasKey('success', $response);
        $this->assertArrayHasKey('total', $response);
        $this->assertArrayHasKey('items', $response);

        //assuming this is first test in file
        $this->assertGreaterThanOrEqual(1, count($response['items']));

        $hydratedUser = $response['items'][0];
        $this->assertArrayHasKey('id', $hydratedUser);
        $this->assertArrayHasKey('username', $hydratedUser);
        $this->assertArrayHasKey('email', $hydratedUser);
        $this->assertArrayHasKey('firstName', $hydratedUser);
        $this->assertArrayHasKey('lastName', $hydratedUser);
        $this->assertArrayHasKey('middleName', $hydratedUser);
        $this->assertArrayHasKey('state', $hydratedUser);
        $this->assertArrayHasKey('groups', $hydratedUser);
        $this->assertCount(1, $hydratedUser['groups']);
        $this->assertArrayHasKey('meta', $hydratedUser);
        $this->assertEquals($userMeta, $hydratedUser['meta']);
    }

    public function testIsMetaInfoStoredOnCreation()
    {
        $userMeta = array(
            'modera_backend_service_account_plugin' => array(
                'isService' => true,
                'password' => '1234',
            ),
        );

        $params = array(
            'record' => array(
                'id' => '',
                'lastName' => 'Full Display Name',
                'username' => 'serviceAccount',
                'email' => '[email protected]',
                'meta' => $userMeta,
            ),
        );

        $controller = $this->getController();

        $response = $controller->createAction($params);

        $this->assertTrue($response['success']);
        /*
         * @var User[]
         */
        $userList = static::$em->getRepository(User::clazz())->findAll();

        $lastUser = array_pop($userList);

        $this->assertEquals('[email protected]', $lastUser->getEmail());
        $this->assertEquals($userMeta, $lastUser->getMeta());

        return $lastUser;
    }

    public function testIsMetaInfoStoredOnCreation_NoMeta()
    {
        $params = array(
            'record' => array(
                'id' => '',
                'lastName' => 'Full Display Name',
                'username' => 'serviceAccount_NoMeta',
                'email' => '[email protected]',
                'meta' => '',
            ),
        );

        $controller = $this->getController();

        $response = $controller->createAction($params);

        $this->assertTrue($response['success']);
        /*
         * @var User[]
         */
        $userList = static::$em->getRepository(User::clazz())->findAll();

        $lastUser = array_pop($userList);

        $this->assertEquals('[email protected]', $lastUser->getEmail());
        $this->assertEquals(array(), $lastUser->getMeta());

        return $lastUser;
    }

    /**
     * @depends testIsMetaInfoStoredOnCreation
     *
     * @param User $user
     */
    public function testIsMetaInfoStoredOnUpdate(User $user)
    {
        $userMeta = array(
            'modera_backend_service_account_plugin' => array(
                'isService' => true,
                'password' => '5678',
            ),
        );

        $params = array(
            'record' => array(
                'id' => $user->getId(),
                'lastName' => $user->getLastName(),
                'username' => $user->getUsername(),
                'email' => $user->getEmail(),
                'meta' => $userMeta,
            ),
        );

        $controller = $this->getController();

        $response = $controller->updateAction($params);

        $this->assertTrue($response['success']);
        /*
         * @var User[] $userList
         */
        $userFromDb = static::$em->getRepository(User::clazz())->find($user->getId());

        $this->assertEquals('[email protected]', $userFromDb->getEmail());
        $this->assertEquals($userMeta, $userFromDb->getMeta());
    }

    /**
     * @depends testIsMetaInfoStoredOnCreation
     *
     * @param User $user
     */
    public function testIsMetaStoredOnUpdate_NoMeta(User $user)
    {
        $params = array(
            'record' => array(
                'id' => $user->getId(),
                'lastName' => $user->getLastName(),
                'username' => $user->getUsername(),
                'email' => $user->getEmail(),
                'meta' => '',
            ),
        );

        $controller = $this->getController();

        $response = $controller->updateAction($params);

        $this->assertTrue($response['success']);
        /*
         * @var User[]
         */
        $userList = static::$em->getRepository(User::clazz())->findAll();

        $lastUser = array_pop($userList);
$myVar = 'Value';
$higher = false;

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

        $this->assertEquals('[email protected]', $user->getEmail());
        $this->assertTrue(is_array($user->getMeta()));
        $this->assertCount(0, $user->getMeta());
    }

    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);
    }

    /**
     * @return UsersController
     */
    private function getController()
    {
        $controller = new UsersController();
        $controller->setContainer(static::$container);

        return $controller;
    }

    /**
     * @return array
     */
    private static function getTablesClasses()
    {
        return array(
            Permission::clazz(),
            PermissionCategory::clazz(),
            User::clazz(),
            Group::clazz(),
            Activity::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\ActivityLoggerBundle\Entity\Activity;
7			use Modera\BackendSecurityBundle\Controller\UsersController;
8			use Modera\FoundationBundle\Testing\FunctionalTestCase;
9			use Modera\SecurityBundle\Entity\Group;
10			use Modera\SecurityBundle\Entity\Permission;
11			use Modera\SecurityBundle\Entity\PermissionCategory;
12			use Modera\SecurityBundle\Entity\User;
13			use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
14
15			/**
16			* @author Alex Plaksin <[email protected]>
17			* @copyright 2016 Modera Foundation
18			*/
19			class UsersControllerTest extends FunctionalTestCase
20			{
21			/**
22			* @var SchemaTool
23			*/
24			private static $schemaTool;
25
26			private static $encoder;
27
28			/**
29			* @var User
30			*/
31			private static $user;
32
33			/**
34			* {@inheritdoc}
35			*/
36			public static function doSetUpBeforeClass()
37			{
38			static::$schemaTool = new SchemaTool(static::$em);
			0 ignored issues – show Bug introduced 2016-05-10 13:20 UTC by Report Bug Copy Issue Report Since `$schemaTool` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$schemaTool` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
39			static::$schemaTool->dropSchema(static::getTablesMetadata());

modera / ModeraBackendSecurityBundle

Push — master ( e22522...ee64fa )

UsersControllerTest::getTablesClasses() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like