FactoryTest::can_create_many_objects_legacy() - Code Metrics - Inspection of "[RFC] Remove "visual duplication" of ModelFactory:..." - zenstruck/foundry - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#111)

by Wouter
created 2021-01-16 22:30 UTC
FactoryTest::can_create_many_objects_legacy() A

↳ Parent: FactoryTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	23
Code Lines	16
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	16
c	0
b	0
f	0
dl	0
loc	23
rs	9.7333
cc	1
nc	1
nop	0
<?php

namespace Zenstruck\Foundry\Tests\Unit;

use Doctrine\Persistence\ManagerRegistry;
use Doctrine\Persistence\ObjectManager;
use Faker;
use PHPUnit\Framework\TestCase;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Bridge\PhpUnit\ExpectDeprecationTrait;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
use Zenstruck\Foundry\Factory;
use Zenstruck\Foundry\Proxy;
use Zenstruck\Foundry\Test\Factories;
use Zenstruck\Foundry\Tests\Fixtures\Entity\Category;
use Zenstruck\Foundry\Tests\Fixtures\Entity\Post;

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

    /**
     * @test
     */
    public function can_instantiate_object(): void
    {
        $attributeArray = ['title' => 'title', 'body' => 'body'];
        $attributeCallback = static function(Faker\Generator $faker) {
        $attributeCallback = static function(/** @scrutinizer ignore-unused */ Faker\Generator $faker) {
            return ['title' => 'title', 'body' => 'body'];
        };

        $this->assertSame('title', (new Factory(Post::class, $attributeArray))->create()->getTitle());
        $this->assertSame('title', (new Factory(Post::class, $attributeArray))->create()->/** @scrutinizer ignore-call */ getTitle());
        $this->assertSame('title', (new Factory(Post::class))->create($attributeArray)->getTitle());
        $this->assertSame('title', (new Factory(Post::class))->withAttributes($attributeArray)->create()->getTitle());
        $this->assertSame('title', (new Factory(Post::class, $attributeCallback))->create()->getTitle());
        $this->assertSame('title', (new Factory(Post::class))->create($attributeCallback)->getTitle());
        $this->assertSame('title', (new Factory(Post::class))->withAttributes($attributeCallback)->create()->getTitle());
    }

    /**
     * @test
     * @group legacy
     */
    public function can_instantiate_many_objects_legacy(): void
    {
        $this->expectDeprecation('Since zenstruck/foundry 1.7: Calling instance method "'.Factory::class.'::createMany()" is deprecated and will be removed in 2.0, use the static "'.Factory::class.':createMany()" method instead.');

        $attributeArray = ['title' => 'title', 'body' => 'body'];
        $attributeCallback = static function(Faker\Generator $faker) {
        $attributeCallback = static function(/** @scrutinizer ignore-unused */ Faker\Generator $faker) {
            return ['title' => 'title', 'body' => 'body'];
        };

        $objects = (new Factory(Post::class, $attributeArray))->createMany(3);
        $objects = (new Factory(Post::class, $attributeArray))->/** @scrutinizer ignore-call */ createMany(3);

        $this->assertCount(3, $objects);
        $this->assertSame('title', $objects[0]->getTitle());
        $this->assertSame('title', $objects[1]->getTitle());
        $this->assertSame('title', $objects[2]->getTitle());

        $objects = (new Factory(Post::class))->createMany(3, $attributeArray);

        $this->assertCount(3, $objects);
        $this->assertSame('title', $objects[0]->getTitle());
        $this->assertSame('title', $objects[1]->getTitle());
        $this->assertSame('title', $objects[2]->getTitle());

        $objects = (new Factory(Post::class))->withAttributes($attributeArray)->createMany(3);

        $this->assertCount(3, $objects);
        $this->assertSame('title', $objects[0]->getTitle());
        $this->assertSame('title', $objects[1]->getTitle());
        $this->assertSame('title', $objects[2]->getTitle());

        $objects = (new Factory(Post::class, $attributeCallback))->createMany(3);

        $this->assertCount(3, $objects);
        $this->assertSame('title', $objects[0]->getTitle());
        $this->assertSame('title', $objects[1]->getTitle());
        $this->assertSame('title', $objects[2]->getTitle());

        $objects = (new Factory(Post::class))->createMany(3, $attributeCallback);

        $this->assertCount(3, $objects);
        $this->assertSame('title', $objects[0]->getTitle());
        $this->assertSame('title', $objects[1]->getTitle());
        $this->assertSame('title', $objects[2]->getTitle());

        $objects = (new Factory(Post::class))->withAttributes($attributeCallback)->createMany(3);

        $this->assertCount(3, $objects);
        $this->assertSame('title', $objects[0]->getTitle());
        $this->assertSame('title', $objects[1]->getTitle());
        $this->assertSame('title', $objects[2]->getTitle());
    }

    /**
     * @test
     */
    public function can_set_instantiator(): void
    {
        $attributeArray = ['title' => 'original title', 'body' => 'original body'];

        $object = (new Factory(Post::class))
            ->instantiateWith(function(array $attributes, string $class) use ($attributeArray) {
                $this->assertSame(Post::class, $class);
                $this->assertSame($attributes, $attributeArray);

                return new Post('title', 'body');
            })
            ->create($attributeArray)
        ;

        $this->assertSame('title', $object->getTitle());
        $this->assertSame('body', $object->getBody());
        $this->assertSame('body', $object->/** @scrutinizer ignore-call */ getBody());
    }

    /**
     * @test
     */
    public function can_add_before_instantiate_events(): void
    {
        $attributeArray = ['title' => 'original title', 'body' => 'original body'];

        $object = (new Factory(Post::class))
            ->beforeInstantiate(function(array $attributes) {
                $attributes['title'] = 'title';

                return $attributes;
            })
            ->beforeInstantiate(function(array $attributes) {
                $attributes['body'] = 'body';

                return $attributes;
            })
            ->create($attributeArray)
        ;

        $this->assertSame('title', $object->getTitle());
        $this->assertSame('body', $object->getBody());
    }

    /**
     * @test
     */
    public function before_instantiate_event_must_return_an_array(): void
    {
        $this->expectException(\LogicException::class);
        $this->expectExceptionMessage('Before Instantiate event callback must return an array.');

        (new Factory(Post::class))->beforeInstantiate(function() {})->create();
    }

    /**
     * @test
     */
    public function can_add_after_instantiate_events(): void
    {
        $attributesArray = ['title' => 'title', 'body' => 'body'];

        $object = (new Factory(Post::class))
            ->afterInstantiate(function(Post $post, array $attributes) use ($attributesArray) {
                $this->assertSame($attributesArray, $attributes);

                $post->increaseViewCount();
            })
            ->afterInstantiate(function(Post $post, array $attributes) use ($attributesArray) {
                $this->assertSame($attributesArray, $attributes);

                $post->increaseViewCount();
            })
            ->create($attributesArray)
        ;

        $this->assertSame(2, $object->getViewCount());
        $this->assertSame(2, $object->/** @scrutinizer ignore-call */ getViewCount());
    }

    /**
     * @test
     */
    public function can_register_custom_faker(): void
    {
        $defaultFaker = Factory::faker();
        Factory::configuration()->setFaker(Faker\Factory::create());

        $this->assertNotSame(\spl_object_id(Factory::faker()), \spl_object_id($defaultFaker));
    }

    /**
     * @test
     */
    public function can_register_default_instantiator(): void
    {
        Factory::configuration()->setInstantiator(function() {
            return new Post('different title', 'different body');
        });

        $object = (new Factory(Post::class, ['title' => 'title', 'body' => 'body']))->create();

        $this->assertSame('different title', $object->getTitle());
        $this->assertSame('different body', $object->getBody());
    }

    /**
     * @test
     */
    public function instantiating_with_proxy_attribute_normalizes_to_underlying_object(): void
    {
        $object = (new Factory(Post::class))->create([
            'title' => 'title',
            'body' => 'body',
            'category' => new Proxy(new Category()),
        ]);

        $this->assertInstanceOf(Category::class, $object->getCategory());
        $this->assertInstanceOf(Category::class, $object->/** @scrutinizer ignore-call */ getCategory());
    }

    /**
     * @test
     */
    public function instantiating_with_factory_attribute_instantiates_the_factory(): void
    {
        $object = (new Factory(Post::class))->create([
            'title' => 'title',
            'body' => 'body',
            'category' => new Factory(Category::class),
        ]);

        $this->assertInstanceOf(Category::class, $object->getCategory());
    }

    /**
     * @test
     */
    public function factory_is_immutable(): void
    {
        $factory = new Factory(Post::class);
        $objectId = \spl_object_id($factory);

        $this->assertNotSame(\spl_object_id($factory->withAttributes([])), $objectId);
        $this->assertNotSame(\spl_object_id($factory->withoutPersisting()), $objectId);
        $this->assertNotSame(\spl_object_id($factory->instantiateWith(function() {})), $objectId);
        $this->assertNotSame(\spl_object_id($factory->beforeInstantiate(function() {})), $objectId);
        $this->assertNotSame(\spl_object_id($factory->afterInstantiate(function() {})), $objectId);
        $this->assertNotSame(\spl_object_id($factory->afterPersist(function() {})), $objectId);
    }

    /**
     * @test
     */
    public function can_create_object(): void
    {
        $registry = $this->createMock(ManagerRegistry::class);
        $registry
            ->expects($this->exactly(2))
            ->method('getManagerForClass')
            ->with(Post::class)
            ->willReturn($this->createMock(ObjectManager::class))
        ;

        Factory::configuration()->setManagerRegistry($registry);

        $object = (new Factory(Post::class))->create(['title' => 'title', 'body' => 'body']);

        $this->assertInstanceOf(Proxy::class, $object);
        $this->assertSame('title', $object->getTitle());
    }

    /**
     * @test
     * @group legacy
     */
    public function can_create_many_objects_legacy(): void
    {
        $this->expectDeprecation('Since zenstruck/foundry 1.7: Calling instance method "'.Factory::class.'::createMany()" is deprecated and will be removed in 2.0, use the static "'.Factory::class.':createMany()" method instead.');

        $registry = $this->createMock(ManagerRegistry::class);
        $registry
            ->expects($this->exactly(6))
            ->method('getManagerForClass')
            ->with(Post::class)
            ->willReturn($this->createMock(ObjectManager::class))
        ;

        Factory::configuration()->setManagerRegistry($registry);

        $objects = (new Factory(Post::class))->createMany(3, ['title' => 'title', 'body' => 'body']);

        $this->assertCount(3, $objects);
        $this->assertInstanceOf(Proxy::class, $objects[0]);
        $this->assertInstanceOf(Proxy::class, $objects[1]);
        $this->assertInstanceOf(Proxy::class, $objects[2]);
        $this->assertSame('title', $objects[0]->getTitle());
        $this->assertSame('title', $objects[1]->getTitle());
        $this->assertSame('title', $objects[2]->getTitle());
    }

    /**
     * @test
     */
    public function can_add_after_persist_events(): void
    {
        $registry = $this->createMock(ManagerRegistry::class);
        $registry
            ->expects($this->exactly(2)) // once for persisting, once for each afterPersist event
            ->method('getManagerForClass')
            ->with(Post::class)
            ->willReturn($this->createMock(ObjectManager::class))
        ;

        Factory::configuration()->setManagerRegistry($registry);

        $expectedAttributes = ['shortDescription' => 'short desc', 'title' => 'title', 'body' => 'body'];
        $calls = 0;

        $object = (new Factory(Post::class, ['shortDescription' => 'short desc']))
            ->afterPersist(function(Proxy $post, array $attributes) use ($expectedAttributes, &$calls) {
                /* @var Post $post */
                $this->assertSame($expectedAttributes, $attributes);

                $post->increaseViewCount();
                ++$calls;
            })
            ->afterPersist(function(Post $post, array $attributes) use ($expectedAttributes, &$calls) {
                $this->assertSame($expectedAttributes, $attributes);

                $post->increaseViewCount();
                ++$calls;
            })
            ->afterPersist(function(Post $post, array $attributes) use ($expectedAttributes, &$calls) {
                $this->assertSame($expectedAttributes, $attributes);

                $post->increaseViewCount();
                ++$calls;
            })
            ->afterPersist(function($post) use (&$calls) {
                $this->assertInstanceOf(Proxy::class, $post);

                ++$calls;
            })
            ->afterPersist(static function() use (&$calls) {
                ++$calls;
            })
            ->create(['title' => 'title', 'body' => 'body'])
        ;

        $this->assertSame(3, $object->getViewCount());
        $this->assertSame(5, $calls);
    }

    /**
     * @test
     */
    public function trying_to_persist_without_manager_registry_throws_exception(): void
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('Foundry was booted without doctrine. Ensure your TestCase extends '.KernelTestCase::class);

        (new Factory(Post::class))->create(['title' => 'title', 'body' => 'body'])->save();
    }
}

zenstruck / foundry

Pull Request — master (#111)

FactoryTest::can_create_many_objects_legacy() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
