public void Setup()
{
_snapstore = new Moq.Mock <IStoreSnapshots>();
_eventstore = new Moq.Mock <IStoreEvents>();
_channel = new Moq.Mock <IDelayedChannel>();
_delayedEvent = new Moq.Mock <IDelayedMessage>();
_state = new FakeState {
Id = "test"
};
_event = new Moq.Mock <IFullEvent>();
_event.Setup(x => x.Event).Returns(new FakeEvent());
_event.Setup(x => x.Descriptor.StreamType).Returns(StreamTypes.Domain);
var conflictingEvent = new ConflictingEvents {
Events = new[] { _event.Object }
};
_delayedEvent.Setup(x => x.Message).Returns(conflictingEvent);
_channel.Setup(x => x.Age(Moq.It.IsAny <string>(), Moq.It.IsAny <string>()))
.Returns(Task.FromResult((TimeSpan?)TimeSpan.FromSeconds(60)));
_channel.Setup(x => x.Pull(Moq.It.IsAny <string>(), Moq.It.IsAny <string>(), Moq.It.IsAny <int?>()))
.Returns(Task.FromResult(new[] { _delayedEvent.Object }.AsEnumerable()));
_eventstore.Setup(x => x.WriteEvents <FakeEntity>(Moq.It.IsAny <string>(), Moq.It.IsAny <Id>(), Moq.It.IsAny <Id[]>(), Moq.It.IsAny <IFullEvent[]>(), Moq.It.IsAny <IDictionary <string, string> >(), Moq.It.IsAny <long?>()))
.Returns(Task.FromResult(0L));
}
public async Task EventBus_Should_Invoke_Event_Handlers_Implicit_Topic()
{
// Create handlers
var state = new FakeState {
Data = "A"
};
var fakeHandler1 = new FakeEventHandler1(state);
var fakeHandler2 = new FakeEventHandler2(state);
// Create message broker
var messageBroker = new FakeMessageBroker();
messageBroker.Subscribe(fakeHandler1);
messageBroker.Subscribe(fakeHandler2);
// Create service bus
var eventBus = new FakeEventBus(messageBroker);
eventBus.Subscribe(fakeHandler1);
eventBus.Subscribe(fakeHandler2);
// Publish to service bus
var @event = new FakeIntegrationEvent("B");
await eventBus.PublishAsync(@event);
// Assert
Assert.Equal(@event.CreationDate, state.Date);
Assert.Equal("B", state.Data);
}
public async Task EventBus_Should_Invoke_Event_Handlers(TopicType topicType, string prefix)
{
// Topic name
var topicName = topicType == TopicType.Explicit ? "my-topic" : null;
// Create handlers
var state = new FakeState {
Data = "A"
};
var fakeHandler1 = new FakeEventHandler1(state);
var fakeHandler2 = new FakeEventHandler2(state);
// Create message broker
var messageBroker = new FakeMessageBroker();
messageBroker.Subscribe(fakeHandler1, topicName, prefix);
messageBroker.Subscribe(fakeHandler2, topicName, prefix);
// Create service bus
var eventBus = new FakeEventBus(messageBroker);
eventBus.Subscribe(fakeHandler1, topicName, prefix);
eventBus.Subscribe(fakeHandler2, topicName, prefix);
// Publish to service bus
var @event = new FakeIntegrationEvent("B");
await eventBus.PublishAsync(@event, topicName, prefix);
// Assert
Assert.Equal(@event.CreationDate, state.Date);
Assert.Equal("B", state.Data);
}
public void ReduceShouldApplyMiddleware()
{
var fakeState = new FakeState();
var emptyAction = new EmptyAction();
_rootReducer.Reduce(fakeState, emptyAction);
Assert.AreEqual(fakeState, _middleware.State);
Assert.AreEqual(emptyAction, _middleware.Action);
}
public void ReduceShouldExecuteEachReducer()
{
var action = new EmptyAction();
var oldState = new FakeState();
var newState = _rootReducer.Reduce(oldState, action);
Assert.AreSame(action, _actionReducer.Action);
Assert.AreSame(oldState, _actionReducer.PreviousState);
Assert.AreNotSame(newState, oldState);
}
public void Setup()
{
_state = new FakeState();
_mapper = new Moq.Mock <IEventMapper>();
_mapper.Setup(x => x.GetMappedTypeFor(typeof(Test))).Returns(typeof(Test));
_mapper.Setup(x => x.GetMappedTypeFor(typeof(TestAgain))).Returns(typeof(TestAgain));
var fake = new FakeConfiguration();
fake.FakeContainer.Setup(x => x.Resolve <IEventMapper>()).Returns(_mapper.Object);
Configuration.Settings = fake;
}
public async Task ShouldProvideStateWhileRepeating()
{
// needs to be a reference type for this purpose
var fake = new FakeState();
var task = Internal.Timer.Repeat((state) =>
{
var _count = state as FakeState;
_count.counter++;
return(Task.CompletedTask);
}, fake, TimeSpan.FromMilliseconds(1), "test");
await Task.Delay(200).ConfigureAwait(false);
task.IsCompleted.Should().BeFalse();
fake.counter.Should().BeGreaterOrEqualTo(2);
}
public async Task ShouldExpireTimerWithState()
{
// needs to be a reference type for this purpose
var fake = new FakeState();
var task = Internal.Timer.Expire((state) =>
{
var _count = state as FakeState;
_count.counter++;
return(Task.CompletedTask);
}, fake, TimeSpan.FromMilliseconds(1), "test");
await Task.Delay(200).ConfigureAwait(false);
task.IsCompleted.Should().BeTrue();
fake.counter.Should().Be(1);
}
public async Task new_snapshot_replaces_old()
{
Func <string, long, IFullEvent, Task> eventCb = null;
_consumer.Setup(
x =>
x.SubscribeToStreamEnd(Moq.It.Is <string>(m => m.EndsWith(StreamTypes.Snapshot)),
Moq.It.IsAny <CancellationToken>(), Moq.It.IsAny <Func <string, long, IFullEvent, Task> >(),
Moq.It.IsAny <Func <Task> >()))
.Callback <string, CancellationToken, Func <string, long, IFullEvent, Task>, Func <Task> >(
(stream, token, onEvent, onDisconnect) =>
{
eventCb = onEvent;
})
.Returns(Task.FromResult(true));
var cts = new CancellationTokenSource();
await _subscriber.Setup("test", Version.Parse("0.0.0")).ConfigureAwait(false);
await _subscriber.Connect().ConfigureAwait(false);
Assert.NotNull(eventCb);
var memento = new FakeState();
var memento2 = new FakeState();
memento.Version = 1;
memento2.Version = 2;
var message = new Moq.Mock <IFullEvent>();
message.Setup(x => x.Descriptor).Returns(new EventDescriptor());
message.Setup(x => x.Event).Returns(memento);
await eventCb("test", 0, message.Object);
message.Setup(x => x.Event).Returns(memento2);
await eventCb("test", 0, message.Object);
var snapshot = await _subscriber.Retreive("test").ConfigureAwait(false);
Assert.AreEqual(2, (snapshot.Payload as IState).Version);
cts.Cancel();
}
public void registered_handlers_are_executed_when_event_is_raised()
{
var state = new FakeState();
var locator = MockRepository.GenerateStub<IServiceLocator>();
locator.Stub(x => x.GetInstance<IState>()).Return(state);
ServiceLocator.SetLocatorProvider(() => locator);
var mockTest1Handler = MockRepository.GenerateMock<Handles<TestEvent1>>();
var mockTest2Handler = MockRepository.GenerateMock<Handles<TestEvent2>>();
locator.Expect(x => x.GetAllInstances<Handles<TestEvent1>>())
.Return(new[]{mockTest1Handler});
ServiceLocator.SetLocatorProvider(() => locator);
DomainEvent.Raise(new TestEvent1());
mockTest1Handler.AssertWasCalled(x => x.Handle(null), options => options.IgnoreArguments());
mockTest2Handler.AssertWasNotCalled(x => x.Handle(null), options => options.IgnoreArguments());
}
public void registered_handlers_are_executed_when_event_is_raised()
{
var state = new FakeState();
var locator = MockRepository.GenerateStub <IServiceLocator>();
locator.Stub(x => x.GetInstance <IState>()).Return(state);
ServiceLocator.SetLocatorProvider(() => locator);
var mockTest1Handler = MockRepository.GenerateMock <Handles <TestEvent1> >();
var mockTest2Handler = MockRepository.GenerateMock <Handles <TestEvent2> >();
locator.Expect(x => x.GetAllInstances <Handles <TestEvent1> >())
.Return(new[] { mockTest1Handler });
ServiceLocator.SetLocatorProvider(() => locator);
DomainEvent.Raise(new TestEvent1());
mockTest1Handler.AssertWasCalled(x => x.Handle(null), options => options.IgnoreArguments());
mockTest2Handler.AssertWasNotCalled(x => x.Handle(null), options => options.IgnoreArguments());
}
public void callbacks_are_cleared_when_clear_is_called()
{
var state = new FakeState();
var locator = MockRepository.GenerateStub<IServiceLocator>();
locator.Stub(x => x.GetInstance<IState>()).Return(state);
ServiceLocator.SetLocatorProvider(() => locator);
var mockTestEvent1Handler = MockRepository.GenerateMock<Handles<TestEvent1>>();
var mockTestEvent2Handler = MockRepository.GenerateMock<Handles<TestEvent2>>();
DomainEvent.RegisterCallback<TestEvent1>(mockTestEvent1Handler.Handle);
DomainEvent.RegisterCallback<TestEvent2>(mockTestEvent2Handler.Handle);
var callbacksListFromStorage = state.Local.Get<IList<Delegate>>("DomainEvent.Callbacks");
Assert.That(callbacksListFromStorage, Is.Not.Null);
Assert.That(callbacksListFromStorage.Count, Is.EqualTo(2));
DomainEvent.ClearCallbacks();
callbacksListFromStorage = state.Local.Get<IList<Delegate>>(typeof(DomainEvent).FullName + "DomainEvent.Callbacks");
Assert.That(callbacksListFromStorage, Is.Null);
}
public async Task gets_snapshot_is_clone()
{
Func <string, long, IFullEvent, Task> eventCb = null;
_consumer.Setup(
x =>
x.SubscribeToStreamEnd(Moq.It.Is <string>(m => m.EndsWith(StreamTypes.Snapshot)),
Moq.It.IsAny <CancellationToken>(), Moq.It.IsAny <Func <string, long, IFullEvent, Task> >(),
Moq.It.IsAny <Func <Task> >()))
.Callback <string, CancellationToken, Func <string, long, IFullEvent, Task>, Func <Task> >(
(stream, token, onEvent, onDisconnect) =>
{
eventCb = onEvent;
})
.Returns(Task.FromResult(true));
var cts = new CancellationTokenSource();
await _subscriber.Setup("test", Version.Parse("0.0.0")).ConfigureAwait(false);
await _subscriber.Connect().ConfigureAwait(false);
Assert.NotNull(eventCb);
var memento = new FakeState();
memento.Version = 1;
var message = new Moq.Mock <IFullEvent>();
message.Setup(x => x.Descriptor).Returns(new EventDescriptor());
message.Setup(x => x.Event).Returns(memento);
await eventCb("test", 0, message.Object);
var read = await _subscriber.Retreive("test").ConfigureAwait(false);
// A change to the base memento shouldn't change what we get from snapshot reader (it should have cloned the snapshot)
memento.Version = 2;
Assert.AreEqual(1, (read.Payload as IState).Version);
cts.Cancel();
}
public void registered_callbacks_are_called_when_event_is_raised()
{
var state = new FakeState();
var locator = MockRepository.GenerateStub<IServiceLocator>();
locator.Stub(x => x.GetInstance<IState>()).Return(state);
ServiceLocator.SetLocatorProvider(() => locator);
var mockTestEvent1Handler = MockRepository.GenerateMock<Handles<TestEvent1>>();
var mockTestEvent2Handler = MockRepository.GenerateMock<Handles<TestEvent2>>();
DomainEvent.RegisterCallback<TestEvent1>(mockTestEvent1Handler.Handle);
DomainEvent.RegisterCallback<TestEvent2>(mockTestEvent2Handler.Handle);
var callbacksListFromStorage = state.Local.Get<IList<Delegate>>("DomainEvent.Callbacks");
Assert.That(callbacksListFromStorage, Is.Not.Null);
Assert.That(callbacksListFromStorage.Count, Is.EqualTo(2));
DomainEvent.Raise(new TestEvent1());
mockTestEvent1Handler.AssertWasCalled(x => x.Handle(null), options => options.IgnoreArguments());
mockTestEvent2Handler.AssertWasNotCalled(x => x.Handle(null), options => options.IgnoreArguments());
}
public void callbacks_are_cleared_when_clear_is_called()
{
var state = new FakeState();
var locator = MockRepository.GenerateStub <IServiceLocator>();
locator.Stub(x => x.GetInstance <IState>()).Return(state);
ServiceLocator.SetLocatorProvider(() => locator);
var mockTestEvent1Handler = MockRepository.GenerateMock <Handles <TestEvent1> >();
var mockTestEvent2Handler = MockRepository.GenerateMock <Handles <TestEvent2> >();
DomainEvent.RegisterCallback <TestEvent1>(mockTestEvent1Handler.Handle);
DomainEvent.RegisterCallback <TestEvent2>(mockTestEvent2Handler.Handle);
var callbacksListFromStorage = state.Local.Get <IList <Delegate> >("DomainEvent.Callbacks");
Assert.That(callbacksListFromStorage, Is.Not.Null);
Assert.That(callbacksListFromStorage.Count, Is.EqualTo(2));
DomainEvent.ClearCallbacks();
callbacksListFromStorage = state.Local.Get <IList <Delegate> >(typeof(DomainEvent).FullName + "DomainEvent.Callbacks");
Assert.That(callbacksListFromStorage, Is.Null);
}
static async Task Main(string[] args)
{
var context = new FakeContext();
/*context.Agent.RegisterAgent("TestAgent", () => {
* var agent = new TestAgent();
* agent.RegisterFunction("TestAgent", (int input) => {
* Debug.Assert(input == 42);
* return 78;
* });
* return agent;
* });*/
context.Agent.RegisterAgent("TestAgent", () => context.Agent);
context.Agent.RegisterFunction("TestAgent", (int input) => {
Debug.Assert(input == 42);
return(78);
});
context.Agent.RegisterFunction("Dynamic", (dynamic item) => {
Debug.Assert((string)item.Message == "This was read from a dynamic object!");
return(new { Sum = item.A + item.B });
});
context.Agent.RegisterFunction("Log", (string input) => {
Debug.Assert(input == $"TestAgent returned 78");
});
var state = new FakeState();
var result = await Launcher.StatefulSum(10, state, default);
Debug.Assert(result == 10);
Debug.Assert(state.GetValue <int>("StatefulSum") == 10);
await Launcher.RunAsync(true, context, state, default);
}
public void registered_callbacks_are_called_when_event_is_raised()
{
var state = new FakeState();
var locator = MockRepository.GenerateStub <IServiceLocator>();
locator.Stub(x => x.GetInstance <IState>()).Return(state);
ServiceLocator.SetLocatorProvider(() => locator);
var mockTestEvent1Handler = MockRepository.GenerateMock <Handles <TestEvent1> >();
var mockTestEvent2Handler = MockRepository.GenerateMock <Handles <TestEvent2> >();
DomainEvent.RegisterCallback <TestEvent1>(mockTestEvent1Handler.Handle);
DomainEvent.RegisterCallback <TestEvent2>(mockTestEvent2Handler.Handle);
var callbacksListFromStorage = state.Local.Get <IList <Delegate> >("DomainEvent.Callbacks");
Assert.That(callbacksListFromStorage, Is.Not.Null);
Assert.That(callbacksListFromStorage.Count, Is.EqualTo(2));
DomainEvent.Raise(new TestEvent1());
mockTestEvent1Handler.AssertWasCalled(x => x.Handle(null), options => options.IgnoreArguments());
mockTestEvent2Handler.AssertWasNotCalled(x => x.Handle(null), options => options.IgnoreArguments());
}
public void EventBus_Should_Remove_Event_Handlers(TopicType topicType, string prefix)
{
// Topic name
var topicName = topicType == TopicType.Explicit ? "my-topic" : null;
// Create handlers
var state = new FakeState {
Data = "A"
};
var fakeHandler1 = new FakeEventHandler1(state);
var fakeHandler2 = new FakeEventHandler2(state);
// Create message broker
var messageBroker = new FakeMessageBroker();
messageBroker.Subscribe(fakeHandler1, topicName, prefix);
messageBroker.Subscribe(fakeHandler2, topicName, prefix);
// Create service bus
var eventBus = new FakeEventBus(messageBroker);
eventBus.Subscribe(fakeHandler1, topicName, prefix);
eventBus.Subscribe(fakeHandler2, topicName, prefix);
// Remove handler
eventBus.UnSubscribe(fakeHandler1, topicName, prefix);
// Assert
Assert.Single(eventBus.Topics);
Assert.Single(eventBus.Topics.First().Value);
// Remove handler
eventBus.UnSubscribe(fakeHandler2, topicName, prefix);
// Assert
Assert.Empty(eventBus.Topics);
}
public virtual void TestSetup()
{
State = new FakeState();
}
public virtual void TestSetup()
{
State = new FakeState();
}
public void Init()
{
_fakeContext = new FakeContext();
_fakeState = new FakeState();
}
