/** * {@inheritdoc} */ public function _setUpFiles($structure = NULL) { $structure = $structure ?: ['tmp' => []]; $this->root = vfsStream::setup('root', 0777, $structure); $this->adapter = new TempFileAdapter($this->root->url() . '/tmp/', 'bmtest_'); $this->manager = new TempFileManager($this->adapter); }
/** * @param string $className * @dataProvider provider */ public function testGeneratesTestCodeCorrectly($className) { $generatedFile = vfsStream::url('root') . '/' . $className . 'Test.php'; $generator = new TestGenerator($className, __DIR__ . '/_fixture/_input/' . $className . '.php', $className . 'Test', $generatedFile); $generator->write(); $this->assertStringMatchesFormatFile(__DIR__ . '/_fixture/_expected/' . $className . 'Test.php', file_get_contents($generatedFile)); }
function it_creates_internal_io_factory_with_vfs_stream() { $this->serviceContainer->get('ecomdev.phpspec.magento_di_adapter.vfs')->willReturn(vfsStream::setup('custom_root_dir')); $factory = $this->ioFactory(); $factory->shouldImplement(\Closure::class); $factory($this->serviceContainer)->shouldImplement(Io::class); }
/** * We ignore items that are not covered by the map. */ public function testLoadUncovered() { vfsStream::setup('StaticMapTestLoadUncovered', null, ['a.php' => '<?php']); $object = new StaticMap(['A' => vfsStream::url('a.php'), 'B' => vfsStream::url('Covered.php')]); $object->load('StaticMapTestLoadUncoveredC_XYZ'); $this->assertFalse(class_exists('StaticMapTestLoadUncoveredC_XYZ', false)); }
/** * Provides Mutex factories. * * @return callable[][] The mutex factories. */ public function provideMutexFactories() { $cases = ["NoMutex" => [function () { return new NoMutex(); }], "TransactionalMutex" => [function () { $pdo = new \PDO("sqlite::memory:"); $pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION); return new TransactionalMutex($pdo); }], "FlockMutex" => [function () { vfsStream::setup("test"); return new FlockMutex(fopen(vfsStream::url("test/lock"), "w")); }], "SemaphoreMutex" => [function () { return new SemaphoreMutex(sem_get(ftok(__FILE__, "a"))); }], "SpinlockMutex" => [function () { $mock = $this->getMockForAbstractClass(SpinlockMutex::class, ["test"]); $mock->expects($this->any())->method("acquire")->willReturn(true); $mock->expects($this->any())->method("release")->willReturn(true); return $mock; }], "LockMutex" => [function () { $mock = $this->getMockForAbstractClass(LockMutex::class); $mock->expects($this->any())->method("lock")->willReturn(true); $mock->expects($this->any())->method("unlock")->willReturn(true); return $mock; }]]; if (getenv("MEMCACHE_HOST")) { $cases["MemcacheMutex"] = [function () { $memcache = new Memcache(); $memcache->connect(getenv("MEMCACHE_HOST")); return new MemcacheMutex("test", $memcache); }]; $cases["MemcachedMutex"] = [function () { $memcache = new Memcached(); $memcache->addServer(getenv("MEMCACHE_HOST"), 11211); return new MemcachedMutex("test", $memcache); }]; } if (getenv("REDIS_URIS")) { $uris = explode(",", getenv("REDIS_URIS")); $cases["PredisMutex"] = [function () use($uris) { $clients = array_map(function ($uri) { return new Client($uri); }, $uris); return new PredisMutex($clients, "test"); }]; $cases["PHPRedisMutex"] = [function () use($uris) { $apis = array_map(function ($uri) { $redis = new Redis(); $uri = parse_url($uri); if (!empty($uri["port"])) { $redis->connect($uri["host"], $uri["port"]); } else { $redis->connect($uri["host"]); } return $redis; }, $uris); return new PHPRedisMutex($apis, "test"); }]; } return $cases; }
/** * {@inheritdoc} */ public function testLoad() { $xml = <<<'EOF' <?xml version="1.0" encoding="UTF-8"?> <mediatypes> <mediatype name="mp4" category="video"> <mimetypes> <mimetype>video/mp4</mimetype> </mimetypes> </mediatype> <mediatype name="jpg" category="image"> <mimetypes> <mimetype>image/jpg</mimetype> <mimetype>image/jpeg</mimetype> </mimetypes> </mediatype> </mediatypes> EOF; vfsStream::setup('root', null, ['types.xml' => $xml]); $mediatypes = $this->loader->load(vfsStream::url('root/types.xml')); $this->assertCount(2, $mediatypes); $this->assertTrue($mediatypes->has('video:mp4')); $this->assertSame('mp4', $mediatypes->get('video:mp4')->getName()); $this->assertSame('video', $mediatypes->get('video:mp4')->getCategory()); $this->assertCount(1, $mediatypes->get('video:mp4')->getMimetypes()); $this->assertSame(['video/mp4'], $mediatypes->get('video:mp4')->getMimetypes()); $this->assertTrue($mediatypes->has('image:jpg')); $this->assertSame('jpg', $mediatypes->get('image:jpg')->getName()); $this->assertSame('image', $mediatypes->get('image:jpg')->getCategory()); $this->assertCount(2, $mediatypes->get('image:jpg')->getMimetypes()); $this->assertSame(['image/jpg', 'image/jpeg'], $mediatypes->get('image:jpg')->getMimetypes()); }
/** * @expectedException \ErrorException * @covers \Asm\Ansible\Ansible::checkCommand * @covers \Asm\Ansible\Ansible::checkDir * @covers \Asm\Ansible\Ansible::__construct */ public function testAnsibleCommandNotExecutableException() { $vfs = vfsStream::setup('/tmp'); $ansiblePlaybook = vfsStream::newFile('ansible-playbook', 600)->at($vfs); $ansibleGalaxy = vfsStream::newFile('ansible-galaxy', 444)->at($vfs); $ansible = new Ansible($this->getProjectUri(), $ansiblePlaybook->url(), $ansibleGalaxy->url()); }
/** * set up test environment */ public function setUp() { $root = vfsStream::setup(); $this->file = vfsStream::newFile('foo.txt')->withContent("bar\nbaz")->at($root); $this->underlyingStream = fopen($this->file->url(), 'rb+'); $this->stream = new Stream($this->underlyingStream); }
/** * This test creates an extension based on a JSON file, generated * with version 1.0 of the ExtensionBuilder and compares all * generated files with the originally created ones * This test should help, to find compatibility breaking changes * * @test */ function generateExtensionFromVersion3Configuration() { $this->configurationManager = $this->getMock($this->buildAccessibleProxy('EBT\\ExtensionBuilder\\Configuration\\ConfigurationManager'), array('dummy')); $this->extensionSchemaBuilder = $this->objectManager->get('EBT\\ExtensionBuilder\\Service\\ExtensionSchemaBuilder'); $testExtensionDir = $this->fixturesPath . 'TestExtensions/test_extension_v3/'; $jsonFile = $testExtensionDir . \EBT\ExtensionBuilder\Configuration\ConfigurationManager::EXTENSION_BUILDER_SETTINGS_FILE; if (file_exists($jsonFile)) { // compatibility adaptions for configurations from older versions $extensionConfigurationJSON = json_decode(file_get_contents($jsonFile), TRUE); $extensionConfigurationJSON = $this->configurationManager->fixExtensionBuilderJSON($extensionConfigurationJSON, FALSE); } else { $extensionConfigurationJSON = array(); $this->fail('JSON file not found'); } $this->extension = $this->extensionSchemaBuilder->build($extensionConfigurationJSON); $this->fileGenerator->setSettings(array('codeTemplateRootPath' => PATH_typo3conf . 'ext/extension_builder/Resources/Private/CodeTemplates/Extbase/', 'extConf' => array('enableRoundtrip' => '0'))); $newExtensionDir = vfsStream::url('testDir') . '/'; $this->extension->setExtensionDir($newExtensionDir . 'test_extension/'); $this->fileGenerator->build($this->extension); $referenceFiles = \TYPO3\CMS\Core\Utility\GeneralUtility::getAllFilesAndFoldersInPath(array(), $testExtensionDir); foreach ($referenceFiles as $referenceFile) { $createdFile = str_replace($testExtensionDir, $this->extension->getExtensionDir(), $referenceFile); if (!in_array(basename($createdFile), array('ExtensionBuilder.json'))) { $referenceFileContent = str_replace(array('2011-08-11T06:49:00Z', '2011-08-11', '###YEAR###', '2014'), array(date('Y-m-d\\TH:i:00\\Z'), date('Y-m-d'), date('Y'), date('Y')), file_get_contents($referenceFile)); $this->assertFileExists($createdFile, 'File ' . $createdFile . ' was not created!'); // do not compare files that contain a formatted DateTime, as it might have changed between file creation and this comparison if (strpos($referenceFile, 'xlf') === FALSE && strpos($referenceFile, 'yaml') === FALSE) { $originalLines = \TYPO3\CMS\Core\Utility\GeneralUtility::trimExplode(LF, $referenceFileContent, TRUE); $generatedLines = \TYPO3\CMS\Core\Utility\GeneralUtility::trimExplode(LF, file_get_contents($createdFile), TRUE); $this->assertEquals($originalLines, $generatedLines, 'File ' . $createdFile . ' was not equal to original file.'); } } } }
public function testWriteFailsWhenThereIsAProblemWithSymfonyYamlDumper() { $yamlWriterProvider = new YamlWriterProvider($this->mockWriter); $this->mockWriter->expects($this->once())->method('dump')->with(array('result' => false))->willThrowException(new DumpException()); $this->setExpectedException('JGimeno\\TaskReporter\\Infrastructure\\Exception\\YamlProviderException'); $yamlWriterProvider->write(vfsStream::url('settings/config.yml'), array('result' => false)); }
/** * Sets up the fixture, for example, opens a network connection. * This method is called before a test is executed. */ protected function setUp() { $this->dir = vfsStream::setup(); $dir = $this->dir; $tempDir = vfsStream::url($dir->getName()) . '/'; $this->media = $this->getMock('\\Oryzone\\MediaStorage\\Model\\MediaInterface'); $this->media->expects($this->any())->method('getContext')->will($this->returnValue('default')); $this->media->expects($this->any())->method('getName')->will($this->returnValue('sample')); $this->media->expects($this->any())->method('getContent')->will($this->returnValue('http://vimeo.com/56974716')); $this->media->expects($this->any())->method('getMetaValue')->will($this->returnValueMap(array(array('id', null, '56974716')))); $this->variant = $this->getMock('\\Oryzone\\MediaStorage\\Variant\\VariantInterface'); $this->variant->expects($this->any())->method('getName')->will($this->returnValue('default')); $this->variant->expects($this->any())->method('getOptions')->will($this->returnValue(array('width' => 50, 'height' => 30, 'resize' => 'stretch'))); $this->variant->expects($this->any())->method('getMetaValue')->will($this->returnValueMap(array(array('width', null, 50), array('height', null, 30)))); $image = $this->getMock('\\Imagine\\Image\\ImageInterface'); $image->expects($this->any())->method('save')->will($this->returnCallback(function ($destFile) use($dir) { $temp = vfsStream::newFile(basename($destFile)); $dir->addChild($temp); return true; })); $imagine = $this->getMock('\\Imagine\\Image\\ImagineInterface'); $imagine->expects($this->any())->method('open')->will($this->returnValue($image)); $downloader = $this->getMock('\\Oryzone\\MediaStorage\\Downloader\\DownloaderInterface'); $downloader->expects($this->any())->method('download')->will($this->returnCallback(function ($url, $destination) use($dir) { $temp = vfsStream::newFile(basename($destination)); $temp->setContent(file_get_contents(__DIR__ . '/../fixtures/images/sample.jpg')); $dir->addChild($temp); return true; })); $videoService = $this->getMock('\\Oryzone\\MediaStorage\\Integration\\Video\\VideoServiceInterface'); $this->provider = new VimeoProvider($tempDir, $imagine, $videoService, $downloader); }
/** * Setup the test */ public function setUp() { vfsStream::setup('root', null, array('test' => 'testing')); $this->file = vfsStream::url('root/test'); $this->properties = $this->getMock('\\Pants\\Property\\Properties'); $this->task = new Copy($this->properties); }
/** * @covers phpDocumentor\Plugin\Core\Transformer\Writer\CheckStyle::transform */ public function testTransform() { $transformer = m::mock('phpDocumentor\\Transformer\\Transformation'); $transformer->shouldReceive('getTransformer->getTarget')->andReturn(vfsStream::url('CheckStyleTest')); $transformer->shouldReceive('getArtifact')->andReturn('artifact.xml'); $fileDescriptor = m::mock('phpDocumentor\\Descriptor\\FileDescriptor'); $projectDescriptor = m::mock('phpDocumentor\\Descriptor\\ProjectDescriptor'); $projectDescriptor->shouldReceive('getFiles->getAll')->andReturn(array($fileDescriptor)); $error = m::mock('phpDocumentor\\Descriptor\\Validator\\Error'); $fileDescriptor->shouldReceive('getPath')->andReturn('/foo/bar/baz'); $fileDescriptor->shouldReceive('getAllErrors->getAll')->andReturn(array($error)); $error->shouldReceive('getLine')->andReturn(1234); $error->shouldReceive('getCode')->andReturn(5678); $error->shouldReceive('getSeverity')->andReturn('error'); $error->shouldReceive('getContext')->andReturn('myContext'); $this->translator->shouldReceive('translate')->with('5678')->andReturn('5678 %s'); // Call the actual method $this->checkStyle->transform($projectDescriptor, $transformer); // Assert file exists $this->assertTrue($this->fs->hasChild('artifact.xml')); // Inspect XML $xml = <<<XML <?xml version="1.0"?> <checkstyle version="1.3.0"> <file name="/foo/bar/baz"> <error line="1234" severity="error" message="5678 myContext" source="phpDocumentor.file.5678"/> </file> </checkstyle> XML; $expectedXml = new \DOMDocument(); $expectedXml->loadXML($xml); $actualXml = new \DOMDocument(); $actualXml->load(vfsStream::url('CheckStyleTest/artifact.xml')); $this->assertEqualXMLStructure($expectedXml->firstChild, $actualXml->firstChild, true); }
/** */ public function setUp() { ComposerUtility::flushCaches(); vfsStream::setup('Packages'); $this->mockPackageManager = $this->getMockBuilder(\Neos\Flow\Package\PackageManager::class)->disableOriginalConstructor()->getMock(); ObjectAccess::setProperty($this->mockPackageManager, 'composerManifestData', array(), true); }
protected function setUp() { $file = vfsStream::newFile('template'); $this->fileSystem = vfsStream::setup(); $this->fileSystem->addChild($file); $this->filePath = $file->url(); }
public function testFactoryIpFilter() { $this->init(array('logger' => array($this->key => array('path' => vfsStream::url('logs/default.log'), 'ip' => '255.*')))); $logger = $this->factory->createServiceWithName($this->serviceLocator, $this->key, $this->key); $logger->debug('Test'); $this->assertEquals("", file_get_contents(vfsStream::url('logs/default.log'))); }
/** * @test */ public function directoryIsCreated() { $example = new Example('id'); $this->assertFalse($this->root->hasChild('id')); $example->setDirectory(vfsStream::url('exampleDir')); $this->assertTrue($this->root->hasChild('id')); }
/** * 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']); }
public function setUp() { $this->service = new \Nbt\Service(new \Nbt\DataHandler()); $this->vRoot = vfsStream::setup(); $this->vFile = new vfsStreamFile('test.nbt'); $this->vRoot->addChild($this->vFile); }
/** */ public function setUp() { vfsStream::setup('Packages'); $this->mockPackageManager = $this->getMockBuilder('TYPO3\\Flow\\Package\\PackageManager')->disableOriginalConstructor()->getMock(); ObjectAccess::setProperty($this->mockPackageManager, 'composerManifestData', array(), TRUE); $this->packageFactory = new PackageFactory($this->mockPackageManager); }
public function testRemove() { $strategy = $this->getMockForAbstractClass('Corley\\MaintenanceBundle\\Maintenance\\Strategy\\BaseStrategy'); file_put_contents(vfsStream::url('web/a'), "MAINTENANCE"); $strategy->remove(vfsStream::url('web/a')); $this->assertFalse(file_exists(vfsStream::url('web/a'))); }
function let(ParserInterface $parser, FileChecksumInterface $fileChecksum) { $this->parser = $parser; $this->fileChecksum = $fileChecksum; $this->vfs = vfsStream::setup('root', null, ['dummy_file1.txt' => 'some_file_content1']); $this->beConstructedWith($parser, $this->vfs->url() . '/dummy_file1.txt', $this->fileChecksum); }
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 */ public function testThrowsExceptionIfTargetDirectoryExists() { $instance = new ExtensionGenerator(); $instance->setTargetFolder(vfsStream::url('temp')); $this->setExpectedException('RuntimeException'); $instance->generate(); }
/** * 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')); }
/** * Try to load a class that is outside the namespace. */ public function testLoadOutside() { vfsStream::setup('root', null, ['NS' => ['A' => ['B.php' => '<?php class BPSRLoadExists_XYZ {}', 'C.php' => '<?php']]]); $object = new PSR0Namespace(vfsStream::url('root'), 'NS'); $object->load('NS\\A\\D'); $this->assertFalse(class_exists('NS\\A\\D', false)); }
/** * @test */ public function visitRecursiveDirectoryStructure() { $root = vfsStream::setup('root', null, array('test' => array('foo' => array('test.txt' => 'hello'), 'baz.txt' => 'world'), 'foo.txt' => '')); $printVisitor = new vfsStreamPrintVisitor(fopen('vfs://root/foo.txt', 'wb')); $this->assertSame($printVisitor, $printVisitor->visitDirectory($root)); $this->assertEquals("- root\n - test\n - foo\n - test.txt\n - baz.txt\n - foo.txt\n", file_get_contents('vfs://root/foo.txt')); }
/** * @test * @param array $structure * @param array $excludePattern * @param array $expected * @dataProvider getChecksumsForPathReturnsChecksumForFilesDataProvider */ public function getChecksumsForPathReturnsChecksumForFiles(array $structure, array $excludePattern, array $expected) { $baseDirectory = vfsStream::url($this->baseDirectory); $this->createTestStructure($baseDirectory, $structure); $this->assertSame($expected, $this->generator->getChecksumsForPath($baseDirectory, $excludePattern)); $this->assertSame($expected, $this->generator->getChecksumsForPath($baseDirectory . '/', $excludePattern)); }
/** * @test */ public function parse() { vfsStream::newFile('file1', '644')->setContent("test file1")->at($this->root); vfsStream::newFile('file2', '644')->setContent("test file1")->at($this->root); $parser = new DirectoryParser(); $this->assertEquals([['add', 'file1', 'file1'], ['add', 'file2', 'file2']], $parser->parse(vfsStream::url('root'))); }
/** * Creates the mocked filesystem used in the tests */ public function setUp() { vfsStream::setup('Foo'); $this->mockEnvironment = $this->getMock('TYPO3\\Flow\\Utility\\Environment', array(), array(), '', FALSE); $this->mockEnvironment->expects($this->any())->method('getPathToTemporaryDirectory')->will($this->returnValue('vfs://Foo/')); $this->mockEnvironment->expects($this->any())->method('getMaximumPathLength')->will($this->returnValue(1024)); }