EloquentRepositoryCriteriaTests

Complexity

Total Complexity

29

Size/Duplication

Total Lines	471
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	testObjectCriterionPush()	0	9	1
A	testClosureCriterionPush()	0	12	1
A	testClassNameCriterionPush()	0	9	1
A	testClassNameWithAssocArgumentsAssocCriterionPush()	0	12	1
A	testClassNameWithAssocArgumentsSequentialCriterionPush()	0	12	1
A	testClassNameWithSequentialArgumentsAssocCriterionPush()	0	12	1
A	testClassNameWithSequentialArgumentsSequentialCriterionPush()	0	12	1
A	testPushTwoDifferentCriteria()	0	11	1
A	testPushTwoDifferentClosureCriteria()	0	15	1
A	testPushTwoSimilarCriteria()	0	10	1
A	testPushCriteria()	0	18	1
A	testRemoveCriterionWhenPushedByClassName()	0	23	1
B	testRemoveCriterionWhenPushedObject()	0	27	1
B	testRemoveCriterionWhenPushedClosures()	0	28	1
B	testRemoveCriteria()	0	24	1
A	testFlushCriteria()	0	13	1
A	testSetDefaultCriteria()	0	11	1
A	testGetDefaultCriteria()	0	14	1
A	testGetCriteria()	0	13	1
A	testGetCriteriaWithDefault()	0	19	1
A	testGetCriteriaWithSkipCriteria()	0	14	1
A	testGetCriteriaWithDefaultWithSkipCriteria()	0	19	1
A	testGetCriteriaWithSkipDefaultCriteria()	0	18	1
A	testHasCriterion()	0	14	1
A	testHasCriterionByClosure()	0	16	1
A	testGetCriterion()	0	11	1
A	testGetCriterionByClosure()	0	16	1
A	testApplyCriteria()	0	13	1
A	testApplyCriteriaWithClosureCriteria()	0	15	1

<?php

