You are here

Home » API reference » Zircon Profile 8 » FileValidatorTest.php

abstract class FileValidatorTest in Zircon Profile 8

Same name and namespace in other branches
  1. 8.0 vendor/symfony/validator/Tests/Constraints/FileValidatorTest.php \Symfony\Component\Validator\Tests\Constraints\FileValidatorTest

Hierarchy

Expanded class hierarchy of FileValidatorTest

1 string reference to 'FileValidatorTest'
FileValidatorTest::setUp in vendor/symfony/validator/Tests/Constraints/FileValidatorTest.php

File

vendor/symfony/validator/Tests/Constraints/FileValidatorTest.php, line 19

Namespace

Symfony\Component\Validator\Tests\Constraints
View source 
abstract class FileValidatorTest extends AbstractConstraintValidatorTest {
  protected $path;
  protected $file;
  protected function getApiVersion() {
    return Validation::API_VERSION_2_5;
  }
  protected function createValidator() {
    return new FileValidator();
  }
  protected function setUp() {
    parent::setUp();
    $this->path = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'FileValidatorTest';
    $this->file = fopen($this->path, 'w');
    fwrite($this->file, ' ', 1);
  }
  protected function tearDown() {
    parent::tearDown();
    if (is_resource($this->file)) {
      fclose($this->file);
    }
    if (file_exists($this->path)) {
      unlink($this->path);
    }
    $this->path = null;
    $this->file = null;
  }
  public function testNullIsValid() {
    $this->validator
      ->validate(null, new File());
    $this
      ->assertNoViolation();
  }
  public function testEmptyStringIsValid() {
    $this->validator
      ->validate('', new File());
    $this
      ->assertNoViolation();
  }

  /**
   * @expectedException \Symfony\Component\Validator\Exception\UnexpectedTypeException
   */
  public function testExpectsStringCompatibleTypeOrFile() {
    $this->validator
      ->validate(new \stdClass(), new File());
  }
  public function testValidFile() {
    $this->validator
      ->validate($this->path, new File());
    $this
      ->assertNoViolation();
  }
  public function testValidUploadedfile() {
    $file = new UploadedFile($this->path, 'originalName', null, null, null, true);
    $this->validator
      ->validate($file, new File());
    $this
      ->assertNoViolation();
  }
  public function provideMaxSizeExceededTests() {

    // We have various interesting limit - size combinations to test.
    // Assume a limit of 1000 bytes (1 kB). Then the following table
    // lists the violation messages for different file sizes:
    // -----------+--------------------------------------------------------
    // Size       | Violation Message
    // -----------+--------------------------------------------------------
    // 1000 bytes | No violation
    // 1001 bytes | "Size of 1001 bytes exceeded limit of 1000 bytes"
    // 1004 bytes | "Size of 1004 bytes exceeded limit of 1000 bytes"
    //            | NOT: "Size of 1 kB exceeded limit of 1 kB"
    // 1005 bytes | "Size of 1.01 kB exceeded limit of 1 kB"
    // -----------+--------------------------------------------------------
    // As you see, we have two interesting borders:
    // 1000/1001 - The border as of which a violation occurs
    // 1004/1005 - The border as of which the message can be rounded to kB
    // Analogous for kB/MB.
    // Prior to Symfony 2.5, violation messages are always displayed in the
    // same unit used to specify the limit.
    // As of Symfony 2.5, the above logic is implemented.
    return array(
      // limit in bytes
      array(
        1001,
        1000,
        '1001',
        '1000',
        'bytes',
      ),
      array(
        1004,
        1000,
        '1004',
        '1000',
        'bytes',
      ),
      array(
        1005,
        1000,
        '1.01',
        '1',
        'kB',
      ),
      array(
        1000001,
        1000000,
        '1000001',
        '1000000',
        'bytes',
      ),
      array(
        1004999,
        1000000,
        '1005',
        '1000',
        'kB',
      ),
      array(
        1005000,
        1000000,
        '1.01',
        '1',
        'MB',
      ),
      // limit in kB
      array(
        1001,
        '1k',
        '1001',
        '1000',
        'bytes',
      ),
      array(
        1004,
        '1k',
        '1004',
        '1000',
        'bytes',
      ),
      array(
        1005,
        '1k',
        '1.01',
        '1',
        'kB',
      ),
      array(
        1000001,
        '1000k',
        '1000001',
        '1000000',
        'bytes',
      ),
      array(
        1004999,
        '1000k',
        '1005',
        '1000',
        'kB',
      ),
      array(
        1005000,
        '1000k',
        '1.01',
        '1',
        'MB',
      ),
      // limit in MB
      array(
        1000001,
        '1M',
        '1000001',
        '1000000',
        'bytes',
      ),
      array(
        1004999,
        '1M',
        '1005',
        '1000',
        'kB',
      ),
      array(
        1005000,
        '1M',
        '1.01',
        '1',
        'MB',
      ),
      // limit in KiB
      array(
        1025,
        '1Ki',
        '1025',
        '1024',
        'bytes',
      ),
      array(
        1029,
        '1Ki',
        '1029',
        '1024',
        'bytes',
      ),
      array(
        1030,
        '1Ki',
        '1.01',
        '1',
        'KiB',
      ),
      array(
        1048577,
        '1024Ki',
        '1048577',
        '1048576',
        'bytes',
      ),
      array(
        1053818,
        '1024Ki',
        '1029.12',
        '1024',
        'KiB',
      ),
      array(
        1053819,
        '1024Ki',
        '1.01',
        '1',
        'MiB',
      ),
      // limit in MiB
      array(
        1048577,
        '1Mi',
        '1048577',
        '1048576',
        'bytes',
      ),
      array(
        1053818,
        '1Mi',
        '1029.12',
        '1024',
        'KiB',
      ),
      array(
        1053819,
        '1Mi',
        '1.01',
        '1',
        'MiB',
      ),
    );
  }

