public async Task ItWorks()
{
var sub1GotEvent = new ManualResetEvent(false);
var sub2GotEvent = new ManualResetEvent(false);
var sub1 = GetBus(_subscriber1QueueName, async str =>
{
if (str == "weehoo!!")
{
sub1GotEvent.Set();
}
});
var sub2 = GetBus(_subscriber2QueueName, async str =>
{
if (str == "weehoo!!")
{
sub2GotEvent.Set();
}
});
await sub1.Bus.Subscribe<string>();
await sub2.Bus.Subscribe<string>();
await _publisher.Bus.Publish("weehoo!!");
sub1GotEvent.WaitOrDie(TimeSpan.FromSeconds(2));
sub2GotEvent.WaitOrDie(TimeSpan.FromSeconds(2));
}
public void ItWorks()
{
var gotTheMessage = new ManualResetEvent(false);
_handlerActivator.Handle<HugeMessage>(async msg =>
{
gotTheMessage.Set();
});
var hugePayload = string.Concat(Enumerable.Range(0, 128)
.Select(i => string.Concat(Enumerable.Repeat(i.ToString(), 128))));
_bus.SendLocal(new HugeMessage {Payload = hugePayload});
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(2));
var hugePayloadLength = hugePayload.Length;
var sentMessageBodyLength = _sentMessages.Single().Body.Length;
var receivedMessageBodyLength = _receivedMessages.Single().Body.Length;
Console.WriteLine(@"
Huge payload: {0}
Sent message: {1}
Received message: {2}", hugePayloadLength, sentMessageBodyLength, receivedMessageBodyLength);
Assert.That(sentMessageBodyLength, Is.LessThan(hugePayloadLength));
Assert.That(receivedMessageBodyLength, Is.LessThan(hugePayloadLength));
}
public void CheckEncryptedMessages()
{
var transportMessages = new ConcurrentQueue<TransportMessage>();
_transportTap.MessageReceived += transportMessages.Enqueue;
_transportTap.MessageSent += transportMessages.Enqueue;
var gotMessage = new ManualResetEvent(false);
_activator.Handle<string>(async message =>
{
if (message != "hej") throw new ArgumentException("not the right message!!");
gotMessage.Set();
});
_activator.Bus.SendLocal("hej").Wait();
gotMessage.WaitOrDie(TimeSpan.FromSeconds(3));
var messages = transportMessages.ToList();
Assert.That(messages.Count, Is.EqualTo(2));
var headers = messages.First().Headers;
Assert.That(headers[EncryptionHeaders.ContentEncryption], Is.EqualTo("silly"));
}
public async Task UsesNativeDeferralMechanism()
{
var done = new ManualResetEvent(false);
var receiveTime = DateTimeOffset.MinValue;
var hadDeferredUntilHeader = false;
_activator.Handle<TimedMessage>(async (bus, context, message) =>
{
receiveTime = DateTimeOffset.Now;
hadDeferredUntilHeader = context.TransportMessage.Headers.ContainsKey(Headers.DeferredUntil);
done.Set();
});
var sendTime = DateTimeOffset.Now;
await _bus.Defer(TimeSpan.FromSeconds(5), new TimedMessage { Time = sendTime });
done.WaitOrDie(TimeSpan.FromSeconds(8), "Did not receive 5s-deferred message within 8 seconds of waiting....");
var delay = receiveTime - sendTime;
Console.WriteLine("Message was delayed {0}", delay);
Assert.That(delay, Is.GreaterThan(TimeSpan.FromSeconds(4)), "The message not delayed ~5 seconds as expected!");
Assert.That(delay, Is.LessThan(TimeSpan.FromSeconds(8)), "The message not delayed ~5 seconds as expected!");
Assert.That(hadDeferredUntilHeader, Is.False, "Received message still had the '{0}' header - we must remove that", Headers.DeferredUntil);
}
public async Task NizzleName()
{
var gotMessage = new ManualResetEvent(false);
using (var activator = new BuiltinHandlerActivator())
{
activator.Handle<string>(async s =>
{
Console.WriteLine("Got message: {0}", s);
gotMessage.Set();
});
Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "bimse"))
.Options(o =>
{
o.Register<IWorkerFactory>(c =>
{
var transport = c.Get<ITransport>();
var pipeline = c.Get<IPipeline>();
var pipelineInvoker = c.Get<IPipelineInvoker>();
var rebusLoggerFactory = c.Get<IRebusLoggerFactory>();
return new AsyncTaskWorkerFactory(transport, pipeline, pipelineInvoker, rebusLoggerFactory);
});
})
.Start();
await activator.Bus.SendLocal("hej med dig min ven");
gotMessage.WaitOrDie(TimeSpan.FromSeconds(3));
}
}
public void DoesNotBarfInTheBackground()
{
var doneHandlingMessage = new ManualResetEvent(false);
_activator.Handle<string>(async str =>
{
for (var count = 0; count < 5; count++)
{
Console.WriteLine("waiting...");
await Task.Delay(TimeSpan.FromSeconds(20));
}
Console.WriteLine("done waiting!");
doneHandlingMessage.Set();
});
_activator.Bus.SendLocal("hej med dig min ven!").Wait();
doneHandlingMessage.WaitOrDie(TimeSpan.FromMinutes(2));
var logLinesAboveInformation = _loggerFactory
.Where(l => l.Level >= LogLevel.Warn)
.ToList();
Assert.That(!logLinesAboveInformation.Any(), "Expected no warnings - got this: {0}", string.Join(Environment.NewLine, logLinesAboveInformation));
}
public void CanHandleMessagesInsideTranasctionScope(bool useTransactionScope)
{
var done = new ManualResetEvent(false);
var detectedAmbientTransaction = false;
var activator = Using(new BuiltinHandlerActivator());
activator.Handle<string>(async str =>
{
detectedAmbientTransaction = Transaction.Current != null;
done.Set();
});
Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "txtest"))
.Options(o =>
{
if (useTransactionScope)
{
o.HandleMessagesInsideTransactionScope();
}
o.LogPipeline();
})
.Start();
activator.Bus.SendLocal("hej").Wait();
done.WaitOrDie(TimeSpan.FromSeconds(2));
Assert.That(detectedAmbientTransaction, Is.EqualTo(useTransactionScope),
"Detected: {0}, expected: {1}", detectedAmbientTransaction, useTransactionScope);
}
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....");
}
}
PrintHeaders(message);
Assert.That(message.Headers.ContainsKey(AuditHeaders.AuditTime));
Assert.That(message.Headers.ContainsKey(AuditHeaders.HandleTime));
Assert.That(message.Headers.ContainsKey(Headers.Intent));
Assert.That(message.Headers[Headers.Intent], Is.EqualTo(Headers.IntentOptions.PointToPoint));
}
public async Task CanSendAndReceive()
{
var gotMessage = new ManualResetEvent(false);
_handlerActivator
.Handle<string>(async (bus, str) =>
{
if (str == "hej med dig min ven!")
{
Console.WriteLine("w00t!");
await bus.Reply("t00t!");
}
if (str == "t00t!")
{
Console.WriteLine("got t++t!!!");
gotMessage.Set();
}
});
await _bus.Send("hej med dig min ven!");
gotMessage.WaitOrDie(TimeSpan.FromSeconds(30));
}
public async Task DoIt()
{
var builtinHandlerActivator = new BuiltinHandlerActivator();
var allDone = false;
var gotMessage = new ManualResetEvent(false);
builtinHandlerActivator.Handle<string>(async _ =>
{
gotMessage.Set();
await Task.Delay(2000);
allDone = true;
});
var bus = Configure.With(builtinHandlerActivator)
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "shutdown with pending tasks"))
.Start();
using (bus)
{
await bus.SendLocal("hej");
gotMessage.WaitOrDie(TimeSpan.FromSeconds(2));
// make bus shut down here
}
Assert.That(allDone, Is.True, "The message was apparently not handled all the way to the end!!!");
}
public async Task PubSubSeemsToWorkAlsoWithUnsubscribe()
{
var gotString1 = new ManualResetEvent(false);
var subscriber2GotTheMessage = false;
_bus1.Handle<string>(async str => gotString1.Set());
_bus2.Handle<string>(async str =>
{
subscriber2GotTheMessage = true;
});
await _bus1.Bus.Subscribe<string>();
await _bus2.Bus.Subscribe<string>();
await Task.Delay(500);
await _bus2.Bus.Unsubscribe<string>();
await Task.Delay(500);
await _bus3.Bus.Publish("hello there!!!!");
gotString1.WaitOrDie(TimeSpan.FromSeconds(2));
Assert.That(subscriber2GotTheMessage, Is.False, "Didn't expect subscriber 2 to get the string since it was unsubscribed");
}
public async Task YeahItWorks()
{
var events = new List<string>();
var finishedHandled = new ManualResetEvent(false);
_handlerActivator.Handle<string>(async str =>
{
await AppendEvent(events, "1");
await AppendEvent(events, "2");
await AppendEvent(events, "3");
await AppendEvent(events, "4");
finishedHandled.Set();
});
Console.WriteLine(string.Join(Environment.NewLine, events));
await _bus.Send("hej med dig!");
finishedHandled.WaitOrDie(TimeSpan.FromSeconds(10));
Assert.That(events.Count, Is.EqualTo(4));
Assert.That(events[0], Is.StringStarting("event=1"));
Assert.That(events[1], Is.StringStarting("event=2"));
Assert.That(events[2], Is.StringStarting("event=3"));
Assert.That(events[3], Is.StringStarting("event=4"));
}
public void ItWorksWithComplexMessage(bool withCompressionEnabled)
{
var activator = new BuiltinHandlerActivator();
var gotIt = new ManualResetEvent(false);
activator.Handle<TextMessage>(async str =>
{
if (string.Equals(str.Text, LongText))
{
gotIt.Set();
}
else
{
throw new Exception(string.Format("Received text with {0} chars did not match expected text with {1} chars!",
str.Text.Length, LongText.Length));
}
});
Using(activator);
var bus = CreateBus(withCompressionEnabled, activator);
bus.SendLocal(new TextMessage {Text = LongText}).Wait();
gotIt.WaitOrDie(TimeSpan.FromSeconds(10));
}
public void DispatchesDynamicMessageWhenDotNetTypeCannotBeFound()
{
var gotTheMessage = new ManualResetEvent(false);
string messageText = null;
_builtinHandlerActivator.Handle<dynamic>(async message =>
{
Console.WriteLine("Received dynamic message: {0}", message);
messageText = message.something.text;
gotTheMessage.Set();
});
var headers = new Dictionary<string, string>
{
{Headers.MessageId, Guid.NewGuid().ToString()},
{Headers.ContentType, "application/json;charset=utf-8"},
};
var transportMessage = new TransportMessage(headers, Encoding.UTF8.GetBytes(@"{
""something"": {
""text"": ""OMG dynamic JSON BABY!!""
}
}"));
_network.Deliver(InputQueueName, new InMemTransportMessage(transportMessage));
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(2));
Assert.That(messageText, Is.EqualTo("OMG dynamic JSON BABY!!"));
}
public async Task CanSubscribeEvenThoughWeHaveNotConfiguredAnyEndpointMappings()
{
var gotTheString = new ManualResetEvent(false);
_activator.Handle<string>(async str => gotTheString.Set());
await _activator.Bus.Subscribe<string>();
await Task.Delay(500);
await _activator.Bus.Publish("whooo hooo this is a string!!");
gotTheString.WaitOrDie(TimeSpan.FromSeconds(2));
}
public async Task OneWayClientWorks()
{
var gotIt = new ManualResetEvent(false);
_server.Handle<string>(async str =>
{
Console.WriteLine("Got string: {0}", str);
gotIt.Set();
});
await _client.Send("w000000h000000!!!!1111");
gotIt.WaitOrDie(TimeSpan.FromSeconds(3));
}
public async Task CanDeferMessage()
{
var stopwatch = Stopwatch.StartNew();
var gotTheMessage = new ManualResetEvent(false);
_activator.Handle<string>(async str =>
{
stopwatch.Stop();
gotTheMessage.Set();
});
await _activator.Bus.Defer(TimeSpan.FromSeconds(4), "hej med dig!");
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(8));
Assert.That(stopwatch.Elapsed, Is.GreaterThan(TimeSpan.FromSeconds(4)));
}
public async Task ItWorksWhenTheHeaderHasBeenSet()
{
var gotTheMessage = new ManualResetEvent(false);
_destination.Handle<string>(async str =>
{
gotTheMessage.Set();
});
var headers = new Dictionary<string, string>
{
{ Headers.DeferredRecipient, DestinationQueueName }
};
await _oneWayClient.Defer(TimeSpan.FromSeconds(1), "hej med dig min ven!!", headers);
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(4));
}
public async Task SubcriberReceivesMessagesWhenItHasSubscribed()
{
var subscriberReceivedMessage = new ManualResetEvent(false);
const string topicName = "someTopic";
await _subscriberBus.Advanced.Topics.Subscribe(topicName);
_subscriberHandlers.Handle<string>(async str =>
{
subscriberReceivedMessage.Set();
});
await Task.Delay(1000);
await _publisherBus.Advanced.Topics.Publish(topicName, "hej med dig min ven!!!!!");
subscriberReceivedMessage.WaitOrDie(TimeSpan.FromSeconds(30), "Expected to have received a message");
}
public async Task PubSubSeemsToWork()
{
var gotString1 = new ManualResetEvent(false);
var gotString2 = new ManualResetEvent(false);
_bus1.Handle<string>(async str => gotString1.Set());
_bus2.Handle<string>(async str => gotString2.Set());
await _bus1.Bus.Subscribe<string>();
await _bus2.Bus.Subscribe<string>();
await Task.Delay(500);
await _bus3.Bus.Publish("hello there!!!!");
gotString1.WaitOrDie(TimeSpan.FromSeconds(2));
gotString2.WaitOrDie(TimeSpan.FromSeconds(2));
}
public void CanDoItSyncWithoutBlocking()
{
var messageWasProperlyHandled = new ManualResetEvent(false);
var bus = _activator.Bus.Advanced.SyncBus;
_activator.Handle<string>(async str => messageWasProperlyHandled.Set());
var thread = new Thread(() =>
{
bus.SendLocal("ey det virker");
});
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
Assert.That(thread.Join(TimeSpan.FromSeconds(1)), Is.True, "thread did not finish within timeout");
messageWasProperlyHandled.WaitOrDie(timeout: TimeSpan.FromSeconds(2));
}
public async Task WorksOutOfTheBoxWithInternalTimeoutManager()
{
var gotTheMessage = new ManualResetEvent(false);
var activator = new BuiltinHandlerActivator();
activator.Handle<string>(async str => gotTheMessage.Set());
Configure.With(activator)
.Transport(t => t.UseMsmq(_queueName))
.Start();
var stopwatch = Stopwatch.StartNew();
await activator.Bus.Defer(TimeSpan.FromSeconds(5), "hej med dig min ven!");
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(6), "Message was not received within 6,5 seconds (which it should have been since it was only deferred 5 seconds)");
Assert.That(stopwatch.Elapsed, Is.GreaterThan(TimeSpan.FromSeconds(5)), "It must take more than 5 second to get the message back");
}
public async Task AutomaticallyCreatesDestinationQueue()
{
var queueName = TestConfig.QueueName("does_not_exist_yet");
RabbitMqTransportFactory.DeleteQueue(queueName);
// first we send a message to a queue that does not exist at this time
Console.WriteLine($"Sending 'hej med dig min ven!' message to '{queueName}'");
await _bus.Advanced.Routing.Send(queueName, "hej med dig min ven!");
// then we start a server listening on the queue
var gotTheMessage = new ManualResetEvent(false);
StartServer(queueName).Handle<string>(async str =>
{
gotTheMessage.Set();
});
Console.WriteLine("Waiting for message to arrive");
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(5));
Console.WriteLine("Got it :)");
}
public async Task SendAndReceiveOneSingleMessage()
{
var gotTheMessage = new ManualResetEvent(false);
var receivedMessageCount = 0;
_handlerActivator.Handle<string>(async message =>
{
Interlocked.Increment(ref receivedMessageCount);
Console.WriteLine("w00000t! Got message: {0}", message);
gotTheMessage.Set();
});
await _bus.SendLocal("hej med dig min ven!");
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(10));
await Task.Delay(500);
Assert.That(receivedMessageCount, Is.EqualTo(1));
}
public async Task ReceivesManuallyRoutedMessage()
{
var queueName = TestConfig.QueueName("manual_routing");
var gotTheMessage = new ManualResetEvent(false);
StartServer(queueName).Handle<string>(async str =>
{
gotTheMessage.Set();
});
Console.WriteLine($"Sending 'hej med dig min ven!' message to '{queueName}'");
await _bus.Advanced.Routing.Send(queueName, "hej med dig min ven!");
Console.WriteLine("Waiting for message to arrive");
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(5));
Console.WriteLine("Got it :)");
}
public async Task CopiesProperlyHandledMessageToAuditQueue()
{
var gotTheMessage = new ManualResetEvent(false);
_adapter.Handle<string>(async _ =>
{
gotTheMessage.Set();
});
await _bus.SendLocal("woohooo!!!!");
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(5));
var message = await _network.WaitForNextMessageFrom("audit");
PrintHeaders(message);
Assert.That(message.Headers.ContainsKey(AuditHeaders.AuditTime));
Assert.That(message.Headers.ContainsKey(AuditHeaders.HandleTime));
Assert.That(message.Headers.ContainsKey(Headers.Intent));
Assert.That(message.Headers[Headers.Intent], Is.EqualTo(Headers.IntentOptions.PointToPoint));
}
public async Task CanDeferMessage()
{
var messageReceived = new ManualResetEvent(false);
var deliveryTime = DateTime.MaxValue;
_handlerActivator.Handle<string>(async s =>
{
deliveryTime = DateTime.UtcNow;
messageReceived.Set();
});
var sendTime = DateTime.UtcNow;
var delay = TimeSpan.FromSeconds(5);
await _bus.Defer(delay, "hej med dig!");
messageReceived.WaitOrDie(TimeSpan.FromSeconds(8));
var timeToBeDelivered = deliveryTime - sendTime;
Assert.That(timeToBeDelivered, Is.GreaterThanOrEqualTo(delay));
}
public void CannotSendFailedMessageWrapper()
{
var couldNotSendMessage = new ManualResetEvent(false);
Exception caughtException = null;
_activator.Handle<string>(async str =>
{
throw new ArithmeticException();
});
_activator.Handle<IFailed<string>>(async (bus, context, failed) =>
{
// "failed" is an IFailed<string> in here - let's pretend that
// we accidentally Defer that one instead of "failed.Message"
// as we should
try
{
await bus.Defer(TimeSpan.FromSeconds(1), failed);
}
catch(Exception exception)
{
// just what we wanted! :)
caughtException = exception;
couldNotSendMessage.Set();
}
});
_activator.Bus.SendLocal("HOOLOOBOOLOO").Wait();
couldNotSendMessage.WaitOrDie(TimeSpan.FromSeconds(5));
Console.WriteLine($@"This is the exception that we caught:
{caughtException}
You're welcome.");
}
public async Task SentMessageIsBasicallyUnreadable()
{
const string plainTextMessage = "hej med dig min ven!!!";
var gotTheMessage = new ManualResetEvent(false);
_builtinHandlerActivator.Handle<string>(async str =>
{
gotTheMessage.Set();
});
await _bus.Route("bimse", plainTextMessage);
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(2));
var sentMessage = _tap.SentMessages.Single();
var receivedMessage = _tap.ReceivedMessages.Single();
var sentMessageBodyAsString = Encoding.UTF8.GetString(sentMessage.Body);
var receivedMessageBodyAsString = Encoding.UTF8.GetString(receivedMessage.Body);
Assert.That(sentMessageBodyAsString, Is.Not.StringContaining(plainTextMessage));
Assert.That(receivedMessageBodyAsString, Is.Not.StringContaining(plainTextMessage));
}
public void ItWorksWithString(bool withCompressionEnabled)
{
var gotIt = new ManualResetEvent(false);
_activator.Handle<string>(async str =>
{
if (string.Equals(str, LongText))
{
gotIt.Set();
}
else
{
throw new Exception(
$"Received text with {str.Length} chars did not match expected text with {LongText.Length} chars!");
}
});
var bus = CreateBus(withCompressionEnabled, _activator);
bus.SendLocal(LongText).Wait();
gotIt.WaitOrDie(TimeSpan.FromSeconds(10));
}
