/** * {@inheritdoc} * * Expected input format : * { * 'attribute': 'maximum_print_size', * 'code': '210_x_1219_mm', * 'sort_order': 2, * 'labels': { * 'de_DE': '210 x 1219 mm', * 'en_US': '210 x 1219 mm', * 'fr_FR': '210 x 1219 mm' * } * } * * @throws BusinessValidationException */ public function update($attributeOption, array $data, array $options = []) { if (!$attributeOption instanceof AttributeOptionInterface) { throw new \InvalidArgumentException(sprintf('Expects a "Pim\\Bundle\\CatalogBundle\\Model\\AttributeOptionInterface", "%s" provided.', ClassUtils::getClass($attributeOption))); } // TODO: ugly fix to workaround issue with "attribute.group.code: This value should not be blank." // in case of existing option, attribute is a proxy, attribute group too, the validated group code is null $attributeOption->getAttribute() !== null ? $attributeOption->getAttribute()->getGroup()->getCode() : null; $isNew = $attributeOption->getId() === null; $readOnlyFields = ['attribute', 'code']; $updateViolations = new ConstraintViolationList(); foreach ($data as $field => $data) { $isReadOnlyField = in_array($field, $readOnlyFields); if ($isNew || !$isReadOnlyField) { try { $this->setData($attributeOption, $field, $data); } catch (\InvalidArgumentException $e) { $setViolation = new ConstraintViolation($e->getMessage(), $e->getMessage(), [], $attributeOption, null, null); $updateViolations->add($setViolation); } } } $validatorViolations = $this->validator->validate($attributeOption); $updateViolations->addAll($validatorViolations); if ($updateViolations->count() > 0) { throw new BusinessValidationException($updateViolations); } return $this; }
/** * Test creation of new object * * @return void */ public function testCreateNewObject() { $objectContent = ['id' => 'one', 'second_id' => 'two']; $object = new EntityConverterEntity(); $object->setIds($objectContent); $badProperties = new ConstraintViolationList(); $badProperties->add(new ConstraintViolation('This is not a valid property of CLASS', 'This is not a valid property of CLASS', array(), null, null, null)); $this->crudTransformer->expects($this->any())->method('arrayToObject')->willReturn($object); $this->crudTransformer->expects($this->any())->method('arrayToObjectPropertyValidation')->willReturn($badProperties); $referenceObject = new CircularReferenceEntity(); $this->entityConverter->expects($this->any())->method('find')->willReturn($referenceObject); /** @var EntityConverterEntity $newObject */ $newObject = $this->entityConverter->createOrUpdateNewObject('\\Ecentria\\Libraries\\EcentriaRestBundle\\Tests\\Entity\\EntityConverterEntity', new Request(array(), array(), array(), array(), array(), array(), json_encode($objectContent)), EntityConverter::MODE_CREATE, array('references' => array('class' => 'CircularReferenceEntity', 'name' => 'CircularReferenceEntity')), false); //test validation and references conversion $this->assertEquals($referenceObject, $newObject->getCircularReferenceEntity()); $this->assertEquals($badProperties, $newObject->getViolations()); $this->assertFalse($newObject->isValid()); $secondIds = array('id' => 'test ONE', 'second_id' => 'test TWO'); /** @var EntityConverterEntity $secondObject */ $secondObject = $this->entityConverter->createOrUpdateNewObject('\\Ecentria\\Libraries\\EcentriaRestBundle\\Tests\\Entity\\EntityConverterEntity', new Request(array(), array(), $secondIds, array(), array(), array(), json_encode($objectContent)), EntityConverter::MODE_RETRIEVE, array(), false); //test set ids $this->assertEquals($secondIds, $secondObject->getIds()); // Testing set Ids for update mode $secondObject = $this->entityConverter->createOrUpdateNewObject('\\Ecentria\\Libraries\\EcentriaRestBundle\\Tests\\Entity\\EntityConverterEntity', new Request(array(), array(), $secondIds, array(), array(), array(), json_encode($objectContent)), EntityConverter::MODE_UPDATE, array(), false); //test set ids $this->assertEquals($secondIds, $secondObject->getIds()); }
public function testViolations() { $errorHandler = $this->getErrorHandler(); $violations = new ConstraintViolationList(); $violations->add($this->createViolation('test')); $errorHandler->violations($violations); }
public function testWalkConstraintBuildsAViolationIfFailed() { $constraint = new ConstraintA(); $this->walker->walkConstraint($constraint, 'foobar', 'Default', 'firstName.path'); $violations = new ConstraintViolationList(); $violations->add(new ConstraintViolation('message', array('param' => 'value'), 'Root', 'firstName.path', 'foobar')); $this->assertEquals($violations, $this->walker->getViolations()); }
public function testWalkConstraintBuildsAViolationIfFailed() { $constraint = new ConstraintA(); $this->interpolator->expects($this->once())->method('interpolate')->with($this->equalTo('message'), $this->equalTo(array('param' => 'value')))->will($this->returnValue('interpolated text')); $this->walker->walkConstraint($constraint, 'foobar', 'Default', 'firstName.path'); $violations = new ConstraintViolationList(); $violations->add(new ConstraintViolation('interpolated text', 'Root', 'firstName.path', 'foobar')); $this->assertEquals($violations, $this->walker->getViolations()); }
function it_validates_an_item_and_the_validation_fails_with_exception(ValidatorInterface $validator, Constraint $constraint, ConstraintViolationList $list) { $list->count()->willReturn(1); $validator->validate($this->item1, Argument::type('Symfony\\Component\\Validator\\Constraints\\Collection'))->willReturn($list); $this->throwExceptions(true); $this->add('key1', $constraint); $this->shouldThrow('Ddeboer\\DataImport\\Exception\\ValidationException')->during__invoke($this->item1); $this->getViolations()->shouldReturn([1 => $list]); }
private function handleConstraintViolationList(ConstraintViolationList $violationList) { $errors = []; for ($i = 0; $i < $violationList->count(); $i++) { $errors['message'] = $violationList[$i]->getMessage(); $errors['field'] = $violationList[$i]->getPropertyPath(); $errors['code'] = $violationList[$i]->getCode(); } return $this->errorProcessor->processErrors($errors); }
public function testExecuteMultipleMethods() { $object = new ExecuteValidatorTest_Object(); $this->assertTrue($this->validator->isValid($object, new Execute(array('validateOne', 'validateTwo')))); $violations = new ConstraintViolationList(); $violations->add(new ConstraintViolation('My message', array('parameter'), 'Root', 'foo.bar', 'invalidValue')); // context was reset $violations->add(new ConstraintViolation('Other message', array('other parameter'), 'Root', 'initial.property.path', 'otherInvalidValue')); $this->assertEquals($violations, $this->context->getViolations()); }
public function testPluralization() { $translator = new IdentityTranslator(); $translator->setLocale('fr'); $service = new I18nResponseFormatBuilder($translator); $violations = new ConstraintViolationList(); $violations->add(new ConstraintViolation('Two apples', '{0}No apples|{1}One apple|]2,Inf]%count% apples', ['%count%' => 1], null, 'property', 'anything', 1)); $result = $service->formatTranslatableViolationList($violations, false, true, ['en']); $this->assertSame('One apple', $result['en'][0]); }
/** * {@inheritdoc} */ public function validate($prices, array $options = [], $attributeCode) { $violations = new ConstraintViolationList(); foreach ($prices as $price) { if (isset($price['data']) && ($valid = parent::validate($price['data'], $options, $attributeCode))) { $violations->addAll($valid); } } return $violations->count() > 0 ? $violations : null; }
public function testProcessWithAllowedExtraFields() { $this->filter->addOption('allowExtraFields', true); $data = ['title' => null, 'telephone' => '0155/555-555']; $this->filter->add('title', $constraint = new Constraints\NotNull()); $list = new ConstraintViolationList(); $list->add($this->buildConstraintViolation()); $this->validator->expects($this->once())->method('validate')->willReturn($list); $this->assertFalse($this->filter->process($data)); $this->assertEquals([1 => $list], $this->filter->getViolations()); }
function it_throws_exception_on_validation_failure(MethodInterface $method, ValidatorInterface $validator, ConstraintViolationList $violations) { $attributes = ['field' => 'value']; $constraints = ['constraints']; $method->getValidationConstraints()->shouldBeCalled()->willReturn($constraints); $method->getAttributes()->shouldBeCalled()->willReturn($attributes); $violations->count()->willReturn(1); $violations->__toString()->willReturn(''); $validator->validate($attributes, $constraints)->willReturn($violations); $this->shouldThrow('Cardinity\\Exception\\InvalidAttributeValue')->duringValidate($method); }
function it_returns_a_constraint_if_the_decimal_separator_is_not_valid($validator) { $constraintUSD = new ConstraintViolation('Error on number validator', '', [], '', '', ''); $constraintEUR = new ConstraintViolation('Error on number validator', '', [], '', '', ''); $constraints = new ConstraintViolationList([$constraintEUR, $constraintUSD]); $validator->validate('10,00', Argument::any())->willReturn($constraints); $validator->validate('10,05', Argument::any())->willReturn(null); $prices = [['data' => '10,00', 'currency' => 'EUR'], ['data' => '10,05', 'currency' => 'USD']]; $allConstraints = new ConstraintViolationList(); $allConstraints->addAll($constraints); $this->validate($prices, ['decimal_separator' => ','], 'prices')->shouldHaveCount(2); }
private function validate($month, array $months) { $errors = new ConstraintViolationList(); if (count($months) == 0) { //TODO check if this is the first month which is terminated => there does not exist a purchase which is done in an earlier month $errors->add(new ConstraintViolation('accounting.previousMonthNotTerminated', 'accounting.previousMonthNotTerminated', ['%prev' => $month - 1, '%current' => $month], $month, 'month', null)); } else { if (count($months) == 2 && !$months[0]->isReopened()) { $errors->add(new ConstraintViolation('accounting.givenMonthAlreadyTerminated', 'accounting.givenMonthAlreadyTerminated', ['%month' => $month], $month, 'month', null)); } } return $errors; }
/** * Get the validation errors * * @param ConstraintViolationList $errors Validator error list * * @return View */ protected function getErrorsView(ConstraintViolationList $errors) { $msgs = array(); $errorIterator = $errors->getIterator(); foreach ($errorIterator as $validationError) { $msg = $validationError->getMessage(); $params = $validationError->getMessageParameters(); $msgs[][] = $this->get('translator')->trans($msg, $params, 'validators'); } $view = View::create($msgs); $view->setStatusCode(400); return $view; }
/** * * @return ConstraintViolationList */ public function getViolations() { $list = new ConstraintViolationList(); $errors = $this->get('errors'); if ($errors !== null) { if ($errors instanceof ConstraintViolationList) { return $errors; } foreach ($errors as $error) { $list->add(new ConstraintViolation($error, '', [], '', '', null)); } } return $list; }
public function testValidate_multipleGroups() { $entity = new Entity(); $metadata = new ClassMetadata(get_class($entity)); $metadata->addPropertyConstraint('firstName', new FailingConstraint(array('groups' => 'First'))); $metadata->addPropertyConstraint('lastName', new FailingConstraint(array('groups' => 'Second'))); $this->factory->addClassMetadata($metadata); // The constraints of both groups failed $violations = new ConstraintViolationList(); $violations->add(new ConstraintViolation('', array(), $entity, 'firstName', '')); $violations->add(new ConstraintViolation('', array(), $entity, 'lastName', '')); $result = $this->validator->validate($entity, array('First', 'Second')); $this->assertEquals($violations, $result); }
function it_throws_an_exception_when_attribute_option_is_not_valid($attributeRepository, $validator, AttributeOptionInterface $attributeOption, AttributeInterface $attribute, AttributeGroupInterface $attributeGroup, AttributeOptionValueInterface $attributeOptionValue) { $attributeOption->getId()->willReturn(null); $attributeOption->getAttribute()->willReturn($attribute); $attribute->getGroup()->willReturn($attributeGroup); $attributeOption->setCode('mycode')->shouldBeCalled(); $attributeRepository->findOneByIdentifier('myattribute')->willReturn(null); $attributeOption->setAttribute($attribute)->shouldNotBeCalled(); $attributeOption->setSortOrder(12)->shouldBeCalled(); $attributeOption->setLocale('de_DE')->shouldBeCalled(); $attributeOption->getTranslation()->willReturn($attributeOptionValue); $attributeOptionValue->setLabel('210 x 1219 mm')->shouldBeCalled(); $violationList = new ConstraintViolationList(); $violationList->add(new ConstraintViolation('', '', [], $attributeOption, null, null)); $validator->validate($attributeOption)->willReturn($violationList); $this->shouldThrow('Pim\\Bundle\\CatalogBundle\\Exception\\BusinessValidationException')->during('update', [$attributeOption, ['code' => 'mycode', 'attribute' => 'myattribute', 'sort_order' => 12, 'labels' => ['de_DE' => '210 x 1219 mm']]]); }
public function testValidateWithErrors() { $violationList = new ConstraintViolationList(); $violation1 = $this->getMockBuilder('Symfony\\Component\\Validator\\ConstraintViolation')->disableOriginalConstructor()->getMock(); $violation1->expects($this->any())->method('getPropertyPath')->will($this->returnValue('from')); $violationList->add($violation1); $violation2 = $this->getMockBuilder('Symfony\\Component\\Validator\\ConstraintViolation')->disableOriginalConstructor()->getMock(); $violation2->expects($this->any())->method('getPropertyPath')->will($this->returnValue('to')); $violationList->add($violation2); $violation3 = $this->getMockBuilder('Symfony\\Component\\Validator\\ConstraintViolation')->disableOriginalConstructor()->getMock(); $violation3->expects($this->any())->method('getPropertyPath')->will($this->returnValue('cc')); $violationList->add($violation3); $this->context->expects($this->any())->method('getViolations')->will($this->returnValue($violationList)); $this->context->expects($this->any())->method('addViolation')->with($this->constraint->message); $this->context->expects($this->any())->method('getPropertyPath')->will($this->returnValue('cc')); $this->getValidator()->validate(['test wrong email 1', 'test wrong email 2'], $this->constraint); }
/** * Checks whether the given value is a valid URL that may probably be safely used as a redirect url. * * @param string $value URL to validate * * @return boolean true if the url is correct */ protected function isValidRedirectUrl($value) { $validator = Validation::createValidator(); $constraints = array(new Constraints\Type(array('type' => 'string')), new Constraints\Length(array('min' => $this->getParameter('min_length', 10), 'max' => $this->getParameter('max_length', 1000))), new Constraints\Url(array('protocols' => $this->getParameter('allowed_protocols', array('http', 'https'))))); if ($this->getParameter('check_base_href', true)) { $constraints[] = new Constraints\Callback(array('methods' => array(array($this, 'hasCorrectBaseHref')))); } $violations = new ConstraintViolationList(); foreach ($constraints as $constraint) { $violations->addAll($validator->validateValue($value, $constraint)); } if ($violations->count() === 0) { return true; } else { $this->getContext()->getLoggerManager()->logTo('default', \AgaviLogger::WARNING, __METHOD__, $violations->__toString()); return false; } }
/** * {@inheritdoc} */ public function addViolation($message, array $parameters = array(), $invalidValue = null, $plural = null, $code = null) { // The parameters $invalidValue and following are ignored by the new // API, as they are not present in the new interface anymore. // You should use buildViolation() instead. if (func_num_args() > 2) { throw new BadMethodCallException('The parameters $invalidValue, $plural and $code are ' . 'not supported anymore as of Symfony 2.5. Please use ' . 'buildViolation() instead or enable the legacy mode.'); } $this->violations->add(new ConstraintViolation($this->translator->trans($message, $parameters, $this->translationDomain), $message, $parameters, $this->root, $this->propertyPath, $this->value, null, null, $this->constraint)); }
/** * {@inheritdoc} */ public function addViolation($message, array $parameters = array(), $invalidValue = NULL, $plural = NULL, $code = NULL) { // The parameters $invalidValue and following are ignored by the new // API, as they are not present in the new interface anymore. // You should use buildViolation() instead. if (func_num_args() > 2) { throw new \LogicException('Legacy validator API is unsupported.'); } $this->violations->add(new ConstraintViolation($this->translator->trans($message, $parameters, $this->translationDomain), $message, $parameters, $this->root, $this->propertyPath, $this->value, NULL, NULL, $this->constraint)); }
/** * {@inheritdoc} */ public function addViolation($message, array $parameters = array(), $invalidValue = null, $plural = null, $code = null) { // The parameters $invalidValue and following are ignored by the new // API, as they are not present in the new interface anymore. // You should use buildViolation() instead. if (func_num_args() > 2) { @trigger_error('The parameters $invalidValue, $plural and $code in method ' . __METHOD__ . ' are deprecated since version 2.5 and will be removed in 3.0. Use the ' . __CLASS__ . '::buildViolation method instead.', E_USER_DEPRECATED); $this->buildViolation($message, $parameters)->setInvalidValue($invalidValue)->setPlural($plural)->setCode($code)->addViolation(); return; } $this->violations->add(new ConstraintViolation($this->translator->trans($message, $parameters, $this->translationDomain), $message, $parameters, $this->root, $this->propertyPath, $this->value, null, null, $this->constraint)); }
/** * {@inheritdoc} */ public function addViolation() { if (null === $this->plural) { $translatedMessage = $this->translator->trans($this->message, $this->parameters, $this->translationDomain); } else { try { $translatedMessage = $this->translator->transChoice($this->message, $this->plural, $this->parameters, $this->translationDomain); } catch (\InvalidArgumentException $e) { $translatedMessage = $this->translator->trans($this->message, $this->parameters, $this->translationDomain); } } $this->violations->add(new ConstraintViolation($translatedMessage, $this->message, $this->parameters, $this->root, $this->propertyPath, $this->invalidValue, $this->plural, $this->code, $this->constraint, $this->cause)); }
/** * {@inheritDoc} */ public function validateObjectByVarTags($object) { if (!is_object($object)) { throw UnexpectedTypeException::create($object, 'object'); } $classMetadata = $this->metadataFactory->loadMetadata(get_class($object)); $constraintViolationList = new ConstraintViolationList(); foreach ($classMetadata->getProperties() as $propertyName => $propertyMetadata) { $availableVarTypes = $propertyMetadata->getTypes(); if (!count($availableVarTypes)) { continue; } $violationListForProperty = $this->validatePropertyValueByTypes($object, $propertyName, $availableVarTypes); if ($violationListForProperty && count($violationListForProperty)) { foreach ($violationListForProperty as $violationForProperty) { // Recreate violation for save property path $violation = new ConstraintViolation($violationForProperty->getMessage(), $violationForProperty->getMessageTemplate(), $violationForProperty->getMessageParameters(), $violationForProperty->getRoot(), $propertyName, $violationForProperty->getInvalidValue(), $violationForProperty->getMessagePluralization(), $violationForProperty->getCode()); $constraintViolationList->add($violation); } } } return $constraintViolationList; }
public function testValidateValue() { $violations = new ConstraintViolationList(); $violations->add(new ConstraintViolation('Failed', 'Failed', array(), 'Bernhard', '', 'Bernhard')); $this->assertEquals($violations, $this->validator->validateValue('Bernhard', new FailingConstraint())); }
/** * Validates the object and all objects related to this table. * * @see getValidationFailures() * @param ValidatorInterface|null $validator A Validator class instance * @return boolean Whether all objects pass validation. */ public function validate(ValidatorInterface $validator = null) { if (null === $validator) { $validator = new RecursiveValidator(new ExecutionContextFactory(new IdentityTranslator()), new LazyLoadingMetadataFactory(new StaticMethodLoader()), new ConstraintValidatorFactory()); } $failureMap = new ConstraintViolationList(); if (!$this->alreadyInValidation) { $this->alreadyInValidation = true; $retval = null; // We call the validate method on the following object(s) if they // were passed to this object by their corresponding set // method. This object relates to these object(s) by a // foreign key reference. // If validate() method exists, the validate-behavior is configured for related object if (method_exists($this->aOwner, 'validate')) { if (!$this->aOwner->validate($validator)) { $failureMap->addAll($this->aOwner->getValidationFailures()); } } $retval = $validator->validate($this); if (count($retval) > 0) { $failureMap->addAll($retval); } if (null !== $this->collPackPermissions) { foreach ($this->collPackPermissions as $referrerFK) { if (method_exists($referrerFK, 'validate')) { if (!$referrerFK->validate($validator)) { $failureMap->addAll($referrerFK->getValidationFailures()); } } } } if (null !== $this->collUserGroups) { foreach ($this->collUserGroups as $referrerFK) { if (method_exists($referrerFK, 'validate')) { if (!$referrerFK->validate($validator)) { $failureMap->addAll($referrerFK->getValidationFailures()); } } } } $this->alreadyInValidation = false; } $this->validationFailures = $failureMap; return (bool) (!(count($this->validationFailures) > 0)); }
public function testConstraintViolationList() { $violations = new ConstraintViolationList(); $violations->add(new ConstraintViolation('Message of violation', "Message of violation", array(), null, 'foo', null)); $violations->add(new ConstraintViolation('Message of another violation', "Message of another violation", array(), null, 'bar', null)); $this->assertEquals($this->getContent('constraint_violation_list'), $this->serialize($violations)); }
/** * Moves the property path to be relative to field level. * * @param string $field_name * The field name. * @param \Symfony\Component\Validator\ConstraintViolationListInterface $violations * The violations. * * @return \Symfony\Component\Validator\ConstraintViolationList * A new constraint violation list with the changed property path. */ protected function movePropertyPathViolationsRelativeToField($field_name, ConstraintViolationListInterface $violations) { $new_violations = new ConstraintViolationList(); foreach ($violations as $violation) { // All the logic below is necessary to change the property path of the // violations to be relative to the item list, so like title.0.value gets // changed to 0.value. Sadly constraints in Symfony don't have setters so // we have to create new objects. /** @var \Symfony\Component\Validator\ConstraintViolationInterface $violation */ // Create a new violation object with just a different property path. $violation_path = $violation->getPropertyPath(); $path_parts = explode('.', $violation_path); if ($path_parts[0] === $field_name) { unset($path_parts[0]); } $new_path = implode('.', $path_parts); $constraint = NULL; $cause = NULL; $parameters = []; $plural = NULL; if ($violation instanceof ConstraintViolation) { $constraint = $violation->getConstraint(); $cause = $violation->getCause(); $parameters = $violation->getParameters(); $plural = $violation->getPlural(); } $new_violation = new ConstraintViolation($violation->getMessage(), $violation->getMessageTemplate(), $parameters, $violation->getRoot(), $new_path, $violation->getInvalidValue(), $plural, $violation->getCode(), $constraint, $cause); $new_violations->add($new_violation); } return $new_violations; }
/** * {@inheritdoc} */ public function validateContexts() { $violations = new ConstraintViolationList(); // @todo: Implement symfony validator API to let the validator traverse // and set property paths accordingly. foreach ($this->getContexts() as $context) { $violations->addAll($context->validate()); } return $violations; }