/** * @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)); }
/** * {@inheritdoc} * * @param FunctionCallValue $value */ public function resolve(ValueInterface $value, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, array $scope, GenerationContext $context) : ResolvedValueWithFixtureSet { $functionName = $value->getName(); if (false === function_exists($functionName) || array_key_exists($functionName, $this->functionBlacklist)) { return $this->resolver->resolve($value, $fixture, $fixtureSet, $scope, $context); } $arguments = $value->getArguments(); return new ResolvedValueWithFixtureSet($functionName(...$arguments), $fixtureSet); }
/** * {@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); }
/** * {@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); }
private function generateValue(UniqueValue $value, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, array $scope, GenerationContext $context) : array { $realValue = $value->getValue(); if ($realValue instanceof ValueInterface) { $result = $this->resolver->resolve($value->getValue(), $fixture, $fixtureSet, $scope, $context); return [$value->withValue($result->getValue()), $result->getSet()]; } return [$value, $fixtureSet]; }
/** * {@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); }
/** * {@inheritdoc} * * @param DynamicArrayValue $value */ public function resolve(ValueInterface $value, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, array $scope, GenerationContext $context) : ResolvedValueWithFixtureSet { $this->checkResolver(__METHOD__); $quantifier = $value->getQuantifier(); if ($quantifier instanceof ValueInterface) { $result = $this->resolver->resolve($quantifier, $fixture, $fixtureSet, $scope, $context); list($quantifier, $fixtureSet) = [$result->getValue(), $result->getSet()]; } if ($quantifier < 0) { throw InvalidArgumentExceptionFactory::createForInvalidDynamicArrayQuantifier($fixture, $quantifier); } $element = $value->getElement(); if (false === $element instanceof ValueInterface) { $array = array_fill(0, $quantifier, $element); return new ResolvedValueWithFixtureSet($array, $fixtureSet); } $array = []; for ($i = 0; $i < $quantifier; $i++) { $result = $this->resolver->resolve($element, $fixture, $fixtureSet, $scope, $context); $array[] = $result->getValue(); $fixtureSet = $result->getSet(); } return new ResolvedValueWithFixtureSet($array, $fixtureSet); }
/** * @param array $arguments * @param ValueResolverInterface $resolver * @param FixtureInterface $fixture * @param ResolvedFixtureSet $fixtureSet * @param GenerationContext $context * * @throws UnresolvableValueDuringGenerationException * * @return array The first element is an array ($arguments) which is the resolved arguments and the second the new * ResolvedFixtureSet which may contains new fixtures (from the arguments resolution) */ private function resolveArguments(array $arguments, ValueResolverInterface $resolver, FixtureInterface $fixture, ResolvedFixtureSet $fixtureSet, GenerationContext $context) : array { foreach ($arguments as $index => $argument) { if ($argument instanceof ValueInterface) { try { $result = $resolver->resolve($argument, $fixture, $fixtureSet, [], $context); } catch (ResolutionThrowable $throwable) { throw UnresolvableValueDuringGenerationExceptionFactory::createFromResolutionThrowable($throwable); } $fixtureSet = $result->getSet(); $arguments[$index] = $result->getValue(); } } return [$arguments, $fixtureSet]; }
/** * @throws UnresolvableValueException */ private function getReferredFixtureId(ValueResolverInterface $resolver, ValueInterface $value, FixtureInterface $fixture, ResolvedFixtureSet $set, array $scope, GenerationContext $context) : array { $referredFixtureId = $value->getValue(); if ($referredFixtureId instanceof ValueInterface) { $resolvedSet = $resolver->resolve($referredFixtureId, $fixture, $set, $scope, $context); list($referredFixtureId, $set) = [$resolvedSet->getValue(), $resolvedSet->getSet()]; if (false === is_string($referredFixtureId)) { throw UnresolvableValueExceptionFactory::createForInvalidReferenceId($value, $referredFixtureId); } } return [$referredFixtureId, $set]; }