/** * @inheritdoc */ public function hydrate(ObjectInterface $object, ResolvedFixtureSet $fixtureSet, GenerationContext $context) : ResolvedFixtureSet { if (null === $this->resolver) { throw ResolverNotFoundExceptionFactory::createUnexpectedCall(__METHOD__); } $fixture = $fixtureSet->getFixtures()->get($object->getId()); $properties = $fixture->getSpecs()->getProperties(); $scope = ['_instances' => $fixtureSet->getObjects()->toArray()]; foreach ($properties as $property) { /** @var Property $property */ $propertyValue = $property->getValue(); if ($propertyValue instanceof ValueInterface) { try { $result = $this->resolver->resolve($propertyValue, $fixture, $fixtureSet, $scope, $context); } catch (ResolutionThrowable $throwable) { throw UnresolvableValueDuringGenerationExceptionFactory::createFromResolutionThrowable($throwable); } list($propertyValue, $fixtureSet) = [$result->getValue(), $result->getSet()]; $property = $property->withValue($propertyValue); } $scope[$property->getName()] = $propertyValue; $object = $this->hydrator->hydrate($object, $property, $context); } return $fixtureSet->withObjects($fixtureSet->getObjects()->with($object)); }
public function testTestCreateNewExceptionWithFactoryForUnexpectedCall() { $exception = ResolverNotFoundExceptionFactory::createUnexpectedCall('fake'); $this->assertEquals('Expected method "fake" to be called only if it has a resolver.', $exception->getMessage()); $this->assertEquals(0, $exception->getCode()); $this->assertNull($exception->getPrevious()); }
/** * {@inheritdoc} * * @param FixtureReferenceValue $value * * @throws UnresolvableValueException */ public function resolve(ValueInterface $value, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, array $scope, GenerationContext $context) : ResolvedValueWithFixtureSet { if (null === $this->resolver) { throw ResolverNotFoundExceptionFactory::createUnexpectedCall(__METHOD__); } list($referredFixtureId, $fixtureSet) = $this->getReferredFixtureId($this->resolver, $value, $fixture, $fixtureSet, $scope, $context); return $this->decoratedResolver->resolve(new FixtureReferenceValue($referredFixtureId), $fixture, $fixtureSet, $scope, $context); }
/** * {@inheritdoc} * * @throws ResolverNotFoundException */ public function resolve(ValueInterface $value, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, array $scope, GenerationContext $context) : ResolvedValueWithFixtureSet { foreach ($this->resolvers as $resolver) { if ($resolver->canResolve($value)) { return $resolver->resolve($value, $fixture, $fixtureSet, $scope, $context); } } throw ResolverNotFoundExceptionFactory::createForValue($value); }
/** * @inheritdoc */ public function resolve(Parameter $parameter, ParameterBag $unresolvedParameters, ParameterBag $injectedParameters, ResolvingContext $context = null) : ParameterBag { foreach ($this->resolvers as $resolver) { if ($resolver->canResolve($parameter)) { return $resolver->resolve($parameter, $unresolvedParameters, $injectedParameters, $context); } } throw ResolverNotFoundExceptionFactory::createForParameter($parameter->getKey()); }
/** * {@inheritdoc} * * @param FixtureMatchReferenceValue $value * * @throws UnresolvableValueException */ public function resolve(ValueInterface $value, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, array $scope, GenerationContext $context) : ResolvedValueWithFixtureSet { if (null === $this->resolver) { throw ResolverNotFoundExceptionFactory::createUnexpectedCall(__METHOD__); } $possibleIds = $this->getSuitableIds($value, $fixtureSet); $id = Base::randomElement($possibleIds); if (null === $id) { throw UnresolvableValueExceptionFactory::createForNoFixtureOrObjectMatchingThePattern($value); } return $this->resolver->resolve(new FixtureReferenceValue($id), $fixture, $fixtureSet, $scope, $context); }
/** * @param FixtureInterface $fixture * @param ResolvedFixtureSet $set * @param GenerationContext $context * * @throws UnresolvableValueDuringGenerationException * * @return array */ private function resolveFixtureConstructor(FixtureInterface $fixture, ResolvedFixtureSet $set, GenerationContext $context) : array { $specs = $fixture->getSpecs(); $constructor = $specs->getConstructor(); if (null === $constructor || $constructor instanceof NoMethodCall) { return [$fixture, $set]; } if (null === $this->valueResolver) { throw ResolverNotFoundExceptionFactory::createUnexpectedCall(__METHOD__); } list($resolvedArguments, $set) = $this->resolveArguments($constructor->getArguments(), $this->valueResolver, $fixture, $set, $context); return [$fixture->withSpecs($specs->withConstructor($constructor->withArguments($resolvedArguments))), $set]; }
/** * {@inheritdoc} * * @param ListValue $list */ public function resolve(ValueInterface $list, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, array $scope, GenerationContext $context) : ResolvedValueWithFixtureSet { if (null === $this->resolver) { throw ResolverNotFoundExceptionFactory::createUnexpectedCall(__METHOD__); } $values = $list->getValue(); foreach ($values as $index => $value) { if ($value instanceof ValueInterface) { $resolvedSet = $this->resolver->resolve($value, $fixture, $fixtureSet, $scope, $context); $values[$index] = $resolvedSet->getValue(); $fixtureSet = $resolvedSet->getSet(); } } return new ResolvedValueWithFixtureSet(implode('', $values), $fixtureSet); }
/** * {@inheritdoc} * * @param FunctionCallValue $value */ public function resolve(ValueInterface $value, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, array $scope, GenerationContext $context) : ResolvedValueWithFixtureSet { if (null === $this->argumentResolver) { throw ResolverNotFoundExceptionFactory::createUnexpectedCall(__METHOD__); } $arguments = $value->getArguments(); foreach ($arguments as $index => $argument) { if ($argument instanceof ValueInterface) { $resolvedSet = $this->argumentResolver->resolve($argument, $fixture, $fixtureSet, $scope, $context); $arguments[$index] = $resolvedSet->getValue(); $fixtureSet = $resolvedSet->getSet(); } } return $this->resolver->resolve(new FunctionCallValue($value->getName(), $arguments), $fixture, $fixtureSet, $scope, $context); }
/** * @inheritdoc */ public function resolve(Parameter $unresolvedArrayParameter, ParameterBag $unresolvedParameters, ParameterBag $resolvedParameters, ResolvingContext $context = null) : ParameterBag { if (null === $this->resolver) { throw ResolverNotFoundExceptionFactory::createUnexpectedCall(__METHOD__); } $context = ResolvingContext::createFrom($context, $unresolvedArrayParameter->getKey()); $resolvedArray = []; /* @var array $unresolvedArray */ $unresolvedArray = $unresolvedArrayParameter->getValue(); foreach ($unresolvedArray as $index => $unresolvedValue) { // Iterate over all the values of the array to resolve each of them $resolvedParameters = $this->resolver->resolve(new Parameter((string) $index, $unresolvedValue), $unresolvedParameters, $resolvedParameters, $context); $resolvedArray[$index] = $resolvedParameters->get((string) $index); $resolvedParameters = $resolvedParameters->without((string) $index); } $resolvedParameters = $resolvedParameters->with($unresolvedArrayParameter->withValue($resolvedArray)); return $resolvedParameters; }
/** * {@inheritdoc} * * @param FixturePropertyValue $value * * @throws NoSuchPropertyException * @throws UnresolvableValueException */ public function resolve(ValueInterface $value, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, array $scope, GenerationContext $context) : ResolvedValueWithFixtureSet { if (null === $this->resolver) { throw ResolverNotFoundExceptionFactory::createUnexpectedCall(__METHOD__); } $context->markAsNeedsCompleteGeneration(); $fixtureReferenceResult = $this->resolver->resolve($value->getReference(), $fixture, $fixtureSet, $scope, $context); $context->unmarkAsNeedsCompleteGeneration(); /** @var ResolvedFixtureSet $fixtureSet */ list($instance, $fixtureSet) = [$fixtureReferenceResult->getValue(), $fixtureReferenceResult->getSet()]; try { $propertyValue = $this->propertyAccessor->getValue($instance, $value->getProperty()); } catch (SymfonyNoSuchPropertyException $exception) { throw NoSuchPropertyExceptionFactory::createForFixture($fixture, $value, 0, $exception); } catch (\Exception $exception) { throw UnresolvableValueExceptionFactory::create($value, 0, $exception); } return new ResolvedValueWithFixtureSet($propertyValue, $fixtureSet); }
/** * {@inheritdoc} * * @param OptionalValue $value * * @throws UnresolvableValueException */ public function resolve(ValueInterface $value, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, array $scope, GenerationContext $context) : ResolvedValueWithFixtureSet { if (null === $this->resolver) { throw ResolverNotFoundExceptionFactory::createUnexpectedCall(__METHOD__); } $quantifier = $value->getQuantifier(); if ($quantifier instanceof ValueInterface) { $resolvedSet = $this->resolver->resolve($quantifier, $fixture, $fixtureSet, $scope, $context); list($quantifier, $fixtureSet) = [$resolvedSet->getValue(), $resolvedSet->getSet()]; if (false === is_int($quantifier) && false === is_string($quantifier)) { throw UnresolvableValueExceptionFactory::createForInvalidResolvedQuantifierTypeForOptionalValue($value, $quantifier); } } $realValue = mt_rand(0, 100) <= $quantifier ? $value->getFirstMember() : $value->getSecondMember(); if ($realValue instanceof ValueInterface) { return $this->resolver->resolve($realValue, $fixture, $fixtureSet, $scope, $context); } return new ResolvedValueWithFixtureSet($realValue, $fixtureSet); }
/** * @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); }
private function checkResolver(string $checkedMethod) { if (null === $this->resolver) { throw ResolverNotFoundExceptionFactory::createUnexpectedCall($checkedMethod); } }