Fixed dependency on php-etl/pipeline

gplanchat · gplanchat · commit 5365b6c1757e · 2021-09-28T20:24:58.000+02:00
diff --git a/src/Assert/ExtractorAssertTrait.php b/src/Assert/ExtractorAssertTrait.php
@@ -4,6 +4,7 @@
 
 use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineExtractsLike;
 use Kiboko\Contract\Pipeline\ExtractorInterface;
+use Kiboko\Contract\Pipeline\PipelineRunnerInterface;
 use PHPUnit\Framework\Constraint\Constraint;
 use PHPUnit\Framework\Constraint\IsEqual;
 use PHPUnit\Framework\Constraint\IsIdentical;
@@ -12,28 +13,29 @@
 trait ExtractorAssertTrait
 {
     abstract public static function assertThat($value, Constraint $constraint, string $message = ''): void;
+    abstract public function pipelineRunner(): PipelineRunnerInterface;
 
     protected function assertExtractorExtractsLike(iterable $expected, ExtractorInterface $extractor, string $message = '')
     {
-        $this->assertThat($extractor, new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item)), $message);
+        $this->assertThat($extractor, new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item), $this->pipelineRunner()), $message);
     }
 
     protected function assertExtractorDoesNotExtractLike(iterable $expected, ExtractorInterface $extractor, string $message = '')
     {
         $this->assertThat($extractor, new LogicalNot(
-            new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item))
+            new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item), $this->pipelineRunner())
         ), $message);
     }
 
     protected function assertExtractorExtractsExactly(iterable $expected, ExtractorInterface $extractor, string $message = '')
     {
-        $this->assertThat($extractor, new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item)), $message);
+        $this->assertThat($extractor, new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item), $this->pipelineRunner()), $message);
     }
 
     protected function assertExtractorDoesNotExtractExactly(iterable $expected, ExtractorInterface $extractor, string $message = '')
     {
         $this->assertThat($extractor, new LogicalNot(
-            new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item))
+            new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item), $this->pipelineRunner())
         ), $message);
     }
 }
diff --git a/src/Assert/ExtractorBuilderAssertTrait.php b/src/Assert/ExtractorBuilderAssertTrait.php
@@ -4,6 +4,7 @@
 
 use Kiboko\Component\PHPUnitExtension\Constraint\Builder\BuilderProducesCodeThat;
 use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineExtractsLike;
+use Kiboko\Contract\Pipeline\PipelineRunnerInterface;
 use PhpParser\Builder as DefaultBuilder;
 use PHPUnit\Framework\Constraint\Constraint;
 use PHPUnit\Framework\Constraint\IsEqual;
@@ -13,35 +14,36 @@
 trait ExtractorBuilderAssertTrait
 {
     abstract public static function assertThat($value, Constraint $constraint, string $message = ''): void;
+    abstract public function pipelineRunner(): PipelineRunnerInterface;
 
     protected function assertBuildsExtractorExtractsLike(iterable $expected, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new BuilderProducesCodeThat(
-            new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item))
+            new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item), $this->pipelineRunner())
         ), $message);
     }
 
     protected function assertBuildsExtractorDoesNotExtractLike(iterable $expected, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new LogicalNot(
             new BuilderProducesCodeThat(
-                new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item))
+                new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item), $this->pipelineRunner())
             ),
         ), $message);
     }
 
     protected function assertBuildsExtractorExtractsExactly(iterable $expected, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new BuilderProducesCodeThat(
-            new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item))
+            new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item), $this->pipelineRunner())
         ), $message);
     }
 
     protected function assertBuildsExtractorDoesNotExtractExactly(iterable $expected, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new LogicalNot(
             new BuilderProducesCodeThat(
-                new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item))
+                new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item), $this->pipelineRunner())
             ),
         ), $message);
     }
diff --git a/src/Assert/LoaderAssertTrait.php b/src/Assert/LoaderAssertTrait.php
@@ -5,6 +5,7 @@
 use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineLoadsLike;
 use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineWritesFile;
 use Kiboko\Contract\Pipeline\LoaderInterface;
