public async Task HandledByIsAcknowledgeAfterAcknowledgeIsCalled() { var message = new FakeReceiverMessage("Hello, world!"); await message.AcknowledgeAsync(); message.HandledBy.Should().Be(nameof(message.AcknowledgeAsync)); }
public async Task HandledByIsRejectAfterRejectIsCalled() { var message = new FakeReceiverMessage("Hello, world!"); await message.RejectAsync(); message.HandledBy.Should().Be(nameof(message.RejectAsync)); }
public void StringPayloadIsSetFromBase64EncodedBinaryPayload() { var payload = new byte[] { 1, 2, 3, 4, 5 }; var message = new FakeReceiverMessage(payload); message.StringPayload.Should().Be(Convert.ToBase64String(payload)); }
public void BinaryPayloadIsSetFromBinaryPayload() { var payload = new byte[] { 1, 2, 3, 4, 5 }; var message = new FakeReceiverMessage(payload); message.BinaryPayload.Should().BeSameAs(payload); }
public async Task HandledIsTrueAfterRejectIsCalled() { using var message = new FakeReceiverMessage("Hello, world!"); await message.RejectAsync().ConfigureAwait(false); message.Handled.Should().BeTrue(); }
public async Task HandledByIsRollbackAfterRollbackIsCalled() { using var message = new FakeReceiverMessage("Hello, world!"); await message.RollbackAsync().ConfigureAwait(false); message.HandledBy.Should().Be(nameof(message.RollbackAsync)); }
public async Task HandledIsTrueAfterRollbackIsCalled() { var message = new FakeReceiverMessage("Hello, world!"); await message.RollbackAsync(); message.Handled.Should().BeTrue(); }
public async Task HandledIsTrueAfterAcknowledgeIsCalled() { var message = new FakeReceiverMessage("Hello, world!"); await message.AcknowledgeAsync(); message.Handled.Should().BeTrue(); }
public async Task RollbackThrowsIfHandledIsTrue() { using var message = new FakeReceiverMessage("Hello, world!"); await message.AcknowledgeAsync().ConfigureAwait(false); Func <Task> act = () => message.RollbackAsync(); await act.Should().ThrowAsync <InvalidOperationException>() .WithMessage($"Cannot {nameof(message.RollbackAsync)} message: the message has already been handled by {nameof(message.AcknowledgeAsync)}.").ConfigureAwait(false); }
public async Task RejectThrowsIfHandledIsTrue() { var message = new FakeReceiverMessage("Hello, world!"); await message.AcknowledgeAsync(); Func <Task> act = () => message.RejectAsync(); act.Should().Throw <InvalidOperationException>() .WithMessage($"Cannot {nameof(message.RejectAsync)} message: the message has already been handled by {nameof(message.AcknowledgeAsync)}."); }
public async Task RollbackCallsInnerMessageRollbackIfRollbackForwarderIsNull() { var receiver = new FakeReceiver(); var forwardingReceiver = new ForwardingReceiver("foo", receiver, rollbackForwarder: null); var message = new FakeReceiverMessage("Hello, world!"); var forwardingMessage = new ForwardingReceiverMessage(forwardingReceiver, message); await forwardingMessage.RollbackAsync(); message.HandledBy.Should().Be(nameof(IReceiverMessage.RollbackAsync)); }
public async Task AcknowledgeCallsInnerMessageAcknowledgeIfAcknowledgeForwarderIsNull() { using var receiver = new FakeReceiver(); using var forwardingReceiver = new ForwardingReceiver("foo", receiver, acknowledgeForwarder: null); using var message = new FakeReceiverMessage("Hello, world!"); var forwardingMessage = new ForwardingReceiverMessage(forwardingReceiver, message); await forwardingMessage.AcknowledgeAsync().ConfigureAwait(false); message.HandledBy.Should().Be(nameof(IReceiverMessage.AcknowledgeAsync)); }
public async Task AcknowledgeHandlesInnerMessageAccordingToAcknowledgeOutcomeWhenAcknowledgeForwarderIsNotNull(ForwardingOutcome outcome) { var forwarder = new FakeSender(); var receiver = new FakeReceiver(); var forwardingReceiver = new ForwardingReceiver("foo", receiver, acknowledgeForwarder: forwarder, acknowledgeOutcome: outcome); var message = new FakeReceiverMessage("Hello, world!"); var forwardingMessage = new ForwardingReceiverMessage(forwardingReceiver, message); await forwardingMessage.AcknowledgeAsync(); message.HandledBy.Should().Be($"{outcome}Async"); }
public async Task RollbackHandlesInnerMessageAccordingToRollbackOutcomeWhenRollbackForwarderIsNotNull(ForwardingOutcome outcome) { using var forwarder = new FakeSender(); using var receiver = new FakeReceiver(); using var forwardingReceiver = new ForwardingReceiver("foo", receiver, rollbackForwarder: forwarder, rollbackOutcome: outcome); using var message = new FakeReceiverMessage("Hello, world!"); var forwardingMessage = new ForwardingReceiverMessage(forwardingReceiver, message); await forwardingMessage.RollbackAsync().ConfigureAwait(false); message.HandledBy.Should().Be($"{outcome}Async"); }
public async Task AcknowledgeSendsMessageToAcknowledgeForwarderWhenAcknowledgeForwarderIsNotNull() { var forwarder = new FakeSender(); var receiver = new FakeReceiver(); var forwardingReceiver = new ForwardingReceiver("foo", receiver, acknowledgeForwarder: forwarder); var message = new FakeReceiverMessage("Hello, world!"); var forwardingMessage = new ForwardingReceiverMessage(forwardingReceiver, message); await forwardingMessage.AcknowledgeAsync(); forwarder.SentMessages.Should().ContainSingle(); forwarder.SentMessages[0].StringPayload.Should().Be("Hello, world!"); }
public async Task RollbackSendsMessageToRollbackForwarderWhenRollbackForwarderIsNotNull() { using var forwarder = new FakeSender(); using var receiver = new FakeReceiver(); using var forwardingReceiver = new ForwardingReceiver("foo", receiver, rollbackForwarder: forwarder); using var message = new FakeReceiverMessage("Hello, world!"); var forwardingMessage = new ForwardingReceiverMessage(forwardingReceiver, message); await forwardingMessage.RollbackAsync().ConfigureAwait(false); forwarder.SentMessages.Should().ContainSingle(); forwarder.SentMessages[0].StringPayload.Should().Be("Hello, world!"); }
public void PublicHeaderPropertyHasSameContentsAsExplicitInterfaceHeaderProperty() { var message = new FakeReceiverMessage("Hello, world!"); message.Headers.Add("foo", "abc"); message.Headers.Add("bar", 123); HeaderDictionary interfaceHeaders = ((IReceiverMessage)message).Headers; interfaceHeaders.ContainsKey("foo"); interfaceHeaders["foo"].Should().Be("abc"); interfaceHeaders.ContainsKey("bar"); interfaceHeaders["bar"].Should().Be(123); }
public async Task TheCallbackPassedToStart1IsInvokedWhenAMessageIsReceived() { using var receiver = new FakeReceiver(); var received = false; receiver.Start(async m => { received = true; await m.AcknowledgeAsync().ConfigureAwait(false); }); using var message = new FakeReceiverMessage("Hello, world!"); await receiver.MessageHandler.OnMessageReceivedAsync(receiver, message).ConfigureAwait(false); Assert.True(received); }
public async Task OnMessageReceivedCallsInnerHandlerOnMessageReceivedWithForwardingReceiverMessage() { var receiver = new FakeReceiver(); var forwardingReceiver = new ForwardingReceiver("foo", receiver); var messageHandler = new FakeMessageHandler(); var handler = new ForwardingMessageHandler(forwardingReceiver, messageHandler); var message = new FakeReceiverMessage("Hello, world!"); await handler.OnMessageReceivedAsync(receiver, message); messageHandler.ReceivedMessages.Should().ContainSingle(); messageHandler.ReceivedMessages[0].Receiver.Should().BeSameAs(forwardingReceiver); messageHandler.ReceivedMessages[0].Message.Should().BeOfType <ForwardingReceiverMessage>(); ((ForwardingReceiverMessage)messageHandler.ReceivedMessages[0].Message).Message.Should().BeSameAs(message); ((ForwardingReceiverMessage)messageHandler.ReceivedMessages[0].Message).ForwardingReceiver.Should().BeSameAs(forwardingReceiver); }
public void ReceiverMessageConstructorUncompressedStringPayload() { var payload = "Hello, world!"; var receiverMessage = new FakeReceiverMessage(payload, false); var message = new SenderMessage(receiverMessage); message.StringPayload.Should().Be(payload); message.BinaryPayload.Should().BeEquivalentTo(Encoding.UTF8.GetBytes(payload)); message.Headers.Should().ContainKey(HeaderNames.MessageId); message.MessageId.Should().NotBeNull(); message.Headers.Should().NotContainKey(HeaderNames.IsBinaryPayload); message.IsBinary.Should().BeFalse(); message.Headers.Should().NotContainKey(HeaderNames.IsCompressedPayload); message.IsCompressed.Should().BeFalse(); }
public async Task TheCallbackPassedToStart4IsInvokedWhenAMessageIsReceived() { using var receiver = new FakeReceiver(); var received = false; #pragma warning disable CS0618 // Type or member is obsolete receiver.Start((r, m) => { received = true; m.Acknowledge(); }); #pragma warning restore CS0618 // Type or member is obsolete using var message = new FakeReceiverMessage("Hello, world!"); await receiver.MessageHandler.OnMessageReceivedAsync(receiver, message).ConfigureAwait(false); Assert.True(received); }
public void ReceiverMessageConstructorCompressedStringPayload() { var payload = GetCompressablePayload("Hello, world!"); var receiverMessage = new FakeReceiverMessage(payload, true); var message = new SenderMessage(receiverMessage); message.StringPayload.Should().Be(Convert.ToBase64String(_gzip.Compress(Encoding.UTF8.GetBytes(payload)))); message.BinaryPayload.Should().BeEquivalentTo(_gzip.Compress(Encoding.UTF8.GetBytes(payload))); message.Headers.Should().ContainKey(HeaderNames.MessageId); message.MessageId.Should().NotBeNull(); message.Headers.Should().NotContainKey(HeaderNames.IsBinaryPayload); message.IsBinary.Should().BeFalse(); message.Headers[HeaderNames.IsCompressedPayload].Should().Be("true"); message.IsCompressed.Should().BeTrue(); }
public void ReceiverMessageConstructorCompressedBinaryPayload() { var payload = GetCompressablePayload(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); var receiverMessage = new FakeReceiverMessage(payload, true); var message = new SenderMessage(receiverMessage); message.StringPayload.Should().Be(Convert.ToBase64String(_gzip.Compress(payload))); message.BinaryPayload.Should().BeEquivalentTo(_gzip.Compress(payload)); message.Headers.Should().ContainKey(HeaderNames.MessageId); message.MessageId.Should().NotBeNull(); message.Headers[HeaderNames.IsBinaryPayload].Should().Be("true"); message.IsBinary.Should().BeTrue(); message.Headers[HeaderNames.IsCompressedPayload].Should().Be("true"); message.IsCompressed.Should().BeTrue(); }
public void StringPayloadIsSetFromStringPayload() { var message = new FakeReceiverMessage("Hello, world!"); message.StringPayload.Should().BeSameAs("Hello, world!"); }
public void BinaryPayloadIsSetFromUTF8EncodedStringPayload() { var message = new FakeReceiverMessage("Hello, world!"); message.BinaryPayload.Should().BeEquivalentTo(Encoding.UTF8.GetBytes("Hello, world!"), x => x.WithStrictOrdering()); }
public void PublicHeaderPropertyIsNotTheSameAsExplicitInterfaceHeaderProperty() { var message = new FakeReceiverMessage("Hello, world!"); ((object)message.Headers).Should().NotBeSameAs(((IReceiverMessage)message).Headers); }
public void HandledByIsNullBeforeMessageIsHandled() { var message = new FakeReceiverMessage("Hello, world!"); message.HandledBy.Should().BeNull(); }
public void HandledIsFalseBeforeMessageIsHandled() { var message = new FakeReceiverMessage("Hello, world!"); message.Handled.Should().BeFalse(); }