You are here

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

class vfsStreamWrapperMkDirTestCase in Zircon Profile 8

Same name and namespace in other branches
  1. 8.0 vendor/mikey179/vfsStream/src/test/php/org/bovigo/vfs/vfsStreamWrapperDirTestCase.php \org\bovigo\vfs\vfsStreamWrapperMkDirTestCase

Test for org\bovigo\vfs\vfsStreamWrapper around mkdir().

@package bovigo_vfs @subpackage test

Hierarchy

Expanded class hierarchy of vfsStreamWrapperMkDirTestCase

File

vendor/mikey179/vfsStream/src/test/php/org/bovigo/vfs/vfsStreamWrapperDirTestCase.php, line 18

Namespace

org\bovigo\vfs
View source 
class vfsStreamWrapperMkDirTestCase extends vfsStreamWrapperBaseTestCase {

  /**
   * mkdir() should not overwrite existing root
   *
   * @test
   */
  public function mkdirNoNewRoot() {
    $this
      ->assertFalse(mkdir(vfsStream::url('another')));
    $this
      ->assertEquals(2, count($this->foo
      ->getChildren()));
    $this
      ->assertSame($this->foo, vfsStreamWrapper::getRoot());
  }

  /**
   * mkdir() should not overwrite existing root
   *
   * @test
   */
  public function mkdirNoNewRootRecursively() {
    $this
      ->assertFalse(mkdir(vfsStream::url('another/more'), 0777, true));
    $this
      ->assertEquals(2, count($this->foo
      ->getChildren()));
    $this
      ->assertSame($this->foo, vfsStreamWrapper::getRoot());
  }

  /**
   * assert that mkdir() creates the correct directory structure
   *
   * @test
   * @group  permissions
   */
  public function mkdirNonRecursively() {
    $this
      ->assertFalse(mkdir($this->barURL . '/another/more'));
    $this
      ->assertEquals(2, count($this->foo
      ->getChildren()));
    $this
      ->assertTrue(mkdir($this->fooURL . '/another'));
    $this
      ->assertEquals(3, count($this->foo
      ->getChildren()));
    $this
      ->assertEquals(0777, $this->foo
      ->getChild('another')
      ->getPermissions());
  }

  /**
   * assert that mkdir() creates the correct directory structure
   *
   * @test
   * @group  permissions
   */
  public function mkdirRecursively() {
    $this
      ->assertTrue(mkdir($this->fooURL . '/another/more', 0777, true));
    $this
      ->assertEquals(3, count($this->foo
      ->getChildren()));
    $another = $this->foo
      ->getChild('another');
    $this
      ->assertTrue($another
      ->hasChild('more'));
    $this
      ->assertEquals(0777, $this->foo
      ->getChild('another')
      ->getPermissions());
    $this
      ->assertEquals(0777, $this->foo
      ->getChild('another')
      ->getChild('more')
      ->getPermissions());
  }

  /**
   * @test
   * @group  issue_9
   * @since  0.9.0
   */
  public function mkdirWithDots() {
    $this
      ->assertTrue(mkdir($this->fooURL . '/another/../more/.', 0777, true));
    $this
      ->assertEquals(3, count($this->foo
      ->getChildren()));
    $this
      ->assertTrue($this->foo
      ->hasChild('more'));
  }

  /**
   * no root > new directory becomes root
   *
   * @test
   * @group  permissions
   */
  public function mkdirWithoutRootCreatesNewRoot() {
    vfsStreamWrapper::register();
    $this
      ->assertTrue(@mkdir(vfsStream::url('foo')));
    $this
      ->assertEquals(vfsStreamContent::TYPE_DIR, vfsStreamWrapper::getRoot()
      ->getType());
    $this
      ->assertEquals('foo', vfsStreamWrapper::getRoot()
      ->getName());
    $this
      ->assertEquals(0777, vfsStreamWrapper::getRoot()
      ->getPermissions());
  }