+use Kiboko\Contract\Pipeline\PipelineRunnerInterface;
 use PHPUnit\Framework\Constraint\Constraint;
 use PHPUnit\Framework\Constraint\IsEqual;
 use PHPUnit\Framework\Constraint\IsIdentical;
@@ -13,40 +14,41 @@
 trait LoaderAssertTrait
 {
     abstract public static function assertThat($value, Constraint $constraint, string $message = ''): void;
+    abstract public function pipelineRunner(): PipelineRunnerInterface;
 
     protected function assertLoaderLoadsLike(iterable $expected, iterable $input, LoaderInterface $loader, string $message = '')
     {
-        $this->assertThat($loader, new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item)), $message);
+        $this->assertThat($loader, new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner()), $message);
     }
 
     protected function assertLoaderDoesNotLoadLike(iterable $expected, iterable $input, LoaderInterface $loader, string $message = '')
     {
         $this->assertThat($loader, new LogicalNot(
-            new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item))
+            new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner())
         ), $message);
     }
 
     protected function assertLoaderLoadsExactly(iterable $expected, iterable $input, LoaderInterface $loader, string $message = '')
     {
-        $this->assertThat($loader, new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item)), $message);
+        $this->assertThat($loader, new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner()), $message);
     }
 
     protected function assertLoaderDoesNotLoadExactly(iterable $expected, iterable $input, LoaderInterface $loader, string $message = '')
     {
         $this->assertThat($loader, new LogicalNot(
-            new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item))
+            new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner())
         ), $message);
     }
 
     protected function assertLoaderProducesFile(string $expected, iterable $input, LoaderInterface $loader, string $message = '')
     {
-        $this->assertThat($loader, new PipelineWritesFile($input, $expected), $message);
+        $this->assertThat($loader, new PipelineWritesFile($input, $expected, $this->pipelineRunner()), $message);
     }
 
     protected function assertLoaderDoesNotProduceFile(string $expected, iterable $input, LoaderInterface $loader, string $message = '')
     {
         $this->assertThat($loader, new LogicalNot(
-            new PipelineWritesFile($input, $expected),
+            new PipelineWritesFile($input, $expected, $this->pipelineRunner()),
         ), $message);
     }
 }
diff --git a/src/Assert/LoaderBuilderAssertTrait.php b/src/Assert/LoaderBuilderAssertTrait.php
@@ -5,6 +5,7 @@
 use Kiboko\Component\PHPUnitExtension\Constraint\Builder\BuilderProducesCodeThat;
 use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineLoadsLike;
 use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineWritesFile;
+use Kiboko\Contract\Pipeline\PipelineRunnerInterface;
 use PhpParser\Builder as DefaultBuilder;
 use PHPUnit\Framework\Constraint\Constraint;
 use PHPUnit\Framework\Constraint\IsEqual;
@@ -14,51 +15,52 @@
 trait LoaderBuilderAssertTrait
 {
     abstract public static function assertThat($value, Constraint $constraint, string $message = ''): void;
+    abstract public function pipelineRunner(): PipelineRunnerInterface;
 
     protected function assertBuildsLoaderLoadsLike(iterable $expected, iterable $input, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new BuilderProducesCodeThat(
-            new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item))
+            new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner())
         ), $message);
     }
 
     protected function assertBuildsLoaderDoesNotLoadLike(iterable $expected, iterable $input, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new LogicalNot(
             new BuilderProducesCodeThat(
-                new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item))
+                new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner())
             ),
         ), $message);
     }
 
     protected function assertBuildsLoaderLoadsExactly(iterable $expected, iterable $input, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new BuilderProducesCodeThat(
-            new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item))
+            new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner())
         ), $message);
     }
 
     protected function assertBuildsLoaderDoesNotLoadExactly(iterable $expected, iterable $input, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new LogicalNot(
             new BuilderProducesCodeThat(
-                new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item))
+                new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner())
             ),
         ), $message);
     }
 
     protected function assertBuildsLoaderProducesFile(string $expected, iterable $input, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new BuilderProducesCodeThat(
-            new PipelineWritesFile($input, $expected),
+            new PipelineWritesFile($input, $expected, $this->pipelineRunner()),
         ), $message);
     }
 
     protected function assertBuildsLoaderDoesNotProduceFile(string $expected, iterable $input, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new LogicalNot(
             new BuilderProducesCodeThat(
-                new PipelineWritesFile($input, $expected),
+                new PipelineWritesFile($input, $expected, $this->pipelineRunner()),
             ),
         ), $message);
     }
