You are here

Home » API reference » Plug 7 » Abstract2Dot5ApiTest.php

abstract class Abstract2Dot5ApiTest in Plug 7

Verifies that a validator satisfies the API of Symfony 2.5+.

@since 2.5 @author Bernhard Schussek <bschussek@gmail.com>

Hierarchy

  • class \Symfony\Component\Validator\Tests\Validator\AbstractValidatorTest extends \Symfony\Component\Validator\Tests\Validator\PHPUnit_Framework_TestCase

Expanded class hierarchy of Abstract2Dot5ApiTest

File

lib/Symfony/validator/Symfony/Component/Validator/Tests/Validator/Abstract2Dot5ApiTest.php, line 35

Namespace

Symfony\Component\Validator\Tests\Validator
View source 
abstract class Abstract2Dot5ApiTest extends AbstractValidatorTest {

  /**
   * @var ValidatorInterface
   */
  protected $validator;

  /**
   * @param MetadataFactoryInterface $metadataFactory
   *
   * @return ValidatorInterface
   */
  protected abstract function createValidator(MetadataFactoryInterface $metadataFactory, array $objectInitializers = array());
  protected function setUp() {
    parent::setUp();
    $this->validator = $this
      ->createValidator($this->metadataFactory);
  }
  protected function validate($value, $constraints = null, $groups = null) {
    return $this->validator
      ->validate($value, $constraints, $groups);
  }
  protected function validateProperty($object, $propertyName, $groups = null) {
    return $this->validator
      ->validateProperty($object, $propertyName, $groups);
  }
  protected function validatePropertyValue($object, $propertyName, $value, $groups = null) {
    return $this->validator
      ->validatePropertyValue($object, $propertyName, $value, $groups);
  }
  public function testValidateConstraintWithoutGroup() {
    $violations = $this->validator
      ->validate(null, new NotNull());
    $this
      ->assertCount(1, $violations);
  }
  public function testGroupSequenceAbortsAfterFailedGroup() {
    $entity = new Entity();
    $callback1 = function ($value, ExecutionContextInterface $context) {
      $context
        ->addViolation('Message 1');
    };
    $callback2 = function ($value, ExecutionContextInterface $context) {
      $context
        ->addViolation('Message 2');
    };
    $this->metadata
      ->addConstraint(new Callback(array(
      'callback' => function () {
      },
      'groups' => 'Group 1',
    )));
    $this->metadata
      ->addConstraint(new Callback(array(
      'callback' => $callback1,
      'groups' => 'Group 2',
    )));
    $this->metadata
      ->addConstraint(new Callback(array(
      'callback' => $callback2,
      'groups' => 'Group 3',
    )));
    $sequence = new GroupSequence(array(
      'Group 1',
      'Group 2',
      'Group 3',
    ));
    $violations = $this->validator
      ->validate($entity, new Valid(), $sequence);

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
    $this
      ->assertSame('Message 1', $violations[0]
      ->getMessage());
  }
  public function testGroupSequenceIncludesReferences() {
    $entity = new Entity();
    $entity->reference = new Reference();
    $callback1 = function ($value, ExecutionContextInterface $context) {
      $context
        ->addViolation('Reference violation 1');
    };
    $callback2 = function ($value, ExecutionContextInterface $context) {
      $context
        ->addViolation('Reference violation 2');
    };
    $this->metadata
      ->addPropertyConstraint('reference', new Valid());
    $this->referenceMetadata
      ->addConstraint(new Callback(array(
      'callback' => $callback1,
      'groups' => 'Group 1',
    )));
    $this->referenceMetadata
      ->addConstraint(new Callback(array(
      'callback' => $callback2,
      'groups' => 'Group 2',
    )));
    $sequence = new GroupSequence(array(
      'Group 1',
      'Entity',
    ));
    $violations = $this->validator
      ->validate($entity, new Valid(), $sequence);

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
    $this
      ->assertSame('Reference violation 1', $violations[0]
      ->getMessage());
  }
  public function testValidateInSeparateContext() {
    $test = $this;
    $entity = new Entity();
    $entity->reference = new Reference();
    $callback1 = function ($value, ExecutionContextInterface $context) use ($test, $entity) {
      $violations = $context
        ->getValidator()
        ->validate($value->reference, new Valid(), 'Group');

      /** @var ConstraintViolationInterface[] $violations */
      $test
        ->assertCount(1, $violations);
      $test
        ->assertSame('Message value', $violations[0]
        ->getMessage());
      $test
        ->assertSame('Message %param%', $violations[0]
        ->getMessageTemplate());
      $test
        ->assertSame(array(
        '%param%' => 'value',
      ), $violations[0]
        ->getMessageParameters());
      $test
        ->assertSame('', $violations[0]
        ->getPropertyPath());

      // The root is different as we're in a new context
      $test
        ->assertSame($entity->reference, $violations[0]
        ->getRoot());
      $test
        ->assertSame($entity->reference, $violations[0]
        ->getInvalidValue());
      $test
        ->assertNull($violations[0]
        ->getMessagePluralization());
      $test
        ->assertNull($violations[0]
        ->getCode());

      // Verify that this method is called
      $context
        ->addViolation('Separate violation');
    };
    $callback2 = function ($value, ExecutionContextInterface $context) use ($test, $entity) {
      $test
        ->assertSame($test::REFERENCE_CLASS, $context
        ->getClassName());
      $test
        ->assertNull($context
        ->getPropertyName());
      $test
        ->assertSame('', $context
        ->getPropertyPath());
      $test
        ->assertSame('Group', $context
        ->getGroup());
      $test
        ->assertSame($test->referenceMetadata, $context
        ->getMetadata());
      $test
        ->assertSame($entity->reference, $context
        ->getRoot());
      $test
        ->assertSame($entity->reference, $context
        ->getValue());
      $test
        ->assertSame($entity->reference, $value);
      $context
        ->addViolation('Message %param%', array(
        '%param%' => 'value',
      ));
    };
    $this->metadata
      ->addConstraint(new Callback(array(
      'callback' => $callback1,
      'groups' => 'Group',
    )));
    $this->referenceMetadata
      ->addConstraint(new Callback(array(
      'callback' => $callback2,
      'groups' => 'Group',
    )));
    $violations = $this->validator
      ->validate($entity, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
    $test
      ->assertSame('Separate violation', $violations[0]
      ->getMessage());
  }
  public function testValidateInContext() {
    $test = $this;
    $entity = new Entity();
    $entity->reference = new Reference();
    $callback1 = function ($value, ExecutionContextInterface $context) use ($test) {
      $previousValue = $context
        ->getValue();
      $previousObject = $context
        ->getObject();
      $previousMetadata = $context
        ->getMetadata();
      $previousPath = $context
        ->getPropertyPath();
      $previousGroup = $context
        ->getGroup();
      $context
        ->getValidator()
        ->inContext($context)
        ->atPath('subpath')
        ->validate($value->reference);

      // context changes shouldn't leak out of the validate() call
      $test
        ->assertSame($previousValue, $context
        ->getValue());
      $test
        ->assertSame($previousObject, $context
        ->getObject());
      $test
        ->assertSame($previousMetadata, $context
        ->getMetadata());
      $test
        ->assertSame($previousPath, $context
        ->getPropertyPath());
      $test
        ->assertSame($previousGroup, $context
        ->getGroup());
    };
    $callback2 = function ($value, ExecutionContextInterface $context) use ($test, $entity) {
      $test
        ->assertSame($test::REFERENCE_CLASS, $context
        ->getClassName());
      $test
        ->assertNull($context
        ->getPropertyName());
      $test
        ->assertSame('subpath', $context
        ->getPropertyPath());
      $test
        ->assertSame('Group', $context
        ->getGroup());
      $test
        ->assertSame($test->referenceMetadata, $context
        ->getMetadata());
      $test
        ->assertSame($entity, $context
        ->getRoot());
      $test
        ->assertSame($entity->reference, $context
        ->getValue());
      $test
        ->assertSame($entity->reference, $value);
      $context
        ->addViolation('Message %param%', array(
        '%param%' => 'value',
      ));
    };
    $this->metadata
      ->addConstraint(new Callback(array(
      'callback' => $callback1,
      'groups' => 'Group',
    )));
    $this->referenceMetadata
      ->addConstraint(new Callback(array(
      'callback' => $callback2,
      'groups' => 'Group',
    )));
    $violations = $this->validator
      ->validate($entity, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
    $this
      ->assertSame('Message value', $violations[0]
      ->getMessage());
    $this
      ->assertSame('Message %param%', $violations[0]
      ->getMessageTemplate());
    $this
      ->assertSame(array(
      '%param%' => 'value',
    ), $violations[0]
      ->getMessageParameters());
    $this
      ->assertSame('subpath', $violations[0]
      ->getPropertyPath());
    $this
      ->assertSame($entity, $violations[0]
      ->getRoot());
    $this
      ->assertSame($entity->reference, $violations[0]
      ->getInvalidValue());
    $this
      ->assertNull($violations[0]
      ->getMessagePluralization());
    $this
      ->assertNull($violations[0]
      ->getCode());
  }
  public function testValidateArrayInContext() {
    $test = $this;
    $entity = new Entity();
    $entity->reference = new Reference();
    $callback1 = function ($value, ExecutionContextInterface $context) use ($test) {
      $previousValue = $context
        ->getValue();
      $previousObject = $context
        ->getObject();
      $previousMetadata = $context
        ->getMetadata();
      $previousPath = $context
        ->getPropertyPath();
      $previousGroup = $context
        ->getGroup();
      $context
        ->getValidator()
        ->inContext($context)
        ->atPath('subpath')
        ->validate(array(
        'key' => $value->reference,
      ));

      // context changes shouldn't leak out of the validate() call
      $test
        ->assertSame($previousValue, $context
        ->getValue());
      $test
        ->assertSame($previousObject, $context
        ->getObject());
      $test
        ->assertSame($previousMetadata, $context
        ->getMetadata());
      $test
        ->assertSame($previousPath, $context
        ->getPropertyPath());
      $test
        ->assertSame($previousGroup, $context
        ->getGroup());
    };
    $callback2 = function ($value, ExecutionContextInterface $context) use ($test, $entity) {
      $test
        ->assertSame($test::REFERENCE_CLASS, $context
        ->getClassName());
      $test
        ->assertNull($context
        ->getPropertyName());
      $test
        ->assertSame('subpath[key]', $context
        ->getPropertyPath());
      $test
        ->assertSame('Group', $context
        ->getGroup());
      $test
        ->assertSame($test->referenceMetadata, $context
        ->getMetadata());
      $test
        ->assertSame($entity, $context
        ->getRoot());
      $test
        ->assertSame($entity->reference, $context
        ->getValue());
      $test
        ->assertSame($entity->reference, $value);
      $context
        ->addViolation('Message %param%', array(
        '%param%' => 'value',
      ));
    };
    $this->metadata
      ->addConstraint(new Callback(array(
      'callback' => $callback1,
      'groups' => 'Group',
    )));
    $this->referenceMetadata
      ->addConstraint(new Callback(array(
      'callback' => $callback2,
      'groups' => 'Group',
    )));
    $violations = $this->validator
      ->validate($entity, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
    $this
      ->assertSame('Message value', $violations[0]
      ->getMessage());
    $this
      ->assertSame('Message %param%', $violations[0]
      ->getMessageTemplate());
    $this
      ->assertSame(array(
      '%param%' => 'value',
    ), $violations[0]
      ->getMessageParameters());
    $this
      ->assertSame('subpath[key]', $violations[0]
      ->getPropertyPath());
    $this
      ->assertSame($entity, $violations[0]
      ->getRoot());
    $this
      ->assertSame($entity->reference, $violations[0]
      ->getInvalidValue());
    $this
      ->assertNull($violations[0]
      ->getMessagePluralization());
    $this
      ->assertNull($violations[0]
      ->getCode());
  }
  public function testTraverseTraversableByDefault() {
    $test = $this;
    $entity = new Entity();
    $traversable = new \ArrayIterator(array(
      'key' => $entity,
    ));
    $callback = function ($value, ExecutionContextInterface $context) use ($test, $entity, $traversable) {
      $test
        ->assertSame($test::ENTITY_CLASS, $context
        ->getClassName());
      $test
        ->assertNull($context
        ->getPropertyName());
      $test
        ->assertSame('[key]', $context
        ->getPropertyPath());
      $test
        ->assertSame('Group', $context
        ->getGroup());
      $test
        ->assertSame($test->metadata, $context
        ->getMetadata());
      $test
        ->assertSame($traversable, $context
        ->getRoot());
      $test
        ->assertSame($entity, $context
        ->getValue());
      $test
        ->assertSame($entity, $value);
      $context
        ->addViolation('Message %param%', array(
        '%param%' => 'value',
      ));
    };
    $this->metadataFactory
      ->addMetadata(new ClassMetadata('ArrayIterator'));
    $this->metadata
      ->addConstraint(new Callback(array(
      'callback' => $callback,
      'groups' => 'Group',
    )));
    $violations = $this
      ->validate($traversable, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
    $this
      ->assertSame('Message value', $violations[0]
      ->getMessage());
    $this
      ->assertSame('Message %param%', $violations[0]
      ->getMessageTemplate());
    $this
      ->assertSame(array(
      '%param%' => 'value',
    ), $violations[0]
      ->getMessageParameters());
    $this
      ->assertSame('[key]', $violations[0]
      ->getPropertyPath());
    $this
      ->assertSame($traversable, $violations[0]
      ->getRoot());
    $this
      ->assertSame($entity, $violations[0]
      ->getInvalidValue());
    $this
      ->assertNull($violations[0]
      ->getMessagePluralization());
    $this
      ->assertNull($violations[0]
      ->getCode());
  }
  public function testTraversalEnabledOnClass() {
    $entity = new Entity();
    $traversable = new \ArrayIterator(array(
      'key' => $entity,
    ));
    $callback = function ($value, ExecutionContextInterface $context) {
      $context
        ->addViolation('Message');
    };
    $traversableMetadata = new ClassMetadata('ArrayIterator');
    $traversableMetadata
      ->addConstraint(new Traverse(true));
    $this->metadataFactory
      ->addMetadata($traversableMetadata);
    $this->metadata
      ->addConstraint(new Callback(array(
      'callback' => $callback,
      'groups' => 'Group',
    )));
    $violations = $this
      ->validate($traversable, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
  }
  public function testTraversalDisabledOnClass() {
    $test = $this;
    $entity = new Entity();
    $traversable = new \ArrayIterator(array(
      'key' => $entity,
    ));
    $callback = function ($value, ExecutionContextInterface $context) use ($test) {
      $test
        ->fail('Should not be called');
    };
    $traversableMetadata = new ClassMetadata('ArrayIterator');
    $traversableMetadata
      ->addConstraint(new Traverse(false));
    $this->metadataFactory
      ->addMetadata($traversableMetadata);
    $this->metadata
      ->addConstraint(new Callback(array(
      'callback' => $callback,
      'groups' => 'Group',
    )));
    $violations = $this
      ->validate($traversable, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(0, $violations);
  }

  /**
   * @expectedException \Symfony\Component\Validator\Exception\ConstraintDefinitionException
   */
  public function testExpectTraversableIfTraversalEnabledOnClass() {
    $entity = new Entity();
    $this->metadata
      ->addConstraint(new Traverse(true));
    $this->validator
      ->validate($entity);
  }
  public function testReferenceTraversalDisabledOnClass() {
    $test = $this;
    $entity = new Entity();
    $entity->reference = new \ArrayIterator(array(
      'key' => new Reference(),
    ));
    $callback = function ($value, ExecutionContextInterface $context) use ($test) {
      $test
        ->fail('Should not be called');
    };
    $traversableMetadata = new ClassMetadata('ArrayIterator');
    $traversableMetadata
      ->addConstraint(new Traverse(false));
    $this->metadataFactory
      ->addMetadata($traversableMetadata);
    $this->referenceMetadata
      ->addConstraint(new Callback(array(
      'callback' => $callback,
      'groups' => 'Group',
    )));
    $this->metadata
      ->addPropertyConstraint('reference', new Valid());
    $violations = $this
      ->validate($entity, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(0, $violations);
  }
  public function testReferenceTraversalEnabledOnReferenceDisabledOnClass() {
    $test = $this;
    $entity = new Entity();
    $entity->reference = new \ArrayIterator(array(
      'key' => new Reference(),
    ));
    $callback = function ($value, ExecutionContextInterface $context) use ($test) {
      $test
        ->fail('Should not be called');
    };
    $traversableMetadata = new ClassMetadata('ArrayIterator');
    $traversableMetadata
      ->addConstraint(new Traverse(false));
    $this->metadataFactory
      ->addMetadata($traversableMetadata);
    $this->referenceMetadata
      ->addConstraint(new Callback(array(
      'callback' => $callback,
      'groups' => 'Group',
    )));
    $this->metadata
      ->addPropertyConstraint('reference', new Valid(array(
      'traverse' => true,
    )));
    $violations = $this
      ->validate($entity, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(0, $violations);
  }
  public function testReferenceTraversalDisabledOnReferenceEnabledOnClass() {
    $test = $this;
    $entity = new Entity();
    $entity->reference = new \ArrayIterator(array(
      'key' => new Reference(),
    ));
    $callback = function ($value, ExecutionContextInterface $context) use ($test) {
      $test
        ->fail('Should not be called');
    };
    $traversableMetadata = new ClassMetadata('ArrayIterator');
    $traversableMetadata
      ->addConstraint(new Traverse(true));
    $this->metadataFactory
      ->addMetadata($traversableMetadata);
    $this->referenceMetadata
      ->addConstraint(new Callback(array(
      'callback' => $callback,
      'groups' => 'Group',
    )));
    $this->metadata
      ->addPropertyConstraint('reference', new Valid(array(
      'traverse' => false,
    )));
    $violations = $this
      ->validate($entity, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(0, $violations);
  }
  public function testReferenceTraversalRecursionEnabledOnReferenceTraversalEnabledOnClass() {
    $entity = new Entity();
    $entity->reference = new \ArrayIterator(array(
      2 => new \ArrayIterator(array(
        'key' => new Reference(),
      )),
    ));
    $callback = function ($value, ExecutionContextInterface $context) {
      $context
        ->addViolation('Message');
    };
    $traversableMetadata = new ClassMetadata('ArrayIterator');
    $traversableMetadata
      ->addConstraint(new Traverse(true));
    $this->metadataFactory
      ->addMetadata($traversableMetadata);
    $this->referenceMetadata
      ->addConstraint(new Callback(array(
      'callback' => $callback,
      'groups' => 'Group',
    )));
    $this->metadata
      ->addPropertyConstraint('reference', new Valid(array(
      'deep' => true,
    )));
    $violations = $this
      ->validate($entity, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
  }
  public function testReferenceTraversalRecursionDisabledOnReferenceTraversalEnabledOnClass() {
    $test = $this;
    $entity = new Entity();
    $entity->reference = new \ArrayIterator(array(
      2 => new \ArrayIterator(array(
        'key' => new Reference(),
      )),
    ));
    $callback = function ($value, ExecutionContextInterface $context) use ($test) {
      $test
        ->fail('Should not be called');
    };
    $traversableMetadata = new ClassMetadata('ArrayIterator');
    $traversableMetadata
      ->addConstraint(new Traverse(true));
    $this->metadataFactory
      ->addMetadata($traversableMetadata);
    $this->referenceMetadata
      ->addConstraint(new Callback(array(
      'callback' => $callback,
      'groups' => 'Group',
    )));
    $this->metadata
      ->addPropertyConstraint('reference', new Valid(array(
      'deep' => false,
    )));
    $violations = $this
      ->validate($entity, new Valid(), 'Group');

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(0, $violations);
  }
  public function testAddCustomizedViolation() {
    $entity = new Entity();
    $callback = function ($value, ExecutionContextInterface $context) {
      $context
        ->buildViolation('Message %param%')
        ->setParameter('%param%', 'value')
        ->setInvalidValue('Invalid value')
        ->setPlural(2)
        ->setCode(42)
        ->addViolation();
    };
    $this->metadata
      ->addConstraint(new Callback($callback));
    $violations = $this->validator
      ->validate($entity);

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
    $this
      ->assertSame('Message value', $violations[0]
      ->getMessage());
    $this
      ->assertSame('Message %param%', $violations[0]
      ->getMessageTemplate());
    $this
      ->assertSame(array(
      '%param%' => 'value',
    ), $violations[0]
      ->getMessageParameters());
    $this
      ->assertSame('', $violations[0]
      ->getPropertyPath());
    $this
      ->assertSame($entity, $violations[0]
      ->getRoot());
    $this
      ->assertSame('Invalid value', $violations[0]
      ->getInvalidValue());
    $this
      ->assertSame(2, $violations[0]
      ->getMessagePluralization());
    $this
      ->assertSame(42, $violations[0]
      ->getCode());
  }

  /**
   * @expectedException \Symfony\Component\Validator\Exception\UnsupportedMetadataException
   */
  public function testMetadataMustImplementClassMetadataInterface() {
    $entity = new Entity();
    $metadata = $this
      ->getMock('Symfony\\Component\\Validator\\Tests\\Fixtures\\LegacyClassMetadata');
    $metadata
      ->expects($this
      ->any())
      ->method('getClassName')
      ->will($this
      ->returnValue(get_class($entity)));
    $this->metadataFactory
      ->addMetadata($metadata);
    $this->validator
      ->validate($entity);
  }

  /**
   * @expectedException \Symfony\Component\Validator\Exception\UnsupportedMetadataException
   */
  public function testReferenceMetadataMustImplementClassMetadataInterface() {
    $entity = new Entity();
    $entity->reference = new Reference();
    $metadata = $this
      ->getMock('Symfony\\Component\\Validator\\Tests\\Fixtures\\LegacyClassMetadata');
    $metadata
      ->expects($this
      ->any())
      ->method('getClassName')
      ->will($this
      ->returnValue(get_class($entity->reference)));
    $this->metadataFactory
      ->addMetadata($metadata);
    $this->metadata
      ->addPropertyConstraint('reference', new Valid());
    $this->validator
      ->validate($entity);
  }

  /**
   * @expectedException \Symfony\Component\Validator\Exception\UnsupportedMetadataException
   * @group legacy
   */
  public function testLegacyPropertyMetadataMustImplementPropertyMetadataInterface() {
    $this
      ->iniSet('error_reporting', -1 & ~E_USER_DEPRECATED);
    $entity = new Entity();

    // Legacy interface
    $propertyMetadata = $this
      ->getMock('Symfony\\Component\\Validator\\MetadataInterface');
    $metadata = new FakeClassMetadata(get_class($entity));
    $metadata
      ->addCustomPropertyMetadata('firstName', $propertyMetadata);
    $this->metadataFactory
      ->addMetadata($metadata);
    $this->validator
      ->validate($entity);
  }
  public function testNoDuplicateValidationIfClassConstraintInMultipleGroups() {
    $entity = new Entity();
    $callback = function ($value, ExecutionContextInterface $context) {
      $context
        ->addViolation('Message');
    };
    $this->metadata
      ->addConstraint(new Callback(array(
      'callback' => $callback,
      'groups' => array(
        'Group 1',
        'Group 2',
      ),
    )));
    $violations = $this->validator
      ->validate($entity, new Valid(), array(
      'Group 1',
      'Group 2',
    ));

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
  }
  public function testNoDuplicateValidationIfPropertyConstraintInMultipleGroups() {
    $entity = new Entity();
    $callback = function ($value, ExecutionContextInterface $context) {
      $context
        ->addViolation('Message');
    };
    $this->metadata
      ->addPropertyConstraint('firstName', new Callback(array(
      'callback' => $callback,
      'groups' => array(
        'Group 1',
        'Group 2',
      ),
    )));
    $violations = $this->validator
      ->validate($entity, new Valid(), array(
      'Group 1',
      'Group 2',
    ));

    /** @var ConstraintViolationInterface[] $violations */
    $this
      ->assertCount(1, $violations);
  }

  /**
   * @expectedException \Symfony\Component\Validator\Exception\RuntimeException
   */
  public function testValidateFailsIfNoConstraintsAndNoObjectOrArray() {
    $this
      ->validate('Foobar');
  }
  public function testAccessCurrentObject() {
    $test = $this;
    $called = false;
    $entity = new Entity();
    $entity->firstName = 'Bernhard';
    $callback = function ($value, ExecutionContextInterface $context) use ($test, $entity, &$called) {
      $called = true;
      $test
        ->assertSame($entity, $context
        ->getObject());
    };
    $this->metadata
      ->addConstraint(new Callback($callback));
    $this->metadata
      ->addPropertyConstraint('firstName', new Callback($callback));
    $this->validator
      ->validate($entity);
    $this
      ->assertTrue($called);
  }
  public function testInitializeObjectsOnFirstValidation() {
    $test = $this;
    $entity = new Entity();
    $entity->initialized = false;

    // prepare initializers that set "initialized" to true
    $initializer1 = $this
      ->getMock('Symfony\\Component\\Validator\\ObjectInitializerInterface');
    $initializer2 = $this
      ->getMock('Symfony\\Component\\Validator\\ObjectInitializerInterface');
    $initializer1
      ->expects($this
      ->once())
      ->method('initialize')
      ->with($entity)
      ->will($this
      ->returnCallback(function ($object) {
      $object->initialized = true;
    }));
    $initializer2
      ->expects($this
      ->once())
      ->method('initialize')
      ->with($entity);
    $this->validator = $this
      ->createValidator($this->metadataFactory, array(
      $initializer1,
      $initializer2,
    ));

    // prepare constraint which
    // * checks that "initialized" is set to true
    // * validates the object again
    $callback = function ($object, ExecutionContextInterface $context) use ($test) {
      $test
        ->assertTrue($object->initialized);

      // validate again in same group
      $validator = $context
        ->getValidator()
        ->inContext($context);
      $validator
        ->validate($object);

      // validate again in other group
      $validator
        ->validate($object, null, 'SomeGroup');
    };
    $this->metadata
      ->addConstraint(new Callback($callback));
    $this
      ->validate($entity);
    $this
      ->assertTrue($entity->initialized);
  }
  public function testPassConstraintToViolation() {
    $constraint = new FailingConstraint();
    $violations = $this
      ->validate('Foobar', $constraint);
    $this
      ->assertCount(1, $violations);
    $this
      ->assertSame($constraint, $violations[0]
      ->getConstraint());
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Abstract2Dot5ApiTest::$validator protected property
Abstract2Dot5ApiTest::createValidator abstract protected function 2
Abstract2Dot5ApiTest::setUp protected function Overrides AbstractValidatorTest::setUp 1
Abstract2Dot5ApiTest::testAccessCurrentObject public function
Abstract2Dot5ApiTest::testAddCustomizedViolation public function
Abstract2Dot5ApiTest::testExpectTraversableIfTraversalEnabledOnClass public function @expectedException \Symfony\Component\Validator\Exception\ConstraintDefinitionException
Abstract2Dot5ApiTest::testGroupSequenceAbortsAfterFailedGroup public function
Abstract2Dot5ApiTest::testGroupSequenceIncludesReferences public function
Abstract2Dot5ApiTest::testInitializeObjectsOnFirstValidation public function
Abstract2Dot5ApiTest::testLegacyPropertyMetadataMustImplementPropertyMetadataInterface public function @expectedException \Symfony\Component\Validator\Exception\UnsupportedMetadataException @group legacy
Abstract2Dot5ApiTest::testMetadataMustImplementClassMetadataInterface public function @expectedException \Symfony\Component\Validator\Exception\UnsupportedMetadataException
Abstract2Dot5ApiTest::testNoDuplicateValidationIfClassConstraintInMultipleGroups public function
Abstract2Dot5ApiTest::testNoDuplicateValidationIfPropertyConstraintInMultipleGroups public function
Abstract2Dot5ApiTest::testPassConstraintToViolation public function
Abstract2Dot5ApiTest::testReferenceMetadataMustImplementClassMetadataInterface public function @expectedException \Symfony\Component\Validator\Exception\UnsupportedMetadataException
Abstract2Dot5ApiTest::testReferenceTraversalDisabledOnClass public function
Abstract2Dot5ApiTest::testReferenceTraversalDisabledOnReferenceEnabledOnClass public function
Abstract2Dot5ApiTest::testReferenceTraversalEnabledOnReferenceDisabledOnClass public function
Abstract2Dot5ApiTest::testReferenceTraversalRecursionDisabledOnReferenceTraversalEnabledOnClass public function
Abstract2Dot5ApiTest::testReferenceTraversalRecursionEnabledOnReferenceTraversalEnabledOnClass public function
Abstract2Dot5ApiTest::testTraversalDisabledOnClass public function
Abstract2Dot5ApiTest::testTraversalEnabledOnClass public function
Abstract2Dot5ApiTest::testTraverseTraversableByDefault public function
Abstract2Dot5ApiTest::testValidateArrayInContext public function
Abstract2Dot5ApiTest::testValidateConstraintWithoutGroup public function
Abstract2Dot5ApiTest::testValidateFailsIfNoConstraintsAndNoObjectOrArray public function @expectedException \Symfony\Component\Validator\Exception\RuntimeException
Abstract2Dot5ApiTest::testValidateInContext public function
Abstract2Dot5ApiTest::testValidateInSeparateContext public function
Abstract2Dot5ApiTest::validate protected function Overrides AbstractValidatorTest::validate
Abstract2Dot5ApiTest::validateProperty protected function Overrides AbstractValidatorTest::validateProperty
Abstract2Dot5ApiTest::validatePropertyValue protected function Overrides AbstractValidatorTest::validatePropertyValue
AbstractValidatorTest::$metadata public property
AbstractValidatorTest::$metadataFactory public property
AbstractValidatorTest::$referenceMetadata public property
AbstractValidatorTest::ENTITY_CLASS constant
AbstractValidatorTest::REFERENCE_CLASS constant
AbstractValidatorTest::tearDown protected function
AbstractValidatorTest::testArray public function
AbstractValidatorTest::testArrayReference public function
AbstractValidatorTest::testArrayTraversalCannotBeDisabled public function
AbstractValidatorTest::testClassConstraint public function
AbstractValidatorTest::testDisableTraversableTraversal public function
AbstractValidatorTest::testEnableRecursiveTraversableTraversal public function
AbstractValidatorTest::testFailOnScalarReferences public function @expectedException \Symfony\Component\Validator\Exception\NoSuchMetadataException
AbstractValidatorTest::testGetterConstraint public function
AbstractValidatorTest::testIgnoreNullDuringArrayTraversal public function
AbstractValidatorTest::testIgnoreScalarsDuringArrayTraversal public function
AbstractValidatorTest::testLegacyValidatePropertyFailsIfPropertiesNotSupported public function Cannot be UnsupportedMetadataException for BC with Symfony < 2.5.
AbstractValidatorTest::testLegacyValidatePropertyValueFailsIfPropertiesNotSupported public function Cannot be UnsupportedMetadataException for BC with Symfony < 2.5.
AbstractValidatorTest::testMetadataMustExistIfTraversalIsDisabled public function @expectedException \Symfony\Component\Validator\Exception\NoSuchMetadataException
AbstractValidatorTest::testPropagateDefaultGroupToReferenceWhenReplacingDefaultGroup public function
AbstractValidatorTest::testPropertyConstraint public function
AbstractValidatorTest::testRecursiveArray public function
AbstractValidatorTest::testRecursiveArrayReference public function
AbstractValidatorTest::testRecursiveArrayTraversalCannotBeDisabled public function
AbstractValidatorTest::testRecursiveTraversable public function
AbstractValidatorTest::testReferenceClassConstraint public function
AbstractValidatorTest::testReferenceGetterConstraint public function
AbstractValidatorTest::testReferencePropertyConstraint public function
AbstractValidatorTest::testReplaceDefaultGroupByGroupSequenceArray public function
AbstractValidatorTest::testReplaceDefaultGroupByGroupSequenceObject public function
AbstractValidatorTest::testReplaceDefaultGroupWithArrayFromGroupSequenceProvider public function
AbstractValidatorTest::testReplaceDefaultGroupWithObjectFromGroupSequenceProvider public function
AbstractValidatorTest::testsIgnoreNullReference public function
AbstractValidatorTest::testTraversable public function
AbstractValidatorTest::testTraversableReference public function
AbstractValidatorTest::testValidate public function
AbstractValidatorTest::testValidateCustomGroupWhenDefaultGroupWasReplaced public function
AbstractValidatorTest::testValidateDifferentObjectsSeparately public function
AbstractValidatorTest::testValidateMultipleGroups public function
AbstractValidatorTest::testValidateObjectOnlyOncePerGroup public function
AbstractValidatorTest::testValidateProperty public function
AbstractValidatorTest::testValidatePropertyValue public function
AbstractValidatorTest::testValidatePropertyValueWithClassName public function
AbstractValidatorTest::testValidatePropertyValueWithoutConstraints public function https://github.com/symfony/symfony/issues/11604
AbstractValidatorTest::testValidatePropertyWithoutConstraints public function https://github.com/symfony/symfony/issues/11604
AbstractValidatorTest::testValidateSingleGroup public function