  /**
   * trying to create a subdirectory of a file should not work
   *
   * @test
   */
  public function mkdirOnFileReturnsFalse() {
    $this
      ->assertFalse(mkdir($this->baz1URL . '/another/more', 0777, true));
  }

  /**
   * assert that mkdir() creates the correct directory structure
   *
   * @test
   * @group  permissions
   */
  public function mkdirNonRecursivelyDifferentPermissions() {
    $this
      ->assertTrue(mkdir($this->fooURL . '/another', 0755));
    $this
      ->assertEquals(0755, $this->foo
      ->getChild('another')
      ->getPermissions());
  }

  /**
   * assert that mkdir() creates the correct directory structure
   *
   * @test
   * @group  permissions
   */
  public function mkdirRecursivelyDifferentPermissions() {
    $this
      ->assertTrue(mkdir($this->fooURL . '/another/more', 0755, true));
    $this
      ->assertEquals(3, count($this->foo
      ->getChildren()));
    $another = $this->foo
      ->getChild('another');
    $this
      ->assertTrue($another
      ->hasChild('more'));
    $this
      ->assertEquals(0755, $this->foo
      ->getChild('another')
      ->getPermissions());
    $this
      ->assertEquals(0755, $this->foo
      ->getChild('another')
      ->getChild('more')
      ->getPermissions());
  }

  /**
   * assert that mkdir() creates the correct directory structure
   *
   * @test
   * @group  permissions
   */
  public function mkdirRecursivelyUsesDefaultPermissions() {
    $this->foo
      ->chmod(0700);
    $this
      ->assertTrue(mkdir($this->fooURL . '/another/more', 0777, true));
    $this
      ->assertEquals(3, count($this->foo
      ->getChildren()));
    $another = $this->foo
      ->getChild('another');
    $this
      ->assertTrue($another
      ->hasChild('more'));
    $this
      ->assertEquals(0777, $this->foo
      ->getChild('another')
      ->getPermissions());
    $this
      ->assertEquals(0777, $this->foo
      ->getChild('another')
      ->getChild('more')
      ->getPermissions());
  }

  /**
   * no root > new directory becomes root
   *
   * @test
   * @group  permissions
   */
  public function mkdirWithoutRootCreatesNewRootDifferentPermissions() {
    vfsStreamWrapper::register();
    $this
      ->assertTrue(@mkdir(vfsStream::url('foo'), 0755));
    $this
      ->assertEquals(vfsStreamContent::TYPE_DIR, vfsStreamWrapper::getRoot()
      ->getType());
    $this
      ->assertEquals('foo', vfsStreamWrapper::getRoot()
      ->getName());
    $this
      ->assertEquals(0755, vfsStreamWrapper::getRoot()
      ->getPermissions());
  }

  /**
   * no root > new directory becomes root
   *
   * @test
   * @group  permissions
   */
  public function mkdirWithoutRootCreatesNewRootWithDefaultPermissions() {
    vfsStreamWrapper::register();
    $this
      ->assertTrue(@mkdir(vfsStream::url('foo')));
    $this
      ->assertEquals(vfsStreamContent::TYPE_DIR, vfsStreamWrapper::getRoot()
      ->getType());
    $this
      ->assertEquals('foo', vfsStreamWrapper::getRoot()
      ->getName());
    $this
      ->assertEquals(0777, vfsStreamWrapper::getRoot()
      ->getPermissions());
  }

  /**
   * @test
   * @group  permissions
   * @group  bug_15
   */
  public function mkdirDirCanNotCreateNewDirInNonWritingDirectory() {
    vfsStreamWrapper::register();
    vfsStreamWrapper::setRoot(new vfsStreamDirectory('root'));
    vfsStreamWrapper::getRoot()
      ->addChild(new vfsStreamDirectory('restrictedFolder', 00));
    $this
      ->assertFalse(is_writable(vfsStream::url('root/restrictedFolder/')));
    $this
      ->assertFalse(mkdir(vfsStream::url('root/restrictedFolder/newFolder')));
    $this
      ->assertFalse(vfsStreamWrapper::getRoot()
      ->hasChild('restrictedFolder/newFolder'));
  }

