Messaging context tests

ASureBus.Tests/ASureBus/Core/Messaging/MessagingContextInternalTests.cs

@@ -0,0 +1,133 @@
+using ASureBus.Abstractions;
+using ASureBus.Abstractions.Options.Messaging;
+using ASureBus.Core.Messaging;
+using Moq;
+
+namespace ASureBus.Tests.ASureBus.Core.Messaging;
+
+public class MessagingContextInternalTests
+{
+    [Test]
+    public async Task Send_ShouldEnqueueMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmACommand>();
+        var messagingContext = new MessagingContextInternal();
+
+        // Act
+        await messagingContext.Send(message.Object);
+
+        // Assert
+        Assert.That(messagingContext.Messages, Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public async Task Send_WithOptions_ShouldEnqueueMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmACommand>();
+        var options = new SendOptions();
+        var messagingContext = new MessagingContextInternal();
+
+        // Act
+        await messagingContext.Send(message.Object, options);
+
+        // Assert
+        Assert.That(messagingContext.Messages, Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public async Task Send_WithOptions_ShouldEnqueueScheduledMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmACommand>();
+        var options = new SendOptions
+        {
+            ScheduledTime = DateTimeOffset.UtcNow.AddSeconds(10)
+        };
+        var messagingContext = new MessagingContextInternal();
+
+        // Act
+        await messagingContext.Send(message.Object, options);
+
+        // Assert
+        Assert.That(messagingContext.Messages, Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public async Task SendAfter_ShouldEnqueueScheduledMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmACommand>();
+        var delay = TimeSpan.FromMinutes(10);
+        var messagingContext = new MessagingContextInternal();
+
+        // Act
+        await messagingContext.SendAfter(message.Object, delay);
+
+        // Assert
+        Assert.That(messagingContext.Messages, Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public async Task Publish_ShouldEnqueueMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmAnEvent>();
+        var messagingContext = new MessagingContextInternal();
+
+        // Act
+        await messagingContext.Publish(message.Object);
+
+        // Assert
+        Assert.That(messagingContext.Messages, Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public async Task Publish_WithOptions_ShouldEnqueueMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmAnEvent>();
+        var options = new PublishOptions();
+        var messagingContext = new MessagingContextInternal();
+
+        // Act
+        await messagingContext.Publish(message.Object, options);
+
+        // Assert
+        Assert.That(messagingContext.Messages, Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public async Task Publish_WithOptions_ShouldEnqueueScheduledMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmAnEvent>();
+        var options = new PublishOptions
+        {
+            ScheduledTime = DateTimeOffset.UtcNow.AddSeconds(10)
+        };
+        var messagingContext = new MessagingContextInternal();
+
+        // Act
+        await messagingContext.Publish(message.Object, options);
+
+        // Assert
+        Assert.That(messagingContext.Messages, Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public async Task PublishAfter_ShouldEnqueueScheduledMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmAnEvent>();
+        var delay = TimeSpan.FromMinutes(10);
+        var messagingContext = new MessagingContextInternal();
+
+        // Act
+        await messagingContext.PublishAfter(message.Object, delay);
+
+        // Assert
+        Assert.That(messagingContext.Messages, Has.Count.EqualTo(1));
+    }
+}

ASureBus.Tests/ASureBus/Core/Messaging/MessagingContextTests.cs

@@ -0,0 +1,152 @@
+using ASureBus.Abstractions;
+using ASureBus.Abstractions.Options.Messaging;
+using ASureBus.Core.Messaging;
+using Moq;
+
+namespace ASureBus.Tests.ASureBus.Core.Messaging;
+
+[TestFixture]
+public class MessagingContextTests
+{
+    private Mock<IMessageEmitter> _mockEmitter;
+    private MessagingContext _messagingContext;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mockEmitter = new Mock<IMessageEmitter>();
+        _messagingContext = new MessagingContext(_mockEmitter.Object);
+    }
+
+    [Test]
+    public async Task Send_ShouldEnqueueAndFlushMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmACommand>();
+
+        // Act
+        await _messagingContext.Send(message.Object);
+
+        // Assert
+        _mockEmitter.Verify(
+            e => e.FlushAll(It.IsAny<ICollectMessage>(), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task Send_WithOptions_ShouldEnqueueAndFlushMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmACommand>();
+        var options = new SendOptions();
+
+        // Act
+        await _messagingContext.Send(message.Object, options);
+
+        // Assert
+        _mockEmitter.Verify(
+            e => e.FlushAll(It.IsAny<ICollectMessage>(), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task Send_WithOptions_ShouldEnqueueAndFlushScheduledMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmACommand>();
+        var options = new SendOptions
+        {
+            ScheduledTime = DateTimeOffset.UtcNow.AddSeconds(10)
+        };
+
+        // Act
+        await _messagingContext.Send(message.Object, options);
+
+        // Assert
+        _mockEmitter.Verify(
+            e => e.FlushAll(It.IsAny<ICollectMessage>(), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task SendAfter_ShouldEnqueueAndFlushScheduledMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmACommand>();
+        var delay = TimeSpan.FromMinutes(10);
+
+        // Act
+        await _messagingContext.SendAfter(message.Object, delay);
+
+        // Assert
+        _mockEmitter.Verify(
+            e => e.FlushAll(It.IsAny<ICollectMessage>(), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task Publish_ShouldEnqueueAndFlushMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmAnEvent>();
+
+        // Act
+        await _messagingContext.Publish(message.Object);
+
+        // Assert
+        _mockEmitter.Verify(
+            e => e.FlushAll(It.IsAny<ICollectMessage>(), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task Publish_WithOptions_ShouldEnqueueAndFlushMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmAnEvent>();
+        var options = new PublishOptions();
+
+        // Act
+        await _messagingContext.Publish(message.Object, options);
+
+        // Assert
+        _mockEmitter.Verify(
+            e => e.FlushAll(It.IsAny<ICollectMessage>(), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task Publish_WithOptions_ShouldEnqueueAndFlushScheduledMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmAnEvent>();
+        var options = new PublishOptions
+        {
+            ScheduledTime = DateTimeOffset.UtcNow.AddSeconds(10)
+        };
+
+        // Act
+        await _messagingContext.Publish(message.Object, options);
+
+        // Assert
+        _mockEmitter.Verify(
+            e => e.FlushAll(It.IsAny<ICollectMessage>(), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task PublishAfter_ShouldEnqueueAndFlushScheduledMessage()
+    {
+        // Arrange
+        var message = new Mock<IAmAnEvent>();
+        var delay = TimeSpan.FromMinutes(10);
+
+        // Act
+        await _messagingContext.PublishAfter(message.Object, delay);
+
+        // Assert
+        _mockEmitter.Verify(
+            e => e.FlushAll(It.IsAny<ICollectMessage>(), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+}