RepositoryProxyTest::legacy_assertions() - Code Metrics - Inspection of "Use zenstruck/assert for assertions instead of php..." - zenstruck/foundry - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#182)

by Kevin
created 2021-08-14 00:14 UTC
RepositoryProxyTest::legacy_assertions() A

↳ Parent: RepositoryProxyTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	13
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	8
c	1
b	0
f	0
dl	0
loc	13
rs	10
cc	1
nc	1
nop	0
<?php

namespace Zenstruck\Foundry\Tests\Functional;

use Doctrine\Common\Proxy\Proxy as DoctrineProxy;
use PHPUnit\Framework\AssertionFailedError;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Bridge\PhpUnit\ExpectDeprecationTrait;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
use Zenstruck\Assert;
use Zenstruck\Foundry\Proxy;
use Zenstruck\Foundry\Test\Factories;
use Zenstruck\Foundry\Test\ResetDatabase;
use Zenstruck\Foundry\Tests\Fixtures\Entity\Category;
use Zenstruck\Foundry\Tests\Fixtures\Entity\Post;
use Zenstruck\Foundry\Tests\Fixtures\Factories\CategoryFactory;
use Zenstruck\Foundry\Tests\Fixtures\Factories\PostFactory;
use function Zenstruck\Foundry\repository;

/**
 * @author Kevin Bond <[email protected]>
 */
final class RepositoryProxyTest extends KernelTestCase
{
    use ExpectDeprecationTrait, Factories, ResetDatabase;

    /**
     * @test
     */
    public function functions_calls_are_passed_to_underlying_repository(): void
    {
        $this->assertSame('from custom method', repository(Post::class)->customMethod());
        $this->assertSame('from custom method', repository(Post::class)->/** @scrutinizer ignore-call */ customMethod());
    }

    /**
     * @test
     */
    public function assertions(): void
    {
        $repository = repository(Category::class);

        $repository->assert()->empty();

        CategoryFactory::createMany(2);

        $repository->assert()->count(2);
        $repository->assert()->countGreaterThan(1);
        $repository->assert()->countGreaterThanOrEqual(2);
        $repository->assert()->countLessThan(3);
        $repository->assert()->countLessThanOrEqual(2);
        $repository->assert()->exists([]);
        $repository->assert()->notExists(['name' => 'invalid']);

        Assert::that(function() use ($repository) { $repository->assert()->empty(); })
            ->throws(AssertionFailedError::class, \sprintf('Expected %s repository to be empty but it has 2 items.', Category::class))
        ;
        Assert::that(function() use ($repository) { $repository->assert()->count(1); })
            ->throws(AssertionFailedError::class, \sprintf('Expected count of %s repository (2) to be 1.', Category::class))
        ;
        Assert::that(function() use ($repository) { $repository->assert()->countGreaterThan(2); })
            ->throws(AssertionFailedError::class, \sprintf('Expected count of %s repository (2) to be greater than 2.', Category::class))
        ;
        Assert::that(function() use ($repository) { $repository->assert()->countGreaterThanOrEqual(3); })
            ->throws(AssertionFailedError::class, \sprintf('Expected count of %s repository (2) to be greater than or equal to 3.', Category::class))
        ;
        Assert::that(function() use ($repository) { $repository->assert()->countLessThan(2); })
            ->throws(AssertionFailedError::class, \sprintf('Expected count of %s repository (2) to be less than 2.', Category::class))
        ;
        Assert::that(function() use ($repository) { $repository->assert()->countLessThanOrEqual(1); })
            ->throws(AssertionFailedError::class, \sprintf('Expected count of %s repository (2) to be less than or equal to 1.', Category::class))
        ;
        Assert::that(function() use ($repository) { $repository->assert()->exists(['name' => 'invalid-name']); })
            ->throws(AssertionFailedError::class, \sprintf('Expected %s to exist but it does not.', Category::class))
        ;
        Assert::that(function() use ($repository) { $repository->assert()->notExists([]); })
            ->throws(AssertionFailedError::class, \sprintf('Expected %s to not exist but it does.', Category::class))
        ;
    }