diff --git a/src/Assert/TransformerAssertTrait.php b/src/Assert/TransformerAssertTrait.php
@@ -3,6 +3,7 @@
 namespace Kiboko\Component\PHPUnitExtension\Assert;
 
 use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineTransformsLike;
+use Kiboko\Contract\Pipeline\PipelineRunnerInterface;
 use Kiboko\Contract\Pipeline\TransformerInterface;
 use PHPUnit\Framework\Constraint\Constraint;
 use PHPUnit\Framework\Constraint\IsEqual;
@@ -12,28 +13,29 @@
 trait TransformerAssertTrait
 {
     abstract public static function assertThat($value, Constraint $constraint, string $message = ''): void;
+    abstract public function pipelineRunner(): PipelineRunnerInterface;
 
     protected function assertTransformerTransformsLike(iterable $expected, iterable $input, TransformerInterface $transformer, string $message = '')
     {
-        $this->assertThat($transformer, new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item)), $message);
+        $this->assertThat($transformer, new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner()), $message);
     }
 
     protected function assertTransformerDoesNotTransformLike(iterable $expected, iterable $input, TransformerInterface $transformer, string $message = '')
     {
         $this->assertThat($transformer, new LogicalNot(
-            new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item))
+            new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner())
         ), $message);
     }
 
     protected function assertTransformerTransformsExactly(iterable $expected, iterable $input, TransformerInterface $transformer, string $message = '')
     {
-        $this->assertThat($transformer, new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item)), $message);
+        $this->assertThat($transformer, new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner()), $message);
     }
 
     protected function assertTransformerDoesNotTransformExactly(iterable $expected, iterable $input, TransformerInterface $transformer, string $message = '')
     {
         $this->assertThat($transformer, new LogicalNot(
-            new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item))
+            new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner())
         ), $message);
     }
 }
diff --git a/src/Assert/TransformerBuilderAssertTrait.php b/src/Assert/TransformerBuilderAssertTrait.php
@@ -4,6 +4,7 @@
 
 use Kiboko\Component\PHPUnitExtension\Constraint\Builder\BuilderProducesCodeThat;
 use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineTransformsLike;
+use Kiboko\Contract\Pipeline\PipelineRunnerInterface;
 use PhpParser\Builder as DefaultBuilder;
 use PHPUnit\Framework\Constraint\Constraint;
 use PHPUnit\Framework\Constraint\IsEqual;
@@ -13,35 +14,36 @@
 trait TransformerBuilderAssertTrait
 {
     abstract public static function assertThat($value, Constraint $constraint, string $message = ''): void;
+    abstract public function pipelineRunner(): PipelineRunnerInterface;
 
     protected function assertBuildsTransformerTransformsLike(iterable $expected, iterable $input, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new BuilderProducesCodeThat(
-            new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item))
+            new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner())
         ), $message);
     }
 
     protected function assertBuildsTransformerDoesNotTransformLike(iterable $expected, iterable $input, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new LogicalNot(
             new BuilderProducesCodeThat(
-                new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item))
+                new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner())
             ),
         ), $message);
     }
 
     protected function assertBuildsTransformerTransformsExactly(iterable $expected, iterable $input, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new BuilderProducesCodeThat(
-            new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item))
+            new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner())
         ), $message);
     }
 
     protected function assertBuildsTransformerDoesNotTransformExactly(iterable $expected, iterable $input, DefaultBuilder $builder, string $message = '')
     {
         $this->assertThat($builder, new LogicalNot(
             new BuilderProducesCodeThat(
-                new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item))
+                new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner())
             ),
         ), $message);
     }
