Unit tests

src/RabbitMQ.Next.Publisher.Abstractions/DelegatePublishMiddleware.cs

@@ -16,6 +16,11 @@ public DelegatePublishMiddleware(IPublishMiddleware next, Action<object, IMessag
             throw new ArgumentNullException(nameof(middleware));
         }
 
+        if (next == null)
+        {
+            throw new ArgumentNullException(nameof(next));
+        }
+
         this.next = next;
         this.middleware = middleware;
     }

src/RabbitMQ.Next.Publisher.Abstractions/DelegateReturnMiddleware.cs

@@ -15,6 +15,11 @@ public DelegateReturnMiddleware(IReturnMiddleware next, Action<IReturnedMessage>
         {
             throw new ArgumentNullException(nameof(middleware));
         }
+
+        if (next == null)
+        {
+            throw new ArgumentNullException(nameof(next));
+        }
 
         this.next = next;
         this.middleware = middleware;

tests/RabbitMQ.Next.Tests/Publisher/DelegatePublishMiddlewareTests.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using NSubstitute;
+using RabbitMQ.Next.Publisher;
+using Xunit;
+
+namespace RabbitMQ.Next.Tests.Publisher;
+
+public class DelegatePublishMiddlewareTests
+{
+    [Fact]
+    public void ThrowsOnEmptyNext()
+    {
+        var handler = Substitute.For<Action<object, IMessageBuilder>>();
+
+        Assert.Throws<ArgumentNullException>(() => new DelegatePublishMiddleware(null, handler));
+    }
+
+    [Fact]
+    public void ThrowsOnEmptyHandler()
+    {
+        var next = Substitute.For<IPublishMiddleware>();
+
+        Assert.Throws<ArgumentNullException>(() => new DelegatePublishMiddleware(next, null));
+    }
+
+    [Fact]
+    public void ThrowsOnCancellation()
+    {
+        var handler = Substitute.For<Action<object, IMessageBuilder>>();
+        var next = Substitute.For<IPublishMiddleware>();
+
+        var message = Substitute.For<IMessageBuilder>();
+        var middleware = new DelegatePublishMiddleware(next, handler);
+        var cancellation = new CancellationTokenSource();
+        cancellation.Cancel();
+
+        Assert.ThrowsAnyAsync<TaskCanceledException>(async () => await middleware.InvokeAsync("test", message, cancellation.Token));
+        handler.DidNotReceive().Invoke(Arg.Any<object>(), Arg.Any<IMessageBuilder>());
+        next.DidNotReceive().InvokeAsync(Arg.Any<object>(), Arg.Any<IMessageBuilder>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task ShouldCallHandler()
+    {
+        var handler = Substitute.For<Action<object, IMessageBuilder>>();
+        var next = Substitute.For<IPublishMiddleware>();
+
+        var message = Substitute.For<IMessageBuilder>();
+        var middleware = new DelegatePublishMiddleware(next, handler);
+
+        await middleware.InvokeAsync("test", message, default);
+
+        handler.Received().Invoke("test", message);
+    }
+
+    [Fact]
+    public async Task ShouldCallNext()
+    {
+        var handler = Substitute.For<Action<object, IMessageBuilder>>();
+        var next = Substitute.For<IPublishMiddleware>();
+
+        var message = Substitute.For<IMessageBuilder>();
+        var middleware = new DelegatePublishMiddleware(next, handler);
+
+        await middleware.InvokeAsync("test", message, default);
+
+        await next.Received().InvokeAsync("test", message, Arg.Any<CancellationToken>());
+    }
+}

tests/RabbitMQ.Next.Tests/Publisher/DelegateReturnMiddlewareTests.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using NSubstitute;
+using RabbitMQ.Next.Publisher;
+using Xunit;
+
+namespace RabbitMQ.Next.Tests.Publisher;
+
+public class DelegateReturnMiddlewareTests
+{
+    [Fact]
+    public void ThrowsOnEmptyNext()
+    {
+        var handler = Substitute.For<Action<IReturnedMessage>>();
+
+        Assert.Throws<ArgumentNullException>(() => new DelegateReturnMiddleware(null, handler));
+    }
+
+    [Fact]
+    public void ThrowsOnEmptyHandler()
+    {
+        var next = Substitute.For<IReturnMiddleware>();
+
+        Assert.Throws<ArgumentNullException>(() => new DelegateReturnMiddleware(next, null));
+    }
+
+    [Fact]
+    public void ThrowsOnCancellation()
+    {
+        var handler = Substitute.For<Action<IReturnedMessage>>();
+        var next = Substitute.For<IReturnMiddleware>();
+
+        var message = Substitute.For<IReturnedMessage>();
+        var middleware = new DelegateReturnMiddleware(next, handler);
+        var cancellation = new CancellationTokenSource();
+        cancellation.Cancel();
+
+        Assert.ThrowsAnyAsync<TaskCanceledException>(async () => await middleware.InvokeAsync(message, cancellation.Token));
+        handler.DidNotReceive().Invoke(Arg.Any<IReturnedMessage>());
+        next.DidNotReceive().InvokeAsync(Arg.Any<IReturnedMessage>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task ShouldCallHandler()
+    {
+        var handler = Substitute.For<Action<IReturnedMessage>>();
+        var next = Substitute.For<IReturnMiddleware>();
+
+        var message = Substitute.For<IReturnedMessage>();
+        var middleware = new DelegateReturnMiddleware(next, handler);
+
+        await middleware.InvokeAsync(message, default);
+
+        handler.Received().Invoke(message);
+    }
+
+    [Fact]
+    public async Task ShouldCallNext()
+    {
+        var handler = Substitute.For<Action<IReturnedMessage>>();
+        var next = Substitute.For<IReturnMiddleware>();
+
+        var message = Substitute.For<IReturnedMessage>();
+        var middleware = new DelegateReturnMiddleware(next, handler);
+
+        await middleware.InvokeAsync(message, default);
+
+        await next.Received().InvokeAsync(message, Arg.Any<CancellationToken>());
+    }
+}