public async Task Dispose_WaitsDefinedTimeout_WhenPendingTasksTakeLonger()
{
// arrange
var startedHandle = new ManualResetEvent(false);
_handlerActivator.AddHandlerWithBusTemporarilyStopped <string>(async str =>
{
startedHandle.Set();
await Task.Delay(TimeSpan.FromSeconds(10));
});
// act
await _bus.Send("something");
startedHandle.WaitOne();
var timer = Stopwatch.StartNew();
_bus.Dispose();
timer.Stop();
// assert
Assert.That(timer.Elapsed, Is.GreaterThan(TimeSpan.FromSeconds(4)).And.LessThan(TimeSpan.FromSeconds(6)));
}
public void CorrelationSequenceIsIncremented()
{
var correlationSequenceNumbers = new List <int>();
var counter = new SharedCounter(1);
_activator1.AddHandlerWithBusTemporarilyStopped <string>(async(bus, ctx, str) =>
{
correlationSequenceNumbers.Add(int.Parse(ctx.Headers[Headers.CorrelationSequence]));
await bus.Advanced.Routing.Send("bus2", "hej!");
});
_activator2.AddHandlerWithBusTemporarilyStopped <string>(async(bus, ctx, str) =>
{
correlationSequenceNumbers.Add(int.Parse(ctx.Headers[Headers.CorrelationSequence]));
await bus.Advanced.Routing.Send("bus3", "hej!");
});
_activator3.AddHandlerWithBusTemporarilyStopped <string>(async(bus, ctx, str) =>
{
correlationSequenceNumbers.Add(int.Parse(ctx.Headers[Headers.CorrelationSequence]));
counter.Decrement();
});
_activator1.Bus.SendLocal("heeeej!").Wait();
counter.WaitForResetEvent();
Assert.That(correlationSequenceNumbers, Is.EqualTo(new[] { 0, 1, 2 }));
}
public async Task DeferringRequestDoesNotBreakAbilityToReply_DeferWithMessageApi()
{
_service.AddHandlerWithBusTemporarilyStopped <string>(async(bus, context, str) =>
{
const string deferredMessageHeader = "this message was already deferred";
if (!context.TransportMessage.Headers.ContainsKey(deferredMessageHeader))
{
var extraHeaders = new Dictionary <string, string>
{
{ deferredMessageHeader, "" },
{ Headers.ReturnAddress, context.Headers[Headers.ReturnAddress] }
};
Console.WriteLine($"SERVICE deferring '{str}' 1 second (elapsed: {_stopwatch.Elapsed.TotalSeconds:0.# s})");
await bus.Defer(TimeSpan.FromSeconds(1), str, extraHeaders);
return;
}
const string reply = "yeehaa!";
Console.WriteLine($"SERVICE replying '{reply}' (elapsed: {_stopwatch.Elapsed.TotalSeconds:0.# s})");
await bus.Reply(reply);
});
await RunDeferTest();
}
public async Task IncomingMessageHasNoHeaders()
{
var gotMessage = false;
_adapter.AddHandlerWithBusTemporarilyStopped <string>(async str => gotMessage = true);
var body = BodyWith("hej med dig min ven");
var headersWithoutMessageId = new Dictionary <string, string>();
_network.Deliver("test", new TransportMessage(headersWithoutMessageId, body).ToInMemTransportMessage());
await Task.Delay(1000);
PrintLogs();
Assert.That(gotMessage, Is.False, "Did not expect to receive the message");
var loggedErrors = _listLoggerFactory
.Where(l => l.Level == LogLevel.Error)
.ToList();
Assert.That(loggedErrors.Count, Is.EqualTo(1));
var errorLogLine = loggedErrors.Single(e => e.Level == LogLevel.Error);
Assert.That(errorLogLine.Text, Contains.Substring(
$"Received message with empty or absent '{Headers.MessageId}' header"));
}
public void CanDoItSyncWithoutBlocking()
{
var messageWasProperlyHandled = new ManualResetEvent(false);
var bus = _activator.Bus.Advanced.SyncBus;
_activator.AddHandlerWithBusTemporarilyStopped <string>(async str => messageWasProperlyHandled.Set());
var thread = new Thread(() =>
{
bus.SendLocal("ey det virker");
});
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
Assert.That(thread.Join(1000), Is.True, "thread did not finish within timeout");
messageWasProperlyHandled.WaitOrDie(timeout: TimeSpan.FromSeconds(2));
}
public void CanForwardMessageToErrorQueue()
{
var sharedCounter = new SharedCounter(1)
{
Delay = TimeSpan.FromSeconds(0.1)
};
Using(sharedCounter);
_forwarderActivator.AddHandlerWithBusTemporarilyStopped <string>(async(bus, str) =>
{
await bus.Advanced.TransportMessage.Forward(ForwardedMessagesQueue, new Dictionary <string, string> {
{ "testheader", "OK" }
});
});
_receiverActivator.AddHandlerWithBusTemporarilyStopped <string>(async(bus, context, str) =>
{
var headers = context.TransportMessage.Headers;
if (!headers.ContainsKey("testheader"))
{
sharedCounter.Fail("Could not find 'testheader' header!");
return;
}
var headerValue = headers["testheader"];
if (headerValue != "OK")
{
sharedCounter.Fail("'testheader' header had value {0}", headerValue);
return;
}
sharedCounter.Decrement();
});
_forwarderActivator.Bus.SendLocal("hej med dig min ven!!!").Wait();
sharedCounter.WaitForResetEvent();
}
public async Task CanDeferMessage_ToSelf()
{
var messageReceived = new ManualResetEvent(false);
var deliveryTime = DateTime.MaxValue;
_server.AddHandlerWithBusTemporarilyStopped <string>(async s =>
{
deliveryTime = DateTime.UtcNow;
messageReceived.Set();
});
var sendTime = DateTime.UtcNow;
var delay = TimeSpan.FromSeconds(5);
await _server.Bus.DeferLocal(delay, "hej med dig!");
messageReceived.WaitOrDie(TimeSpan.FromSeconds(8));
var timeToBeDelivered = deliveryTime - sendTime;
Assert.That(timeToBeDelivered, Is.GreaterThanOrEqualTo(delay));
}
public async Task ItWorks()
{
const int numberOfRetries = 5;
InitializeBus(numberOfRetries);
var attemptedDeliveries = 0;
_handlerActivator.AddHandlerWithBusTemporarilyStopped <string>(async _ =>
{
Interlocked.Increment(ref attemptedDeliveries);
throw new RebusApplicationException("omgwtf!");
});
await _bus.Send("hej");
var failedMessage = await _network.WaitForNextMessageFrom(ErrorQueueName);
Assert.That(attemptedDeliveries, Is.EqualTo(numberOfRetries));
Assert.That(failedMessage.Headers.GetValue(Headers.ErrorDetails), Contains.Substring("5 unhandled exceptions"));
Assert.That(failedMessage.Headers.GetValue(Headers.SourceQueue), Is.EqualTo(InputQueueName));
}
async Task RunDeferTest()
{
var replyCounter = new SharedCounter(1);
_client.AddHandlerWithBusTemporarilyStopped <string>(async reply =>
{
Console.WriteLine($"CLIENT got reply '{reply}' (elapsed: {_stopwatch.Elapsed.TotalSeconds:0.# s})");
replyCounter.Decrement();
});
await _client.Bus.Send("request");
replyCounter.WaitForResetEvent();
}
public void CanDoItSyncWithoutBlocking()
{
var messageWasProperlyHandled = new ManualResetEvent(false);
var bus = _activator.Bus.Advanced.SyncBus;
_activator.AddHandlerWithBusTemporarilyStopped <string>(async str => messageWasProperlyHandled.Set());
var thread = new Thread(() =>
{
bus.SendLocal("ey det virker");
});
// Setting ApartmentState is not supported in Net 5.0 and on Linux/OSX
if (Environment.Version.Major ! >= 5 && !(RuntimeInformation.IsOSPlatform(OSPlatform.Linux)))
{
thread.SetApartmentState(ApartmentState.STA);
}
thread.Start();
Assert.That(thread.Join(1000), Is.True, "thread did not finish within timeout");
messageWasProperlyHandled.WaitOrDie(timeout: TimeSpan.FromSeconds(2));
}
protected override void SetUp()
{
var network = new InMemNetwork();
var subscriberStore = new InMemorySubscriberStore();
_publisher = GetEndpoint(network, "publisher", c =>
{
c.Subscriptions(s => s.StoreInMemory(subscriberStore));
c.Routing(r => r.TypeBased());
});
_client1GotTheEvent = new ManualResetEvent(false);
_client1 = GetEndpoint(network, "client1", c =>
{
c.Routing(r => r.TypeBased().Map <SomeKindOfEvent>("publisher"));
});
_client1.AddHandlerWithBusTemporarilyStopped <SomeKindOfEvent>(async e => _client1GotTheEvent.Set());
}
public void DoesNotLogWarningsUnderNormalUse()
{
var counter = new SharedCounter(3);
_activator.AddHandlerWithBusTemporarilyStopped <string>(async str => counter.Decrement());
_activator.Bus.SendLocal("hej").Wait();
_activator.Bus.SendLocal("med").Wait();
_activator.Bus.SendLocal("dig").Wait();
counter.WaitForResetEvent();
CleanUpDisposables();
var logLinesWarnLevelOrAbove = _logs.Where(l => l.Level >= LogLevel.Warn).ToList();
Assert.That(logLinesWarnLevelOrAbove.Any(), Is.False, $@"Got the following log lines >= WARN:
{string.Join(Environment.NewLine, logLinesWarnLevelOrAbove)}");
}
public async Task ItWorksWithCovarianceToo()
{
var counter = new SharedCounter(1);
Using(counter);
_activator.AddHandlerWithBusTemporarilyStopped <BaseMessage>(async baseMessage => throw new RebusApplicationException("1st level!!"));
_activator.AddHandlerWithBusTemporarilyStopped <IFailed <BaseMessage> >(async failed =>
{
if (failed.Message is ConcreteMessage)
{
counter.Decrement();
return;
}
counter.Fail("Did not receive the expected message!");
});
await _bus.SendLocal(new ConcreteMessage());
counter.WaitForResetEvent();
}
