public async Task CopiesProperlyHandledMessageToAuditQueue()
{
var gotTheMessage = new ManualResetEvent(false);
_adapter.Handle <string>(async _ =>
{
gotTheMessage.Set();
});
await _bus.SendLocal("woohooo!!!!");
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(5));
InMemTransportMessage message;
var timer = Stopwatch.StartNew();
while ((message = _network.GetNextOrNull("audit")) == null)
{
await Task.Delay(200);
if (timer.Elapsed > TimeSpan.FromSeconds(2))
{
Assert.Fail("Did not receive message copy within 2 seconds of waiting....");
}
}
Assert.That(message.Headers.ContainsKey(Headers.AuditTime));
Assert.That(message.Headers.ContainsKey(Headers.Intent));
Assert.That(message.Headers[Headers.Intent], Is.EqualTo(Headers.IntentOptions.PointToPoint));
}
public void CompressionFirst()
{
SetUpBus(o =>
{
o.EnableCompression();
o.EnableEncryption(EncryptionKey);
});
var transportMessage = _network.GetNextOrNull(InputQueueName);
Console.WriteLine($"Size: {transportMessage.Body.Length} bytes");
}
public void CanSendAndReceive()
{
var messageId = Guid.NewGuid().ToString();
var transportMessageToSend = GetTransportMessage(messageId);
_network.Deliver("bimse", transportMessageToSend.ToInMemTransportMessage());
var receivedTransportMessage = _network.GetNextOrNull("bimse");
Assert.That(receivedTransportMessage, Is.Not.Null);
Assert.That(receivedTransportMessage.Headers.GetValue(Headers.MessageId), Is.EqualTo(messageId));
}
public async Task DoesNotCopyFailedMessage()
{
_adapter.Handle <string>(async _ =>
{
throw new Exception("w00t!!");
});
await _bus.SendLocal("woohooo!!!!");
await Task.Delay(TimeSpan.FromSeconds(3));
var message = _network.GetNextOrNull("audit");
Assert.That(message, Is.Null, "Apparently, a message copy was received anyway!!");
}
public async Task MovesMessageToErrorQueueAsExpected()
{
var message = NewMessage("known-id");
var exception = new IOException("æi altså");
await WithContext(async context =>
{
await _handler.HandlePoisonMessage(message, context, exception);
});
var failedMessage = _network.GetNextOrNull("error");
Assert.That(failedMessage, Is.Not.Null);
Assert.That(failedMessage.Headers[Headers.MessageId], Is.EqualTo("known-id"));
}
/// <summary>
/// Receives the next message from the queue identified by the configured <see cref="AbstractRebusTransport.Address"/>, returning null if none was available
/// </summary>
public override async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (_inputQueueAddress == null)
{
throw new InvalidOperationException("This in-mem transport is initialized without an input queue, hence it is not possible to receive anything!");
}
var nextMessage = _network.GetNextOrNull(_inputQueueAddress);
if (nextMessage == null)
{
return(null);
}
context.OnAborted(_ =>
{
_network.Deliver(_inputQueueAddress, nextMessage, alwaysQuiet: true);
});
return(nextMessage.ToTransportMessage());
}
public void ItWorks_DoNotComplete()
{
const string queueName = "destination-queue";
var network = new InMemNetwork();
network.CreateQueue(queueName);
RunTest(network, destinationAddress: queueName, complete: false);
var transportMessage = network.GetNextOrNull(queueName)?.ToTransportMessage();
Assert.That(transportMessage, Is.Null);
}
public void GetMessages_QueueWithMessages_DoesNotReturnConsumedMessages()
{
_inMemNetwork.Deliver("input", CreateMessage("Hello"));
_inMemNetwork.Deliver("input", CreateMessage("World"));
var nextMessage = _inMemNetwork.GetNextOrNull("input");
AssertMessage(nextMessage, "Hello");
var messages = _inMemNetwork.GetMessages("input");
Assert.That(messages.Count, Is.EqualTo(1));
AssertMessage(messages[0], "World");
}
public void ItWorks_Complete()
{
const string queueName = "destination-queue";
var network = new InMemNetwork();
network.CreateQueue(queueName);
RunTest(network, destinationAddress: queueName, complete: true);
var transportMessage = network.GetNextOrNull(queueName)?.ToTransportMessage();
Assert.That(transportMessage, Is.Not.Null);
Assert.That(Encoding.UTF8.GetString(transportMessage.Body), Is.EqualTo(@"""HEJ MED DIG"""));
}
public static async Task <TransportMessage> WaitForNextMessageFrom(this InMemNetwork network, string queueName, int timeoutSeconds = 5)
{
var stopwatch = Stopwatch.StartNew();
while (true)
{
var nextMessage = network.GetNextOrNull(queueName);
if (nextMessage != null)
{
return(nextMessage.ToTransportMessage());
}
await Task.Delay(100);
if (stopwatch.Elapsed < TimeSpan.FromSeconds(timeoutSeconds))
{
continue;
}
throw new TimeoutException($"Did not receive message from queue '{queueName}' within {timeoutSeconds} s timeout");
}
}
public async Task StillWorksWhenIncomingMessageCannotBeDeserialized()
{
const string brokenJsonString = @"{'broken': 'json', // DIE!!1}";
var headers = new Dictionary <string, string>
{
{ Headers.MessageId, Guid.NewGuid().ToString() },
{ Headers.ContentType, "application/json;charset=utf-8" },
};
var body = Encoding.UTF8.GetBytes(brokenJsonString);
var transportMessage = new TransportMessage(headers, body);
var inMemTransportMessage = new InMemTransportMessage(transportMessage);
_network.Deliver(InputQueueName, inMemTransportMessage);
await Task.Delay(1000);
var failedMessage = _network.GetNextOrNull("error");
Assert.That(failedMessage, Is.Not.Null);
var bodyString = Encoding.UTF8.GetString(failedMessage.Body);
Assert.That(bodyString, Is.EqualTo(brokenJsonString));
}