class EloquentRepositoryCriteriaTests extends AbstractEloquentTests

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    public function testObjectCriterionPush()
    {
        $userRepository = $this->userRepository();
        $criterion      = new FirstTestCriterion();
        $userRepository->pushCriterion($criterion);

        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $this->assertAttributeContains($criterion, 'criteria', $userRepository);
    }

    public function testClosureCriterionPush()
    {
        $userRepository = $this->userRepository();
        $criterion      = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 1);
        };

        $userRepository->pushCriterion($criterion);

        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $this->assertAttributeContains($criterion, 'criteria', $userRepository);
    }

    public function testClassNameCriterionPush()
    {
        $userRepository = $this->userRepository();
        $criterion      = FirstTestCriterion::class;
        $userRepository->pushCriterion($criterion);

        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $this->assertContainsOnlyInstancesOf($criterion, $this->getObjectAttribute($userRepository, 'criteria'));
    }

    public function testClassNameWithAssocArgumentsAssocCriterionPush()
    {
        $userRepository = $this->userRepository();
        $userRepository->pushCriterion([ThirdTestWithArgumentsCriterion::class => ['to' => '2016-09-30', 'from' => '2016-09-01']]);

This line exceeds maximum limit of 120 characters; contains 131 characters

        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $this->assertArrayHasKey(ThirdTestWithArgumentsCriterion::class, $userRepository->getCriteria());

        $criterion = $userRepository->getCriterion(ThirdTestWithArgumentsCriterion::class);
        $this->assertAttributeEquals('2016-09-01', 'from', $criterion);
        $this->assertAttributeEquals('2016-09-30', 'to', $criterion);
    }

    public function testClassNameWithAssocArgumentsSequentialCriterionPush()
    {
        $userRepository = $this->userRepository();
        $userRepository->pushCriterion([ThirdTestWithArgumentsCriterion::class, ['to' => '2016-09-30', 'from' => '2016-09-01']]);

This line exceeds maximum limit of 120 characters; contains 129 characters

        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $this->assertArrayHasKey(ThirdTestWithArgumentsCriterion::class, $userRepository->getCriteria());

        $criterion = $userRepository->getCriterion(ThirdTestWithArgumentsCriterion::class);
        $this->assertAttributeEquals('2016-09-01', 'from', $criterion);
        $this->assertAttributeEquals('2016-09-30', 'to', $criterion);
    }

    public function testClassNameWithSequentialArgumentsAssocCriterionPush()
    {
        $userRepository = $this->userRepository();
        $userRepository->pushCriterion([ThirdTestWithArgumentsCriterion::class => ['2016-09-01', '2016-09-30']]);

        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $this->assertArrayHasKey(ThirdTestWithArgumentsCriterion::class, $userRepository->getCriteria());

        $criterion = $userRepository->getCriterion(ThirdTestWithArgumentsCriterion::class);
        $this->assertAttributeEquals('2016-09-01', 'from', $criterion);
        $this->assertAttributeEquals('2016-09-30', 'to', $criterion);
    }

    public function testClassNameWithSequentialArgumentsSequentialCriterionPush()
    {
        $userRepository = $this->userRepository();
        $userRepository->pushCriterion([ThirdTestWithArgumentsCriterion::class, ['2016-09-01', '2016-09-30']]);

        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $this->assertArrayHasKey(ThirdTestWithArgumentsCriterion::class, $userRepository->getCriteria());

        $criterion = $userRepository->getCriterion(ThirdTestWithArgumentsCriterion::class);
        $this->assertAttributeEquals('2016-09-01', 'from', $criterion);
        $this->assertAttributeEquals('2016-09-30', 'to', $criterion);
    }

    public function testPushTwoDifferentCriteria()
    {
        $userRepository  = $this->userRepository();
        $firstCriterion  = FirstTestCriterion::class;
        $secondCriterion = SecondTestCriterion::class;

        $userRepository->pushCriterion([$firstCriterion]);
        $userRepository->pushCriterion([$secondCriterion]);

        $this->assertAttributeCount(2, 'criteria', $userRepository);
    }

    public function testPushTwoDifferentClosureCriteria()
    {
        $userRepository = $this->userRepository();
        $firstCriterion = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 1);
        };
        $secondCriterion = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 2);
        };

        $userRepository->pushCriterion($firstCriterion);
        $userRepository->pushCriterion($secondCriterion);

        $this->assertAttributeCount(2, 'criteria', $userRepository);
    }

    public function testPushTwoSimilarCriteria()
    {
        $userRepository = $this->userRepository();
        $firstCriterion = FirstTestCriterion::class;

        $userRepository->pushCriterion($firstCriterion);
        $userRepository->pushCriterion($firstCriterion);

        $this->assertAttributeCount(1, 'criteria', $userRepository);
    }

    public function testPushCriteria()
    {
        $userRepository = $this->userRepository();

        $firstCriterion  = FirstTestCriterion::class;
        $secondCriterion = new SecondTestCriterion();
        $thirdCriterion  = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 1);
        };

        $userRepository->pushCriteria([
            $firstCriterion,
            $secondCriterion,
            $thirdCriterion,
        ]);

        $this->assertAttributeCount(3, 'criteria', $userRepository);
    }

    public function testRemoveCriterionWhenPushedByClassName()
    {
        $userRepository  = $this->userRepository();
        $firstCriterion  = FirstTestCriterion::class;
        $secondCriterion = SecondTestCriterion::class;

        $userRepository->pushCriterion($firstCriterion);
        $this->assertAttributeCount(1, 'criteria', $userRepository);

        $userRepository->removeCriterion($firstCriterion);
        $this->assertAttributeCount(0, 'criteria', $userRepository);

        $userRepository->pushCriterion($firstCriterion);
        $userRepository->pushCriterion($secondCriterion);
        $this->assertAttributeCount(2, 'criteria', $userRepository);

        $userRepository->removeCriterion($firstCriterion);
        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $userRepository->removeCriterion($firstCriterion);
        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $userRepository->removeCriterion($secondCriterion);
        $this->assertAttributeCount(0, 'criteria', $userRepository);
    }

    public function testRemoveCriterionWhenPushedObject()
    {
        $userRepository  = $this->userRepository();
        $firstCriterion  = new FirstTestCriterion();
        $secondCriterion = new SecondTestCriterion();

        $userRepository->pushCriterion($firstCriterion);
        $this->assertAttributeCount(1, 'criteria', $userRepository);

        $userRepository->removeCriterion($firstCriterion);
        $this->assertAttributeCount(0, 'criteria', $userRepository);

        $userRepository->pushCriterion($firstCriterion);
        $userRepository->pushCriterion($secondCriterion);
        $this->assertAttributeCount(2, 'criteria', $userRepository);

        $userRepository->removeCriterion($firstCriterion);
        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $userRepository->removeCriterion($firstCriterion);
        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $userRepository->removeCriterion($secondCriterion);
        $this->assertAttributeCount(0, 'criteria', $userRepository);

        $userRepository->pushCriterion($firstCriterion);
        $userRepository->removeCriterion(FirstTestCriterion::class);
        $this->assertAttributeCount(0, 'criteria', $userRepository);
    }

    public function testRemoveCriterionWhenPushedClosures()
    {
        $userRepository = $this->userRepository();
        $firstCriterion = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 1);
        };

        $secondCriterion = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 2);
        };

        $userRepository->pushCriterion($firstCriterion);
        $this->assertAttributeCount(1, 'criteria', $userRepository);

        $userRepository->removeCriterion($firstCriterion);
        $this->assertAttributeCount(0, 'criteria', $userRepository);

        $userRepository->pushCriterion($firstCriterion);
        $userRepository->pushCriterion($secondCriterion);
        $this->assertAttributeCount(2, 'criteria', $userRepository);

        $userRepository->removeCriterion($firstCriterion);
        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $userRepository->removeCriterion($firstCriterion);
        $this->assertAttributeCount(1, 'criteria', $userRepository);
        $userRepository->removeCriterion($secondCriterion);
        $this->assertAttributeCount(0, 'criteria', $userRepository);
    }

    public function testRemoveCriteria()
    {
        $userRepository = $this->userRepository();
        $firstCriterion = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 1);
        };

        $secondCriterion = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 2);
        };

        $userRepository->pushCriterion($firstCriterion);
        $userRepository->pushCriterion($secondCriterion);
        $this->assertAttributeCount(2, 'criteria', $userRepository);

        $userRepository->removeCriteria([$firstCriterion, $secondCriterion]);
        $this->assertAttributeCount(0, 'criteria', $userRepository);

        $userRepository->pushCriterion($firstCriterion);
        $userRepository->pushCriterion($secondCriterion);
        $userRepository->removeCriteria([$firstCriterion]);
        $userRepository->removeCriteria([$secondCriterion]);
        $this->assertAttributeCount(0, 'criteria', $userRepository);
    }

    public function testFlushCriteria()
    {
        $userRepository = $this->userRepository();

        $userRepository->pushCriteria([
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ]);

        $this->assertAttributeCount(2, 'criteria', $userRepository);
        $userRepository->flushCriteria();
        $this->assertAttributeCount(0, 'criteria', $userRepository);
    }

    public function testSetDefaultCriteria()
    {
        $userRepository = $this->userRepository();

        $userRepository->setDefaultCriteria([
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ]);

        $this->assertAttributeCount(2, 'defaultCriteria', $userRepository);
    }

    public function testGetDefaultCriteria()
    {
        $userRepository = $this->userRepository();
        $criteria       = [
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ];

        $userRepository->setDefaultCriteria($criteria);
        $defaultCriteria = $userRepository->getDefaultCriteria();

        $this->assertArrayHasKey(FirstTestCriterion::class, $defaultCriteria);
        $this->assertArrayHasKey(SecondTestCriterion::class, $defaultCriteria);
    }

    public function testGetCriteria()
    {
        $userRepository = $this->userRepository();
        $criteria       = [
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ];

        $userRepository->pushCriteria($criteria);

        $this->assertArrayHasKey(FirstTestCriterion::class, $userRepository->getCriteria());
        $this->assertArrayHasKey(SecondTestCriterion::class, $userRepository->getCriteria());
    }

    public function testGetCriteriaWithDefault()
    {
        $userRepository = $this->userRepository();

        $criteria = [
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ];

        $defaultCriteria = [
            function ($query, $repository) {

The parameter $repository is not used and could be removed.

                return $query->where('id', 1);
            },
        ];

        $userRepository->setDefaultCriteria($defaultCriteria)->pushCriteria($criteria);

        $this->assertCount(3, $userRepository->getCriteria());
    }

    public function testGetCriteriaWithSkipCriteria()
    {
        $userRepository = $this->userRepository();

        $criteria = [
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ];

        $userRepository->pushCriteria($criteria)->skipCriteria();

        $this->assertAttributeEquals(true, 'skipCriteria', $userRepository);
        $this->assertEmpty($userRepository->getCriteria());
    }

    public function testGetCriteriaWithDefaultWithSkipCriteria()
    {
        $userRepository = $this->userRepository();

        $criteria = [
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ];
        $defaultCriteria = [
            function ($query, $repository) {

The parameter $repository is not used and could be removed.

                return $query->where('id', 1);
            },
        ];

        $userRepository->setDefaultCriteria($defaultCriteria)->pushCriteria($criteria)->skipCriteria();

        $this->assertAttributeEquals(true, 'skipCriteria', $userRepository);
        $this->assertEmpty($userRepository->getCriteria());
    }

    public function testGetCriteriaWithSkipDefaultCriteria()
    {
        $userRepository = $this->userRepository();

        $criteria = [
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ];
        $defaultCriteria = [
            function ($query, $repository) {

The parameter $repository is not used and could be removed.

                return $query->where('id', 1);
            },
        ];

        $userRepository->setDefaultCriteria($defaultCriteria)->pushCriteria($criteria)->skipDefaultCriteria();
        $this->assertAttributeEquals(true, 'skipDefaultCriteria', $userRepository);
        $this->assertCount(2, $userRepository->getCriteria());
    }

    public function testHasCriterion()
    {
        $userRepository = $this->userRepository();

        $criteria = [
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ];

        $userRepository->pushCriteria($criteria);

        $this->assertTrue($userRepository->hasCriterion(FirstTestCriterion::class));
        $this->assertTrue($userRepository->hasCriterion(SecondTestCriterion::class));
    }

    public function testHasCriterionByClosure()
    {
        $userRepository = $this->userRepository();
        $firstCriteria  = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 1);
        };

        $secondCriteria = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 2);
        };

        $userRepository->pushCriteria([$firstCriteria, $secondCriteria]);

        $this->assertTrue($userRepository->hasCriterion($firstCriteria));
        $this->assertTrue($userRepository->hasCriterion($secondCriteria));
    }

    public function testGetCriterion()
    {
        $userRepository = $this->userRepository();
        $userRepository->pushCriteria([
            FirstTestCriterion::class,
            SecondTestCriterion::class,
        ]);

        $this->assertInstanceOf(FirstTestCriterion::class, $userRepository->getCriterion(FirstTestCriterion::class));
        $this->assertInstanceOf(SecondTestCriterion::class, $userRepository->getCriterion(SecondTestCriterion::class));
    }

    public function testGetCriterionByClosure()
    {
        $userRepository = $this->userRepository();
        $firstCriteria  = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 1);
        };

        $secondCriteria = function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 2);
        };

        $userRepository->pushCriteria([$firstCriteria, $secondCriteria]);
        $this->assertSame($firstCriteria, $userRepository->getCriterion($firstCriteria));
        $this->assertSame($secondCriteria, $userRepository->getCriterion($secondCriteria));
        $this->assertNotSame($secondCriteria, $userRepository->getCriterion($firstCriteria));
    }

    public function testApplyCriteria()
    {
        $userRepository = $this->userRepository();
        $userRepository->pushCriteria([
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ]);

        $resultQuery = $userRepository->applyCriteria($userRepository->createModel(), $userRepository);

        $this->assertEquals('select * from "users" where "id" = ? and "id" = ?', $resultQuery->toSql());
        $this->assertEquals([0 => 1, 1 => 2], $resultQuery->getBindings());
    }

    public function testApplyCriteriaWithClosureCriteria()
    {
        $userRepository = $this->userRepository();
        $userRepository->pushCriteria([
            new FirstTestCriterion(),
            new SecondTestCriterion(),
        ])->pushCriterion(function ($query, $repository) {

The parameter $repository is not used and could be removed.

            return $query->where('id', 3);
        });

        $resultQuery = $userRepository->applyCriteria($userRepository->createModel(), $userRepository);

        $this->assertEquals('select * from "users" where "id" = ? and "id" = ? and "id" = ?', $resultQuery->toSql());
        $this->assertEquals([0 => 1, 1 => 2, 2 => 3], $resultQuery->getBindings());
    }
}

class FirstTestCriterion implements \Rinvex\Repository\Contracts\CriterionContract

PSR1 recommends that each class should be in its own file to aid autoloaders.

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    public function apply($query, $repository)
    {
        return $query->where('id', 1);
    }
}

class SecondTestCriterion implements \Rinvex\Repository\Contracts\CriterionContract

PSR1 recommends that each class should be in its own file to aid autoloaders.

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    public function apply($query, $repository)
    {
        return $query->where('id', 2);
    }
}

class ThirdTestWithArgumentsCriterion implements \Rinvex\Repository\Contracts\CriterionContract

PSR1 recommends that each class should be in its own file to aid autoloaders.

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    protected $from;
    protected $to;

Avoid variables with short names like $to. Configured minimum length is 3.

    public function __construct($from, $to)

Avoid variables with short names like $to. Configured minimum length is 3.

    {
        $this->from = $from;
        $this->to   = $to;
    }

    public function apply($query, $repository)
    {
        return $query->whereBetween('created_at', [$this->from, $this->to]);
    }
}