ADDED TEST: new exceptions, other bridge methods.

Author: hsehszroc

Src/PipelineBridge.php

@@ -29,11 +29,11 @@ class PipelineBridge {
 
 	/**
 	 * @param string|Pipe|Closure(mixed $subject, Closure $next, mixed ...$use): mixed $from
-	 * @throws InvalidPipeError When invalid pipe given.
+	 * @throws InvalidPipeError            When invalid pipe given.
+	 * @throws UnexpectedPipelineException When could not determine thrown exception.
 	 */
 	public static function toPipe( string|Closure|Pipe $from ): Pipe {
 		$pipe = Pipeline::resolve( pipe: $from );
-
 		return new class( $pipe ) implements Pipe {
 			public function __construct( private readonly Closure $pipe ) {}
 
@@ -61,7 +61,6 @@ public static function toMiddleware( mixed $middleware ): object {
 					: $default
 			);
 
-		$provided    = $middleware;
 		$isClassName = is_string( $middleware ) && class_exists( $middleware );
 
 		try {
@@ -76,9 +75,8 @@ public static function toMiddleware( mixed $middleware ): object {
 			if ( null === $middleware ) {
 				throw new InvalidMiddlewareForPipeError(
 					sprintf(
-						'Invalid or Non-existing class "%1$s". Middleware must be a Closure, an'
-						. ' instance of %2$s or a concrete\'s classname that implements %2$s.',
-						$isClassName ? $provided : $provided::class,
+						'Invalid middleware type. Middleware must be a Closure, an'
+						. ' instance of "%1$s" or a concrete\'s classname that implements "%1$s".',
 						$interface
 					)
 				);

Tests/BridgeTest.php

@@ -9,6 +9,7 @@
 
 namespace TheWebSolver\Codegarage;
 
+use Closure;
 use MiddlewareAdapter;
 use Psr7Adapter\Request;
 use Psr7Adapter\Response;
@@ -19,23 +20,90 @@
 use Psr7Adapter\ServerRequestInterface;
 use Psr15Adapter\RequestHandlerInterface;
 use TheWebSolver\Codegarage\Lib\Pipeline;
+use TheWebSolver\Codegarage\Stub\PipeStub;
+use TheWebSolver\Codegarage\Lib\PipeInterface;
 use TheWebSolver\Codegarage\Lib\PipelineBridge;
+use TheWebSolver\Codegarage\Lib\InvalidMiddlewareForPipeError;
 use TheWebSolver\Codegarage\Lib\MiddlewarePsrNotFoundException;
 
 class BridgeTest extends TestCase {
-	private bool $PSRPackageInstalled;
-	protected function setUp(): void {
-		$this->PSRPackageInstalled = interface_exists( '\\Psr\\Http\\Server\\MiddlewareInterface' );
+	private function addPsrPackageFixtures(): void {
+		PipelineBridge::setMiddlewareAdapter(
+			interface: MiddlewareInterface::class,
+			className: MiddlewareAdapter::class
+		);
+	}
 
-		require_once __DIR__ . '/Stub/PsrStubs.php';
+	private function removePsrPackageFixtures(): void {
+		PipelineBridge::setMiddlewareAdapter( interface: '', className: '' );
+	}
 
+	/** @dataProvider provideVariousPipes */
+	public function testPipeConversion( string|Closure|PipeInterface $from ): void {
+		$this->assertInstanceOf( PipeInterface::class, PipelineBridge::toPipe( $from ) );
 	}
 
-	public function testPSRBridge() {
-		PipelineBridge::setMiddlewareAdapter(
-			interface: MiddlewareInterface::class,
-			className: MiddlewareAdapter::class
+	/** @return array<mixed[]> */
+	public function provideVariousPipes(): array {
+		return array(
+			array( fn( $subject, $next ) => $next( $subject ) ),
+			array( PipeStub::class ),
+			array(
+				new class implements PipeInterface {
+					public function handle( mixed $subject, Closure $next, mixed ...$use ): mixed {
+						return $next( $subject );
+					}
+				}
+			),
 		);
+	}
+
+	/** @dataProvider provideMiddlewares */
+	public function testMiddlewareConversion( mixed $middleware, ?string $thrown ): void {
+		$this->addPsrPackageFixtures();
+
+		if ( $thrown ) {
+			$this->expectException( $thrown );
+		}
+
+		$this->assertInstanceOf( MiddlewareInterface::class, PipelineBridge::toMiddleware( $middleware ) );
+	}
+
+	/** @dataProvider provideMiddlewares */
+	public function testMiddlewareToPipeConversion( mixed $middleware, ?string $thrown ): void {
+		// The middleware gets converted to pipe irrespective of middleware being invalid.
+		// The exception is only thrown when converted pipe handles the subject.
+		$this->assertInstanceOf( PipeInterface::class, PipelineBridge::middlewareToPipe( $middleware ) );
+	}
+
+	/** @return array<mixed[]>*/
+	public function provideMiddlewares(): array {
+		return array(
+			array( Middleware::class, null ),
+			array( $this->createMock( MiddlewareInterface::class ), null ),
+			array( '\\Invalid\\Middleware', InvalidMiddlewareForPipeError::class ),
+			array( true, InvalidMiddlewareForPipeError::class ),
+			array( static::class, InvalidMiddlewareForPipeError::class ),
+			array(
+				static fn( ServerRequestInterface $r, RequestHandlerInterface $h ) => new Response(),
+				null,
+			),
+			array(
+				new class implements MiddlewareInterface {
+					public function process(
+						ServerRequestInterface $request,
+						RequestHandlerInterface $handler
+					): ResponseInterface {
+						return new Response();
+					}
+				},
+				null,
+			),
+		);
+	}
+
+	public function testPSRBridge() {
+		$this->addPsrPackageFixtures();
 
 		$request = new Request();
 		$handler = new class() implements RequestHandlerInterface {
@@ -70,10 +138,10 @@ public function process(
 
 		$this->assertSame( expected: 350, actual: $handler->handle( $request )->getStatusCode() );
 
-		PipelineBridge::resetMiddlewareAdapter();
+		$this->removePsrPackageFixtures();
 
 		// Must always throw exception if core PSR-15 implementation not used.
-		if ( ! $this->PSRPackageInstalled ) {
+		if ( ! CODEGARAGE_PSR_PACKAGE_INSTALLED ) {
 			$this->expectException( MiddlewarePsrNotFoundException::class );
 			$this->expectExceptionMessage( 'Cannot find PSR15 HTTP Server Middleware.' );
 

Tests/PipelineTest.php

@@ -21,9 +21,9 @@
 
 class PipelineTest extends TestCase {
 	/** @dataProvider provideVariousPipeTypes */
-	public function testPipeResolver( mixed $pipe, bool $throws ): void {
-		if ( $throws ) {
-			$this->expectException( InvalidPipeError::class );
+	public function testPipeResolver( mixed $pipe, ?string $thrown ): void {
+		if ( $thrown ) {
+			$this->expectException( $thrown );
 		}
 
 		$this->assertSame(
@@ -38,16 +38,17 @@ public function testPipeResolver( mixed $pipe, bool $throws ): void {
 	/** @return mixed[] */
 	public static function provideVariousPipeTypes(): array {
 		return array(
-			array( PipeStub::class, false ),
-			array( static fn ( string $subject, Closure $next ): string => $next( $subject ), false ),
-			array( '\\Undefined\\ClassName', true ),
+			array( PipeStub::class, null ),
+			array( static fn ( string $subject, Closure $next ): string => $next( $subject ), null ),
+			array( '\\Undefined\\ClassName', InvalidPipeError::class ),
+			array( static::class, UnexpectedPipelineException::class ),
 			array(
 				new class() implements PipeInterface {
 					public function handle( mixed $subject, Closure $next, mixed ...$use ): mixed {
 						return $subject;
 					}
 				},
-				false,
+				null,
 			),
 		);
 	}