EloquentRepositoryCriteriaTests

Complexity

Total Complexity

25

Size/Duplication

Total Lines	419
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	1
Bugs	0	Features	0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	testObjectCriterionPush()	0	9	1
A	testClosureCriterionPush()	0	11	1
A	testClassNameCriterionPush()	0	9	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 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);
    }
}