  /**
   * @test
   * @group  issue_28
   */
  public function mkDirShouldNotOverwriteExistingDirectories() {
    vfsStream::setup('root');
    $dir = vfsStream::url('root/dir');
    $this
      ->assertTrue(mkdir($dir));
    $this
      ->assertFalse(@mkdir($dir));
  }

  /**
   * @test
   * @group  issue_28
   * @expectedException PHPUnit_Framework_Error
   * @expectedExceptionMessage  mkdir(): Path vfs://root/dir exists
   */
  public function mkDirShouldNotOverwriteExistingDirectoriesAndTriggerE_USER_WARNING() {
    vfsStream::setup('root');
    $dir = vfsStream::url('root/dir');
    $this
      ->assertTrue(mkdir($dir));
    $this
      ->assertFalse(mkdir($dir));
  }

  /**
   * @test
   * @group  issue_28
   */
  public function mkDirShouldNotOverwriteExistingFiles() {
    $root = vfsStream::setup('root');
    vfsStream::newFile('test.txt')
      ->at($root);
    $this
      ->assertFalse(@mkdir(vfsStream::url('root/test.txt')));
  }

  /**
   * @test
   * @group  issue_28
   * @expectedException PHPUnit_Framework_Error
   * @expectedExceptionMessage  mkdir(): Path vfs://root/test.txt exists
   */
  public function mkDirShouldNotOverwriteExistingFilesAndTriggerE_USER_WARNING() {
    $root = vfsStream::setup('root');
    vfsStream::newFile('test.txt')
      ->at($root);
    $this
      ->assertFalse(mkdir(vfsStream::url('root/test.txt')));
  }

  /**
   * @test
   * @group  permissions
   * @group  bug_15
   */
  public function canNotIterateOverNonReadableDirectory() {
    vfsStreamWrapper::register();
    vfsStreamWrapper::setRoot(new vfsStreamDirectory('root', 00));
    $this
      ->assertFalse(@opendir(vfsStream::url('root')));
    $this
      ->assertFalse(@dir(vfsStream::url('root')));
  }

  /**
   * assert is_dir() returns correct result
   *
   * @test
   */
  public function is_dir() {
    $this
      ->assertTrue(is_dir($this->fooURL));
    $this
      ->assertTrue(is_dir($this->fooURL . '/.'));
    $this
      ->assertTrue(is_dir($this->barURL));
    $this
      ->assertTrue(is_dir($this->barURL . '/.'));
    $this
      ->assertFalse(is_dir($this->baz1URL));
    $this
      ->assertFalse(is_dir($this->baz2URL));
    $this
      ->assertFalse(is_dir($this->fooURL . '/another'));
    $this
      ->assertFalse(is_dir(vfsStream::url('another')));
  }

  /**
   * can not unlink without root
   *
   * @test
   */
  public function canNotUnlinkDirectoryWithoutRoot() {
    vfsStreamWrapper::register();
    $this
      ->assertFalse(@rmdir(vfsStream::url('foo')));
  }

  /**
   * rmdir() can not remove files
   *
   * @test
   */
  public function rmdirCanNotRemoveFiles() {
    $this
      ->assertFalse(rmdir($this->baz1URL));
    $this
      ->assertFalse(rmdir($this->baz2URL));
  }

  /**
   * rmdir() can not remove a non-existing directory
   *
   * @test
   */
  public function rmdirCanNotRemoveNonExistingDirectory() {
    $this
      ->assertFalse(rmdir($this->fooURL . '/another'));
  }

