/** * @param TemplatingFixture $fixture * @param FixtureReference[] $extendedFixtureReferences * @param FixtureBag $unresolvedFixtures * @param TemplatingFixtureBag $resolvedFixtures * @param ResolvingContext $context * * @throws FixtureNotFoundException * * @return array The first element is a FixtureBag with all the extended fixtures and the second is a * TemplatingFixtureBag which may contain new fixtures (from the resolution) */ private function resolveExtendedFixtures(TemplatingFixture $fixture, array $extendedFixtureReferences, FixtureBag $unresolvedFixtures, TemplatingFixtureBag $resolvedFixtures, ResolvingContext $context) : array { $fixtures = new FixtureBag(); foreach ($extendedFixtureReferences as $reference) { $fixtureId = $reference->getId(); $context->add($fixtureId); if (false === $unresolvedFixtures->has($fixtureId)) { throw FixtureNotFoundExceptionFactory::create($fixtureId); } if ($resolvedFixtures->has($fixtureId)) { if (false === $resolvedFixtures->hasTemplate($fixtureId)) { throw InvalidArgumentExceptionFactory::createForFixtureExtendingANonTemplateFixture($fixture, $fixtureId); } $fixtures = $fixtures->with($resolvedFixtures->getTemplate($fixtureId)); continue; } $unresolvedFixture = $unresolvedFixtures->get($fixtureId); if (false === $unresolvedFixture instanceof TemplatingFixture) { throw InvalidArgumentExceptionFactory::createForFixtureExtendingANonTemplateFixture($fixture, $fixtureId); } $resolvedFixtures = $this->resolve($unresolvedFixtures->get($fixtureId), $unresolvedFixtures, $resolvedFixtures, $context); $fixtures = $fixtures->with($resolvedFixtures->get($fixtureId)); } return [$fixtures, $resolvedFixtures]; }
/** * @inheritdoc */ public function process(ParserInterface $parser, string $file, array $data) : array { if (false === array_key_exists('include', $data)) { throw InvalidArgumentExceptionFactory::createForNoIncludeStatementInData($file); } $include = $data['include']; unset($data['include']); if (null === $include) { return $data; } if (false === is_array($include)) { throw TypeErrorFactory::createForInvalidIncludeStatementInData($include, $file); } foreach ($include as $includeFile) { if (false === is_string($includeFile)) { throw TypeErrorFactory::createForInvalidIncludedFilesInData($includeFile, $file); } if (0 === strlen($includeFile)) { throw InvalidArgumentExceptionFactory::createForEmptyIncludedFileInData($file); } $filePathToInclude = $this->fileLocator->locate($includeFile, dirname($file)); $fileToIncludeData = $parser->parse($filePathToInclude); if (array_key_exists('include', $fileToIncludeData)) { $fileToIncludeData = $this->process($parser, $file, $fileToIncludeData); } $data = $this->dataMerger->mergeInclude($data, $fileToIncludeData); } return $data; }
/** * @param int $percentage Element of ]0;100[. */ public function __construct(int $percentage) { if ($percentage < 0 || $percentage > 100) { throw InvalidArgumentExceptionFactory::createForInvalidOptionalFlagBoundaries($percentage); } $this->percentage = $percentage; }
public function __construct(string $type) { if (false === array_key_exists($type, self::$values)) { throw InvalidArgumentExceptionFactory::createForInvalidExpressionLanguageTokenType($type); } $this->value = $type; }
private function isIdentical($val1, $val2) : bool { if (gettype($val1) !== gettype($val2)) { return false; } if (is_object($val1)) { return $val1 == $val2; } if (is_scalar($val1) || null === $val1) { return $val1 === $val2; } if (false === is_array($val1)) { throw InvalidArgumentExceptionFactory::createForUnsupportedTypeForIdenticalValuesCheck($val1); } foreach ($val1 as $key => $item) { if (is_string($key)) { if (false === $this->isIdentical($item, $val2[$key])) { return false; } continue; } if (false === $this->arrayHasValue($item, $val2)) { return false; } } return true; }
public function __construct(ChainableParameterResolverInterface $resolver, int $limit = 5) { $this->resolver = $resolver; if (2 >= $limit) { throw InvalidArgumentExceptionFactory::createForInvalidLimitValueForRecursiveCalls($limit); } $this->limit = $limit; }
/** * @param string $id Unique across a fixture set, is used to generate unique values. * @param mixed $value */ public function __construct(string $id, $value) { $this->id = $id; if ($value instanceof self) { throw InvalidArgumentExceptionFactory::createForRedundantUniqueValue($id); } $this->value = deep_clone($value); }
public function __construct(FixtureInterface $fixture, FlagBag $flags) { if ($fixture->getId() !== $flags->getKey()) { throw InvalidArgumentExceptionFactory::createForFlagBagKeyMismatch($fixture, $flags); } $this->fixture = clone $fixture; $this->flags = $flags; }
private function createPositiveIntegerValidatorClosure() : \Closure { return function ($value) { if (is_int($value) && 0 < $value) { return $value; } throw InvalidArgumentExceptionFactory::createForExpectedConfigurationPositiveIntegerValue($value); }; }
public function __construct(UniqueValuesPool $pool, ValueResolverInterface $resolver = null, int $limit = 150) { $this->pool = $pool; $this->resolver = $resolver; if ($limit < 1) { throw InvalidArgumentExceptionFactory::createForInvalidLimitValue($limit); } $this->limit = $limit; }
/** * {@inheritDoc} * * @param string $file Local PHP file */ public function parse(string $file) : array { if (false === file_exists($file)) { throw InvalidArgumentExceptionFactory::createForFileCouldNotBeFound($file); } $data = (include $file); if (false === is_array($data)) { throw TypeErrorFactory::createForInvalidFixtureFileReturnedData($file); } return $data; }
private function getGenerator(GeneratorFactory $factory, string $formatter) { $explodedFormatter = explode(':', $formatter); $size = count($explodedFormatter); if (1 === $size) { return [$factory->getSeedGenerator(), $explodedFormatter[0]]; } if (2 === $size) { return [$factory->createOrReturnExistingInstance($explodedFormatter[0]), $explodedFormatter[1]]; } throw InvalidArgumentExceptionFactory::createForInvalidFakerFormatter($formatter); }
/** * {@inheritdoc} * * @throws LexException */ public function lex(string $value) : array { foreach (self::PATTERNS as $pattern => $tokenTypeConstant) { if (1 === preg_match($pattern, $value, $matches)) { if (null === $tokenTypeConstant) { throw InvalidArgumentExceptionFactory::createForInvalidExpressionLanguageToken($value); } return [new Token($matches[0], new TokenType($tokenTypeConstant))]; } } return $this->lexer->lex($value); }
/** * @param string|ValueInterface $reference e.g. "user0" */ public function __construct($reference) { if (false === is_string($reference) && false === $reference instanceof ValueInterface) { if (null === $reference) { $referenceString = 'null'; } elseif (is_array($reference)) { $referenceString = 'array'; } else { $referenceString = is_scalar($reference) ? gettype($reference) : get_class($reference); } throw InvalidArgumentExceptionFactory::createForInvalidReferenceType($referenceString); } $this->reference = $reference; }
/** * @param FixtureInterface $scope * @param string $method * * @return array The first element is a ServiceReferenceInterface ($caller) and the second a string ($method) */ private function getCallerReference(FixtureInterface $scope, string $method) : array { if (false === strpos($method, '::')) { return [new StaticReference($scope->getClassName()), $method]; } $explodedMethod = explode('::', $method); if (2 < count($explodedMethod)) { throw InvalidArgumentExceptionFactory::createForInvalidConstructorMethod($method); } list($caller, $method) = $explodedMethod; if (0 === strpos($caller, '@')) { return [new InstantiatedReference(substr($caller, 1)), $method]; } return [new StaticReference($caller), $method]; }
public function __construct(array $objects = []) { foreach ($objects as $id => $object) { if ($object instanceof ObjectInterface) { if ($id !== $object->getId()) { throw InvalidArgumentExceptionFactory::createForReferenceKeyMismatch($id, $object->getId()); } $this->objects[$id] = $object; $this->array[$id] = $object->getInstance(); continue; } $this->objects[$id] = new CompleteObject(new SimpleObject($id, $object)); $this->array[$id] = $object; } }
/** * {@inheritDoc} * * @param string $file Local YAML file * * @throws ParseException */ public function parse(string $file) : array { if (false === file_exists($file)) { throw InvalidArgumentExceptionFactory::createForFileCouldNotBeFound($file); } try { $data = $this->yamlParser->parse(file_get_contents($file)); // $data is null only if the YAML file was empty; otherwise an exception is thrown return null === $data ? [] : $data; } catch (\Exception $exception) { if ($exception instanceof SymfonyParseException) { throw ParseExceptionFactory::createForInvalidYaml($file, 0, $exception); } throw ParseExceptionFactory::createForUnparsableFile($file, 0, $exception); } }
/** * @param LexerInterface $referenceLexer * @param string $valueFragment * * @throws LexException * * @return Token[] */ private function lexFragment(LexerInterface $referenceLexer, string $valueFragment) : array { foreach (self::PATTERNS as $pattern => $tokenTypeConstant) { if (1 === preg_match($pattern, $valueFragment, $matches)) { if (null === $tokenTypeConstant) { throw InvalidArgumentExceptionFactory::createForInvalidExpressionLanguageToken($valueFragment); } $match = $matches[1]; if (self::REFERENCE_LEXER === $tokenTypeConstant) { return $referenceLexer->lex($match); } return [new Token($match, new TokenType($tokenTypeConstant))]; } } throw ExpressionLanguageExceptionFactory::createForCouldNotLexValue($valueFragment); }
/** * @inheritdoc */ public function parse(string $file) : array { try { $realPath = $this->fileLocator->locate($file); } catch (FileNotFoundException $exception) { throw InvalidArgumentExceptionFactory::createForFileCouldNotBeFound($file, 0, $exception); } if (array_key_exists($realPath, $this->cache)) { return $this->cache[$realPath]; } $data = $this->parser->parse($realPath); if (array_key_exists('include', $data)) { $data = $this->includeProcessor->process($this, $file, $data); } $this->cache[$realPath] = $data; return $data; }
/** * {@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); }
public function testTestCreateForInvalidOptionalFlagBoundaries() { $exception = InvalidArgumentExceptionFactory::createForInvalidOptionalFlagBoundaries(200); $this->assertEquals('Expected optional flag to be an integer element of [0;100]. Got "200" instead.', $exception->getMessage()); $this->assertEquals(0, $exception->getCode()); $this->assertNull($exception->getPrevious()); }