public void CanHoldUsingModelRouter()
{
IRouter <TestModel> modelRouter = new Router <TestModel>(_model.Id, _router);
IEventObservable <BaseEvent, IEventContext, TestModel> baseEventStream = modelRouter.GetEventObservable(new HoldBaseEventsBasedOnModelStrategy <FooEvent, BaseEvent>());
int receivedBaseEvents = 0, reveivedBarEvents = 0;
baseEventStream.Observe((model, baseEvent, context) =>
{
receivedBaseEvents++;
});
IEventObservable <BarEvent, IEventContext, TestModel> fooEventStream = modelRouter.GetEventObservable(new HoldEventsBasedOnModelStrategy <BarEvent>());
fooEventStream.Observe((model, barEvent, context) =>
{
reveivedBarEvents++;
});
var event1 = new FooEvent("EventPayload1");
var event2 = new BarEvent("EventPayload2");
_router.PublishEvent(_model.Id, event1);
_router.PublishEvent(_model.Id, event2);
receivedBaseEvents.ShouldBe(0);
reveivedBarEvents.ShouldBe(0);
ReleasedEvent(event1.Id, HeldEventAction.Release);
ReleasedEvent(event2.Id, HeldEventAction.Release);
receivedBaseEvents.ShouldBe(1);
reveivedBarEvents.ShouldBe(1);
}
public EventPublisherTestsFixture()
{
FooEvent = new FooEvent(DateTime.UtcNow);
BarEvent = () => new BarEvent(DateTime.Now);
UnitOfWorkContext = new Mock <IUnitOfWorkContext>();
EventPublisher = new EventPublisher(UnitOfWorkContext.Object);
}
public UnitOfWorkContextTestsFixture SetEvents()
{
var fooEvent = new FooEvent {
Created = Now
};
var barEvent = new BarEvent {
Created = Now
};
Events.Add(fooEvent);
Events.Add(barEvent);
UnitOfWorkContextInstance.AddEvent(fooEvent);
UnitOfWorkContextInstance.AddEvent(() => new FooEvent {
Created = Now
});
UnitOfWorkContext.AddEvent(barEvent);
UnitOfWorkContext.AddEvent(() => new BarEvent {
Created = Now
});
Now = DateTime.UtcNow;
return(this);
}
protected override void RunTest()
{
ObserveEventsOnThis();
var fooEvent = new FooEvent();
Router.PublishEvent(fooEvent);
ContextWasReceived.ShouldBe(true);
}
protected override void RunTest()
{
ObserveEventsOnThis();
var fooEvent = new FooEvent();
Router.PublishEvent(fooEvent);
ReceivedEvent.ShouldBe(fooEvent);
}
public void Constructing_an_instance_should_initialize_the_event()
{
String aMessage = "Hello world";
IEvent theEvent = new FooEvent();
var target = new EventNotHandledException(theEvent, aMessage);
target.Event.Should().Be(theEvent);
}
public void Constructing_an_instance_should_initialize_the_message()
{
String message = "Hello world";
IEvent aEvent = new FooEvent();
var target = new EventNotHandledException(aEvent, message);
target.Message.Should().Be(message);
}
public void Constructing_an_instance_should_initialize_the_event()
{
String aMessage = "Hello world";
IEvent theEvent = new FooEvent();
var target = new EventNotHandledException(theEvent, aMessage);
target.Event.Should().Be(theEvent);
}
public void WhenAnEventIsHeldADiscriptionIsAddedToModel()
{
SetUpFooEventHoldingStrategy();
var e = new FooEvent("EventPayload");
_router.PublishEvent(_model.Id, e);
_model.HeldEvents.Count.ShouldBe(1);
_model.HeldEvents[0].EventId.ShouldBe(e.Id);
}
public void Constructing_an_instance_should_initialize_the_message()
{
String message = "Hello world";
IEvent aEvent = new FooEvent();
var target = new EventNotHandledException(aEvent, message);
target.Message.Should().Be(message);
}
public void Constructing_an_instance_should_initialize_the_inner_exception()
{
String aMessage = "Hello world";
IEvent aEvent = new FooEvent();
var theInnerException = new Exception();
var target = new EventNotHandledException(aEvent, aMessage, theInnerException);
target.InnerException.Should().Be(theInnerException);
}
public void can_register_for_an_event()
{
FooHandler handler = new FooHandler();
Bus.Register(handler);
var fooEvent = new FooEvent();
Bus.Raise(fooEvent);
handler.EventsCaught.ElementsShouldEqual(fooEvent);
}
public void Constructing_an_instance_should_initialize_the_inner_exception()
{
String aMessage = "Hello world";
IEvent aEvent = new FooEvent();
var theInnerException = new Exception();
var target = new EventNotHandledException(aEvent, aMessage, theInnerException);
target.InnerException.Should().Be(theInnerException);
}
public void TestTypeMatch()
{
FooEvent fooEvent = new FooEvent();
_channel.Pipeline.FireUserEventTriggered(fooEvent);
Assert.Single(_fooEventCatcher.CaughtEvents);
Assert.Empty(_allEventCatcher.CaughtEvents);
Assert.Equal(0, fooEvent.ReferenceCount);
Assert.False(_channel.Finish());
}
public void MutipleEventsCanBeHeld()
{
SetUpFooEventHoldingStrategy();
var event1 = new FooEvent("EventPayload1");
var event2 = new FooEvent("EventPayload2");
_router.PublishEvent(_model.Id, event1);
_router.PublishEvent(_model.Id, event2);
_model.HeldEvents.Count.ShouldBe(2);
_model.HeldEvents[0].EventId.ShouldBe(event1.Id);
_model.HeldEvents[1].EventId.ShouldBe(event2.Id);
}
protected override void RunTest()
{
ObserveEventsOnThis();
var fooEvent = new FooEvent();
var barEvent = new BarEvent();
Router.PublishEvent(fooEvent);
Router.PublishEvent(barEvent);
_receivedEvents.Count.ShouldBe(2);
_receivedEvents[0].ShouldBe(fooEvent);
_receivedEvents[1].ShouldBe(barEvent);
}
public async Task when_subscribing_to_externally_produced_event_then_fetches_observable_from_components()
{
var expected = new FooEvent();
var observable = new[] { expected }.ToObservable();
var stream = new EventStreamComponent(Mock.Of <IServiceProvider>(s =>
s.GetService(typeof(SComponentModel)) == Mock.Of <IComponentModel>(c =>
c.GetExtensions <IObservable <FooEvent> >() == new[] { observable })));
var actual = await stream.Of <FooEvent>().FirstAsync();
Assert.Same(expected, actual);
}
public async Task when_subscribing_to_externally_produced_event_then_fetches_observable_from_components()
{
var expected = new FooEvent();
var observable = new[] { expected }.ToObservable();
var stream = new EventStreamComponent(Mock.Of<IServiceProvider>(s =>
s.GetService(typeof(SComponentModel)) == Mock.Of<IComponentModel>(c =>
c.GetExtensions<IObservable<FooEvent>>() == new[] { observable })));
var actual = await stream.Of<FooEvent>().FirstAsync();
Assert.Same(expected, actual);
}
public void when_subscribing_and_pushing_events_then_succeeds()
{
var stream = GlobalServices.GetService <SComponentModel, IComponentModel>().GetService <IEventStream>();
var expected = new FooEvent();
FooEvent actual = null;
var subscription = stream.Of <FooEvent>().Subscribe(e => actual = e);
stream.Push(expected);
Assert.Same(expected, actual);
}
public void IfObservationDisposedReleasedEventNotObserved()
{
SetUpFooEventHoldingStrategy();
var event1 = new FooEvent("EventPayload1");
_router.PublishEvent(_model.Id, event1);
_fooEventStreamDisposable.Dispose();
ReleasedEvent(event1.Id, HeldEventAction.Ignore);
_receivedFooEvents.Count.ShouldBe(0);
// TODO note disposing the stream doesn't trash the held events on the model. Need to do something about this
_model.HeldEvents.Count.ShouldBe(1);
}
public void when_subscribing_and_pushing_events_then_succeeds()
{
var stream = GlobalServices.GetService<SComponentModel, IComponentModel>().GetService<IEventStream>();
var expected = new FooEvent();
FooEvent actual = null;
var subscription = stream.Of<FooEvent>().Subscribe(e => actual = e);
stream.Push(expected);
Assert.Same(expected, actual);
}
public void One_handler_can_handle_multiple_events()
{
var handler = new FooBarBazHandler();
Bus.Register(handler);
var fooEvent = new FooEvent();
var barEvent = new BarEvent();
var bazEvent = new BazEvent();
Bus.Raise(fooEvent);
Bus.Raise(barEvent);
Bus.Raise(bazEvent);
handler.EventsCaught.ElementsShouldEqual(fooEvent, barEvent, bazEvent);
}
public async Task RunAsync()
{
var fooEvent = new FooEvent {
Id = 1
};
await PublishAsync(fooEvent);
var barEvent = new BarEvent {
Date = new DateTime(2019, 12, 31)
};
await PublishAsync(barEvent);
}
public void Registers_handlers()
{
var registry = new FakeAssemblyRegistry();
var registrar = new EventBusAutoRegistrar(registry);
registrar.InstallTo(Bus);
var testEvent = new FooEvent();
Bus.Raise(testEvent);
TestHandler.EventsCaught.ShouldContain(testEvent);
}
public void Can_register_multiple_handlers()
{
var handler1 = new FooHandler();
var handler2 = new FooHandler();
Bus.Register(handler1);
Bus.Register(handler2);
var fooEvent = new FooEvent();
Bus.Raise(fooEvent);
handler1.EventsCaught.ElementsShouldEqual(fooEvent);
handler2.EventsCaught.ElementsShouldEqual(fooEvent);
}
public UnitOfWorkContextTestsFixture SetEventsOnSeparateAsyncFlow()
{
var fooEvent = new FooEvent {
Created = Now
};
var barEvent = new BarEvent {
Created = Now
};
Events.Add(fooEvent);
Events.Add(barEvent);
var tasks = new List <Task>
{
Task.Run(() =>
{
IUnitOfWorkContext unitOfWorkContextInstance = new UnitOfWorkContext();
UnitOfWorkContextInstance.AddEvent(fooEvent);
unitOfWorkContextInstance.AddEvent(() => new FooEvent {
Created = Now
});
UnitOfWorkContext.AddEvent(barEvent);
UnitOfWorkContext.AddEvent(() => new BarEvent {
Created = Now
});
}),
Task.Run(() =>
{
IUnitOfWorkContext unitOfWorkContextInstance = new UnitOfWorkContext();
UnitOfWorkContextInstance.AddEvent(fooEvent);
unitOfWorkContextInstance.AddEvent(() => new FooEvent {
Created = Now
});
UnitOfWorkContext.AddEvent(barEvent);
UnitOfWorkContext.AddEvent(() => new BarEvent {
Created = Now
});
})
};
Task.WhenAll(tasks).GetAwaiter().GetResult();
Now = DateTime.UtcNow;
return(this);
}
public void CanHoldDifferingEventTypes()
{
SetUpFooEventHoldingStrategy();
SetUpBarEventHoldingStrategy();
var event1 = new FooEvent("EventPayload1");
var event2 = new BarEvent("EventPayload2");
_router.PublishEvent(_model.Id, event1);
_router.PublishEvent(_model.Id, event2);
ReleasedEvent(event1.Id, HeldEventAction.Release);
ReleasedEvent(event2.Id, HeldEventAction.Release);
_receivedFooEvents.Count.ShouldBe(1);
_receivedFooEvents[0].Payload.ShouldBe("EventPayload1");
_receivedBarEvents.Count.ShouldBe(1);
_receivedBarEvents[0].Payload.ShouldBe("EventPayload2");
}
public void IgnoreEventsAreNotReleased()
{
SetUpFooEventHoldingStrategy();
var event1 = new FooEvent("EventPayload1");
var event2 = new FooEvent("EventPayload2");
var event3 = new FooEvent("EventPayload3");
_router.PublishEvent(_model.Id, event1);
_router.PublishEvent(_model.Id, event2);
_router.PublishEvent(_model.Id, event3);
ReleasedEvent(event3.Id, HeldEventAction.Ignore);
ReleasedEvent(event1.Id, HeldEventAction.Release);
ReleasedEvent(event2.Id, HeldEventAction.Release);
_receivedFooEvents.Count.ShouldBe(2);
_receivedFooEvents[0].Payload.ShouldBe("EventPayload1");
_receivedFooEvents[1].Payload.ShouldBe("EventPayload2");
}
public void MutipleEventsCanReleased()
{
SetUpFooEventHoldingStrategy();
var event1 = new FooEvent("EventPayload1");
var event2 = new FooEvent("EventPayload2");
_router.PublishEvent(_model.Id, event1);
_router.PublishEvent(_model.Id, event2);
ReleasedEvent(_model.HeldEvents[1].EventId, HeldEventAction.Release);
_receivedFooEvents.Count.ShouldBe(1);
_receivedFooEvents[0].Payload.ShouldBe("EventPayload2");
ReleasedEvent(_model.HeldEvents[0].EventId, HeldEventAction.Release);
_receivedFooEvents.Count.ShouldBe(2);
_receivedFooEvents[1].Payload.ShouldBe("EventPayload1");
}
public void It_should_be_serializable()
{
var aMessage = "Hello world";
IEvent aEvent = new FooEvent();
var theException = new EventNotHandledException(aEvent, aMessage);
EventNotHandledException deserializedException = null;
using (var buffer = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(buffer, theException);
buffer.Seek(0, SeekOrigin.Begin);
deserializedException = (EventNotHandledException)formatter.Deserialize(buffer);
}
deserializedException.Should().NotBeNull();
}
public void It_should_be_serializable()
{
var aMessage = "Hello world";
IEvent aEvent = new FooEvent();
var theException = new EventNotHandledException(aEvent, aMessage);
EventNotHandledException deserializedException = null;
using (var buffer = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(buffer, theException);
buffer.Seek(0, SeekOrigin.Begin);
deserializedException = (EventNotHandledException)formatter.Deserialize(buffer);
}
deserializedException.Should().NotBeNull();
}
static async Task Main(string[] args)
{
LogManager.Use <DefaultFactory>()
.Level(LogLevel.Info);
var config = new EndpointConfiguration(Assembly.GetEntryAssembly().GetName().Name);
config.EnableInstallers();
config.UseSerialization <NewtonsoftSerializer>();
config.SendFailedMessagesTo("error");
config.AuditProcessedMessagesTo("audit");
config.SendOnly();
// Configure ASB
var transport = config.UseTransport <AzureServiceBusTransport>();
transport.ConnectionString(Environment.GetEnvironmentVariable("AzureServiceBus_ConnectionString"));
var endpointInstance = await Endpoint.Start(config)
.ConfigureAwait(false);
Console.WriteLine("Press enter to send a message");
Console.WriteLine("Press any key to exit");
var count = 2000;
var numberOfMessages = count;
var tasks = new List <Task>();
while (count-- > 0)
{
var fooEvent = new FooEvent
{
Id = Guid.NewGuid().ToString()
};
tasks.Add(endpointInstance.Publish(fooEvent));
}
Console.WriteLine($"Sending {numberOfMessages} messages...");
await Task.WhenAll(tasks).ConfigureAwait(false);
Console.WriteLine("Done.");
}
protected override void RunTest()
{
ObserveEventsOnThis();
var fooEvent = new FooEvent();
var barEvent = new BarEvent();
var bazEvent = new BazEvent();
var buzzEvent = new BuzzEvent();
Router.PublishEvent(fooEvent);
AssertLastReceivedEvent(1, ObservationStage.Preview, fooEvent);
Router.PublishEvent(barEvent);
AssertLastReceivedEvent(2, ObservationStage.Normal, barEvent);
Router.PublishEvent(bazEvent);
AssertLastReceivedEvent(3, ObservationStage.Normal, bazEvent);
Router.PublishEvent(buzzEvent);
AssertLastReceivedEvent(4, ObservationStage.Committed, buzzEvent);
}
public void CanHoldByBaseEvent()
{
List <BaseEvent> receivedBarEvents = new List <BaseEvent>();
IEventObservable <BaseEvent, IEventContext, TestModel> fooEventStream = _router.GetEventObservable(_model.Id, new HoldBaseEventsBasedOnModelStrategy <FooEvent, BaseEvent>());
IEventObservable <BaseEvent, IEventContext, TestModel> barEventStream = _router.GetEventObservable(_model.Id, new HoldBaseEventsBasedOnModelStrategy <BarEvent, BaseEvent>());
var stream = EventObservable.Merge(fooEventStream, barEventStream);
stream.Observe((baseEvent, context, model) =>
{
receivedBarEvents.Add(baseEvent);
});
var event1 = new FooEvent("EventPayload1");
var event2 = new BarEvent("EventPayload2");
_router.PublishEvent(_model.Id, event1);
_router.PublishEvent(_model.Id, event2);
ReleasedEvent(event1.Id, HeldEventAction.Release);
ReleasedEvent(event2.Id, HeldEventAction.Release);
receivedBarEvents.Count.ShouldBe(2);
receivedBarEvents[0].ShouldBeAssignableTo <FooEvent>();
receivedBarEvents[1].ShouldBeAssignableTo <BarEvent>();
}
public void SecondFooSubscription(FooEvent @event)
{
SecondFooWasHandled = true;
}
public void Apply(FooEvent e)
{
}
public async Task ThenTheExceptionShouldBeThrownBack()
{
var testEvent = new FooEvent();
Assert.That(() => Subject.Publish(testEvent), Throws.TypeOf <Exception>());
}
public void FirstFooSubscription(FooEvent @event)
{
FirstFooWasHandled = true;
}
public void Foo()
{
var e = new FooEvent();
ApplyEvent(e);
}
