public IMessageBusListener Build()
        {
            var provisionOrderHandler = new MobileProvisionOrderSentHandler(orderSentLogger, serviceProvider);

            messageBus.Subscribe <ProvisionOrderSentMessage, IHandlerAsync <ProvisionOrderSentMessage> >(provisionOrderHandler);

            var provisionOrderCompletedHandler = new OrderCompletedHandler(provisioningOrderCompletedLogger, monitoring, serviceProvider);

            messageBus.Subscribe <ProvisionOrderCompletedMessage, IHandlerAsync <ProvisionOrderCompletedMessage> >(provisionOrderCompletedHandler);

            var activateOrderSentHandler = new ActivateOrderSentHandler(activateOrderSentLogger, serviceProvider);

            messageBus.Subscribe <ActivateOrderSentMessage, IHandlerAsync <ActivateOrderSentMessage> >(activateOrderSentHandler);

            var activateOrderCompletedHandler = new ActivateOrderCompletedHandler(activateOrderCompletedLogger, monitoring, serviceProvider);

            messageBus.Subscribe <ActivateOrderCompletedMessage, IHandlerAsync <ActivateOrderCompletedMessage> >(activateOrderCompletedHandler);

            var activateOrderRejectedHandler = new ActivateOrderRejectedHandler(activateOrderRejectedLogger, monitoring, serviceProvider);

            messageBus.Subscribe <ActivateOrderRejectedMessage, IHandlerAsync <ActivateOrderRejectedMessage> >(activateOrderRejectedHandler);

            var ceaseOrderSentHandler = new CeaseOrderSentHandler(ceaseOrderSentLogger, serviceProvider);

            messageBus.Subscribe <CeaseOrderSentMessage, IHandlerAsync <CeaseOrderSentMessage> >(ceaseOrderSentHandler);

            var ceaseOrderCompletedHandler = new CeaseOrderCompletedHandler(ceaseOrderCompletedLogger, monitoring, serviceProvider);

            messageBus.Subscribe <CeaseOrderCompletedMessage, IHandlerAsync <CeaseOrderCompletedMessage> >(ceaseOrderCompletedHandler);

            return(new MessageBusListener(messageBus, sqsService, new MessageDeserializer()));
        }
            public HandleShould()
            {
                var dateTimeCreatorMock = new Mock <IDateTimeCreator>();

                var inProgressOrder = new Order(new OrderDataEntity()
                {
                    State = "Sent"
                });

                expectedMobile = new Mobile(dateTimeCreatorMock.Object, new MobileDataEntity()
                {
                    GlobalId = Guid.NewGuid(),
                    State    = MobileState.ProcessingActivate.ToString(),
                    Orders   = new List <OrderDataEntity>()
                    {
                        inProgressOrder.GetDataEntity()
                    }
                });
                inputMessage = new ActivateOrderCompletedMessage()
                {
                    MobileOrderId = expectedMobile.GlobalId
                };

                mobileRepositoryMock        = new Mock <IRepository <Mobile> >();
                getMobileByOrderIdQueryMock = new Mock <IGetMobileByOrderIdQuery>();
                var loggerMock     = new Mock <ILogger <ActivateOrderCompletedHandler> >();
                var monitoringMock = new Mock <IMonitoring>();

                getMobileByOrderIdQueryMock.Setup(x => x.Get(inputMessage.MobileOrderId))
                .Returns(expectedMobile);

                var serviceProviderMock = ServiceProviderHelper.GetMock();

                serviceProviderMock.Setup(x => x.GetService(typeof(IGetMobileByOrderIdQuery))).Returns(getMobileByOrderIdQueryMock.Object);
                serviceProviderMock.Setup(x => x.GetService(typeof(IRepository <Mobile>))).Returns(mobileRepositoryMock.Object);

                sut = new ActivateOrderCompletedHandler(loggerMock.Object, monitoringMock.Object, serviceProviderMock.Object);
            }