Graviton\CoreBundle\Tests\Controller\SerializerSelectExclusionStrategyTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	123
Duplicated Lines	24.39 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	19	3
A	testRqlSelectionOnArrays()	15	15	1
A	testRqlSelectionOnNested()	15	15	1
A	testRqlSelectionOnNestedDouble()	0	15	1
B	testSelectExclusionStrategyPrivateCreateArrayByPath()	0	25	1

<?php
/**
 * SerializerSelectExclusionStrategyTest class file
 */

namespace Graviton\CoreBundle\Tests\Controller;

use Graviton\RestBundle\ExclusionStrategy\SelectExclusionStrategy;
use Graviton\TestBundle\Test\RestTestCase;
use GravitonDyn\TestCaseDeepEqualNamingBundle\DataFixtures\MongoDB\LoadTestCaseDeepEqualNamingData;
use Symfony\Component\HttpFoundation\Response;
use GravitonDyn\TestCasePrimitiveArrayBundle\DataFixtures\MongoDB\LoadTestCasePrimitiveArrayData;
use GravitonDyn\TestCaseNullExtrefBundle\DataFixtures\MongoDB\LoadTestCaseNullExtrefData;

/**
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link     http://swisscom.ch
 */
class SerializerSelectExclusionStrategyTest extends RestTestCase
{

    /**
     * load fixtures (in this case we can reuse fixtures from other tests)
     *
     * @return void
     */
    public function setUp()
    {
        if (!class_exists(LoadTestCasePrimitiveArrayData::class)) {
            $this->markTestSkipped('TestCasePrimitiveArray definition is not loaded');
        }
        if (!class_exists(LoadTestCaseNullExtrefData::class)) {
            $this->markTestSkipped('TestCaseNullExtref definition is not loaded');
        }

        $this->loadFixtures(
            [
                LoadTestCasePrimitiveArrayData::class,
                LoadTestCaseNullExtrefData::class,
                LoadTestCaseDeepEqualNamingData::class
            ],
            null,
            'doctrine_mongodb'
        );
    }

    /**
     * Test testRqlSelectionOnArrays testing the correct serialization of nested arrays
     *
     * @return void
     */
    public function testRqlSelectionOnArrays()

This method seems to be duplicated in your project.

    {
        $expectedResult = json_decode(
            file_get_contents(dirname(__FILE__).'/../resources/serializer-exclusion-array.json'),
            false
        );

        $client = static::createRestClient();
        $client->request(
            'GET',
            '/testcase/primitivearray/testdata?select(hash.strarray,arrayhash.intarray,arrayhash.hasharray)'
        );
        $this->assertEquals(Response::HTTP_OK, $client->getResponse()->getStatusCode());
        $this->assertEquals($expectedResult, $client->getResults());
    }

    /**
     * Test testRqlSelectionOnNested testing the correct serialization of deeply nested values
     *
     * @return void
     */
    public function testRqlSelectionOnNested()

This method seems to be duplicated in your project.

    {
        $expectedResult = json_decode(
            file_get_contents(dirname(__FILE__).'/../resources/serializer-exclusion-nested.json'),
            false
        );

        $client = static::createRestClient();
        $client->request(
            'GET',
            '/testcase/nullextref/testdata?select(requiredExtref,requiredExtrefDeep.deep.deep,optionalExtrefDeep)'
        );
        $this->assertEquals(Response::HTTP_OK, $client->getResponse()->getStatusCode());
        $this->assertEquals($expectedResult, $client->getResults());
    }

    /**
     * Test testRqlSelectionOnNestedDouble testing the correct serialization of deeply nested values
     * The error was that if fields had the same name only first was checked and only the second if first not empty
     *
     * @return void
     */
    public function testRqlSelectionOnNestedDouble()
    {
        $expectedResult = json_decode(
            file_get_contents(dirname(__FILE__).'/../resources/serializer-exclusion-nested-double.json'),
            false
        );

        $client = static::createRestClient();
        $client->request(
            'GET',
            '/testcase/deep-naming/?select(level.levela.levela1,level.levelb.levelb1)'
        );
        $this->assertEquals(Response::HTTP_OK, $client->getResponse()->getStatusCode());
        $this->assertEquals($expectedResult, $client->getResults());
    }

    /**
     * Test the private select function
     *
     * @return void
     */
    public function testSelectExclusionStrategyPrivateCreateArrayByPath()
    {
        /** @var SelectExclusionStrategy $class */
        $class = $this->getContainer()->get('graviton.rest.serializer.exclusionstrategy.selectexclusionstrategy');
        $method = $this->getPrivateClassMethod(get_class($class), 'createArrayByPath');

        $mainResult = [];

        $path = 'level.levela.levela1';
        $arr = $method->invokeArgs($class, [$path]);
        $mainResult = array_merge_recursive($mainResult, $arr);

        $path = 'level.levelb.levelb1';
        $arr = $method->invokeArgs($class, [$path]);
        $mainResult = array_merge_recursive($mainResult, $arr);

        $expectedResult = [
            'level' => [
                'levela' => ['levela1' => true],
                'levelb' => ['levelb1' => true]
            ]
        ];

        $this->assertEquals($expectedResult, $mainResult);
    }
}