  /**
   * @dataProvider provideMaxSizeExceededTests
   */
  public function testMaxSizeExceeded($bytesWritten, $limit, $sizeAsString, $limitAsString, $suffix) {
    fseek($this->file, $bytesWritten - 1, SEEK_SET);
    fwrite($this->file, '0');
    fclose($this->file);
    $constraint = new File(array(
      'maxSize' => $limit,
      'maxSizeMessage' => 'myMessage',
    ));
    $this->validator
      ->validate($this
      ->getFile($this->path), $constraint);
    $this
      ->buildViolation('myMessage')
      ->setParameter('{{ limit }}', $limitAsString)
      ->setParameter('{{ size }}', $sizeAsString)
      ->setParameter('{{ suffix }}', $suffix)
      ->setParameter('{{ file }}', '"' . $this->path . '"')
      ->setCode(File::TOO_LARGE_ERROR)
      ->assertRaised();
  }
  public function provideMaxSizeNotExceededTests() {
    return array(
      // limit in bytes
      array(
        1000,
        1000,
      ),
      array(
        1000000,
        1000000,
      ),
      // limit in kB
      array(
        1000,
        '1k',
      ),
      array(
        1000000,
        '1000k',
      ),
      // limit in MB
      array(
        1000000,
        '1M',
      ),
      // limit in KiB
      array(
        1024,
        '1Ki',
      ),
      array(
        1048576,
        '1024Ki',
      ),
      // limit in MiB
      array(
        1048576,
        '1Mi',
      ),
    );
  }

  /**
   * @dataProvider provideMaxSizeNotExceededTests
   */
  public function testMaxSizeNotExceeded($bytesWritten, $limit) {
    fseek($this->file, $bytesWritten - 1, SEEK_SET);
    fwrite($this->file, '0');
    fclose($this->file);
    $constraint = new File(array(
      'maxSize' => $limit,
      'maxSizeMessage' => 'myMessage',
    ));
    $this->validator
      ->validate($this
      ->getFile($this->path), $constraint);
    $this
      ->assertNoViolation();
  }

