public async Task StreamingEventsAreBufferedUntilStateOfTheWorldIsRetrieved()
        {
            var mre           = new ManualResetEvent(false);
            var existingEvent = new TestAggregateCreatedEvent(new Guid("b166fbb3-b7f9-49d2-8a61-0b4df5fff561"), "Test1");

            A.CallTo(() => _persistenceClient.Retrieve(typeof(TestAggregateCreatedEvent)))
            .Returns(Task.Run(() =>
            {
                mre.WaitOne();
                return(new IEvent[] { existingEvent });
            }));

            var reader = new TestAggregateReader(_persistenceClient, _streamingClient);
            await Task.Factory.StartNew(async() =>
            {
                await reader.StartAsync();
                Assert.AreEqual(2, reader.Get().Length);

                _allEventsSubject.OnNext(new TestAggregateCreatedEvent(new Guid("15dd702a-7106-434e-9aa0-2f8f67fdd85d"), "Test3"));
                Assert.AreEqual(3, reader.Get().Length);
            });

            Assert.AreEqual(0, reader.Get().Length);

            _allEventsSubject.OnNext(new TestAggregateCreatedEvent(new Guid("db8cedf3-a4f8-4d0c-835b-e05692d69937"), "Test2"));

            Assert.AreEqual(0, reader.Get().Length);

            mre.Set();
        }
        public async Task OnSaveEventPublishIsCalled()
        {
            var writer = new TestAggregateWriter(_persistenceClient, _streamingClient);
            await writer.StartAsync();

            var createdEvent = new TestAggregateCreatedEvent(new Guid("b166fbb3-b7f9-49d2-8a61-0b4df5fff561"), "Test1");
            await writer.Save(createdEvent);

            A.CallTo(() => _persistenceClient.Save(
                         A <string> .Ignored,
                         A <int> .Ignored,
                         A <IEvent> .Ignored))
            .MustHaveHappenedOnceExactly();

            A.CallTo(() => _streamingClient.Publish(A <IEvent> .Ignored))
            .MustHaveHappenedOnceExactly();
        }
        public async Task ExistingEventsAreLoadedAndProcessedOnStart()
        {
            var existingEvent = new TestAggregateCreatedEvent(new Guid("b166fbb3-b7f9-49d2-8a61-0b4df5fff561"), "Test1");

            A.CallTo(() => _persistenceClient.Retrieve(typeof(TestAggregateCreatedEvent)))
            .Returns(new IEvent[] { existingEvent });

            var reader = new TestAggregateReader(_persistenceClient, _streamingClient);
            await reader.StartAsync();

            var aggregates = reader.Get();

            Assert.AreEqual(1, aggregates.Length);

            var actualAggregate = aggregates[0];

            Assert.AreEqual(existingEvent.AggregateId, actualAggregate.Id);
            Assert.AreEqual(existingEvent.Foo, actualAggregate.Foo);
        }
        public async Task ExistingEventsWithSameAggregateIdAreAppliedToSameAggregate()
        {
            var createdEvent = new TestAggregateCreatedEvent(new Guid("b166fbb3-b7f9-49d2-8a61-0b4df5fff561"), "Test1_Initial");
            var updatedEvent = new TestAggregateUpdatedEvent(new Guid("b166fbb3-b7f9-49d2-8a61-0b4df5fff561"), "Test1_Updated");

            A.CallTo(() => _persistenceClient.Retrieve(typeof(TestAggregateCreatedEvent)))
            .Returns(new IEvent[] { createdEvent });
            A.CallTo(() => _persistenceClient.Retrieve(typeof(TestAggregateUpdatedEvent)))
            .Returns(new IEvent[] { updatedEvent });

            var reader = new TestAggregateReader(_persistenceClient, _streamingClient);
            await reader.StartAsync();

            var aggregates = reader.Get();

            Assert.AreEqual(1, aggregates.Length);

            var actualAggregate = aggregates[0];

            Assert.AreEqual(updatedEvent.Foo, actualAggregate.Foo);
        }
        public async Task WhenSavingNewEventUsesVersionOfAggregateAsExpectedVersion()
        {
            var createdEvent = new TestAggregateCreatedEvent(new Guid("b166fbb3-b7f9-49d2-8a61-0b4df5fff561"), "Test1_Initial");
            var updatedEvent = new TestAggregateUpdatedEvent(new Guid("b166fbb3-b7f9-49d2-8a61-0b4df5fff561"), "Test1_Updated");

            A.CallTo(() => _persistenceClient.Retrieve(typeof(TestAggregateCreatedEvent)))
            .Returns(new IEvent[] { createdEvent });
            A.CallTo(() => _persistenceClient.Retrieve(typeof(TestAggregateUpdatedEvent)))
            .Returns(new IEvent[] { updatedEvent });

            var writer = new TestAggregateWriter(_persistenceClient, _streamingClient);
            await writer.StartAsync();

            var newUpdatedEvent = new TestAggregateUpdatedEvent(new Guid("b166fbb3-b7f9-49d2-8a61-0b4df5fff561"), "Test1_Updated_SecondTime");

            await writer.Save(newUpdatedEvent);

            A.CallTo(() => _persistenceClient.Save(
                         "TestAggregateRoot_b166fbb3-b7f9-49d2-8a61-0b4df5fff561",
                         1,
                         A <IEvent> .Ignored))
            .MustHaveHappenedOnceExactly();
        }
 private void When(TestAggregateCreatedEvent createdEvent)
 {
     Id  = createdEvent.AggregateId;
     Foo = createdEvent.Foo;
 }
 private void Apply(TestAggregateCreatedEvent e)
 {
     Id    = e.SourceId;
     Value = e.Value;
 }