public function build() { $this->setObjectManager($this->createEntityManager()); $this->serializerBuilder = BreezeSerializerBuilder::create($this->getObjectManager()); $this->validatorBuilder = new ValidatorBuilder(); if ($this->annotationsEnabled) { $this->validatorBuilder->enableAnnotationMapping(); } foreach ($this->mappings as $mapping) { if (isset($mapping['serializer'])) { $this->serializerBuilder->addMetadataDir($mapping['serializer']); } if (isset($mapping['validation'])) { if ($mapping['type'] == 'xml') { $this->validatorBuilder->addXmlMapping($mapping['validation']); } else { if ($mapping['type'] == 'yaml') { $this->validatorBuilder->addYamlMapping($mapping['validation']); } } // else if ($mapping['type'] == 'annotation') { // $this->validatorBuilder->enableAnnotationMapping(); // } } } $serializer = $this->serializerBuilder->build(); $this->setSerializer($serializer); $validator = $this->validatorBuilder->getValidator(); $this->setValidator($validator); }
protected function setUp() { $entities = array(new EntityCategory(1, 'category name 1'), new EntityCategory(2, 'category name 2')); $configuration = $this->getMock('Doctrine\\ORM\\Configuration'); $objectManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock(); $objectManager->expects($this->any())->method('getConfiguration')->will($this->returnValue($configuration)); $objectManager->expects($this->any())->method('getExpressionBuilder')->will($this->returnValue(new Expr())); $query = $this->getMock('Doctrine\\ORM\\AbstractQuery', array('execute', '_doExecute', 'getSql', 'setFirstResult', 'setMaxResults'), array($objectManager)); $query->expects($this->any())->method('execute')->will($this->returnValue($entities)); $query->expects($this->any())->method('setFirstResult')->will($this->returnValue($query)); $query->expects($this->any())->method('setMaxResults')->will($this->returnValue($query)); $objectManager->expects($this->any())->method('createQuery')->withAnyParameters()->will($this->returnValue($query)); $queryBuilder = new QueryBuilder($objectManager); $entityClass = 'FSi\\Bundle\\DataGridBundle\\Tests\\Fixtures\\EntityCategory'; $classMetadata = new ClassMetadata($entityClass); $classMetadata->identifier = array('id'); $classMetadata->fieldMappings = array('id' => array('fieldName' => 'id', 'type' => 'integer')); $classMetadata->reflFields = array('id' => new \ReflectionProperty($entityClass, 'id')); $repository = $this->getMock('Doctrine\\ORM\\EntityRepository', array(), array($objectManager, $classMetadata)); $repository->expects($this->any())->method('createQueryBuilder')->withAnyParameters()->will($this->returnValue($queryBuilder)); $repository->expects($this->any())->method('findAll')->will($this->returnValue($entities)); $objectManager->expects($this->any())->method('getClassMetadata')->withAnyParameters()->will($this->returnValue($classMetadata)); $objectManager->expects($this->any())->method('getRepository')->will($this->returnValue($repository)); $objectManager->expects($this->any())->method('contains')->will($this->returnValue(true)); $managerRegistry = $this->getMock('Doctrine\\Common\\Persistence\\ManagerRegistry'); $managerRegistry->expects($this->any())->method('getManagerForClass')->will($this->returnValue($objectManager)); $managerRegistry->expects($this->any())->method('getManagers')->will($this->returnValue(array())); $validatorBuilder = new ValidatorBuilder(); $resolvedTypeFactory = new ResolvedFormTypeFactory(); $formRegistry = new FormRegistry(array(new CoreExtension(), new DoctrineOrmExtension($managerRegistry), new CsrfExtension(new CsrfTokenManager()), new ValidatorExtension($validatorBuilder->getValidator())), $resolvedTypeFactory); $formFactory = new FormFactory($formRegistry, $resolvedTypeFactory); $this->dataGrid = $this->getMock('FSi\\Component\\DataGrid\\DataGridInterface'); $this->dataGrid->expects($this->any())->method('getName')->will($this->returnValue('grid')); $this->extension = new FormExtension($formFactory); }
public function setUp() { $validatorBuilder = new ValidatorBuilder(); $validatorBuilder->enableAnnotationMapping(); $this->testSubject = new ValidatorInterceptor($validatorBuilder->getValidator()); $this->mockInterceptorChain = $this->getMock(InterceptorChainInterface::class); $this->uow = $this->getMock(UnitOfWorkInterface::class); }
/** @test */ public function it_serializes_exception_to_json() { $constraint = new Collection(['email' => new Email(), 'name' => new NotBlank(), 'birthday' => new Date()]); $data = ['additional' => 'foo']; $builder = new ValidatorBuilder(); $violationList = $builder->getValidator()->validate($data, $constraint); $exception = new ValidationErrorException($violationList, 'Validation failed', 100); $this->assertSame(400, $exception->getStatusCode()); $this->assertJsonStringEqualsJsonString(json_encode(['message' => 'Validation failed', 'logref' => 100, '_embedded' => ['errors' => [['message' => 'This field is missing.', 'path' => '/email'], ['message' => 'This field is missing.', 'path' => '/name'], ['message' => 'This field is missing.', 'path' => '/birthday'], ['message' => 'This field was not expected.', 'path' => '/additional']]]]), $exception->getHal()->asJson()); }
/** * @test */ public function simpleForm() { Helper::addServiceClass(SimpleForm::class); $form = Helper::getService(SimpleForm::class); $builder = new ValidatorBuilder(); $builder->enableAnnotationMapping(); $validator = $builder->getValidator(); $response = $validator->validate($form); $this->assertEquals(5, count($response)); }
public function validate($model) { $builder = new ValidatorBuilder(); $builder->setTranslator($this->service->getTranslator()); $validator = $builder->getValidator(); $validations = $this->getValidations(); $this->violations = new ConstraintViolationList(); foreach ($validations as $column => $validation) { $method = 'get' . NameUtils::toStudlyCase($column); if (method_exists($model, $method)) { $value = $model->{$method}(); $constraints = []; foreach ($validation as $options) { $name = $options['constraint']; unset($options['constraint']); $constraints[] = $this->getConstraint($name, $options); } $violations = $validator->validate($value, $constraints); $this->violations->addAll($violations); } } return (bool) (!(count($this->violations) > 0)); }
use Symfony\Component\Validator\ValidatorBuilder; use Symfony\Component\Translation\Translator; use Symfony\Component\Validator\Constraints\Collection; use Symfony\Component\Validator\Constraints\NotBlank; use Symfony\Component\Validator\Constraints\Length; use Symfony\Component\Validator\Constraints\Email; use Symfony\Component\Validator\Constraints\Type; use Symfony\Component\Validator\Constraints\Range; use Symfony\Component\Validator\Constraints\Choice; use Symfony\Component\Validator\Constraints\CardScheme; use Symfony\Component\Validator\Constraints\DateTime; // see http://symfony.com/doc/current/reference/constraints/Collection.html // builder which creates Validator as we need $builder = new ValidatorBuilder(); $builder->setTranslator(new Translator('cs_CZ')); $validator = $builder->getValidator(); // Example no. 1 // ------------- // // This example shows that Collection constrains checks // if array field fulfill our constraints or // if some array fields are missing or // if there are some extra fields in validated array echo "Example no. 1: \n"; $inputData = ['name' => '', 'age' => '', 'isActive' => '', 'createdAt' => '']; $violations = $validator->validate($inputData, new Collection(['name' => new NotBlank(), 'email' => new Email(['groups' => 'test'])]), ['test']); App\Utils::printViolations($violations); // Example no. 2 // ------------- // // In this example, we can see that there are some options we can
/** * @return ValidatorInterface */ private function getValidatorWithAnnotationReader() { $validator = new ValidatorBuilder(); $validator->enableAnnotationMapping($this->getAnnotationReader()); return $validator->getValidator(); }
<?php require __DIR__ . '/../vendor/autoload.php'; use Scheduler\Repositories\UserSQLiteRepository; use Scheduler\Services\UserService; use Scheduler\Validation\UserValidator; use Scheduler\Validation\ValidationHelper; use Symfony\Component\Validator\ValidatorBuilder; $app = new Proton\Application(); $app['database'] = __DIR__ . '/../DB/scheduler.db'; $app['user_repository'] = function () use($app) { return new UserSQLiteRepository($app['database']); }; $app['validation_helper'] = function () use($app) { $validatorBuilder = new ValidatorBuilder(); $validator = $validatorBuilder->getValidator(); return new ValidationHelper($validator); }; $app['user_validator'] = function () use($app) { return new UserValidator($app['validation_helper']); }; $app['user_service'] = function () use($app) { return new UserService($app['user_repository'], $app['user_validator']); };
private function bindingResultBuild() { $bind = new BindingResult(); $builder = new ValidatorBuilder(); $builder->enableAnnotationMapping(); foreach ($this->modelAttributes as $param) { if (in_array($param, $this->invokeParams)) { foreach ($builder->getValidator()->validate($param) as $offset => $violation) { $bind->offsetSet($offset, $violation); } } } $bindRef = new \ReflectionObject($bind); $propRef = $bindRef->getProperty('map'); $propRef->setAccessible(true); $map = array(); foreach ($this->reflMethod->getParameters() as $param) { if (!$param instanceof BindingResult && $param->getClass()) { $map[$param->getClass()->getName()] = $param->getName(); } } $propRef->setValue($bind, $map); return $bind; }