diff --git a/src/Constraint/Pipeline/PipelineExtractsLike.php b/src/Constraint/Pipeline/PipelineExtractsLike.php
@@ -2,10 +2,10 @@
 
 namespace Kiboko\Component\PHPUnitExtension\Constraint\Pipeline;
 
-use Kiboko\Component\Pipeline\PipelineRunner;
 use Kiboko\Contract\Pipeline\ExtractorInterface;
 use Kiboko\Contract\Pipeline\NullRejection;
 use Kiboko\Contract\Pipeline\NullState;
+use Kiboko\Contract\Pipeline\PipelineRunnerInterface;
 use PHPUnit\Framework\Constraint\Constraint;
 
 /** @template Type */
@@ -17,7 +17,8 @@ final class PipelineExtractsLike extends Constraint
     /** @param list<Type> $expected */
     public function __construct(
         private iterable $expected,
-        callable $itemConstraintFactory
+        callable $itemConstraintFactory,
+        private PipelineRunnerInterface $runner,
     ) {
         $this->itemConstraintFactory = $itemConstraintFactory;
     }
@@ -61,32 +62,13 @@ public function matches($other): bool
             ]));
         }
 
-        $runner = new PipelineRunner(null);
         $extract = $other->extract();
-        if (is_array($extract)) {
-            $iterator = $runner->run(
-                new \ArrayIterator($extract),
-                $this->passThroughCoroutine(),
-                new NullRejection(),
-                new NullState(),
-            );
-        } elseif ($extract instanceof \Iterator) {
-            $iterator = $runner->run(
-                $extract,
-                $this->passThroughCoroutine(),
-                new NullRejection(),
-                new NullState(),
-            );
-        } elseif ($extract instanceof \Traversable) {
-            $iterator = $runner->run(
-                new \IteratorIterator($extract),
-                $this->passThroughCoroutine(),
-                new NullRejection(),
-                new NullState(),
-            );
-        } else {
-            throw new \RuntimeException('Invalid data source, expecting array or Traversable.');
-        }
+        $iterator = $this->runner->run(
+            $this->asIterator($extract),
+            $this->passThroughCoroutine(),
+            new NullRejection(),
+            new NullState(),
+        );
         $both->attachIterator($iterator);
 
         $index = 0;
