public function testWithWillCallAddNamespaceOnBuilder() { $builder = m::mock(FlowBuilderInterface::class); Flow::setBuilder($builder); $builder->shouldReceive('addNamespace')->with('Graze\\DataFlow\\')->once(); Flow::with('Graze\\DataFlow\\'); }
public function testStaticFlow() { $file = $this->makeFile('replaceText/static/from', 'some text'); $flow = Flow::replaceText('text', 'bananas'); $output = $flow->flow($file); static::assertNotSame($file, $output); static::assertInstanceOf(LocalFile::class, $output); static::assertEquals(['some bananas'], $output->getContents()); }
public function testStaticFlow() { $file = $this->makeFile('tail/static', "line 1\nline 2\nline 3"); $flow = Flow::tail(1); $output = $flow->flow($file); static::assertNotSame($file, $output); static::assertInstanceOf(LocalFile::class, $output); static::assertEquals(["line 3"], $output->getContents()); }
public function testStaticFlow() { $file = $this->makeFile('makeDirectory/static/file'); $flow = Flow::makeDirectory(); static::assertFalse(is_dir($file->getDirectory())); $output = $flow->flow($file); static::assertInstanceOf(LocalFile::class, $output); static::assertTrue(is_dir($output->getDirectory())); }
public function testInvokeFlow() { $file = $this->makeFile('gunzip/invoke/source', 'some text'); $compressed = Flow::compress(Gzip::NAME)->flow($file); $flow = new Gunzip(); $output = call_user_func($flow, $compressed); static::assertNotSame($file, $output); static::assertInstanceOf(LocalFile::class, $output); static::assertEquals(CompressionFactory::TYPE_NONE, $output->getCompression()); }
public function testInvokeFlow() { $file = $this->makeFile('encoding.invoke.utf8', mb_convert_encoding('some#¢±±§', 'UTF-8')); $file->setEncoding('UTF-8'); $flow = Flow::convertEncoding('UTF-16'); $output = call_user_func($flow, $file); static::assertNotSame($file, $output); static::assertInstanceOf(LocalFile::class, $output); static::assertEquals('UTF-16', $output->getEncoding()); }
public function testStaticFlow() { $file = $this->makeFile('gzip/static/source', 'some text'); $file->setCompression(CompressionFactory::TYPE_NONE); $flow = Flow::gzip(); $output = $flow->flow($file); static::assertNotSame($file, $output); static::assertInstanceOf(LocalFile::class, $output); static::assertEquals(Gzip::NAME, $output->getCompression()); }
public function testInvokeFlow() { $file = $this->makeFile('moves/invoke/source/file', 'some text'); $target = $this->makeFile('moves/invoke/target/'); $flow = Flow::moveFiles($target); $output = call_user_func($flow, new FileNodeCollection([$file])); static::assertInstanceOf(FileNodeCollection::class, $output); static::assertEquals(1, $output->count()); static::assertEquals('moves/invoke/target/file', $output->getAll()[0]->getPath()); static::assertFalse($file->exists(), "The original file should not exist"); }
public function testStaticFlow() { $file1 = $this->makeFile('merge/static/file1', "line 1\nline 2\n"); $file2 = $this->makeFile('merge/static/file2', "line 3\nline 4\n"); $merged = $this->makeFile('merge/static/merged'); $flow = Flow::merge($merged); $collection = new FileNodeCollection([$file1, $file2]); $output = $flow->flow($collection); static::assertSame($output, $merged); static::assertEquals(["line 1", "line 2", "line 3", "line 4"], $output->getContents()); }
public function testCopyFileWithDirectoryTargetWillUseOriginalFileName() { $file = $this->makeFile('copy/todir/source', 'some text'); $target = $this->makeFile('copy/todir/target/'); $flow = Flow::copyFile($target); $output = $flow->flow($file); static::assertNotSame($target, $output); static::assertInstanceOf(FileNode::class, $output); static::assertEquals($file->getContents(), $output->getContents()); static::assertEquals('source', $output->getFilename()); static::assertEquals('copy/todir/target/source', $output->getPath()); }
public function testInvokeFlow() { $flow1 = m::mock(FlowInterface::class); $flow2 = m::mock(FlowInterface::class); $runner = Flow::run($flow1, $flow2); $node1 = m::mock(NodeInterface::class); $node2 = m::mock(NodeInterface::class); $node3 = m::mock(NodeInterface::class); $flow1->shouldReceive('flow')->with($node1)->andReturn($node2); $flow2->shouldReceive('flow')->with($node2)->andReturn($node3); static::assertEquals($node3, call_user_func($runner, $node1)); }
public function testInvokeFlow() { $func = function () use(&$called) { $called = true; return true; }; $flow = Flow::first($func); $node = m::mock(NodeCollectionInterface::class); $node->shouldReceive('first')->with($func)->andReturn($node); $response = call_user_func($flow, $node); static::assertSame($response, $node); }
public function testStaticFlow() { $eachFlow = m::mock(FlowInterface::class); $flow = Flow::each($eachFlow); $node = m::mock(NodeInterface::class); $collection = new NodeCollection([$node]); $eachFlow->shouldReceive('flow')->with($node)->andReturn($node); $response = $flow->flow($collection); static::assertNotSame($response, $collection); static::assertEquals($collection->getAll(), $response->getAll()); static::assertInstanceOf(NodeCollectionInterface::class, $response); }
public function testInvokeFlow() { $called = null; $return = m::mock(NodeInterface::class); $callbackFlow = Flow::callback(function ($item) use(&$called, $return) { $called = $item; return $return; }); $node = m::mock(NodeInterface::class); $output = call_user_func($callbackFlow, $node); static::assertEquals($return, $output); static::assertEquals($called, $node); }
public function testInvokeFlow() { $flow1 = m::mock(FlowInterface::class); $flow2 = m::mock(FlowInterface::class); $runner = Flow::toAll($flow1, $flow2); $node1 = m::mock(NodeInterface::class); $node2 = m::mock(NodeInterface::class); $node3 = m::mock(NodeInterface::class); $flow1->shouldReceive('flow')->with($node1)->andReturn($node2); $flow2->shouldReceive('flow')->with($node1)->andReturn($node3); $output = call_user_func($runner, $node1); static::assertInstanceOf(NodeCollection::class, $output); static::assertEquals([$node2, $node3], $output->getAll()); }