Merge branch 'md-writerMock' into 'v1.7.0'

Add WriterMock

See merge request redbitcz/composer/utils!27

Author: Martin Dostál

src/IO/IBufferWriter.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Redbitcz\Utils\IO;
+
+interface IBufferWriter extends IOutStream
+{
+    public function hasOutputContent(): bool;
+
+    public function getOutputContent(): string;
+
+    public function hasErrorContent(): bool;
+
+    public function getErrorContent(): string;
+}

src/IO/LazyStreamWriter.php

@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Redbitcz\Utils\IO;
+
+use LogicException;
+
+/**
+ * Same as `FileWriter`, but is opening file descriptors only on first write them
+ */
+class LazyStreamWriter implements IOutStream
+{
+    /** @var callable */
+    private $outputStreamFactory;
+    /** @var callable */
+    private $errorStreamFactory;
+    /** @var resource|null */
+    private $outputStream;
+    /** @var resource|null */
+    private $errorStream;
+
+    /**
+     * @param callable $outputStreamFactory Callback which return writable stream handler resource
+     * @param callable $errorStreamFactory Callback which return writable stream handler resource
+     */
+    public function __construct(callable $outputStreamFactory, callable $errorStreamFactory)
+    {
+        $this->outputStreamFactory = $outputStreamFactory;
+        $this->errorStreamFactory = $errorStreamFactory;
+    }
+
+    public function write(string $string): void
+    {
+        if ($this->outputStream === null) {
+            $this->outputStream = $this->createStream($this->outputStreamFactory);
+        }
+
+        fwrite($this->outputStream, $string);
+    }
+
+    public function error(string $string): void
+    {
+        if ($this->errorStream === null) {
+            $this->errorStream = $this->createStream($this->errorStreamFactory);
+        }
+
+        fwrite($this->errorStream, $string);
+    }
+
+    /**
+     * @return resource
+     */
+    private function createStream(callable $factory)
+    {
+        $stream = $factory();
+
+        if (is_resource($stream) === false) {
+            $type = is_object($stream) ? get_class($stream) : gettype($stream);
+            throw new LogicException(
+                "Stream factory callback must returns valid stream handler resource, {$type} returned"
+            );
+        }
+
+        return $stream;
+    }
+}

src/IO/MemoryWriter.php

@@ -0,0 +1,108 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Redbitcz\Utils\IO;
+
+use Closure;
+use RuntimeException;
+
+class MemoryWriter implements IBufferWriter
+{
+    /** @var resource|null */
+    private $outputStream;
+
+    /** @var resource|null */
+    private $errorStream;
+
+    /** @var LazyStreamWriter */
+    private $writer;
+
+    public function __construct()
+    {
+        $this->writer = new LazyStreamWriter(
+            Closure::fromCallable([$this, 'createOutputStream']),
+            Closure::fromCallable([$this, 'createErrorStream']),
+        );
+    }
+
+    public function __destruct()
+    {
+        if ($this->hasOutputContent()) {
+            fclose($this->outputStream);
+        }
+
+        if ($this->hasErrorContent()) {
+            fclose($this->errorStream);
+        }
+    }
+
+    public function write(string $string): void
+    {
+        $this->writer->write($string);
+    }
+
+    public function error(string $string): void
+    {
+        $this->writer->error($string);
+    }
+
+    /**
+     * @return resource
+     */
+    private function createOutputStream()
+    {
+        return $this->outputStream = $this->createMemoryStream();
+    }
+
+    /**
+     * @return resource
+     */
+    private function createErrorStream()
+    {
+        return $this->errorStream = $this->createMemoryStream();
+    }
+
+    public function hasOutputContent(): bool
+    {
+        return isset($this->outputStream);
+    }
+
+    public function getOutputContent(): string
+    {
+        return $this->hasOutputContent() ? $this->getStreamContent($this->outputStream) : '';
+    }
+
+    public function hasErrorContent(): bool
+    {
+        return isset($this->errorStream);
+    }
+
+    public function getErrorContent(): string
+    {
+        return $this->hasErrorContent() ? $this->getStreamContent($this->errorStream) : '';
+    }
+
+    /**
+     * @return resource
+     */
+    private function createMemoryStream()
+    {
+        $fileHandler = fopen('php://memory', 'wb+');
+
+        if ($fileHandler === false) {
+            throw new RuntimeException("Unable to create Memory stream (php://memory)");
+        }
+
+        return $fileHandler;
+    }
+
+    /**
+     * @param resource $fileHandler
+     * @return string
+     */
+    private function getStreamContent($fileHandler): string
+    {
+        return stream_get_contents($fileHandler, -1, 0);
+    }
+}