  /**
   * rmdir() can not remove non-empty directories
   *
   * @test
   */
  public function rmdirCanNotRemoveNonEmptyDirectory() {
    $this
      ->assertFalse(rmdir($this->fooURL));
    $this
      ->assertFalse(rmdir($this->barURL));
  }

  /**
   * @test
   */
  public function rmdirCanRemoveEmptyDirectory() {
    vfsStream::newDirectory('empty')
      ->at($this->foo);
    $this
      ->assertTrue($this->foo
      ->hasChild('empty'));
    $this
      ->assertTrue(rmdir($this->fooURL . '/empty'));
    $this
      ->assertFalse($this->foo
      ->hasChild('empty'));
  }

  /**
   * @test
   */
  public function rmdirCanRemoveEmptyDirectoryWithDot() {
    vfsStream::newDirectory('empty')
      ->at($this->foo);
    $this
      ->assertTrue($this->foo
      ->hasChild('empty'));
    $this
      ->assertTrue(rmdir($this->fooURL . '/empty/.'));
    $this
      ->assertFalse($this->foo
      ->hasChild('empty'));
  }

  /**
   * rmdir() can remove empty directories
   *
   * @test
   */
  public function rmdirCanRemoveEmptyRoot() {
    $this->foo
      ->removeChild('bar');
    $this->foo
      ->removeChild('baz2');
    $this
      ->assertTrue(rmdir($this->fooURL));
    $this
      ->assertFalse(file_exists($this->fooURL));

    // make sure statcache was cleared
    $this
      ->assertNull(vfsStreamWrapper::getRoot());
  }

  /**
   * @test
   * @group  permissions
   * @group  bug_15
   */
  public function rmdirDirCanNotRemoveDirFromNonWritingDirectory() {
    vfsStreamWrapper::register();
    vfsStreamWrapper::setRoot(new vfsStreamDirectory('root', 00));
    vfsStreamWrapper::getRoot()
      ->addChild(new vfsStreamDirectory('nonRemovableFolder'));
    $this
      ->assertFalse(is_writable(vfsStream::url('root')));
    $this
      ->assertFalse(rmdir(vfsStream::url('root/nonRemovableFolder')));
    $this
      ->assertTrue(vfsStreamWrapper::getRoot()
      ->hasChild('nonRemovableFolder'));
  }

  /**
   * @test
   * @group  permissions
   * @group  bug_17
   */
  public function issue17() {
    vfsStreamWrapper::register();
    vfsStreamWrapper::setRoot(new vfsStreamDirectory('root', 0770));
    vfsStreamWrapper::getRoot()
      ->chgrp(vfsStream::GROUP_USER_1)
      ->chown(vfsStream::OWNER_USER_1);
    $this
      ->assertFalse(mkdir(vfsStream::url('root/doesNotWork')));
    $this
      ->assertFalse(vfsStreamWrapper::getRoot()
      ->hasChild('doesNotWork'));
  }

  /**
   * @test
   * @group  bug_19
   */
  public function accessWithDoubleDotReturnsCorrectContent() {
    $this
      ->assertEquals('baz2', file_get_contents(vfsStream::url('foo/bar/../baz2')));
  }

  /**
   * @test
   * @group bug_115
   */
  public function accessWithExcessDoubleDotsReturnsCorrectContent() {
    $this
      ->assertEquals('baz2', file_get_contents(vfsStream::url('foo/../../../../bar/../baz2')));
  }

  /**
   * @test
   * @group bug_115
   */
  public function alwaysResolvesRootDirectoryAsOwnParentWithDoubleDot() {
    vfsStreamWrapper::getRoot()
      ->chown(vfsStream::OWNER_USER_1);
    $this
      ->assertTrue(is_dir(vfsStream::url('foo/..')));
    $stat = stat(vfsStream::url('foo/..'));
    $this
      ->assertEquals(vfsStream::OWNER_USER_1, $stat['uid']);
  }