    /**
     * @test
     * @group legacy
     */
    public function legacy_assertions(): void
    {
        $repository = repository(Category::class);

        $repository->assertEmpty();
        /** @scrutinizer ignore-deprecated */ $repository->assertEmpty();

        CategoryFactory::createMany(2);

        $repository->assertCount(2);
        /** @scrutinizer ignore-deprecated */ $repository->assertCount(2);
        $repository->assertCountGreaterThan(1);
        /** @scrutinizer ignore-deprecated */ $repository->assertCountGreaterThan(1);
        $repository->assertCountGreaterThanOrEqual(2);
        /** @scrutinizer ignore-deprecated */ $repository->assertCountGreaterThanOrEqual(2);
        $repository->assertCountLessThan(3);
        /** @scrutinizer ignore-deprecated */ $repository->assertCountLessThan(3);
        $repository->assertCountLessThanOrEqual(2);
        /** @scrutinizer ignore-deprecated */ $repository->assertCountLessThanOrEqual(2);
    }

    /**
     * @test
     */
    public function can_fetch_objects(): void
    {
        $repository = repository(Category::class);

        CategoryFactory::createMany(2);

        $objects = $repository->findAll();

        $this->assertCount(2, $objects);
        $this->assertInstanceOf(Proxy::class, $objects[0]);

        $objects = $repository->findBy([]);

        $this->assertCount(2, $objects);
        $this->assertInstanceOf(Proxy::class, $objects[0]);
    }

    /**
     * @test
     */
    public function find_can_be_passed_proxy_or_object_or_array(): void
    {
        $repository = repository(Category::class);
        $proxy = CategoryFactory::createOne(['name' => 'foo']);

        $this->assertInstanceOf(Proxy::class, $repository->find($proxy));
        $this->assertInstanceOf(Proxy::class, $repository->find($proxy->object()));
        $this->assertInstanceOf(Proxy::class, $repository->find(['name' => 'foo']));
    }

    /**
     * @test
     */
    public function can_find_random_object(): void
    {
        CategoryFactory::createMany(5);

        $ids = [];

        while (5 !== \count(\array_unique($ids))) {
            $ids[] = repository(Category::class)->random()->getId();
            $ids[] = repository(Category::class)->random()->/** @scrutinizer ignore-call */ getId();
        }

        $this->assertCount(5, \array_unique($ids));
    }

    /**
     * @test
     */
    public function at_least_one_object_must_exist_to_get_random_object(): void
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage(\sprintf('At least 1 "%s" object(s) must have been persisted (0 persisted).', Category::class));