diff --git a/src/Constraint/Pipeline/PipelineLoadsLike.php b/src/Constraint/Pipeline/PipelineLoadsLike.php
diff --git a/src/Constraint/Pipeline/PipelineTransformsLike.php b/src/Constraint/Pipeline/PipelineTransformsLike.php
diff --git a/src/Constraint/Pipeline/PipelineWritesFile.php b/src/Constraint/Pipeline/PipelineWritesFile.php

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`
`5`	`5`	`use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineExtractsLike;`
`6`	`6`	`use Kiboko\Contract\Pipeline\ExtractorInterface;`
	`7`	`+use Kiboko\Contract\Pipeline\PipelineRunnerInterface;`
`7`	`8`	`use PHPUnit\Framework\Constraint\Constraint;`
`8`	`9`	`use PHPUnit\Framework\Constraint\IsEqual;`
`9`	`10`	`use PHPUnit\Framework\Constraint\IsIdentical;`
`@@ -12,28 +13,29 @@`
`12`	`13`	`trait ExtractorAssertTrait`
`13`	`14`	`{`
`14`	`15`	`abstract public static function assertThat($value, Constraint $constraint, string $message = ''): void;`
	`16`	`+ abstract public function pipelineRunner(): PipelineRunnerInterface;`
`15`	`17`
`16`	`18`	`protected function assertExtractorExtractsLike(iterable $expected, ExtractorInterface $extractor, string $message = '')`
`17`	`19`	`{`
`18`		`- $this->assertThat($extractor, new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item)), $message);`
	`20`	`+ $this->assertThat($extractor, new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item), $this->pipelineRunner()), $message);`
`19`	`21`	`}`
`20`	`22`
`21`	`23`	`protected function assertExtractorDoesNotExtractLike(iterable $expected, ExtractorInterface $extractor, string $message = '')`
`22`	`24`	`{`
`23`	`25`	`$this->assertThat($extractor, new LogicalNot(`
`24`		`- new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item))`
	`26`	`+ new PipelineExtractsLike($expected, fn ($item) => new IsEqual($item), $this->pipelineRunner())`
`25`	`27`	`), $message);`
`26`	`28`	`}`
`27`	`29`
`28`	`30`	`protected function assertExtractorExtractsExactly(iterable $expected, ExtractorInterface $extractor, string $message = '')`
`29`	`31`	`{`
`30`		`- $this->assertThat($extractor, new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item)), $message);`
	`32`	`+ $this->assertThat($extractor, new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item), $this->pipelineRunner()), $message);`
`31`	`33`	`}`
`32`	`34`
`33`	`35`	`protected function assertExtractorDoesNotExtractExactly(iterable $expected, ExtractorInterface $extractor, string $message = '')`
`34`	`36`	`{`
`35`	`37`	`$this->assertThat($extractor, new LogicalNot(`
`36`		`- new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item))`
	`38`	`+ new PipelineExtractsLike($expected, fn ($item) => new IsIdentical($item), $this->pipelineRunner())`
`37`	`39`	`), $message);`
`38`	`40`	`}`
`39`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineLoadsLike;`
`6`	`6`	`use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineWritesFile;`
`7`	`7`	`use Kiboko\Contract\Pipeline\LoaderInterface;`
	`8`	`+use Kiboko\Contract\Pipeline\PipelineRunnerInterface;`
`8`	`9`	`use PHPUnit\Framework\Constraint\Constraint;`
`9`	`10`	`use PHPUnit\Framework\Constraint\IsEqual;`
`10`	`11`	`use PHPUnit\Framework\Constraint\IsIdentical;`
`@@ -13,40 +14,41 @@`
`13`	`14`	`trait LoaderAssertTrait`
`14`	`15`	`{`
`15`	`16`	`abstract public static function assertThat($value, Constraint $constraint, string $message = ''): void;`
	`17`	`+ abstract public function pipelineRunner(): PipelineRunnerInterface;`
`16`	`18`
`17`	`19`	`protected function assertLoaderLoadsLike(iterable $expected, iterable $input, LoaderInterface $loader, string $message = '')`
`18`	`20`	`{`
`19`		`- $this->assertThat($loader, new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item)), $message);`
	`21`	`+ $this->assertThat($loader, new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner()), $message);`
`20`	`22`	`}`
`21`	`23`
`22`	`24`	`protected function assertLoaderDoesNotLoadLike(iterable $expected, iterable $input, LoaderInterface $loader, string $message = '')`
`23`	`25`	`{`
`24`	`26`	`$this->assertThat($loader, new LogicalNot(`
`25`		`- new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item))`
	`27`	`+ new PipelineLoadsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner())`
`26`	`28`	`), $message);`
`27`	`29`	`}`
`28`	`30`
`29`	`31`	`protected function assertLoaderLoadsExactly(iterable $expected, iterable $input, LoaderInterface $loader, string $message = '')`
`30`	`32`	`{`
`31`		`- $this->assertThat($loader, new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item)), $message);`
	`33`	`+ $this->assertThat($loader, new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner()), $message);`
`32`	`34`	`}`
`33`	`35`
`34`	`36`	`protected function assertLoaderDoesNotLoadExactly(iterable $expected, iterable $input, LoaderInterface $loader, string $message = '')`
`35`	`37`	`{`
`36`	`38`	`$this->assertThat($loader, new LogicalNot(`
`37`		`- new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item))`
	`39`	`+ new PipelineLoadsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner())`