  /**
   * @expectedException \Symfony\Component\Validator\Exception\ConstraintDefinitionException
   */
  public function testInvalidMaxSize() {
    $constraint = new File(array(
      'maxSize' => '1abc',
    ));
    $this->validator
      ->validate($this->path, $constraint);
  }
  public function provideBinaryFormatTests() {
    return array(
      array(
        11,
        10,
        null,
        '11',
        '10',
        'bytes',
      ),
      array(
        11,
        10,
        true,
        '11',
        '10',
        'bytes',
      ),
      array(
        11,
        10,
        false,
        '11',
        '10',
        'bytes',
      ),
      // round(size) == 1.01kB, limit == 1kB
      array(
        ceil(1000 * 1.01),
        1000,
        null,
        '1.01',
        '1',
        'kB',
      ),
      array(
        ceil(1000 * 1.01),
        '1k',
        null,
        '1.01',
        '1',
        'kB',
      ),
      array(
        ceil(1024 * 1.01),
        '1Ki',
        null,
        '1.01',
        '1',
        'KiB',
      ),
      array(
        ceil(1024 * 1.01),
        1024,
        true,
        '1.01',
        '1',
        'KiB',
      ),
      array(
        ceil(1024 * 1.01 * 1000),
        '1024k',
        true,
        '1010',
        '1000',
        'KiB',
      ),
      array(
        ceil(1024 * 1.01),
        '1Ki',
        true,
        '1.01',
        '1',
        'KiB',
      ),
      array(
        ceil(1000 * 1.01),
        1000,
        false,
        '1.01',
        '1',
        'kB',
      ),
      array(
        ceil(1000 * 1.01),
        '1k',
        false,
        '1.01',
        '1',
        'kB',
      ),
      array(
        ceil(1024 * 1.01 * 10),
        '10Ki',
        false,
        '10.34',
        '10.24',
        'kB',
      ),
    );
  }

  /**
   * @dataProvider provideBinaryFormatTests
   */
  public function testBinaryFormat($bytesWritten, $limit, $binaryFormat, $sizeAsString, $limitAsString, $suffix) {
    fseek($this->file, $bytesWritten - 1, SEEK_SET);
    fwrite($this->file, '0');
    fclose($this->file);
    $constraint = new File(array(
      'maxSize' => $limit,
      'binaryFormat' => $binaryFormat,
      'maxSizeMessage' => 'myMessage',
    ));
    $this->validator
      ->validate($this
      ->getFile($this->path), $constraint);
    $this
      ->buildViolation('myMessage')
      ->setParameter('{{ limit }}', $limitAsString)
      ->setParameter('{{ size }}', $sizeAsString)
      ->setParameter('{{ suffix }}', $suffix)
      ->setParameter('{{ file }}', '"' . $this->path . '"')
      ->setCode(File::TOO_LARGE_ERROR)
      ->assertRaised();
  }
  public function testValidMimeType() {
    $file = $this
      ->getMockBuilder('Symfony\\Component\\HttpFoundation\\File\\File')
      ->setConstructorArgs(array(
      __DIR__ . '/Fixtures/foo',
    ))
      ->getMock();
    $file
      ->expects($this
      ->once())
      ->method('getPathname')
      ->will($this
      ->returnValue($this->path));
    $file
      ->expects($this
      ->once())
      ->method('getMimeType')
      ->will($this
      ->returnValue('image/jpg'));
    $constraint = new File(array(
      'mimeTypes' => array(
        'image/png',
        'image/jpg',
      ),
    ));
    $this->validator
      ->validate($file, $constraint);
    $this
      ->assertNoViolation();
  }
  public function testValidWildcardMimeType() {
    $file = $this
      ->getMockBuilder('Symfony\\Component\\HttpFoundation\\File\\File')
      ->setConstructorArgs(array(
      __DIR__ . '/Fixtures/foo',
    ))
      ->getMock();
    $file
      ->expects($this
      ->once())
      ->method('getPathname')
      ->will($this
      ->returnValue($this->path));
    $file
      ->expects($this
      ->once())
      ->method('getMimeType')
      ->will($this
      ->returnValue('image/jpg'));
    $constraint = new File(array(
      'mimeTypes' => array(
        'image/*',
      ),
    ));
    $this->validator
      ->validate($file, $constraint);
    $this
      ->assertNoViolation();
  }
  public function testInvalidMimeType() {
    $file = $this
      ->getMockBuilder('Symfony\\Component\\HttpFoundation\\File\\File')
      ->setConstructorArgs(array(
      __DIR__ . '/Fixtures/foo',
    ))
      ->getMock();
    $file
      ->expects($this
      ->once())
      ->method('getPathname')
      ->will($this
      ->returnValue($this->path));
    $file
      ->expects($this
      ->once())
      ->method('getMimeType')
      ->will($this
      ->returnValue('application/pdf'));
    $constraint = new File(array(
      'mimeTypes' => array(
        'image/png',
        'image/jpg',
      ),
      'mimeTypesMessage' => 'myMessage',
    ));
    $this->validator
      ->validate($file, $constraint);
    $this
      ->buildViolation('myMessage')
      ->setParameter('{{ type }}', '"application/pdf"')
      ->setParameter('{{ types }}', '"image/png", "image/jpg"')
      ->setParameter('{{ file }}', '"' . $this->path . '"')
      ->setCode(File::INVALID_MIME_TYPE_ERROR)
      ->assertRaised();
  }
  public function testInvalidWildcardMimeType() {
    $file = $this
      ->getMockBuilder('Symfony\\Component\\HttpFoundation\\File\\File')
      ->setConstructorArgs(array(
      __DIR__ . '/Fixtures/foo',
    ))
      ->getMock();
    $file
      ->expects($this
      ->once())
      ->method('getPathname')
      ->will($this
      ->returnValue($this->path));
    $file
      ->expects($this
      ->once())
      ->method('getMimeType')
      ->will($this
      ->returnValue('application/pdf'));
    $constraint = new File(array(
      'mimeTypes' => array(
        'image/*',
        'image/jpg',
      ),
      'mimeTypesMessage' => 'myMessage',
    ));
    $this->validator
      ->validate($file, $constraint);
    $this
      ->buildViolation('myMessage')
      ->setParameter('{{ type }}', '"application/pdf"')
      ->setParameter('{{ types }}', '"image/*", "image/jpg"')
      ->setParameter('{{ file }}', '"' . $this->path . '"')
      ->setCode(File::INVALID_MIME_TYPE_ERROR)
      ->assertRaised();
  }
  public function testDisallowEmpty() {
    ftruncate($this->file, 0);
    $constraint = new File(array(
      'disallowEmptyMessage' => 'myMessage',
    ));
    $this->validator
      ->validate($this
      ->getFile($this->path), $constraint);
    $this
      ->buildViolation('myMessage')
      ->setParameter('{{ file }}', '"' . $this->path . '"')
      ->setCode(File::EMPTY_ERROR)
      ->assertRaised();
  }