tests/IO/LazyStreamWriterTest.php

@@ -0,0 +1,31 @@
+<?php
+/** @testCase */
+
+declare(strict_types=1);
+
+namespace Tests\IO;
+
+use LogicException;
+use Redbitcz\Utils\IO\LazyStreamWriter;
+use Tester\Assert;
+use Tester\TestCase;
+
+require __DIR__ . '/../../vendor/autoload.php';
+
+class LazyStreamWriterTest extends TestCase
+{
+    public function testInvalidCallback(): void
+    {
+        Assert::exception(static function () {
+            $writer = new LazyStreamWriter(function() {return null;}, function() {return null;});
+            $writer->write('foo');
+        }, LogicException::class);
+
+        Assert::exception(static function () {
+            $writer = new LazyStreamWriter(function() {return null;}, function() {return null;});
+            $writer->error('foo');
+        }, LogicException::class);
+    }
+}
+
+(new LazyStreamWriterTest)->run();

tests/IO/MemoryWriterTest.php

@@ -0,0 +1,85 @@
+<?php
+/** @testCase */
+
+declare(strict_types=1);
+
+namespace Tests\IO;
+
+use Redbitcz\Utils\IO\MemoryWriter;
+use Tester\Assert;
+use Tester\TestCase;
+
+require __DIR__ . '/../../vendor/autoload.php';
+
+class MemoryWriterTest extends TestCase
+{
+    /**
+     * @return string[][]
+     */
+    public function getTestOutputData(): array
+    {
+        return [
+            ['Hello'],
+            ['Lorem ipsum'],
+            ["Lorem ipsum\n"],
+            ["Lorem ipsum\ntest"],
+            [""],
+            ["\n"],
+            ["\n\n"],
+        ];
+    }
+
+    /**
+     * @dataProvider getTestOutputData
+     * @param string $testData
+     */
+    public function testOutput(string $testData): void
+    {
+        $writer = new MemoryWriter();
+
+        $writer->write($testData);
+        $writer->error('noob');
+
+        Assert::equal($testData, $writer->getOutputContent());
+        Assert::equal('noob', $writer->getErrorContent());
+    }
+
+    /**
+     * @dataProvider getTestOutputData
+     * @param string $testData
+     */
+    public function testError(string $testData): void
+    {
+        $writer = new MemoryWriter();
+
+        $writer->write('noob');
+        $writer->error($testData);
+
+        Assert::equal('noob', $writer->getOutputContent());
+        Assert::equal($testData, $writer->getErrorContent());
+    }
+
+    public function testEmpty(): void
+    {
+        $writer = new MemoryWriter();
+
+        Assert::equal('', $writer->getOutputContent());
+        Assert::equal('', $writer->getErrorContent());
+    }
+
+    public function testHasContent(): void
+    {
+        $writer = new MemoryWriter();
+
+        Assert::equal(false, $writer->hasOutputContent());
+        Assert::equal(false, $writer->hasErrorContent());
+
+        $writer->write('foo');
+        $writer->error('bar');
+
+        Assert::equal(true, $writer->hasOutputContent());
+        Assert::equal(true, $writer->hasErrorContent());
+    }
+}
+
+(new MemoryWriterTest)->run();