  /**
   * @test
   * @since  0.11.0
   * @group  issue_23
   */
  public function unlinkCanNotRemoveNonEmptyDirectory() {
    try {
      $this
        ->assertFalse(unlink($this->barURL));
    } catch (\PHPUnit_Framework_Error $fe) {
      $this
        ->assertEquals('unlink(vfs://foo/bar): Operation not permitted', $fe
        ->getMessage());
    }
    $this
      ->assertTrue($this->foo
      ->hasChild('bar'));
    $this
      ->assertFileExists($this->barURL);
  }

  /**
   * @test
   * @since  0.11.0
   * @group  issue_23
   */
  public function unlinkCanNotRemoveEmptyDirectory() {
    vfsStream::newDirectory('empty')
      ->at($this->foo);
    try {
      $this
        ->assertTrue(unlink($this->fooURL . '/empty'));
    } catch (\PHPUnit_Framework_Error $fe) {
      $this
        ->assertEquals('unlink(vfs://foo/empty): Operation not permitted', $fe
        ->getMessage());
    }
    $this
      ->assertTrue($this->foo
      ->hasChild('empty'));
    $this
      ->assertFileExists($this->fooURL . '/empty');
  }

  /**
   * @test
   * @group  issue_32
   */
  public function canCreateFolderOfSameNameAsParentFolder() {
    $root = vfsStream::setup('testFolder');
    mkdir(vfsStream::url('testFolder') . '/testFolder/subTestFolder', 0777, true);
    $this
      ->assertTrue(file_exists(vfsStream::url('testFolder/testFolder/subTestFolder/.')));
  }

  /**
   * @test
   * @group  issue_32
   */
  public function canRetrieveFolderOfSameNameAsParentFolder() {
    $root = vfsStream::setup('testFolder');
    mkdir(vfsStream::url('testFolder') . '/testFolder/subTestFolder', 0777, true);
    $this
      ->assertTrue($root
      ->hasChild('testFolder'));
    $this
      ->assertNotNull($root
      ->getChild('testFolder'));
  }

}

Members