  /**
   * @dataProvider uploadedFileErrorProvider
   */
  public function testUploadedFileError($error, $message, array $params = array(), $maxSize = null) {
    $file = new UploadedFile('/path/to/file', 'originalName', 'mime', 0, $error);
    $constraint = new File(array(
      $message => 'myMessage',
      'maxSize' => $maxSize,
    ));
    $this->validator
      ->validate($file, $constraint);
    $this
      ->buildViolation('myMessage')
      ->setParameters($params)
      ->setCode($error)
      ->assertRaised();
  }
  public function uploadedFileErrorProvider() {
    $tests = array(
      array(
        UPLOAD_ERR_FORM_SIZE,
        'uploadFormSizeErrorMessage',
      ),
      array(
        UPLOAD_ERR_PARTIAL,
        'uploadPartialErrorMessage',
      ),
      array(
        UPLOAD_ERR_NO_FILE,
        'uploadNoFileErrorMessage',
      ),
      array(
        UPLOAD_ERR_NO_TMP_DIR,
        'uploadNoTmpDirErrorMessage',
      ),
      array(
        UPLOAD_ERR_CANT_WRITE,
        'uploadCantWriteErrorMessage',
      ),
      array(
        UPLOAD_ERR_EXTENSION,
        'uploadExtensionErrorMessage',
      ),
    );
    if (class_exists('Symfony\\Component\\HttpFoundation\\File\\UploadedFile')) {

      // when no maxSize is specified on constraint, it should use the ini value
      $tests[] = array(
        UPLOAD_ERR_INI_SIZE,
        'uploadIniSizeErrorMessage',
        array(
          '{{ limit }}' => UploadedFile::getMaxFilesize() / 1048576,
          '{{ suffix }}' => 'MiB',
        ),
      );

      // it should use the smaller limitation (maxSize option in this case)
      $tests[] = array(
        UPLOAD_ERR_INI_SIZE,
        'uploadIniSizeErrorMessage',
        array(
          '{{ limit }}' => 1,
          '{{ suffix }}' => 'bytes',
        ),
        '1',
      );

      // it correctly parses the maxSize option and not only uses simple string comparison
      // 1000M should be bigger than the ini value
      $tests[] = array(
        UPLOAD_ERR_INI_SIZE,
        'uploadIniSizeErrorMessage',
        array(
          '{{ limit }}' => UploadedFile::getMaxFilesize() / 1048576,
          '{{ suffix }}' => 'MiB',
        ),
        '1000M',
      );

      // it correctly parses the maxSize option and not only uses simple string comparison
      // 1000M should be bigger than the ini value
      $tests[] = array(
        UPLOAD_ERR_INI_SIZE,
        'uploadIniSizeErrorMessage',
        array(
          '{{ limit }}' => '0.1',
          '{{ suffix }}' => 'MB',
        ),
        '100K',
      );
    }
    return $tests;
  }
  protected abstract function getFile($filename);

}

