public async Task ItWorks()
{
var network = new InMemNetwork();
var builder = new ContainerBuilder();
var stuff = new ConcurrentQueue <string>();
builder.RegisterInstance(stuff);
builder.RegisterRebus(configure =>
configure
.Logging(l => l.None())
.Transport(t => t.UseInMemoryTransport(network, "test"))
.Options(o => o.SimpleRetryStrategy(secondLevelRetriesEnabled: true, maxDeliveryAttempts: 1))
);
builder.RegisterHandler <MyTestHandler>();
await using var container = builder.Build();
var bus = container.Resolve <IBus>();
Console.WriteLine("Sending message");
await bus.SendLocal("hej søtte!");
Console.WriteLine("Waiting for message to arrive in queue 'done'...");
await network.WaitForNextMessageFrom("done");
Console.WriteLine("Got the message!");
Assert.That(stuff.Count, Is.EqualTo(1),
"Expected second level handler to have been called only once!!");
}
public async Task CanMoveMessageToErrorQueueEvenThoughExceptionIsNotSerializable()
{
using (var activator = new BuiltinHandlerActivator())
{
activator.Handle <string>(async str =>
{
throw new ThisOneCannotBeSerialized("BAM!!!!!!!!!!!11111111111111111");
});
var network = new InMemNetwork();
var bus = Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "unserializable exceptions"))
.Options(o => o.SimpleRetryStrategy(maxDeliveryAttempts: 1))
.Start();
const string knownString = "JUST SOME LISP!!!!11((((((((((((((((((()))))))))))))))))))))))";
await bus.SendLocal(knownString);
var failedMessage = await network.WaitForNextMessageFrom("error");
Assert.That(Encoding.UTF8.GetString(failedMessage.Body), Is.EqualTo(JsonConvert.SerializeObject(knownString)));
}
}
static IBus GetFailingBus(BuiltinHandlerActivator activator, InMemNetwork network, string recipientQueueName, ErrorBehavior errorBehavior)
{
var deliveryAttempts = 0;
var bus = Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "forwarder"))
.Routing(t =>
{
t.AddTransportMessageForwarder(async transportMessage =>
{
deliveryAttempts++;
if (deliveryAttempts < 10)
{
throw new RebusApplicationException("fake an error");
}
return(ForwardAction.ForwardTo(recipientQueueName));
}, errorBehavior);
})
.Options(o =>
{
o.SetNumberOfWorkers(1);
o.SetMaxParallelism(1);
})
.Start();
return(bus);
}
protected override void SetUp()
{
var network = new InMemNetwork();
_events = new ConcurrentQueue <string>();
_uowActivator = new BuiltinHandlerActivator();
_otherActivator = new BuiltinHandlerActivator();
Using(_uowActivator);
Using(_otherActivator);
_uowBus = Configure.With(_uowActivator)
.Logging(l => l.Console(LogLevel.Warn))
.Transport(t => t.UseInMemoryTransport(network, UowQueueName))
.Options(o =>
{
o.EnableUnitOfWork(c => _events,
commitAction: (c, e) => RegisterEvent("uow committed"),
rollbackAction: (c, e) => RegisterEvent("uow rolled back"),
cleanupAction: (c, e) => RegisterEvent("uow cleaned up"));
o.SimpleRetryStrategy(maxDeliveryAttempts: 1);
//o.LogPipeline(true);
})
.Start();
Configure.With(_otherActivator)
.Logging(l => l.Console(LogLevel.Warn))
.Transport(t => t.UseInMemoryTransport(network, OtherQueueName))
.Start();
}
protected override void SetUp()
{
_network = new InMemNetwork();
_attachmentsBaseDirectory = NewTempDirectory();
_activator = Using(new BuiltinHandlerActivator());
}
protected override void SetUp()
{
var inMemNetwork = new InMemNetwork();
_service = CreateEndpoint(inMemNetwork, "service");
_client = CreateEndpoint(inMemNetwork, "client");
}
public async Task CanRevealNumberOfRetries()
{
var retryCounts = new ConcurrentQueue <int>();
var activator = Using(new BuiltinHandlerActivator());
// create random header key every time to verify that it is actually used
var headerKey = $"retry-count/{Guid.NewGuid()}";
activator.Handle <Fail>(async(_, context, _) =>
{
Console.WriteLine($@"Got message {context.TransportMessage.GetMessageId()}:
{string.Join(Environment.NewLine, context.Headers.Select(kvp => $" {kvp.Key}: {kvp.Value}"))}");
retryCounts.Enqueue(int.Parse(context.Headers.GetValue(headerKey)));
throw new Exception("oh no!");
});
var network = new InMemNetwork();
var bus = Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "who-cares"))
.Options(o => o.AddRetryCountHeader(key: headerKey))
.Options(o => o.LogPipeline(verbose: true))
.Start();
// send message that will fail
await bus.SendLocal(new Fail());
// wait until the message is dead-lettered
_ = await network.WaitForNextMessageFrom("error");
Assert.That(retryCounts.Count, Is.EqualTo(5));
Assert.That(retryCounts.ToArray(), Is.EqualTo(new[] { 0, 1, 2, 3, 4 }));
}
protected override void SetUp()
{
_activator = Using(new BuiltinHandlerActivator());
_network = new InMemNetwork();
Configure.With(_activator)
.Logging(l => l.Use(new ConsoleLoggerFactory(false)
{
Filters =
{
//logStatement => logStatement.Level >= LogLevel.Warn
// || logStatement.Type.FullName.Contains("ThreadPoolWorker")
}
}))
.Transport(t => t.UseInMemoryTransport(_network, "threadpool-workers-test"))
.Options(o =>
{
#pragma warning disable 618
o.UseClassicRebusWorkersMessageDispatch();
#pragma warning restore 618
o.SetNumberOfWorkers(0);
o.SetMaxParallelism(1);
})
.Start();
}
public async Task CanDoIt()
{
using var gotTheEvent = new ManualResetEvent(initialState: false);
using var activator = new BuiltinHandlerActivator();
var subscriberStore = new InMemorySubscriberStore();
var network = new InMemNetwork();
var starter = Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "buggerino"))
.Subscriptions(s => s.StoreInMemory(subscriberStore))
.Create();
var publisher = Configure.With(Using(new BuiltinHandlerActivator()))
.Transport(t => t.UseInMemoryTransportAsOneWayClient(network))
.Subscriptions(s => s.StoreInMemory(subscriberStore))
.Start();
Task Handle(ThisIsTheEventWeAreTalkingAbout configurationUpdatedEvent)
{
Console.WriteLine($"Got event: {configurationUpdatedEvent}");
gotTheEvent.Set();
return(Task.CompletedTask);
}
activator.Handle <ThisIsTheEventWeAreTalkingAbout>((ThisIsTheEventWeAreTalkingAbout e) => Handle(e));
await starter.Bus.Subscribe(typeof(ThisIsTheEventWeAreTalkingAbout));
starter.Start();
await publisher.Publish(new ThisIsTheEventWeAreTalkingAbout());
gotTheEvent.WaitOrDie(timeout: TimeSpan.FromSeconds(2));
}
protected override void SetUp()
{
_inMemDataStore = new InMemDataStore();
_network = new InMemNetwork();
_activator = Using(new BuiltinHandlerActivator());
}
static IBus StartBus(InMemNetwork network, string queueName, ConcurrentQueue <string> recordedEvents)
{
var activator = new BuiltinHandlerActivator();
activator.Handle(async(string message) =>
{
recordedEvents.Enqueue($"GOT MESSAGE: {message}");
});
return(Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, queueName))
.Options(o =>
{
o.Decorate(c =>
{
var events = c.Get <BusLifetimeEvents>();
events.BusStarting += () => recordedEvents.Enqueue("Bus starting");
events.BusStarted += () => recordedEvents.Enqueue("Bus started");
events.BusDisposing += () => recordedEvents.Enqueue("Bus disposing");
events.BusDisposed += () => recordedEvents.Enqueue("Bus disposed");
return events;
});
})
.Start());
}
public async Task AssignsDefaultReturnAddressOnSentMessage()
{
var network = new InMemNetwork();
var sender = Using(new BuiltinHandlerActivator());
Configure.With(sender)
.Transport(t => t.UseInMemoryTransport(network, "queue-a"))
.Routing(r => r.TypeBased().Map <string>("queue-b"))
.Options(o => o.SetDefaultReturnAddress("a totally different queue name"))
.Start();
var receiver = Using(new BuiltinHandlerActivator());
var returnAddress = "";
var done = new ManualResetEvent(false);
receiver.Handle <string>(async(bus, context, message) =>
{
returnAddress = context.Headers[Headers.ReturnAddress];
done.Set();
});
Configure.With(receiver)
.Transport(t => t.UseInMemoryTransport(network, "queue-b"))
.Start();
await sender.Bus.Send("HEJ MED DIG MIN VEEEEN!");
done.WaitOrDie(TimeSpan.FromSeconds(2));
Assert.That(returnAddress, Is.EqualTo("a totally different queue name"), "Expected a totally different queue name here");
}
public async Task ItWorks()
{
var counter = new SharedCounter(20);
var activator = new BuiltinHandlerActivator();
Using(activator);
activator.Register(() => new SimpleSaga1(counter));
activator.Register(() => new SimpleSaga2(counter));
var network = new InMemNetwork();
var bus = Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "enforce exclusive access buggg repro"))
.Options(o => { o.SetNumberOfWorkers(2); })
.Sagas(s =>
{
s.StoreInMemory();
s.EnforceExclusiveAccess();
})
.Routing(r => r.TypeBased().Map <StartSaga>("enforce exclusive access buggg repro"))
.Timeouts(t => t.StoreInMemory())
.Start();
for (int i = 0; i < 10; i++)
{
var id = Guid.NewGuid();
Console.WriteLine($"Sending message with id {id}");
await bus.Send(new StartSaga { SessionId = id });
}
counter.WaitForResetEvent();
}
public CreateAccountMessageHandlerTests()
{
var subscriberStore = new InMemorySubscriberStore();
var network = new InMemNetwork();
hostBuilder.ConfigureContainer <ContainerBuilder>(builder =>
{
builder.RegisterRebus((configurer, _) =>
{
return(configurer
.Transport(t => t.UseInMemoryTransport(network, _queueName))
.Subscriptions(s => s.StoreInMemory(subscriberStore))
.Options(b => b.SimpleRetryStrategy(maxDeliveryAttempts: 1))
.Events(e =>
{
e.AfterMessageHandled += (bus, hdrs, msg, ctx, args) => _messageProccessedEvent.Set();
}));
});
builder.RegisterHandler <CreateAccountMessageHandler>();
});
var publisherActivator = new BuiltinHandlerActivator();
_publisher = Configure.With(publisherActivator)
.Transport(t => t.UseInMemoryTransportAsOneWayClient(network))
.Subscriptions(s => s.StoreInMemory(subscriberStore))
.Start();
_host = hostBuilder.Start();
}
protected override void SetUp()
{
var logger = new ListLoggerFactory(detailed: true);
_network = new InMemNetwork();
// start the external timeout manager
Configure.With(Using(new BuiltinHandlerActivator()))
.Logging(l => l.Use(logger))
.Transport(t => t.UseInMemoryTransport(_network, _queueNameTimeoutManager))
.Timeouts(t => t.StoreInMemory())
.Start();
_gotTheMessage = new ManualResetEvent(false);
// start the client
var client = Using(new BuiltinHandlerActivator());
client.Handle <string>(async str => _gotTheMessage.Set());
Configure.With(client)
.Logging(l => l.Use(logger))
.Transport(t => t.UseInMemoryTransport(_network, _queueName))
.Timeouts(t => t.UseExternalTimeoutManager(_queueNameTimeoutManager))
.Start();
_bus = client.Bus;
}
public async Task CheckIt()
{
var activator = Using(new BuiltinHandlerActivator());
var network = new InMemNetwork();
var rolledBackMessageReceived = new ManualResetEvent(initialState: false);
activator.Handle <ThisMessageShouldNotBeSent>(async _ => rolledBackMessageReceived.Set());
activator.Handle <string>(async(bus, context, message) =>
{
using (var scope = new RebusTransactionScope())
{
await scope.CompleteAsync();
}
await bus.SendLocal(new ThisMessageShouldNotBeSent());
throw new InvalidOperationException("OH NO!");
});
Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "queue-name"))
.Options(o => o.FailFastOn <InvalidOperationException>(when: exception => exception.Message.Contains("OH NO!")))
.Start();
await activator.Bus.SendLocal("HEJ MED DIG MIN VEN");
Assert.That(rolledBackMessageReceived.WaitOne(TimeSpan.FromSeconds(3)), Is.False,
"Did not expect to receive the ThisMessageShouldNotBeSent, because its Rebus handler transaction was rolled back by an exception");
}
public void CheckThatItDoesNotEnlistInOtherBusTransactionCotnext()
{
_listLoggerFactory = new ListLoggerFactory(true);
_firstNetwork = new InMemNetwork();
_secondNetwork = new InMemNetwork();
_activator1 = StartBus(_firstNetwork, "endpoint");
_activator2 = StartBus(_secondNetwork, "proper-destination");
// prepare dead-end queue on first network
_firstNetwork.CreateQueue("dead-end");
// register handler on first network's endpoint that forwards to 'proper-destination' by using the other bus
_activator1.Register(() =>
{
var otherBus = _activator2.Bus;
var handler = new HandlerThatUsesAnotherBus(otherBus);
return(handler);
});
// prepare handler on the bus on the other network so we can receive the message
var gotTheMessage = new ManualResetEvent(false);
_activator2.Handle <string>(async str => gotTheMessage.Set());
_activator1.Bus.SendLocal("hej med dig min ven!!").Wait();
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(3), @"Looks like we never got the message.
If everything was working properly, the forwarded message would have
been sent in its own transaction context, thus sent&committed
immediately when calling bus.....Forward");
}
protected override void SetUp()
{
_network = new InMemNetwork();
_activator1 = StartBus("queue-1");
_activator2 = StartBus("queue-2", b => b.RegisterAsOwnerOf <RelevantMessage>());
}
void InitializeBus(int numberOfRetries, IFailFastChecker failFastChecker = null)
{
_network = new InMemNetwork();
_handlerActivator = new BuiltinHandlerActivator();
_bus = Configure.With(_handlerActivator)
.Logging(l => l.Console(minLevel: LogLevel.Warn))
.Transport(t => t.UseInMemoryTransport(_network, InputQueueName))
.Routing(r => r.TypeBased().Map <string>(InputQueueName))
.Options(o =>
{
o.SetNumberOfWorkers(1);
o.SetMaxParallelism(1);
o.SimpleRetryStrategy(maxDeliveryAttempts: numberOfRetries, errorQueueAddress: ErrorQueueName);
if (failFastChecker != null)
{
o.Register(_ => failFastChecker);
}
})
.Start();
Using(_bus);
}
public async Task VeryBasicTransactionThing()
{
const string destinationQueueName = "another-queue";
var network = new InMemNetwork();
network.CreateQueue(destinationQueueName);
var transport = new InMemTransport(network, "test-queue");
transport.Initialize();
using (var scope = new RebusTransactionScope())
{
var headers = new Dictionary <string, string> {
{ Headers.MessageId, Guid.NewGuid().ToString() }
};
await transport.Send(
destinationAddress : destinationQueueName,
message : new TransportMessage(headers, new byte[] { 1, 2, 3 }),
context : scope.TransactionContext
);
Assert.That(network.Count(destinationQueueName), Is.EqualTo(0),
$"Expected ZERO messages in queue '{destinationQueueName}' at this point, because the scope was not completed");
await scope.CompleteAsync();
}
Assert.That(network.Count(destinationQueueName), Is.EqualTo(1),
$"Expected 1 message in queue '{destinationQueueName}' at this point, because the scope is completed now");
}
protected override void SetUp()
{
// installs a transport decorator that throws an exception, if the sent message size exceeds the given threshold
void FailIfMessageSizeExceeds(OptionsConfigurer optionsConfigurer, int messageSizeLimitBytes) =>
optionsConfigurer.Decorate <ITransport>(c => new ThrowExceptionsOnBigMessagesTransportDecorator(c.Get <ITransport>(), messageSizeLimitBytes));
_activator = new BuiltinHandlerActivator();
Using(_activator);
_subscriberStore = new InMemorySubscriberStore();
_network = new InMemNetwork();
_dataStore = new InMemDataStore();
_starter = Configure.With(_activator)
.Transport(t => t.UseInMemoryTransport(_network, "automatic-claim-check"))
.Options(o => o.LogPipeline(verbose: true))
.Subscriptions(s => s.StoreInMemory(_subscriberStore))
.DataBus(d =>
{
d.SendBigMessagesAsAttachments(bodySizeThresholdBytes: limit / 2);
d.StoreInMemory(_dataStore);
})
.Options(o => FailIfMessageSizeExceeds(o, limit))
.Create();
}
public async Task CanForwardToMultipleRecipients()
{
var network = new InMemNetwork();
var activator = new BuiltinHandlerActivator();
Using(activator);
var recipients = new[] { "recipient-A", "recipient-B" }.ToList();
recipients.ForEach(network.CreateQueue);
Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "forwarder"))
.Routing(t =>
{
t.AddTransportMessageForwarder(async transportMessage => ForwardAction.ForwardTo(recipients));
})
.Start();
await activator.Bus.SendLocal("HEJ MED DIG!!!");
var transportMessages = await Task.WhenAll(recipients.Select(async queue =>
{
var message = await network.WaitForNextMessageFrom(queue);
return(message);
}));
Assert.That(transportMessages.Length, Is.EqualTo(2));
}
protected override void SetUp()
{
var network = new InMemNetwork(outputEventsToConsole: true);
_client = CreateBus(network);
_forwarder = CreateBus(network, "forwarder");
_receiver = CreateBus(network, "receiver");
}
protected override void SetUp()
{
_inMemNetwork = new InMemNetwork();
_inMemDataStore = new InMemDataStore();
_senderBus = StartBus("sender").Bus;
_receiverActivator = StartBus("receiver");
}
protected override void SetUp()
{
var network = new InMemNetwork(outputEventsToConsole: true);
(_client, _clientStarter) = CreateBus(network);
(_forwarder, _forwarderStarter) = CreateBus(network, "forwarder");
(_receiver, _receiverStarter) = CreateBus(network, "receiver");
}
protected override void SetUp()
{
base.SetUp();
SqlTestHelper.DropTable("RebusOutbox");
_network = new InMemNetwork();
_subscriberStore = new InMemorySubscriberStore();
}
static TimeSpan RunTest(int numberOfMessages, PipelineStepProfilerStats profilerStats)
{
using (var adapter = new BuiltinHandlerActivator())
{
var network = new InMemNetwork();
Configure.With(adapter)
.Logging(l => l.Console(LogLevel.Warn))
.Transport(t => t.UseInMemoryTransport(network, "perftest"))
.Options(o =>
{
o.SetNumberOfWorkers(0);
o.SetMaxParallelism(1);
o.Decorate <IPipeline>(c => new PipelineStepProfiler(c.Get <IPipeline>(), profilerStats));
o.Register <IPipelineInvoker>(c => new DefaultPipelineInvoker(c.Get <IPipeline>()));
})
.Start();
var serializer = new SystemTextJsonSerializer(new SimpleAssemblyQualifiedMessageTypeNameConvention());
var boy = new SomeMessage("hello there!");
for (var counter = 0; counter < numberOfMessages; counter++)
{
var headers = new Dictionary <string, string> {
{ Headers.MessageId, Guid.NewGuid().ToString() }
};
var message = new Message(headers, boy);
var transportMessage = serializer.Serialize(message).Result;
var inMemTransportMessage = transportMessage.ToInMemTransportMessage();
network.Deliver("perftest", inMemTransportMessage);
}
;
var numberOfReceivedMessages = 0;
var gotAllMessages = new ManualResetEvent(false);
adapter.Handle <SomeMessage>(async m =>
{
Interlocked.Increment(ref numberOfReceivedMessages);
if (Volatile.Read(ref numberOfReceivedMessages) == numberOfMessages)
{
gotAllMessages.Set();
}
});
var stopwatch = Stopwatch.StartNew();
adapter.Bus.Advanced.Workers.SetNumberOfWorkers(1);
gotAllMessages.WaitOrDie(TimeSpan.FromSeconds(30));
return(stopwatch.Elapsed);
}
}
IBus CreateSender(InMemNetwork network)
{
var activator = Using(new BuiltinHandlerActivator());
return(Configure.With(activator)
.Logging(l => l.Console())
.Transport(t => t.UseInMemoryTransportAsOneWayClient(network))
.Routing(r => r.TypeBased().Map <string>("whatever dude"))
.Start());
}
protected override void SetUp()
{
_adapter = new BuiltinHandlerActivator();
_network = new InMemNetwork();
_bus = Configure.With(_adapter)
.Transport(t => t.UseInMemoryTransport(_network, "test"))
.Options(o => o.EnableMessageAuditing("audit"))
.Start();
}
protected override void SetUp()
{
_activator = Using(new BuiltinHandlerActivator());
_network = new InMemNetwork();
_bus = Configure.With(_activator)
.Transport(t => t.UseInMemoryTransport(_network, InputQueueName))
.Options(o => o.SimpleRetryStrategy(secondLevelRetriesEnabled: true))
.Start();
}
