EloquentRepositoryCriteriaTests::testRemoveCriterionWhenPushedObject() - Code Metrics - Inspection of "Criteria implementation" - rinvex/laravel-repositories - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — develop (#76)

unknown

created 2016-09-10 15:31 UTC

testRemoveCriterionWhenPushedObject() B

↳ Parent: EloquentRepositoryCriteriaTests

Complexity

Conditions	1
Paths	1

Size

Total Lines	27
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	27
rs	8.8571
cc	1
eloc	20
nc	1
nop	0

<?php

class EloquentRepositoryCriteriaTests extends AbstractEloquentTests
namespace YourVendor;

class YourClass { }
{
    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) {

            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) {

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

            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) {

            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) {

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

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

            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) {

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

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

            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) {

                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) {

                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) {

                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) {

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

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

            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) {

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

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

            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) {

            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
namespace YourVendor;

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

class SecondTestCriterion implements \Rinvex\Repository\Contracts\CriterionContract
namespace YourVendor;

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



1			<?php
2
3			class EloquentRepositoryCriteriaTests extends AbstractEloquentTests
			0 ignored issues – show Coding Style Compatibility introduced 2016-09-10 14:57 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
4			{
5			public function testObjectCriterionPush()
6			{
7			$userRepository = $this->userRepository();
8			$criterion = new FirstTestCriterion();
9			$userRepository->pushCriterion($criterion);
10
11			$this->assertAttributeCount(1, 'criteria', $userRepository);
12			$this->assertAttributeContains($criterion, 'criteria', $userRepository);
13			}
14
15			public function testClosureCriterionPush()
16			{
17			$userRepository = $this->userRepository();
18			$criterion = function ($query, $repository) {
			0 ignored issues – show Unused Code introduced 2016-09-10 14:57 UTC by Report Bug Copy Issue Report The parameter `$repository` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
19			return $query->where('id', 1);
20			};
21
22			$userRepository->pushCriterion($criterion);
23
24			$this->assertAttributeCount(1, 'criteria', $userRepository);
25			$this->assertAttributeContains($criterion, 'criteria', $userRepository);
26			}
27
28			public function testClassNameCriterionPush()
29			{
30			$userRepository = $this->userRepository();
31			$criterion = FirstTestCriterion::class;
32			$userRepository->pushCriterion($criterion);
33
34			$this->assertAttributeCount(1, 'criteria', $userRepository);
35			$this->assertContainsOnlyInstancesOf($criterion, $this->getObjectAttribute($userRepository, 'criteria'));
36			}
37
38			public function testPushTwoDifferentCriteria()

rinvex / laravel-repositories

Pull Request — develop (#76)

testRemoveCriterionWhenPushedObject() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like