Members

Namesort descending Modifiers Type Description Overrides
AbstractConstraintValidatorTest::$constraint protected property
AbstractConstraintValidatorTest::$context protected property 1
AbstractConstraintValidatorTest::$defaultTimezone protected property
AbstractConstraintValidatorTest::$group protected property
AbstractConstraintValidatorTest::$metadata protected property
AbstractConstraintValidatorTest::$object protected property
AbstractConstraintValidatorTest::$propertyPath protected property
AbstractConstraintValidatorTest::$root protected property
AbstractConstraintValidatorTest::$validator protected property 1
AbstractConstraintValidatorTest::$value protected property
AbstractConstraintValidatorTest::assertNoViolation protected function
AbstractConstraintValidatorTest::assertViolation Deprecated protected function
AbstractConstraintValidatorTest::assertViolations Deprecated protected function
AbstractConstraintValidatorTest::buildViolation protected function
AbstractConstraintValidatorTest::createContext protected function
AbstractConstraintValidatorTest::createViolation Deprecated protected function
AbstractConstraintValidatorTest::expectNoValidate protected function
AbstractConstraintValidatorTest::expectValidateAt protected function
AbstractConstraintValidatorTest::expectValidateValueAt protected function
AbstractConstraintValidatorTest::restoreDefaultTimezone protected function
AbstractConstraintValidatorTest::setDefaultTimezone protected function
AbstractConstraintValidatorTest::setGroup protected function
AbstractConstraintValidatorTest::setObject protected function
AbstractConstraintValidatorTest::setProperty protected function
AbstractConstraintValidatorTest::setPropertyPath protected function
AbstractConstraintValidatorTest::setRoot protected function
AbstractConstraintValidatorTest::setValue protected function
FileValidatorTest::$file protected property
FileValidatorTest::$path protected property
FileValidatorTest::createValidator protected function Overrides AbstractConstraintValidatorTest::createValidator
FileValidatorTest::getApiVersion protected function Overrides AbstractConstraintValidatorTest::getApiVersion
FileValidatorTest::getFile abstract protected function 2
FileValidatorTest::provideBinaryFormatTests public function
FileValidatorTest::provideMaxSizeExceededTests public function
FileValidatorTest::provideMaxSizeNotExceededTests public function
FileValidatorTest::setUp protected function Overrides AbstractConstraintValidatorTest::setUp
FileValidatorTest::tearDown protected function Overrides AbstractConstraintValidatorTest::tearDown
FileValidatorTest::testBinaryFormat public function @dataProvider provideBinaryFormatTests
FileValidatorTest::testDisallowEmpty public function
FileValidatorTest::testEmptyStringIsValid public function
FileValidatorTest::testExpectsStringCompatibleTypeOrFile public function @expectedException \Symfony\Component\Validator\Exception\UnexpectedTypeException
FileValidatorTest::testInvalidMaxSize public function @expectedException \Symfony\Component\Validator\Exception\ConstraintDefinitionException
FileValidatorTest::testInvalidMimeType public function
FileValidatorTest::testInvalidWildcardMimeType public function
FileValidatorTest::testMaxSizeExceeded public function @dataProvider provideMaxSizeExceededTests
FileValidatorTest::testMaxSizeNotExceeded public function @dataProvider provideMaxSizeNotExceededTests
FileValidatorTest::testNullIsValid public function
FileValidatorTest::testUploadedFileError public function @dataProvider uploadedFileErrorProvider
FileValidatorTest::testValidFile public function
FileValidatorTest::testValidMimeType public function
FileValidatorTest::testValidUploadedfile public function
FileValidatorTest::testValidWildcardMimeType public function
FileValidatorTest::uploadedFileErrorProvider public function