public function testGenerateObjects()
{
$loadedParameters = new ParameterBag(['loaded' => true]);
$injectedParameters = new ParameterBag(['injected' => true]);
$fixture = new DummyFixture('dummy');
$fixtures = (new FixtureBag())->with($fixture);
$objects = new ObjectBag(['std' => new \stdClass()]);
$set = new FixtureSet($loadedParameters, $injectedParameters, $fixtures, $objects);
$resolvedParameters = $injectedParameters->with(new Parameter('loaded', true));
$resolvedSet = new ResolvedFixtureSet($resolvedParameters, $fixtures, $objects);
$resolverProphecy = $this->prophesize(FixtureSetResolverInterface::class);
$resolverProphecy->resolve($set)->willReturn($resolvedSet);
/** @var FixtureSetResolverInterface $resolver */
$resolver = $resolverProphecy->reveal();
$context = new GenerationContext();
$objectGeneratorProphecy = $this->prophesize(ObjectGeneratorInterface::class);
$objectGeneratorProphecy->generate($fixture, $resolvedSet, $context)->willReturn($objectsAfterFirstPass = $objects->with(new SimpleObject('foo', StdClassFactory::create(['pass' => 'first']))));
$contextAfterFirstPass = clone $context;
$contextAfterFirstPass->setToSecondPass();
$objectGeneratorProphecy->generate($fixture, new ResolvedFixtureSet($resolvedSet->getParameters(), $resolvedSet->getFixtures(), $objectsAfterFirstPass), $contextAfterFirstPass)->willReturn($objectsAfterFirstPass = $objects->with(new SimpleObject('foo', StdClassFactory::create(['pass' => 'second']))));
/** @var ObjectGeneratorInterface $objectGenerator */
$objectGenerator = $objectGeneratorProphecy->reveal();
$expected = new ObjectSet($resolvedParameters, $objects->with(new SimpleObject('foo', StdClassFactory::create(['pass' => 'second']))));
$generator = new DoublePassGenerator($resolver, $objectGenerator);
$actual = $generator->generate($set);
$this->assertEquals($expected, $actual);
$resolverProphecy->resolve(Argument::any())->shouldHaveBeenCalledTimes(1);
$objectGeneratorProphecy->generate(Argument::cetera())->shouldHaveBeenCalledTimes(2);
}
/**
* @inheritdoc
*/
public function resolve(ParameterBag $unresolvedParameters, ParameterBag $injectedParameters = null) : ParameterBag
{
if (null === $injectedParameters) {
$injectedParameters = new ParameterBag();
}
foreach ($injectedParameters as $injectedParameterKey => $injectedParameterValue) {
if ($unresolvedParameters->has($injectedParameterKey)) {
$injectedParameters = $injectedParameters->without($injectedParameterKey);
}
}
return $this->resolver->resolve($unresolvedParameters, $injectedParameters);
}
/**
* @param ParameterResolverInterface $resolver
* @param Parameter $parameter Parameter being resolved
* @param string $key Key of the parameter that need to be resolved to resolve $parameter
* @param ParameterBag $unresolvedParameters
* @param ParameterBag $resolvedParameters
* @param ResolvingContext $context
*
* @return ParameterBag
*/
private function resolveStringKey(ParameterResolverInterface $resolver = null, Parameter $parameter, string $key, ParameterBag $unresolvedParameters, ParameterBag $resolvedParameters, ResolvingContext $context) : ParameterBag
{
if ($resolvedParameters->has($key)) {
return $resolvedParameters;
}
if (false === $unresolvedParameters->has($key)) {
throw ParameterNotFoundExceptionFactory::createForWhenResolvingParameter($key, $parameter);
}
$context->checkForCircularReference($key);
$context->add($key);
if (null === $resolver) {
throw ResolverNotFoundExceptionFactory::createUnexpectedCall(__METHOD__);
}
return $resolver->resolve(new Parameter($key, $unresolvedParameters->get($key)), $unresolvedParameters, $resolvedParameters, $context);
}
/**
* Resolves a parameter two times and if a different result is obtained will resolve the parameter again until two
* successive resolution give the same result.
*
* {@inheritdoc}
*
* @param Parameter $parameter
*
* @throws RecursionLimitReachedException
*/
public function resolve(Parameter $parameter, ParameterBag $unresolvedParameters, ParameterBag $resolvedParameters, ResolvingContext $context = null, ParameterBag $previousResult = null, int $counter = 1) : ParameterBag
{
if (null === $previousResult) {
$result = $this->resolver->resolve($parameter, $unresolvedParameters, $resolvedParameters, $context);
return $this->resolve($parameter, $unresolvedParameters, $resolvedParameters, $context, $result);
}
$parameterKey = $parameter->getKey();
$previousParameterValue = $previousResult->get($parameterKey);
$counter = $this->incrementCounter($counter, $this->limit, $parameterKey);
$newResult = $this->resolver->resolve($parameter->withValue($previousParameterValue), $unresolvedParameters, $resolvedParameters, $context);
$newParameterValue = $newResult->get($parameterKey);
$result = $this->mergeResults($previousResult, $newResult);
if ($previousParameterValue === $newParameterValue) {
return $result;
}
return $this->resolve($parameter, $unresolvedParameters, $resolvedParameters, $context, $result, $counter);
}
/**
* {@inheritdoc}
*
* @param bool|int|float $parameter
*/
public function resolve(Parameter $parameter, ParameterBag $unresolvedParameters, ParameterBag $resolvedParameters) : ParameterBag
{
return $resolvedParameters->with($parameter);
}