Namesort descending Modifiers Type Description Overrides
vfsStreamWrapperBaseTestCase::$bar protected property sub directory
vfsStreamWrapperBaseTestCase::$barURL protected property URL of sub directory
vfsStreamWrapperBaseTestCase::$baz1 protected property a file
vfsStreamWrapperBaseTestCase::$baz1URL protected property URL of file 1
vfsStreamWrapperBaseTestCase::$baz2 protected property another file
vfsStreamWrapperBaseTestCase::$baz2URL protected property URL of file 2
vfsStreamWrapperBaseTestCase::$foo protected property root directory
vfsStreamWrapperBaseTestCase::$fooURL protected property URL of root directory
vfsStreamWrapperBaseTestCase::setUp public function set up test environment
vfsStreamWrapperMkDirTestCase::accessWithDoubleDotReturnsCorrectContent public function @test @group bug_19
vfsStreamWrapperMkDirTestCase::accessWithExcessDoubleDotsReturnsCorrectContent public function @test @group bug_115
vfsStreamWrapperMkDirTestCase::alwaysResolvesRootDirectoryAsOwnParentWithDoubleDot public function @test @group bug_115
vfsStreamWrapperMkDirTestCase::canCreateFolderOfSameNameAsParentFolder public function @test @group issue_32
vfsStreamWrapperMkDirTestCase::canNotIterateOverNonReadableDirectory public function @test @group permissions @group bug_15
vfsStreamWrapperMkDirTestCase::canNotUnlinkDirectoryWithoutRoot public function can not unlink without root
vfsStreamWrapperMkDirTestCase::canRetrieveFolderOfSameNameAsParentFolder public function @test @group issue_32
vfsStreamWrapperMkDirTestCase::issue17 public function @test @group permissions @group bug_17
vfsStreamWrapperMkDirTestCase::is_dir public function assert is_dir() returns correct result
vfsStreamWrapperMkDirTestCase::mkdirDirCanNotCreateNewDirInNonWritingDirectory public function @test @group permissions @group bug_15
vfsStreamWrapperMkDirTestCase::mkdirNoNewRoot public function mkdir() should not overwrite existing root
vfsStreamWrapperMkDirTestCase::mkdirNoNewRootRecursively public function mkdir() should not overwrite existing root
vfsStreamWrapperMkDirTestCase::mkdirNonRecursively public function assert that mkdir() creates the correct directory structure
vfsStreamWrapperMkDirTestCase::mkdirNonRecursivelyDifferentPermissions public function assert that mkdir() creates the correct directory structure
vfsStreamWrapperMkDirTestCase::mkdirOnFileReturnsFalse public function trying to create a subdirectory of a file should not work
vfsStreamWrapperMkDirTestCase::mkdirRecursively public function assert that mkdir() creates the correct directory structure
vfsStreamWrapperMkDirTestCase::mkdirRecursivelyDifferentPermissions public function assert that mkdir() creates the correct directory structure
vfsStreamWrapperMkDirTestCase::mkdirRecursivelyUsesDefaultPermissions public function assert that mkdir() creates the correct directory structure
vfsStreamWrapperMkDirTestCase::mkDirShouldNotOverwriteExistingDirectories public function @test @group issue_28
vfsStreamWrapperMkDirTestCase::mkDirShouldNotOverwriteExistingDirectoriesAndTriggerE_USER_WARNING public function @test @group issue_28 @expectedException PHPUnit_Framework_Error @expectedExceptionMessage mkdir(): Path vfs://root/dir exists
vfsStreamWrapperMkDirTestCase::mkDirShouldNotOverwriteExistingFiles public function @test @group issue_28
vfsStreamWrapperMkDirTestCase::mkDirShouldNotOverwriteExistingFilesAndTriggerE_USER_WARNING public function @test @group issue_28 @expectedException PHPUnit_Framework_Error @expectedExceptionMessage mkdir(): Path vfs://root/test.txt exists
vfsStreamWrapperMkDirTestCase::mkdirWithDots public function @test @group issue_9 @since 0.9.0
vfsStreamWrapperMkDirTestCase::mkdirWithoutRootCreatesNewRoot public function no root > new directory becomes root
vfsStreamWrapperMkDirTestCase::mkdirWithoutRootCreatesNewRootDifferentPermissions public function no root > new directory becomes root
vfsStreamWrapperMkDirTestCase::mkdirWithoutRootCreatesNewRootWithDefaultPermissions public function no root > new directory becomes root
vfsStreamWrapperMkDirTestCase::rmdirCanNotRemoveFiles public function rmdir() can not remove files
vfsStreamWrapperMkDirTestCase::rmdirCanNotRemoveNonEmptyDirectory public function rmdir() can not remove non-empty directories
vfsStreamWrapperMkDirTestCase::rmdirCanNotRemoveNonExistingDirectory public function rmdir() can not remove a non-existing directory
vfsStreamWrapperMkDirTestCase::rmdirCanRemoveEmptyDirectory public function @test
vfsStreamWrapperMkDirTestCase::rmdirCanRemoveEmptyDirectoryWithDot public function @test
vfsStreamWrapperMkDirTestCase::rmdirCanRemoveEmptyRoot public function rmdir() can remove empty directories
vfsStreamWrapperMkDirTestCase::rmdirDirCanNotRemoveDirFromNonWritingDirectory public function @test @group permissions @group bug_15
vfsStreamWrapperMkDirTestCase::unlinkCanNotRemoveEmptyDirectory public function @test @since 0.11.0 @group issue_23
vfsStreamWrapperMkDirTestCase::unlinkCanNotRemoveNonEmptyDirectory public function @test @since 0.11.0 @group issue_23