示例#1
0
        public void CreateAccountEventIsPublishedToBus()
        {
            using (MassTransitDispatcher massTransitDispatcher = new MassTransitDispatcher(bus))
            {
                PollingClient   pollingClient  = new PollingClient(store.Advanced, 100);
                IObserveCommits commitObserver = pollingClient.ObserveFrom(null);

                IEventHandler <SimpleAggregateCreated> denormalizer = A.Fake <IEventHandler <SimpleAggregateCreated> >();
                AutoResetEvent are = new AutoResetEvent(false);
                A.CallTo(() => denormalizer.Handle(A <SimpleAggregateCreated> .Ignored)).Invokes(() => are.Set());

                bus.Subscribe(denormalizer);

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

                        Guid aggregateID = Guid.NewGuid();

                        SimpleAggregate aggregate = new SimpleAggregate(aggregateID, DateTime.Now);
                        repository.Save(aggregate, Guid.NewGuid(), (o) => { });

                        are.WaitOne(10000).Should().BeTrue("event should be dispatched and recieved within timeout");
                    }
                }
            }
        }
        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 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);
                }
            }
        }