public function testThrowsAnExceptionWhenACircularReferenceIsDetected() { $context = new GenerationContext(); $context->markIsResolvingFixture('bar'); $context->markIsResolvingFixture('foo'); try { $context->markIsResolvingFixture('foo'); $this->fail('Expected exception to be thrown.'); } catch (CircularReferenceException $exception) { $this->assertEquals('Circular reference detected for the parameter "foo" while resolving ["bar", "foo"].', $exception->getMessage()); } }
public function testPicksTheFirstSuitableResolverToResolveTheGivenValue() { $value = new FakeValue(); $fixture = new FakeFixture(); $set = ResolvedFixtureSetFactory::create(); $scope = ['scope' => 'epocs']; $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $expected = new ResolvedValueWithFixtureSet(10, ResolvedFixtureSetFactory::create(null, null, (new ObjectBag())->with(new SimpleObject('dummy', new \stdClass())))); $instantiator1Prophecy = $this->prophesize(ChainableValueResolverInterface::class); $instantiator1Prophecy->canResolve($value)->willReturn(false); /* @var ChainableValueResolverInterface $instantiator1 */ $instantiator1 = $instantiator1Prophecy->reveal(); $instantiator2Prophecy = $this->prophesize(ChainableValueResolverInterface::class); $instantiator2Prophecy->canResolve($value)->willReturn(true); $instantiator2Prophecy->resolve($value, $fixture, $set, $scope, $context)->willReturn($expected); /* @var ChainableValueResolverInterface $instantiator2 */ $instantiator2 = $instantiator2Prophecy->reveal(); $instantiator3Prophecy = $this->prophesize(ChainableValueResolverInterface::class); $instantiator3Prophecy->canResolve(Argument::any())->shouldNotBeCalled(); /* @var ChainableValueResolverInterface $instantiator3 */ $instantiator3 = $instantiator3Prophecy->reveal(); $registry = new ValueResolverRegistry([$instantiator1, $instantiator2, $instantiator3]); $actual = $registry->resolve($value, $fixture, $set, $scope, $context); $this->assertSame($expected, $actual); $instantiator1Prophecy->canResolve(Argument::any())->shouldHaveBeenCalledTimes(1); $instantiator2Prophecy->canResolve(Argument::any())->shouldHaveBeenCalledTimes(1); $instantiator2Prophecy->resolve(Argument::cetera())->shouldHaveBeenCalledTimes(1); }
public function testReturnsSetWithResolvedValue() { $value = new FixturePropertyValue($reference = new FakeValue(), $property = 'prop'); $fixture = new FakeFixture(); $set = ResolvedFixtureSetFactory::create(new ParameterBag(['foo' => 'bar'])); $scope = ['val' => 'scopie']; $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $valueResolverContext = new GenerationContext(); $valueResolverContext->markIsResolvingFixture('foo'); $valueResolverContext->markAsNeedsCompleteGeneration(); $valueResolverProphecy = $this->prophesize(ValueResolverInterface::class); $valueResolverProphecy->resolve($reference, $fixture, $set, $scope, $valueResolverContext)->willReturn(new ResolvedValueWithFixtureSet($instance = new \stdClass(), $newSet = ResolvedFixtureSetFactory::create(new ParameterBag(['ping' => 'pong'])))); /** @var ValueResolverInterface $valueResolver */ $valueResolver = $valueResolverProphecy->reveal(); $propertyAccessorProphecy = $this->prophesize(PropertyAccessorInterface::class); $propertyAccessorProphecy->getValue($instance, $property)->willReturn('yo'); /** @var PropertyAccessorInterface $propertyAccessor */ $propertyAccessor = $propertyAccessorProphecy->reveal(); $expected = new ResolvedValueWithFixtureSet('yo', $newSet); $resolver = new FixturePropertyReferenceResolver($propertyAccessor, $valueResolver); $actual = $resolver->resolve($value, $fixture, $set, $scope, $context); $this->assertEquals($expected, $actual); $valueResolverProphecy->resolve(Argument::cetera())->shouldHaveBeenCalledTimes(1); $propertyAccessorProphecy->getValue(Argument::cetera())->shouldHaveBeenCalledTimes(1); }
/** * @testdox Do a instantiate-hydrate-calls cycle to generate the object described by the fixture. */ public function testGenerate() { $this->markTestIncomplete('TODO'); $fixture = new SimpleFixture('dummy', \stdClass::class, SpecificationBagFactory::create()); $set = ResolvedFixtureSetFactory::create(); $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $instance = new \stdClass(); $instantiatedObject = new SimpleObject($fixture->getId(), $instance); $instantiatorProphecy = $this->prophesize(InstantiatorInterface::class); $instantiatorProphecy->instantiate($fixture, $set, $context)->willReturn($setWithInstantiatedObject = ResolvedFixtureSetFactory::create(null, null, (new ObjectBag())->with($instantiatedObject))); /** @var InstantiatorInterface $instantiator */ $instantiator = $instantiatorProphecy->reveal(); $hydratedInstance = clone $instance; $hydratedInstance->hydrated = true; $hydratedObject = new SimpleObject($fixture->getId(), $hydratedInstance); $hydratorProphecy = $this->prophesize(HydratorInterface::class); $hydratorProphecy->hydrate($instantiatedObject, $setWithInstantiatedObject, $context)->willReturn($setWithHydratedObject = ResolvedFixtureSetFactory::create(null, null, (new ObjectBag())->with($hydratedObject))); /** @var HydratorInterface $hydrator */ $hydrator = $hydratorProphecy->reveal(); $instanceAfterCalls = clone $hydratedInstance; $instanceAfterCalls->calls = true; $objectAfterCalls = new SimpleObject($fixture->getId(), $instanceAfterCalls); $callerProphecy = $this->prophesize(CallerInterface::class); $callerProphecy->doCallsOn($hydratedObject, $setWithHydratedObject)->willReturn($setWithObjectAfterCalls = ResolvedFixtureSetFactory::create(null, null, (new ObjectBag())->with($objectAfterCalls))); /** @var CallerInterface $caller */ $caller = $callerProphecy->reveal(); $generator = new SimpleObjectGenerator(new FakeValueResolver(), $instantiator, $hydrator, $caller); $objects = $generator->generate($fixture, $set, $context); $this->assertEquals($setWithObjectAfterCalls->getObjects(), $objects); $instantiatorProphecy->instantiate(Argument::cetera())->shouldHaveBeenCalledTimes(1); $hydratorProphecy->hydrate(Argument::cetera())->shouldHaveBeenCalledTimes(1); $callerProphecy->doCallsOn(Argument::cetera())->shouldHaveBeenCalledTimes(1); }
public function testIterateOverEveryInstantiatorAndUseTheFirstValidOne() { $fixture = new FakeFixture(); $set = ResolvedFixtureSetFactory::create(); $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $expected = ResolvedFixtureSetFactory::create(null, null, (new ObjectBag())->with(new SimpleObject('dummy', new \stdClass()))); $instantiator1Prophecy = $this->prophesize(ChainableInstantiatorInterface::class); $instantiator1Prophecy->canInstantiate($fixture)->willReturn(false); /* @var ChainableInstantiatorInterface $instantiator1 */ $instantiator1 = $instantiator1Prophecy->reveal(); $instantiator2Prophecy = $this->prophesize(ChainableInstantiatorInterface::class); $instantiator2Prophecy->canInstantiate($fixture)->willReturn(true); $instantiator2Prophecy->instantiate($fixture, $set, $context)->willReturn($expected); /* @var ChainableInstantiatorInterface $instantiator2 */ $instantiator2 = $instantiator2Prophecy->reveal(); $instantiator3Prophecy = $this->prophesize(ChainableInstantiatorInterface::class); $instantiator3Prophecy->canInstantiate(Argument::any())->shouldNotBeCalled(); /* @var ChainableInstantiatorInterface $instantiator3 */ $instantiator3 = $instantiator3Prophecy->reveal(); $registry = new InstantiatorRegistry([$instantiator1, $instantiator2, $instantiator3]); $actual = $registry->instantiate($fixture, $set, $context); $this->assertSame($expected, $actual); $instantiator1Prophecy->canInstantiate(Argument::any())->shouldHaveBeenCalledTimes(1); $instantiator2Prophecy->canInstantiate(Argument::any())->shouldHaveBeenCalledTimes(1); $instantiator2Prophecy->instantiate(Argument::cetera())->shouldHaveBeenCalledTimes(1); }
public function testReturnsTheResultOfTheDecoratedInstantiatorIfTheFixtureHasNotBeenInstantiated() { $fixture = new DummyFixture('dummy'); $set = ResolvedFixtureSetFactory::create(); $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $decoratedInstantiatorProphecy = $this->prophesize(InstantiatorInterface::class); $decoratedInstantiatorProphecy->instantiate($fixture, $set, $context)->willReturn($expected = $set->withObjects((new ObjectBag())->with(new SimpleObject('dummy', new \stdClass())))); /** @var InstantiatorInterface $decoratedInstantiator */ $decoratedInstantiator = $decoratedInstantiatorProphecy->reveal(); $instantiator = new ExistingInstanceInstantiator($decoratedInstantiator); $actual = $instantiator->instantiate($fixture, $set, $context); $this->assertSame($expected, $actual); $decoratedInstantiatorProphecy->instantiate(Argument::cetera())->shouldHaveBeenCalledTimes(1); }
public function testReturnsSetWithResolvedValue() { $value = new FunctionCallValue('foo'); $fixture = new FakeFixture(); $set = ResolvedFixtureSetFactory::create(new ParameterBag(['foo' => 'bar'])); $scope = ['val' => 'scopie']; $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $fakerGeneratorProphecy = $this->prophesize(FakerGenerator::class); $fakerGeneratorProphecy->format('foo', [])->willReturn('bar'); /** @var FakerGenerator $fakerGenerator */ $fakerGenerator = $fakerGeneratorProphecy->reveal(); $expected = new ResolvedValueWithFixtureSet('bar', $set); $resolver = new FakerFunctionCallValueResolver($fakerGenerator); $actual = $resolver->resolve($value, $fixture, $set, $scope, $context); $this->assertEquals($expected, $actual); }
public function testResolvesAllTheValuesInArrayBeforeImplodingIt() { $value = new ListValue(['a', new FakeValue(), 'c', new FakeValue()]); $fixture = new FakeFixture(); $set = ResolvedFixtureSetFactory::create(new ParameterBag(['foo' => 'bar'])); $scope = ['scope' => 'epocs']; $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $valueResolverProphecy = $this->prophesize(ValueResolverInterface::class); $valueResolverProphecy->resolve(new FakeValue(), $fixture, $set, $scope, $context)->willReturn(new ResolvedValueWithFixtureSet('b', $newSet = ResolvedFixtureSetFactory::create(new ParameterBag(['foo' => 'baz'])))); $valueResolverProphecy->resolve(new FakeValue(), $fixture, $newSet, $scope, $context)->willReturn(new ResolvedValueWithFixtureSet('d', $newSet2 = ResolvedFixtureSetFactory::create(new ParameterBag(['foo' => 'zab'])))); /** @var ValueResolverInterface $valueResolver */ $valueResolver = $valueResolverProphecy->reveal(); $expected = new ResolvedValueWithFixtureSet('abcd', $newSet2); $resolver = new ListValueResolver($valueResolver); $actual = $resolver->resolve($value, $fixture, $set, $scope, $context); $this->assertEquals($expected, $actual); $valueResolverProphecy->resolve(Argument::cetera())->shouldHaveBeenCalledTimes(2); }
public function testResolvesAllPropertyValues() { $object = new SimpleObject('dummy', new \stdClass()); $set = ResolvedFixtureSetFactory::create(null, $fixtures = (new FixtureBag())->with($fixture = new SimpleFixture('dummy', \stdClass::class, new SpecificationBag(null, (new PropertyBag())->with($username = new Property('username', $usernameValue = new FakeValue()))->with($group = new Property('group', $groupValue = new FakeValue())), new MethodCallBag())))); $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $resolverProphecy = $this->prophesize(ValueResolverInterface::class); $setAfterFirstResolution = ResolvedFixtureSetFactory::create(new ParameterBag(['iteration' => 1]), $fixtures); $resolverProphecy->resolve($usernameValue, $fixture, $set, ['_instances' => $set->getObjects()->toArray()], $context)->willReturn(new ResolvedValueWithFixtureSet('Bob', $setAfterFirstResolution)); $setAfterSecondResolution = ResolvedFixtureSetFactory::create(new ParameterBag(['iteration' => 2]), $fixtures); $resolverProphecy->resolve($groupValue, $fixture, $setAfterFirstResolution, ['_instances' => $set->getObjects()->toArray(), 'username' => 'Bob'], $context)->willReturn(new ResolvedValueWithFixtureSet('Badass', $setAfterSecondResolution)); /** @var ValueResolverInterface $resolver */ $resolver = $resolverProphecy->reveal(); $hydratorProphecy = $this->prophesize(PropertyHydratorInterface::class); $newInstance = new \stdClass(); $newInstance->username = '******'; $newObject = $object->withInstance($newInstance); $hydratorProphecy->hydrate($object, $username->withValue('Bob'), $context)->willReturn($newObject); $secondNewInstance = clone $newInstance; $secondNewInstance->group = 'Badass'; $secondNewObject = $object->withInstance($secondNewInstance); $hydratorProphecy->hydrate($newObject, $group->withValue('Badass'), $context)->willReturn($secondNewObject); /** @var PropertyHydratorInterface $hydrator */ $hydrator = $hydratorProphecy->reveal(); $expected = new ResolvedFixtureSet(new ParameterBag(['iteration' => 2]), $fixtures, new ObjectBag(['dummy' => $secondNewObject])); $hydrator = new SimpleHydrator($hydrator, $resolver); $actual = $hydrator->hydrate($object, $set, $context); $this->assertEquals($expected, $actual); }
public function testResolvesAllArgumentsValuesBeforePassingThemToTheDecoratedResolver() { $value = new FunctionCallValue('foo', ['scalar', new FakeValue(), 'another scalar']); $fixture = new FakeFixture(); $set = ResolvedFixtureSetFactory::create(new ParameterBag(['foo' => 'bar'])); $scope = ['val' => 'scopie']; $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $argumentResolverProphecy = $this->prophesize(ValueResolverInterface::class); $argumentResolverProphecy->resolve(new FakeValue(), $fixture, $set, $scope, $context)->willReturn(new ResolvedValueWithFixtureSet($instance = new \stdClass(), $newSet = ResolvedFixtureSetFactory::create(new ParameterBag(['ping' => 'pong'])))); /** @var ValueResolverInterface $argumentResolver */ $argumentResolver = $argumentResolverProphecy->reveal(); $decoratedResolverProphecy = $this->prophesize(ValueResolverInterface::class); $decoratedResolverProphecy->resolve(new FunctionCallValue('foo', ['scalar', $instance, 'another scalar']), $fixture, $newSet, $scope, $context)->willReturn($expected = new ResolvedValueWithFixtureSet('end', ResolvedFixtureSetFactory::create(new ParameterBag(['gnip' => 'gnop'])))); /** @var ValueResolverInterface $decoratedResolver */ $decoratedResolver = $decoratedResolverProphecy->reveal(); $resolver = new FunctionCallArgumentResolver($decoratedResolver, $argumentResolver); $actual = $resolver->resolve($value, $fixture, $set, $scope, $context); $this->assertEquals($expected, $actual); }
public function testReturnsResultOfTheDecoratedResolverIfFunctionIsBlacklisted() { $value = new FunctionCallValue('strtolower', ['BAR']); $fixture = new FakeFixture(); $set = ResolvedFixtureSetFactory::create(new ParameterBag(['foo' => 'bar'])); $scope = ['val' => 'scopie']; $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $decoratedResolverProphecy = $this->prophesize(ValueResolverInterface::class); $decoratedResolverProphecy->resolve($value, $fixture, $set, $scope, $context)->willReturn($expected = new ResolvedValueWithFixtureSet('bar', ResolvedFixtureSetFactory::create(new ParameterBag(['foo' => 'bar', 'ping' => 'pong'])))); /** @var ValueResolverInterface $decoratedResolver */ $decoratedResolver = $decoratedResolverProphecy->reveal(); $resolver = new PhpFunctionCallValueResolver(['strtolower'], $decoratedResolver); $actual = $resolver->resolve($value, $fixture, $set, $scope, $context); $this->assertEquals($expected, $actual); $decoratedResolverProphecy->resolve(Argument::cetera())->shouldHaveBeenCalledTimes(1); }
public function testIfTheReferenceRefersToANonInstantiatedFixtureThenGenerateItBeforeReturningTheInstance() { $value = new FixtureReferenceValue('dummy'); $fixture = new FakeFixture(); $set = ResolvedFixtureSetFactory::create(null, $fixtures = (new FixtureBag())->with($referredFixture = new SimpleFixture('dummy', 'Dummy', SpecificationBagFactory::create())), null); $scope = []; $context = new GenerationContext(); $generatorContext = new GenerationContext(); $generatorContext->markIsResolvingFixture('dummy'); $generatorProphecy = $this->prophesize(ObjectGeneratorInterface::class); $generatorProphecy->generate($referredFixture, $set, $generatorContext)->willReturn($objects = new ObjectBag(['dummy' => $expectedInstance = new \stdClass()])); /** @var ObjectGeneratorInterface $generator */ $generator = $generatorProphecy->reveal(); $expected = new ResolvedValueWithFixtureSet($expectedInstance, ResolvedFixtureSetFactory::create(null, $fixtures, $objects)); $resolver = new FixtureReferenceResolver($generator); $actual = $resolver->resolve($value, $fixture, $set, $scope, $context); $this->assertEquals($expected, $actual); $this->assertEquals($context, $generatorContext); $generatorProphecy->generate(Argument::cetera())->shouldHaveBeenCalledTimes(1); }
public function testReturnsResultOfTheDecoratedResolverIfReferenceDoesNotMatchSelf() { $valueProphecy = $this->prophesize(ValueInterface::class); $valueProphecy->getValue()->willReturn('a_random_fixture_id'); /** @var ValueInterface $value */ $value = $valueProphecy->reveal(); $expectedObject = new \stdClass(); $expectedObject->foo = 'bar'; $set = ResolvedFixtureSetFactory::create(null, $fixtureBag = (new FixtureBag())->with($dummyFixture = new SimpleFixture('dummy', 'Dummy', SpecificationBagFactory::create()))->with($anotherDummyFixture = new SimpleFixture('another_dummy', 'Dummy', SpecificationBagFactory::create())), new ObjectBag(['dummy' => $expectedObject])); $scope = ['injected' => true]; $context = new GenerationContext(); $context->markIsResolvingFixture('bar'); $decoratedResolverProphecy = $this->prophesize(ChainableValueResolverInterface::class); $decoratedResolverProphecy->resolve($value, $dummyFixture, $set, $scope, $context)->willReturn($expected = new ResolvedValueWithFixtureSet($resolvedFixture = new SimpleFixture('resolved_fixture', 'Dummy', SpecificationBagFactory::create()), ResolvedFixtureSetFactory::create(null, $fixtureBag->with($resolvedFixture)))); /** @var ChainableValueResolverInterface $decoratedResolver */ $decoratedResolver = $decoratedResolverProphecy->reveal(); $resolver = new SelfFixtureReferenceResolver($decoratedResolver); $actual = $resolver->resolve($value, $dummyFixture, $set, $scope, $context); $this->assertEquals($expected, $actual); $valueProphecy->getValue()->shouldHaveBeenCalledTimes(1); $decoratedResolverProphecy->resolve(Argument::cetera())->shouldHaveBeenCalledTimes(1); }
public function testResolvesElementAsManyTimeAsNecessaryIfItIsAValue() { $quantifier = 2; $element = new FakeValue(); $value = new DynamicArrayValue($quantifier, $element); $fixture = new DummyFixture('dummy'); $set = ResolvedFixtureSetFactory::create(); $scope = ['injected' => true]; $context = new GenerationContext(); $context->markIsResolvingFixture('bar'); $decoratedResolverProphecy = $this->prophesize(ValueResolverInterface::class); $setAfterFirstResolution = ResolvedFixtureSetFactory::create(new ParameterBag(['iteration' => 0])); $decoratedResolverProphecy->resolve($element, $fixture, $set, $scope, $context)->willReturn(new ResolvedValueWithFixtureSet(10, $setAfterFirstResolution)); $setAfterSecondResolution = ResolvedFixtureSetFactory::create(new ParameterBag(['iteration' => 1])); $decoratedResolverProphecy->resolve($element, $fixture, $setAfterFirstResolution, $scope, $context)->willReturn(new ResolvedValueWithFixtureSet(100, $setAfterSecondResolution)); /** @var ValueResolverInterface $decoratedResolver */ $decoratedResolver = $decoratedResolverProphecy->reveal(); $resolver = new DynamicArrayValueResolver($decoratedResolver); $result = $resolver->resolve($value, $fixture, $set, $scope, $context); $this->assertSame([10, 100], $result->getValue()); $this->assertEquals($setAfterSecondResolution, $result->getSet()); }
public function testResolvesReferenceBeforeHandingOverTheResolutionToTheDecoratedResolver() { $idValue = new FakeValue(); $value = new FixtureReferenceValue($idValue); $expectedObject = new \stdClass(); $expectedObject->foo = 'bar'; $set = ResolvedFixtureSetFactory::create(null, $fixtureBag = (new FixtureBag())->with($dummyFixture = new SimpleFixture('dummy', 'Dummy', SpecificationBagFactory::create()))->with($anotherDummyFixture = new SimpleFixture('another_dummy', 'Dummy', SpecificationBagFactory::create())), $objectBag = new ObjectBag(['dummy' => $expectedObject])); $scope = ['injected' => true]; $context = new GenerationContext(); $context->markIsResolvingFixture('bar'); $valueResolverProphecy = $this->prophesize(ValueResolverInterface::class); $valueResolverProphecy->resolve($idValue, $dummyFixture, $set, $scope, $context)->willReturn(new ResolvedValueWithFixtureSet('alice', $newSet = ResolvedFixtureSetFactory::create(null, $fixtureBag->with(new SimpleFixture('value_resolver_fixture', 'Dummy', SpecificationBagFactory::create())), $newObjectBag = $objectBag->with(new SimpleObject('value_resolver_fixture', new \stdClass()))))); /** @var ValueResolverInterface $valueResolver */ $valueResolver = $valueResolverProphecy->reveal(); $decoratedResolverProphecy = $this->prophesize(ChainableValueResolverInterface::class); $decoratedResolverProphecy->resolve(new FixtureReferenceValue('alice'), $dummyFixture, $newSet, $scope, $context)->willReturn($expected = new ResolvedValueWithFixtureSet($expectedObject, ResolvedFixtureSetFactory::create(null, $fixtureBag, $newObjectBag->with(new SimpleObject('alice', $expectedObject))))); /** @var ChainableValueResolverInterface $decoratedResolver */ $decoratedResolver = $decoratedResolverProphecy->reveal(); $resolver = new UnresolvedFixtureReferenceIdResolver($decoratedResolver, $valueResolver); $actual = $resolver->resolve($value, $dummyFixture, $set, $scope, $context); $this->assertEquals($expected, $actual); $valueResolverProphecy->resolve(Argument::cetera())->shouldHaveBeenCalledTimes(1); $decoratedResolverProphecy->resolve(Argument::cetera())->shouldHaveBeenCalledTimes(1); }
/** * @param FixtureIdInterface|FixtureInterface $referredFixture * @param string $referredFixtureId * @param ResolvedFixtureSet $fixtureSet * @param GenerationContext $context * * @return ResolvedValueWithFixtureSet */ private function resolveReferredFixture(FixtureIdInterface $referredFixture, string $referredFixtureId, ResolvedFixtureSet $fixtureSet, GenerationContext $context) : ResolvedValueWithFixtureSet { if ($fixtureSet->getObjects()->has($referredFixture)) { $referredObject = $fixtureSet->getObjects()->get($referredFixture); if ($referredObject instanceof CompleteObject || false === $context->needsCompleteGeneration()) { return new ResolvedValueWithFixtureSet($referredObject->getInstance(), $fixtureSet); } } // Object is either not completely generated or has not been generated at all yet if (false === $referredFixture instanceof FixtureInterface) { throw FixtureNotFoundExceptionFactory::create($referredFixtureId); } $context->markIsResolvingFixture($referredFixtureId); $objects = $this->generator->generate($referredFixture, $fixtureSet, $context); $fixtureSet = $fixtureSet->withObjects($objects); return new ResolvedValueWithFixtureSet($fixtureSet->getObjects()->get($referredFixture)->getInstance(), $fixtureSet); }
public function testDoesNotResolveArgumentsIfSpecifiedNoConstructor() { $specs = SpecificationBagFactory::create(); $fixture = new SimpleFixture('dummy', 'stdClass', $specs); $set = ResolvedFixtureSetFactory::create(); $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $expected = ResolvedFixtureSetFactory::create(null, (new FixtureBag())->with($fixture), new ObjectBag(['dummy' => new \stdClass()])); $resolverProphecy = $this->prophesize(ValueResolverInterface::class); $resolverProphecy->resolve(Argument::cetera())->shouldNotBeCalled(); /** @var ValueResolverInterface $resolver */ $resolver = $resolverProphecy->reveal(); $decoratedInstantiatorProphecy = $this->prophesize(InstantiatorInterface::class); $decoratedInstantiatorProphecy->instantiate($fixture, $set, $context)->willReturn($expected); /** @var InstantiatorInterface $decoratedInstantiator */ $decoratedInstantiator = $decoratedInstantiatorProphecy->reveal(); $instantiator = new InstantiatorResolver($decoratedInstantiator, $resolver); $actual = $instantiator->instantiate($fixture, $set, $context); $this->assertSame($expected, $actual); }
public function testThrowsIfLimitForGenerationOfUniqueValuesIsReached() { $uniqueId = 'uniqid'; $realValue = new FakeValue(); $value = new UniqueValue($uniqueId, $realValue); $fixture = new FakeFixture(); $set = ResolvedFixtureSetFactory::create(); $scope = ['scope' => 'epocs']; $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $pool = new UniqueValuesPool(); $pool->add(new UniqueValue($uniqueId, 10)); $pool->add(new UniqueValue($uniqueId, 11)); $decoratedResolverProphecy = $this->prophesize(ValueResolverInterface::class); $decoratedResolverProphecy->resolve($realValue, $fixture, $set, $scope, $context)->willReturn(new ResolvedValueWithFixtureSet(10, $set)); /** @var ValueResolverInterface $decoratedResolver */ $decoratedResolver = $decoratedResolverProphecy->reveal(); $resolver = new UniqueValueResolver($pool, $decoratedResolver); try { $resolver->resolve($value, $fixture, $set, $scope, $context); $this->fail('Expected exception to be thrown.'); } catch (UniqueValueGenerationLimitReachedException $exception) { $decoratedResolverProphecy->resolve(Argument::cetera())->shouldHaveBeenCalledTimes(150); } }
public function testTheMatchingFixtureCanBeFromLoadedFixtures() { $value = FixtureMatchReferenceValue::createWildcardReference('dummy'); $fixture = new DummyFixture('injected_fixture'); $set = ResolvedFixtureSetFactory::create(null, (new FixtureBag())->with(new DummyFixture('dummy'))); $scope = ['foo' => 'bar']; $context = new GenerationContext(); $context->markIsResolvingFixture('foo'); $valueResolverProphecy = $this->prophesize(ValueResolverInterface::class); $valueResolverProphecy->resolve(new FixtureReferenceValue('dummy'), $fixture, $set, $scope, $context)->willReturn($expected = new ResolvedValueWithFixtureSet('dummy', $newSet = ResolvedFixtureSetFactory::create(new ParameterBag(['ping' => 'pong']), (new FixtureBag())->with($fixture)))); /** @var ValueResolverInterface $valueResolver */ $valueResolver = $valueResolverProphecy->reveal(); $resolver = new FixtureWildcardReferenceResolver($valueResolver); $actual = $resolver->resolve($value, $fixture, $set, $scope, $context); $this->assertSame($expected, $actual); }