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 void Init() { _fakeContext = new FakeContext(); _fakeState = new FakeState(); }