public function test_create_token_folder_if_it_does_not_exist()
{
$this->assertFalse(vfsStreamWrapper::getRoot()->hasChild('tokens'), 'Folder should not exists');
$tokenizer = $this->instantiateClass('token_filename_retrieve.token', vfsStream::url('testDir/tokens'), $this->token_content, new Filesystem());
$tokenizer->retrieve();
$this->assertTrue(vfsStreamWrapper::getRoot()->hasChild('tokens'), 'Folder should now exists even if retrieve notes file does not');
}
/**
* Sets up the test fixture.
*
* @return void
*/
public function setUp()
{
vfsStreamWrapper::register();
vfsStreamWrapper::setRoot(new vfsStreamDirectory('test'));
$this->forum = 'test';
$this->contents = new Forum_Contents(vfsStream::url('test'));
}
private function createFile($filePath, $body = 'hello')
{
vfsStream::newFile($filePath)->at(vfsStreamWrapper::getRoot());
$path = vfsStream::url('root/' . $filePath);
file_put_contents($path, $body);
return $path;
}
public function setUp()
{
vfsStreamWrapper::register();
$root = vfsStream::setup('logs');
$mockFile = vfsStream::newFile('logging_helper.log')->at($root);
$root->addChild($mockFile);
}
public function testConstruct()
{
// test non existent file
$nonExistentFilePath = "non/existent/file.php";
try {
new ConsoleRunner($nonExistentFilePath, $this->pidFactory, []);
$this->fail("Should not be able to create a console runner without a console file that exists");
} catch (RunnerException $e) {
$this->assertContains($nonExistentFilePath, $e->getMessage());
}
// test non executable file
$nonExecutableFilePath = "nonExecutableFile.php";
$nonExecutableFile = vfsStream::newFile($nonExecutableFilePath, 00);
vfsStreamWrapper::getRoot()->addChild($nonExecutableFile);
$nonExecutableFilePath = $this->getPath($nonExecutableFilePath);
try {
new ConsoleRunner($nonExecutableFilePath, $this->pidFactory, []);
$this->fail("Should not be able to create a console runner without a console file that is executable");
} catch (RunnerException $e) {
$this->assertContains($nonExecutableFilePath, $e->getMessage());
}
// test valid file
$consolePath = "console.php";
$nonExecutableFile = vfsStream::newFile($consolePath, 0444);
vfsStreamWrapper::getRoot()->addChild($nonExecutableFile);
$consolePath = $this->getPath($consolePath);
$runner = new ConsoleRunner($consolePath, $this->pidFactory, []);
$this->assertAttributeEquals($consolePath, "consolePath", $runner);
}
protected function setFileSystem()
{
vfsStreamWrapper::register();
$root = vfsStream::newDirectory('build');
vfsStreamWrapper::setRoot($root);
return $root;
}
/**
* Tests the YAML file discovery.
*/
public function testDiscovery()
{
vfsStreamWrapper::register();
$root = new vfsStreamDirectory('modules');
vfsStreamWrapper::setRoot($root);
$url = vfsStream::url('modules');
mkdir($url . '/test_1');
file_put_contents($url . '/test_1/test_1.test.yml', 'name: test');
file_put_contents($url . '/test_1/test_2.test.yml', 'name: test');
mkdir($url . '/test_2');
file_put_contents($url . '/test_2/test_3.test.yml', 'name: test');
// Write an empty YAML file.
file_put_contents($url . '/test_2/test_4.test.yml', '');
// Set up the directories to search.
$directories = array('test_1' => $url . '/test_1', 'test_2' => $url . '/test_1', 'test_3' => $url . '/test_2', 'test_4' => $url . '/test_2');
$discovery = new YamlDiscovery('test', $directories);
$data = $discovery->findAll();
$this->assertEquals(count($data), count($directories));
$this->assertArrayHasKey('test_1', $data);
$this->assertArrayHasKey('test_2', $data);
$this->assertArrayHasKey('test_3', $data);
$this->assertArrayHasKey('test_4', $data);
foreach (array('test_1', 'test_2', 'test_3') as $key) {
$this->assertArrayHasKey('name', $data[$key]);
$this->assertEquals($data[$key]['name'], 'test');
}
$this->assertSame(array(), $data['test_4']);
}
protected function setUp()
{
parent::setUp();
vfsStreamWrapper::register();
$this->vfs = new vfsStreamDirectory('chunks');
vfsStreamWrapper::setRoot($this->vfs);
}
public function setUp(DiInterface $di = NULL, Config $config = NULL)
{
vfsStream::setup('root');
vfsStream::newFile('file.php')->at(vfsStreamWrapper::getRoot());
$this->file = vfsStream::url('root/file.php');
parent::setUp($di, $config);
}
/**
* @test
* @expectedException \Neos\FluidAdaptor\View\Exception\InvalidTemplateResourceException
*/
public function getPartialPathAndFilenameThrowsExceptionIfPartialFileIsADirectory()
{
vfsStreamWrapper::register();
mkdir('vfs://MyPartials/NotAFile');
$this->standaloneView->setPartialRootPath('vfs://MyPartials');
$this->standaloneView->getTemplatePaths()->getPartialSource('NotAFile');
}
public function testFactoryCreateServiceWithName()
{
$this->init(array('logger' => array($this->key => array('path' => vfsStream::url('logs/default.log')))));
$this->assertFalse(vfsStreamWrapper::getRoot()->hasChild('default.log'));
$this->assertInstanceOf('Zend\\Log\\Logger', $this->factory->createServiceWithName($this->serviceLocator, $this->key, $this->key));
$this->assertTrue(vfsStreamWrapper::getRoot()->hasChild('default.log'));
}
public function setUp()
{
$this->rootDir = new vfsStreamDirectory('queries');
vfsStreamWrapper::register();
vfsStreamWrapper::setRoot($this->rootDir);
$this->loader = new FilesystemQueryLoader($this->rootDir->url());
}
/**
* Sets up this testcase
*
* @return void
*/
protected function setUp()
{
if (!class_exists('org\\bovigo\\vfs\\vfsStreamWrapper')) {
$this->markTestSkipped('File backend tests are not available with this phpunit version.');
}
vfsStreamWrapper::register();
vfsStreamWrapper::setRoot(new vfsStreamDirectory('Foo'));
}
/**
* @test
*/
public function passwordShouldBeAddToRsaIfPasswordPassed()
{
vfsStream::newFile('id_rsa')->at(vfsStreamWrapper::getRoot());
$authentication = new Rsa('root', vfsStream::url('root/id_rsa'), 'password');
/** @var \Crypt_RSA $rsa */
$rsa = $authentication->getAuthentication();
$this->assertEquals('password', $rsa->password);
}
/**
* Retrieves the virtual file system path
*
* @param string $path The path relative to the root folder
*
* @return string
*/
protected function vfsPath($path = '')
{
$root = vfsStreamWrapper::getRoot()->getName();
if (empty($path)) {
return vfsStream::url($root);
}
return vfsStream::url($root . '/' . $path);
}
public function tearDownCacheDir()
{
vfsStreamWrapper::register();
$cacheDir = vfsStream::url('zf2-module-test');
if (is_dir($cacheDir)) {
static::rmdir($cacheDir);
}
}
public function setUp()
{
$this->buildDir = new vfsStreamDirectory('build');
vfsStreamWrapper::register();
vfsStreamWrapper::setRoot($this->buildDir);
$this->filesystem = m::mock('Symfony\\Component\\Filesystem\\Filesystem');
$this->application = new Application($this->getMockKernel());
}
function __construct()
{
parent::__construct();
vfsStreamWrapper::register();
\Mockery::getConfiguration()->allowMockingNonExistentMethods(false);
$this->objectMother = new \UnitTest\Lib\ObjectMother($this);
$this->onCreate();
}
/**
* PHPUnit cannot add this to code coverage
*
* @codeCoverageIgnore
*
* @param $swaggerPath
*
* @throws \org\bovigo\vfs\vfsStreamException
*/
public static function initSchemaManager($swaggerPath)
{
vfsStreamWrapper::register();
vfsStreamWrapper::setRoot(new vfsStreamDirectory('root'));
file_put_contents(vfsStream::url('root') . '/swagger.json', json_encode(Yaml::parse(file_get_contents($swaggerPath))));
self::$schemaManager = new SchemaManager(vfsStream::url('root') . '/swagger.json');
self::$document = new SwaggerDocument($swaggerPath);
}
public function testCacheWSDLIsWorldWritable()
{
vfsStreamWrapper::register();
vfsStreamWrapper::setRoot(new vfsStreamDirectory('tmp'));
$SOAP = $this->getMock('SSRS\\Soap\\NTLM', array('setCacheWSDLPermission'), array('http://'));
$SOAP->expects($this->once())->method('setCacheWSDLPermission')->with($this->equalTo(0666));
$SOAP->setCachePath(vfsStream::url('tmp/file.wsdl'))->cacheWSDL('$fileContents');
}
public function setUp()
{
vfsStreamWrapper::register();
$root = new vfsStreamDirectory('root');
vfsStreamWrapper::setRoot($root);
vfsStream::copyFromFileSystem(__DIR__ . '/../package');
$this->config = ['version' => '1.0.4', 'configFile' => vfsStream::url('root/app/code/community/Slovenian/LocalePackSl/etc/config.xml'), 'packageFile' => vfsStream::url('root/package.xml')];
}
/**
* Sets up the fixture, for example, opens a network connection.
* This method is called before a test is executed.
*/
protected function setUp()
{
$this->object = new NlReader();
vfsStreamWrapper::register();
$root = vfsStream::newDirectory('tmp');
vfsStreamWrapper::setRoot($root);
$this->file = vfsStream::newFile('items.csv', 0764)->withContent("73-ou-XW46\nApple\n1\na")->at($root);
}
/**
* @test
*
* @covers Cocur\Bundle\BuildBundle\Writer\FilesystemWriter::write()
* @covers Cocur\Bundle\BuildBundle\Writer\FilesystemWriter::getRealName()
*/
public function writeShouldWriteIfFileIsInDirectory()
{
$root = vfsStreamWrapper::getRoot();
$this->writer->write('/foo', 'Foobar');
$this->assertTrue($root->hasChild('foo'));
$this->assertTrue($root->getChild('foo')->hasChild('index.html'));
$this->assertEquals('Foobar', $root->getChild('foo')->getChild('index.html')->getContent());
}
protected function setUp()
{
$this->root = new vfsStreamDirectory('test');
vfsStreamWrapper::register();
vfsStreamWrapper::setRoot($this->root);
$this->responder = new StaticHtmlFileResponder($this->root->url(), 'file');
$this->response = new Response();
}
public function testExtractPublicKeyToFileWriteError()
{
$root = vfsStream::newDirectory('test');
$root->addChild(vfsStream::newFile('test.key', 00));
vfsStreamWrapper::setRoot($root);
$this->setExpectedException('RuntimeException', 'The public key file "vfs://test/test.key" could not be written:');
$key = $this->helper->createPrivateKey('test');
$this->helper->extractPublicKeyToFile('vfs://test/test.key', $key, 'test');
}
protected function setFileSystem()
{
vfsStreamWrapper::register();
$root = vfsStream::newDirectory('build');
vfsStreamWrapper::setRoot($root);
$packagesBuilder = new PackagesBuilder(new NullOutput(), vfsStream::url('build'), array('repositories' => array(array('type' => 'composer', 'url' => 'http://localhost:54715')), 'require' => array('vendor/name' => '*')), false);
$packagesBuilder->dump(array($this->package));
return $root;
}
public function testSetLastUidCorrectly()
{
$this->initRoot();
$file = vfsStream::url('home/lastui.json');
$lastUidPersistFile = new LastUidPersistFile($file);
$lastUidPersistFile->setLastUid(12);
$this->assertTrue(vfsStreamWrapper::getRoot()->hasChild('lastui.json'), 'The file is not created');
$this->assertTrue(file_get_contents($file) == json_encode(array('lastUid' => 12)), 'The file content is not correct');
}
/** @test */
public function attachPhoto()
{
$pic = 'photo.jpg';
vfsStreamWrapper::register();
$root = vfsStream::newDirectory('pics');
vfsStreamWrapper::setRoot($root);
vfsStream::newFile($pic)->at($root);
$this->entry->attachPhoto(vfsStream::url('pics/' . $pic));
$this->assertTrue($this->entry->hasPhoto());
}
public function testInitWithExistingIdxFile()
{
vfsStreamWrapper::getRoot()->addChild(new vfsStreamFile('idxfile.php'));
$idx = $this->getMock('\\Idephix\\IdephixInterface');
$idx->output = $this->getMock('Symfony\\Component\\Console\\Output\\OutputInterface');
$idx->output->expects($this->exactly(1))->method('writeln')->with("<error>An idxfile.php already exists, generation skipped.</error>");
$initIdxFile = new InitIdxFile('vfs://root');
$initIdxFile->setIdephix($idx);
$initIdxFile->initFile();
}
/**
* @expectedException Message\Cog\Config\Exception
* @expectedExceptionMessage Config file `vfs://config/myconfig.yml` is not readable
*/
public function testExceptionThrownWhenConfigFileNotReadable()
{
vfsStream::setup('config');
vfsStream::newFile('myconfig.yml', 0333)->at(vfsStreamWrapper::getRoot());
$env = new FauxEnvironment();
$env->set('staging');
$loader = new Loader(vfsStream::url('config'), $env);
$registry = new NonLoadingRegistry($loader);
$loader->load($registry);
}
