public async Task CreateAccountEventIsPublishedToBus()
        {
            MassTransitDispatcher massTransitDispatcher = new MassTransitDispatcher(bus);
            PollingClient         pollingClient         = new PollingClient(store.Advanced, 100);
            IObserveCommits       commitObserver        = pollingClient.ObserveFrom(null);

            AccountDenormalizer denormalizer = new AccountDenormalizer();

            bus.Subscribe(denormalizer);

            using (PollingHook pollingHook = new PollingHook(commitObserver))
            {
                using (var subscription = commitObserver.Subscribe(massTransitDispatcher))
                {
                    commitObserver.PollNow();
                    commitObserver.Start();

                    Guid   accountID = Guid.NewGuid();
                    string name      = Guid.NewGuid().ToString();
                    string twitter   = Guid.NewGuid().ToString();

                    System.Diagnostics.Debug.Print(string.Format("Creating account {0}", accountID));
                    client.CreateNewAccount(accountID, name, twitter);

                    DateTime timeoutEnd = DateTime.Now.AddSeconds(10);
                    while (denormalizer.AccountName != name && DateTime.Now < timeoutEnd)
                    {
                        await Task.Delay(100);
                    }

                    denormalizer.AccountName.Should().Be(name);
                }
            }
        }
        public void CreateAccountEventIsStoredAndWhyBotherHavingTheEventHandlerInThisTest()
        {
            var eventHandler = new AccountDenormalizer();

            bus.Subscribe(eventHandler);
            var accountId = client.CreateNewAccount();

            store.OpenStream(accountId, 0, int.MaxValue).CommittedEvents.Count.Should().Be(1);
        }
        public void CreateAccountEventIsStored()
        {
            var eventHandler = new AccountDenormalizer();

            this.bus.Subscribe(eventHandler);

            var accountId = this.client.CreateNewAccount();

            this.store.OpenStream(accountId, 0, int.MaxValue).CommittedEvents.Count.Should().BeGreaterThan(0);
        }
        public void CreateAccountEventIsPublishedToBus()
        {
            var denormalizer = new AccountDenormalizer();

            this.bus.Subscribe(denormalizer);

            Guid   accountID = Guid.NewGuid();
            string name      = Guid.NewGuid().ToString();
            string twitter   = Guid.NewGuid().ToString();

            this.client.CreateNewAccount(accountID, name, twitter);

            denormalizer.AccountName.Should().Be(name);
        }
        public void DeactivingAccountDoesntRetriggerInitialCreate()
        {
            var deactivateHandler = new CloseAccountCommandHandler(new EventStoreRepository(this.store, new AggregateFactory(), new ConflictDetector()));
            var denormalizer      = new AccountDenormalizer();

            this.bus.Subscribe(deactivateHandler);
            this.bus.Subscribe(denormalizer);

            Guid   accountID = Guid.NewGuid();
            string name      = Guid.NewGuid().ToString();
            string twitter   = Guid.NewGuid().ToString();

            this.client.CreateNewAccount(accountID, name, twitter);
            this.client.CloseAccount(accountID);

            denormalizer.AccountName.Should().Be(name);
            denormalizer.IsActive.Should().Be(false);
            this.store.OpenStream(accountID, 0, int.MaxValue).CommittedEvents.Count.Should().Be(2);
        }
        public async Task TyingItTogether()
        {
            var denormalizer = new AccountDenormalizer();

            bus.Subscribe(denormalizer);
            bus.Subscribe(new KaChingNotifier());
            bus.Subscribe(new OmgSadnessNotifier());

            var massTransitDispatcher = new MassTransitDispatcher(bus);
            var pollingClient         = new PollingClient(store.Advanced, 100);
            var commitObserver        = pollingClient.ObserveFrom(null);

            using (PollingHook pollingHook = new PollingHook(commitObserver))
            {
                using (var subscription = commitObserver.Subscribe(massTransitDispatcher))
                {
                    commitObserver.PollNow();
                    commitObserver.Start();

                    Guid   accountID = Guid.NewGuid();
                    string name      = Guid.NewGuid().ToString();
                    string twitter   = Guid.NewGuid().ToString();

                    client.CreateNewAccount(accountID, name, twitter);
                    client.CloseAccount(accountID);

                    DateTime timeoutEnd = DateTime.Now.AddSeconds(10);
                    while ((denormalizer.AccountName != name ||
                            denormalizer.IsActive) &&
                           DateTime.Now < timeoutEnd)
                    {
                        await Task.Delay(100);
                    }

                    denormalizer.AccountName.Should().Be(name);
                    denormalizer.IsActive.Should().Be(false);
                    store.OpenStream(accountID, 0, int.MaxValue).CommittedEvents.Count.Should().Be(2);
                }
            }
        }