public void Initialize()
{
fixture = new Fixture();
testBusEngine = new InMemoryBusEngine();
mockLoggerFactory = new Mock<ILoggerFactory>();
mockLogger = new Mock<ILogger>();
mockCommandContextFactory = new Mock<ICommandContextFactory>();
mockCommandMessageFactory = new Mock<ICommandMessageFactory>();
mockEventContextFactory = new Mock<IEventContextFactory>();
mockEventMessageFactory = new Mock<IEventMessageFactory>();
mockContainer = new Mock<IContainer>();
mockScope = new Mock<IScope>();
mockCorrelationIdGenerator = new Mock<ICorrelationIdGenerator>();
options = new NybusOptions
{
LoggerFactory = mockLoggerFactory.Object,
CommandContextFactory = mockCommandContextFactory.Object,
EventContextFactory = mockEventContextFactory.Object,
CommandMessageFactory = mockCommandMessageFactory.Object,
EventMessageFactory = mockEventMessageFactory.Object,
Container = mockContainer.Object,
CorrelationIdGenerator = mockCorrelationIdGenerator.Object
};
mockCommandHandler = new Mock<ICommandHandler<TestCommand>>();
mockEventHandler = new Mock<IEventHandler<TestEvent>>();
mockContainer.Setup(p => p.BeginScope()).Returns(mockScope.Object);
mockLoggerFactory.Setup(p => p.CreateLogger(It.IsAny<string>())).Returns(() => mockLogger.Object);
}
public void Commands_are_pushed_into_observable()
{
var busEngine = new InMemoryBusEngine();
var builder = new NybusBusBuilder(busEngine);
var list = new List <TestCommand>();
var disposable = builder.ObserveCommand <TestCommand>().Select(c => c.Message).Subscribe(list.Add);
var observable = scheduler.CreateHotObservable(
OnNext(500, fixture.Create <CommandMessage <TestCommand> >()),
OnNext(600, fixture.Create <CommandMessage <TestCommand> >()),
OnNext(1000, fixture.Create <CommandMessage <TestCommand> >()),
OnNext(1200, fixture.Create <CommandMessage <TestCommand> >()),
OnNext(1500, fixture.Create <CommandMessage <TestCommand> >())
);
var results = scheduler.Start(() => observable.Do(msg => Task.WaitAll(busEngine.HandleCommand(msg))).Select(c => c.Command), 100, 150, 3000);
disposable.Dispose();
for (int i = 0; i < list.Count; i++)
{
Assert.That(list[i], Is.SameAs(results.Messages[i].Value.Value));
}
}
public void Initialize()
{
fixture = new Fixture();
testBusEngine = new InMemoryBusEngine();
mockLoggerFactory = new Mock <ILoggerFactory>();
mockLogger = new Mock <ILogger>();
mockCommandContextFactory = new Mock <ICommandContextFactory>();
mockCommandMessageFactory = new Mock <ICommandMessageFactory>();
mockEventContextFactory = new Mock <IEventContextFactory>();
mockEventMessageFactory = new Mock <IEventMessageFactory>();
mockContainer = new Mock <IContainer>();
mockScope = new Mock <IScope>();
mockCorrelationIdGenerator = new Mock <ICorrelationIdGenerator>();
options = new NybusOptions
{
LoggerFactory = mockLoggerFactory.Object,
CommandContextFactory = mockCommandContextFactory.Object,
EventContextFactory = mockEventContextFactory.Object,
CommandMessageFactory = mockCommandMessageFactory.Object,
EventMessageFactory = mockEventMessageFactory.Object,
Container = mockContainer.Object,
CorrelationIdGenerator = mockCorrelationIdGenerator.Object
};
mockCommandHandler = new Mock <ICommandHandler <TestCommand> >();
mockEventHandler = new Mock <IEventHandler <TestEvent> >();
mockContainer.Setup(p => p.BeginScope()).Returns(mockScope.Object);
mockLoggerFactory.Setup(p => p.CreateLogger(It.IsAny <string>())).Returns(() => mockLogger.Object);
}
static void Main(string[] args)
{
var logger = new NLogLogger(NLog.LogManager.GetLogger("Test"));
var options = new NybusOptions
{
Logger = logger
};
var engine = new InMemoryBusEngine();
var busBuilder = new NybusBusBuilder(engine, options);
var consoleLocker = new object();
IDisposable testEventHandle = busBuilder.ObserveEvent<TestEvent>().Buffer(TimeSpan.FromSeconds(1)).Subscribe(tc =>
{
lock (consoleLocker)
{
Console.WriteLine($"Received {tc.Count} events during the last 1 seconds");
foreach (var i in tc)
{
Console.WriteLine($"\t{i.CorrelationId:D} - {i.Message.Id} - '{i.Message.Message}'");
}
Console.WriteLine();
}
});
IDisposable testCommandHandle = busBuilder.ObserveCommand<TestCommand>().Buffer(10).Subscribe(tc =>
{
lock (consoleLocker)
{
Console.WriteLine($"Received {tc.Count} commands");
foreach (var i in tc)
{
Console.WriteLine($"\t{i.CorrelationId:D} - {i.Message.Id} - '{i.Message.Message}'");
}
Console.WriteLine();
}
});
IBus bus = busBuilder.Build();
Task.WaitAll(bus.Start());
Task.WhenAll(InvokeManyEvents(bus, 50), InvokeManyCommands(bus, 50)).WaitAndUnwrapException();
Console.WriteLine("Press ENTER to exit.");
Console.ReadLine();
testEventHandle.Dispose();
testCommandHandle.Dispose();
Task.WaitAll(bus.Stop());
}
public void InMemoryBusEngine_IsCommandHandled_is_true_when_ObserveCommand()
{
var busEngine = new InMemoryBusEngine();
var builder = new NybusBusBuilder(busEngine);
var observable = builder.ObserveCommand <TestCommand>();
busEngine.IsCommandHandled <TestCommand>();
}
public void InMemoryBusEngine_IsEventHandled_is_true_when_ObserveEvent()
{
var busEngine = new InMemoryBusEngine();
var builder = new NybusBusBuilder(busEngine);
var observable = builder.ObserveEvent <TestEvent>();
busEngine.IsEventHandeld <TestEvent>();
}
public void NotifyFail_raises_event(InMemoryBusEngine sut, EventMessage <FirstTestEvent> testMessage, EventHandler <MessageEventArgs> handler)
{
sut.OnMessageNotifyFail += handler;
sut.NotifyFailAsync(testMessage);
sut.OnMessageNotifyFail -= handler;
Mock.Get(handler).Verify(p => p(sut, It.Is <MessageEventArgs>(m => ReferenceEquals(m.Message, testMessage))));
}
public async Task Stop_completes_the_sequence_if_started(InMemoryBusEngine sut)
{
var sequence = await sut.StartAsync();
var isCompleted = false;
sequence.Subscribe(
onNext: _ => { },
onError: _ => { },
onCompleted: () => isCompleted = true
);
await sut.StopAsync();
Assert.That(isCompleted, Is.True);
}
public async Task Sent_events_are_received([Frozen] IEnvelopeService envelopeService, InMemoryBusEngine sut, EventMessage <FirstTestEvent> testMessage, IFixture fixture)
{
fixture.Customize <Envelope>(c => c
.With(p => p.Type, testMessage.Type)
.With(p => p.Headers, testMessage.Headers)
.With(p => p.Content)
.With(p => p.MessageId, testMessage.MessageId)
.With(p => p.MessageType, testMessage.MessageType)
);
Mock.Get(envelopeService).Setup(p => p.CreateEnvelope(It.IsAny <EventMessage <FirstTestEvent> >())).ReturnsUsingFixture(fixture);
Mock.Get(envelopeService).Setup(p => p.CreateEventMessage(It.IsAny <Envelope>(), It.IsAny <Type>())).Returns(testMessage);
sut.SubscribeToEvent <FirstTestEvent>();
var sequence = await sut.StartAsync().ConfigureAwait(false);
var items = sequence.DumpInList();
await sut.SendMessageAsync(testMessage);
Assert.That(items.First(), Is.EqualTo(testMessage).Using <EventMessage <FirstTestEvent> >((x, y) => x.MessageId == y.MessageId));
}
public async Task Sent_commands_are_received([Frozen] IEnvelopeService envelopeService, InMemoryBusEngine sut, CommandMessage <FirstTestCommand> testMessage, IFixture fixture, string headerKey, string headerValue)
{
fixture.Customize <Envelope>(c => c
.With(p => p.Type, testMessage.Type)
.With(p => p.Headers, testMessage.Headers)
.With(p => p.Content)
.With(p => p.MessageId, testMessage.MessageId)
.With(p => p.MessageType, testMessage.MessageType)
);
Mock.Get(envelopeService).Setup(p => p.CreateEnvelope(It.IsAny <CommandMessage <FirstTestCommand> >())).ReturnsUsingFixture(fixture);
Mock.Get(envelopeService).Setup(p => p.CreateCommandMessage(It.IsAny <Envelope>(), It.IsAny <Type>())).Returns(testMessage);
testMessage.Headers[headerKey] = headerValue;
sut.SubscribeToCommand <FirstTestCommand>();
var sequence = await sut.StartAsync().ConfigureAwait(false);
var items = sequence.DumpInList();
await sut.SendMessageAsync(testMessage);
Assert.That(items.First().Headers, Contains.Key(headerKey));
Assert.That(items.First().Headers[headerKey], Is.EqualTo(headerValue));
}
public void SubscribeToEvent_adds_type_AcceptedTypes_list(InMemoryBusEngine sut)
{
sut.SubscribeToEvent <FirstTestEvent>();
Assert.That(sut.IsTypeAccepted(typeof(FirstTestEvent)));
}
public async Task Events_are_ignored_if_not_registered([Frozen] IMessageDescriptorStore messageDescriptorStore, [Frozen] IEnvelopeService envelopeService, InMemoryBusEngine sut, EventMessage <FirstTestEvent> testMessage, IFixture fixture)
{
fixture.Customize <Envelope>(c => c
.With(p => p.Type, testMessage.Type)
.With(p => p.Headers, testMessage.Headers)
.With(p => p.Content)
.With(p => p.MessageId, testMessage.MessageId)
.With(p => p.MessageType, testMessage.MessageType)
);
Mock.Get(envelopeService).Setup(p => p.CreateEnvelope(It.IsAny <EventMessage <FirstTestEvent> >())).ReturnsUsingFixture(fixture);
Mock.Get(envelopeService).Setup(p => p.CreateEventMessage(It.IsAny <Envelope>(), It.IsAny <Type>())).Returns(testMessage);
var sequence = await sut.StartAsync().ConfigureAwait(false);
var items = sequence.DumpInList();
await sut.SendMessageAsync(testMessage);
Assert.That(items, Is.Empty);
}
public void SubscribeToCommand_adds_type_to_AcceptedTypes_list(InMemoryBusEngine sut)
{
sut.SubscribeToCommand <FirstTestCommand>();
Assert.That(sut.IsTypeAccepted(typeof(FirstTestCommand)));
}
public void NotifyFail_returns_completed_task(InMemoryBusEngine sut, EventMessage <FirstTestEvent> testMessage)
{
Assert.That(sut.NotifyFailAsync(testMessage), Is.SameAs(Task.CompletedTask));
}
public void NotifySuccess_returns_completed_task(InMemoryBusEngine sut, CommandMessage <FirstTestCommand> testMessage)
{
Assert.That(sut.NotifySuccessAsync(testMessage), Is.SameAs(Task.CompletedTask));
}
public async Task Stop_is_ignored_if_not_started(InMemoryBusEngine sut)
{
await sut.StopAsync();
}