        repository(Category::class)->random();
    }

    /**
     * @test
     */
    public function can_find_random_set_of_objects(): void
    {
        CategoryFactory::createMany(5);

        $objects = repository(Category::class)->randomSet(3);

        $this->assertCount(3, $objects);
        $this->assertCount(3, \array_unique(\array_map(static function($category) { return $category->getId(); }, $objects)));
    }

    /**
     * @test
     */
    public function random_set_number_must_be_positive(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('$number must be positive (-1 given).');

        repository(Category::class)->randomSet(-1);
    }

    /**
     * @test
     */
    public function the_number_of_persisted_objects_must_be_at_least_the_random_set_number(): void
    {
        CategoryFactory::createOne();

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage(\sprintf('At least 2 "%s" object(s) must have been persisted (1 persisted).', Category::class));

        repository(Category::class)->randomSet(2);
    }

    /**
     * @test
     */
    public function can_find_random_range_of_objects(): void
    {
        CategoryFactory::createMany(5);

        $counts = [];

        while (4 !== \count(\array_unique($counts))) {
            $counts[] = \count(repository(Category::class)->randomRange(0, 3));
        }

        $this->assertCount(4, \array_unique($counts));
        $this->assertContains(0, $counts);
        $this->assertContains(1, $counts);
        $this->assertContains(2, $counts);
        $this->assertContains(3, $counts);
        $this->assertNotContains(4, $counts);
        $this->assertNotContains(5, $counts);
    }

    /**
     * @test
     */
    public function the_number_of_persisted_objects_must_be_at_least_the_random_range_max(): void
    {
        CategoryFactory::createOne();

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage(\sprintf('At least 2 "%s" object(s) must have been persisted (1 persisted).', Category::class));

        repository(Category::class)->randomRange(0, 2);
    }

    /**
     * @test
     */
    public function random_range_min_cannot_be_less_than_zero(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('$min must be positive (-1 given).');

        repository(Category::class)->randomRange(-1, 3);
    }

    /**
     * @test
     */
    public function random_set_max_cannot_be_less_than_min(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('$max (3) cannot be less than $min (5).');

        repository(Category::class)->randomRange(5, 3);
    }

    /**
     * @see https://github.com/zenstruck/foundry/issues/42
     *
     * @test
     */
    public function doctrine_proxies_are_converted_to_foundry_proxies(): void
    {
        PostFactory::createOne(['category' => CategoryFactory::new()]);

        // clear the em so nothing is tracked
        static::$kernel->getContainer()->get('doctrine')->getManager()->clear();

        // load a random Post which causes the em to track a "doctrine proxy" for category
        PostFactory::random();

        // load a random Category which should be a "doctrine proxy"
        $category = CategoryFactory::random()->object();

        // ensure the category is a "doctrine proxy" and a Category
        $this->assertInstanceOf(DoctrineProxy::class, $category);
        $this->assertInstanceOf(Category::class, $category);
    }

    /**
     * @test
     */
    public function proxy_wrapping_orm_entity_manager_can_order_by_in_find_one_by(): void
    {
        $categoryA = CategoryFactory::createOne();

        $categoryB = CategoryFactory::createOne();

        $categoryC = CategoryFactory::createOne();

        $this->assertSame($categoryC->getId(), CategoryFactory::repository()->findOneBy([], ['id' => 'DESC'])->getId());
    }

    /**
     * @test
     */
    public function first_and_last_return_the_correct_object(): void
    {
        $categoryA = CategoryFactory::createOne(['name' => '3']);
        $categoryB = CategoryFactory::createOne(['name' => '2']);

        $categoryC = CategoryFactory::createOne(['name' => '1']);
        $repository = CategoryFactory::repository();

        $this->assertSame($categoryA->getId(), $repository->first()->getId());
        $this->assertSame($categoryC->getId(), $repository->first('name')->getId());
        $this->assertSame($categoryC->getId(), $repository->last()->getId());
        $this->assertSame($categoryA->getId(), $repository->last('name')->getId());
    }

    /**
     * @test
     */
    public function first_and_last_return_null_if_empty(): void
    {
        $this->assertNull(CategoryFactory::repository()->first());
        $this->assertNull(CategoryFactory::repository()->first('name'));
        $this->assertNull(CategoryFactory::repository()->last());
        $this->assertNull(CategoryFactory::repository()->last('name'));
    }

    /**
     * @test
     */
    public function repository_proxy_is_countable_and_iterable(): void
    {
        CategoryFactory::createMany(4);

        $repository = CategoryFactory::repository();

        $this->assertCount(4, $repository);
        $this->assertCount(4, \iterator_to_array($repository));
    }

    /**
     * @test
     * @group legacy
     */
    public function can_use_get_count(): void
    {
        CategoryFactory::createMany(4);

        $this->expectDeprecation('Since zenstruck\foundry 1.5.0: Using RepositoryProxy::getCount() is deprecated, use RepositoryProxy::count() (it is now Countable).');

        $this->assertSame(4, CategoryFactory::repository()->getCount());
        $this->assertSame(4, /** @scrutinizer ignore-deprecated */ CategoryFactory::repository()->getCount());
    }
}

zenstruck / foundry

Pull Request — master (#182)

RepositoryProxyTest::legacy_assertions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