`38`	`40`	`), $message);`
`39`	`41`	`}`
`40`	`42`
`41`	`43`	`protected function assertLoaderProducesFile(string $expected, iterable $input, LoaderInterface $loader, string $message = '')`
`42`	`44`	`{`
`43`		`- $this->assertThat($loader, new PipelineWritesFile($input, $expected), $message);`
	`45`	`+ $this->assertThat($loader, new PipelineWritesFile($input, $expected, $this->pipelineRunner()), $message);`
`44`	`46`	`}`
`45`	`47`
`46`	`48`	`protected function assertLoaderDoesNotProduceFile(string $expected, iterable $input, LoaderInterface $loader, string $message = '')`
`47`	`49`	`{`
`48`	`50`	`$this->assertThat($loader, new LogicalNot(`
`49`		`- new PipelineWritesFile($input, $expected),`
	`51`	`+ new PipelineWritesFile($input, $expected, $this->pipelineRunner()),`
`50`	`52`	`), $message);`
`51`	`53`	`}`
`52`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`namespace Kiboko\Component\PHPUnitExtension\Assert;`
`4`	`4`
`5`	`5`	`use Kiboko\Component\PHPUnitExtension\Constraint\Pipeline\PipelineTransformsLike;`
	`6`	`+use Kiboko\Contract\Pipeline\PipelineRunnerInterface;`
`6`	`7`	`use Kiboko\Contract\Pipeline\TransformerInterface;`
`7`	`8`	`use PHPUnit\Framework\Constraint\Constraint;`
`8`	`9`	`use PHPUnit\Framework\Constraint\IsEqual;`
`@@ -12,28 +13,29 @@`
`12`	`13`	`trait TransformerAssertTrait`
`13`	`14`	`{`
`14`	`15`	`abstract public static function assertThat($value, Constraint $constraint, string $message = ''): void;`
	`16`	`+ abstract public function pipelineRunner(): PipelineRunnerInterface;`
`15`	`17`
`16`	`18`	`protected function assertTransformerTransformsLike(iterable $expected, iterable $input, TransformerInterface $transformer, string $message = '')`
`17`	`19`	`{`
`18`		`- $this->assertThat($transformer, new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item)), $message);`
	`20`	`+ $this->assertThat($transformer, new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner()), $message);`
`19`	`21`	`}`
`20`	`22`
`21`	`23`	`protected function assertTransformerDoesNotTransformLike(iterable $expected, iterable $input, TransformerInterface $transformer, string $message = '')`
`22`	`24`	`{`
`23`	`25`	`$this->assertThat($transformer, new LogicalNot(`
`24`		`- new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item))`
	`26`	`+ new PipelineTransformsLike($expected, $input, fn ($item) => new IsEqual($item), $this->pipelineRunner())`
`25`	`27`	`), $message);`
`26`	`28`	`}`
`27`	`29`
`28`	`30`	`protected function assertTransformerTransformsExactly(iterable $expected, iterable $input, TransformerInterface $transformer, string $message = '')`
`29`	`31`	`{`
`30`		`- $this->assertThat($transformer, new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item)), $message);`
	`32`	`+ $this->assertThat($transformer, new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner()), $message);`
`31`	`33`	`}`
`32`	`34`
`33`	`35`	`protected function assertTransformerDoesNotTransformExactly(iterable $expected, iterable $input, TransformerInterface $transformer, string $message = '')`
`34`	`36`	`{`
`35`	`37`	`$this->assertThat($transformer, new LogicalNot(`
`36`		`- new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item))`
	`38`	`+ new PipelineTransformsLike($expected, $input, fn ($item) => new IsIdentical($item), $this->pipelineRunner())`
`37`	`39`	`), $message);`
`38`	`40`	`}`
`39`	`41`	`}`