public void WaitForAllResultsToBeCompleted()
        {
            _awaiter = new ResultAwaiter(_mockResultStore.Object, new TimeoutProvider(1000));
            var invovationCount = 0;
            var results         = new[]
            {
                new DomainResult(_domainCommand, ResultCode.OK, string.Empty),
                new DomainResult(_domainEvent, ResultCode.Unknown, string.Empty)
            };

            _mockResultStore.Setup(x => x.Get(_domainCommand.TrackingId)).Returns(results)
            .Callback(
                () => {
                if (invovationCount == 1)
                {
                    results[0].ResultCode = ResultCode.Failed;
                }
                else if (invovationCount == 2)
                {
                    results[1].ResultCode = ResultCode.OK;
                }

                invovationCount++;
            });


            _awaiter.WaitForResults(_domainCommand);
            Assert.AreEqual(3, invovationCount);
        }
        public void ReturnsThePersistedResult()
        {
            _awaiter = new ResultAwaiter(_mockResultStore.Object, new TimeoutProvider(100));
            _mockResultStore.Setup(x => x.Get(_domainCommand.TrackingId)).Returns(new [] { new DomainResult(_domainCommand, ResultCode.OK, string.Empty) });
            var result = _awaiter.WaitForResults(_domainCommand);

            Assert.AreEqual(ResultCode.OK, result.ResultCode);
        }
        public void WaitUpToTimeout()
        {
            _awaiter = new ResultAwaiter(_mockResultStore.Object, new TimeoutProvider(100));
            var startWait = DateTime.Now;
            var result    = _awaiter.WaitForResults(_domainCommand);
            var endWait   = DateTime.Now;
            var delta     = (endWait - startWait);

            Assert.AreEqual(ResultCode.Unknown, result.ResultCode);
            // Allow 15 ms buffer
            Assert.IsTrue(delta.TotalMilliseconds <= 115, "delta was " + delta);
        }
        public void WorstResultIsReturned()
        {
            _awaiter = new ResultAwaiter(_mockResultStore.Object, new TimeoutProvider(500));

            var results = new[]
            {
                new DomainResult(_domainCommand, ResultCode.OK, string.Empty),
                new DomainResult(_domainEvent, ResultCode.Failed, string.Empty)
            };

            _mockResultStore.Setup(x => x.Get(_domainCommand.TrackingId)).Returns(results);

            var result = _awaiter.WaitForResults(_domainCommand);

            Assert.AreEqual(ResultCode.Failed, result.ResultCode);
        }
Beispiel #5
0
        private static MessagingBus SetupBus(OrderView orderView)
        {
            IPersistanceStore persitenceStore  = new MemoryPersistance();
            IDomainEventQuery domainEventQuery = new InProcPersistedDomainEventQuery(persitenceStore);
            IDomainEventStore domainEventStore = new PyxisDomainEventStore(
                persitenceStore,
                domainEventQuery);
            IDomainResultStoreQuery storeQuery  = new InProcDomainResultStoreQuery(persitenceStore);
            IDomainResultStore      resultStore = new DomainResultPersistanceStore(
                persitenceStore,
                storeQuery);
            ITimeoutProvider timeoutProvider = new TimeoutProvider(1000);
            IResultPublisher resultPublisher = new ResultPublisher(
                resultStore,
                timeoutProvider);
            IResultAwaiter resultAwaiter = new ResultAwaiter(
                resultStore,
                timeoutProvider);
            IList <IHandleCommand>        commandHanlders   = new List <IHandleCommand>();
            IList <IHandleEvent>          eventHandlers     = new List <IHandleEvent>();
            IMessageDispatcher <ICommand> commandDispatcher = new CqrsMessagingHandler(
                resultPublisher,
                commandHanlders,
                eventHandlers);
            ICommandQueue commandQueue = new InProcCommandQueue(commandDispatcher);
            MessagingBus  bus          = new MessagingBus(
                commandQueue,
                resultPublisher,
                resultAwaiter);
            IDomainRepository domainRepository = new DomainRepository(
                domainEventStore,
                bus);
            ISession session = new Session(domainRepository);

            commandHanlders.Add(new OrderCommandHandler(session));
            eventHandlers.Add(new OrderEventHandler(orderView));

            return(bus);
        }