Zenstruck\Foundry\Tests\Functional\RepositoryProxyTest

Complexity

Total Complexity

22

Size/Duplication

Total Lines	316
Duplicated Lines	0 %

Importance

Changes	9
Bugs	0	Features	5

20 Methods

Rating	Name	Duplication	Size	Complexity
A	first_and_last_return_null_if_empty()	0	6	1
A	the_number_of_persisted_objects_must_be_at_least_the_random_range_max()	0	8	1
A	can_use_get_count()	0	7	1
A	assertions()	0	39	1
A	repository_proxy_is_countable_and_iterable()	0	8	1
A	the_number_of_persisted_objects_must_be_at_least_the_random_set_number()	0	8	1
A	first_and_last_return_the_correct_object()	0	11	1
A	random_range_min_cannot_be_less_than_zero()	0	6	1
A	doctrine_proxies_are_converted_to_foundry_proxies()	0	16	1
A	random_set_number_must_be_positive()	0	6	1
A	legacy_assertions()	0	13	1
A	can_find_random_object()	0	11	2
A	find_can_be_passed_proxy_or_object_or_array()	0	8	1
A	can_find_random_range_of_objects()	0	17	2
A	proxy_wrapping_orm_entity_manager_can_order_by_in_find_one_by()	0	7	1
A	random_set_max_cannot_be_less_than_min()	0	6	1
A	can_find_random_set_of_objects()	0	8	1
A	functions_calls_are_passed_to_underlying_repository()	0	3	1
A	can_fetch_objects()	0	15	1
A	at_least_one_object_must_exist_to_get_random_object()	0	6	1

<?php

namespace Zenstruck\Foundry\Tests\Functional;

use Doctrine\Common\Proxy\Proxy as DoctrineProxy;
use PHPUnit\Framework\AssertionFailedError;

The type PHPUnit\Framework\AssertionFailedError was not found. Maybe you did not declare it correctly or list all dependencies?

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 <kevinbond@gmail.com>
 */
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());

The method customMethod() does not exist on Zenstruck\Foundry\RepositoryProxy. Since you implemented __call, consider adding a @method annotation.

    }

    /**
     * @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();

The function Zenstruck\Foundry\RepositoryProxy::assertEmpty() has been deprecated: use RepositoryProxy::assert()->empty()

        CategoryFactory::createMany(2);

        $repository->assertCount(2);

The function Zenstruck\Foundry\RepositoryProxy::assertCount() has been deprecated: use RepositoryProxy::assert()->count()

        $repository->assertCountGreaterThan(1);

The function Zenstruck\Foundry\RepositoryProxy::assertCountGreaterThan() has been deprecated: use RepositoryProxy::assert()->countGreaterThan()

        $repository->assertCountGreaterThanOrEqual(2);

The function Zenstruck\Foundry\RepositoryProxy::assertCountGreaterThanOrEqual() has been deprecated: use RepositoryProxy::assert()->countGreaterThanOrEqual()

        $repository->assertCountLessThan(3);

The function Zenstruck\Foundry\RepositoryProxy::assertCountLessThan() has been deprecated: use RepositoryProxy::assert()->countLessThan()

        $repository->assertCountLessThanOrEqual(2);

The function Zenstruck\Foundry\RepositoryProxy::assertCountLessThanOrEqual() has been deprecated: use RepositoryProxy::assert()->countLessThanOrEqual()

    }

    /**
     * @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();

The method getId() does not exist on Zenstruck\Foundry\Proxy. Since you implemented __call, consider adding a @method annotation.

        }

        $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();

The assignment to $categoryA is dead and can be removed.

        $categoryB = CategoryFactory::createOne();

The assignment to $categoryB is dead and can be removed.

        $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']);

The assignment to $categoryB is dead and can be removed.

        $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());

The function Zenstruck\Foundry\RepositoryProxy::getCount() has been deprecated: use RepositoryProxy::count()

    }
}