public void TimeoutPromptsMessageSending_Data() { var bus = MockRepository.GenerateMock <IBus>(); var sendOneMessageNow = new SendOneMessageNow(); bus.Expect(b => b.Send(Arg <SendOneMessageNow> .Is.NotNull)) .WhenCalled(i => sendOneMessageNow = (SendOneMessageNow)((i.Arguments[0]))); var dataId = Guid.NewGuid(); var originalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("3443", "message"), SmsMetaData = new SmsMetaData { Tags = new List <string> { "a", "b" }, Topic = "topic" } }; var data = new ScheduledSmsData { Id = dataId, OriginalMessage = originalMessage }; var scheduleSms = new ScheduleSms { Bus = bus, Data = data }; var timeoutMessage = new ScheduleSmsTimeout(); scheduleSms.Timeout(timeoutMessage); Assert.That(sendOneMessageNow.SmsData, Is.EqualTo(data.OriginalMessage.SmsData)); Assert.That(sendOneMessageNow.SmsMetaData, Is.EqualTo(data.OriginalMessage.SmsMetaData)); Assert.That(sendOneMessageNow.CorrelationId, Is.EqualTo(data.Id)); bus.VerifyAllExpectations(); }
public void Handle(SendOneMessageNow sendOneMessageNow) { Data.OriginalMessage = sendOneMessageNow; var confirmationData = SmsService.Send(sendOneMessageNow); Data.SmsRequestId = confirmationData.Sid; ProcessConfirmationData(confirmationData); }
public void Timeout(ScheduleSmsTimeout state) { if (!Data.SchedulingPaused && state.TimeoutCounter == Data.TimeoutCounter) { var sendOneMessageNow = new SendOneMessageNow { CorrelationId = Data.Id, SmsData = Data.OriginalMessage.SmsData, SmsMetaData = Data.OriginalMessage.SmsMetaData, ConfirmationEmailAddress = Data.OriginalMessage.ConfirmationEmail }; Bus.Send(sendOneMessageNow); } }
public void SmsUsesTwilio() { _docSession.Expect(d => d.Load <SmsProviderConfiguration>("SmsProviderConfiguration")).Return(_twilioProvider); var messageToSend = new SendOneMessageNow { SmsData = new SmsData("mobile", "message") }; var twilioWrapper = MockRepository.GenerateMock <ITwilioWrapper>(); var smsService = new SmsService { TwilioWrapper = twilioWrapper, RavenDocStore = _ravenDocStore }; twilioWrapper.Expect(t => t.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)); smsService.Send(messageToSend); twilioWrapper.VerifyAllExpectations(); }
public void SendSingleSmsNowFailure() { var sendOneMessageNow = new SendOneMessageNow(); var smsService = MockRepository.GenerateMock <ISmsService>(); var smsFailed = new SmsFailed("sid", "code", "message", "moreinfo", "status"); smsService.Expect(s => s.Send(sendOneMessageNow)).Return(smsFailed); Test.Initialize(); Test.Saga <SmsActioner.SmsActioner>() .WithExternalDependencies(a => a.SmsService = smsService) .ExpectReplyToOriginator <MessageFailedSending>() .ExpectSendLocal <MessageFailedSending>() .When(a => a.Handle(sendOneMessageNow)) .AssertSagaCompletionIs(true); }
public void SendSingleSmsNowSuccess() { var sendOneMessageNow = new SendOneMessageNow(); var smsService = MockRepository.GenerateMock <ISmsService>(); var smsSent = new SmsSent(new SmsConfirmationData("r", DateTime.Now, 0.44m)); smsService.Expect(s => s.Send(sendOneMessageNow)).Return(smsSent); Test.Initialize(); Test.Saga <SmsActioner.SmsActioner>() .WithExternalDependencies(a => a.SmsService = smsService) .ExpectPublish <MessageSent>() .ExpectReplyToOriginator <MessageSuccessfullyDelivered>() .ExpectSendLocal <MessageSuccessfullyDelivered>() .When(a => a.Handle(sendOneMessageNow)) .AssertSagaCompletionIs(true); }
public SmsStatus Send(SendOneMessageNow messageToSend) { using (var session = RavenDocStore.GetStore().OpenSession(RavenDocStore.ConfigurationDatabaseName())) { var smsProvider = session.Load <SmsProviderConfiguration>("SmsProviderConfiguration"); if (smsProvider == null) { throw new Exception("No SMS provider selected"); } switch (smsProvider.SmsProvider) { case SmsProvider.Nexmo: return(NexmoWrapper.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)); case SmsProvider.Twilio: return(TwilioWrapper.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)); } throw new Exception("SMS Provder delivery not implemented for " + smsProvider.SmsProvider.ToString()); } }
public void ValidForm_AcknowledgesIncomingSms_SendSmsPutOnBus() { var response = new RespondToSmsIncoming { IncomingSmsId = Guid.NewGuid() }; var smsReceivedData = new SmsReceivedData { SmsData = new SmsData("mobile", "message"), SmsId = response.IncomingSmsId }; var bus = MockRepository.GenerateMock <IBus>(); var raven = MockRepository.GenerateMock <IRavenDocStore>(); var docStore = MockRepository.GenerateMock <IDocumentStore>(); var session = MockRepository.GenerateMock <IDocumentSession>(); raven.Expect(d => d.GetStore()).Return(docStore); docStore.Expect(d => d.OpenSession()).Return(session); session.Expect(s => s.Load <SmsReceivedData>(response.IncomingSmsId.ToString())).Return(smsReceivedData); session.Expect(s => s.SaveChanges()); // TODO : Mock the query action SendOneMessageNow sendMessageNow = null; bus.Expect(b => b.Send(Arg <SendOneMessageNow> .Is.Anything)); // .WhenCalled(b => sendMessageNow = (SendOneMessageNow) b.Arguments[0]); var receivedMessageController = new ReceivedMessageController { Bus = bus, DocumentStore = raven }; receivedMessageController.Respond(response); // Assert.That(sendMessageNow.SmsData.Mobile, Is.EqualTo(smsReceivedData.SmsData.Mobile)); // Assert.That(sendMessageNow.SmsData.Message, Is.EqualTo(response.Message)); // Assert.That(sendMessageNow.CorrelationId, Is.EqualTo(response.IncomingSmsId)); Assert.That(smsReceivedData.Acknowledge, Is.True); }
public void SendSingleSmsNowQueuedThenSuccess() { var sendOneMessageNow = new SendOneMessageNow(); var smsService = MockRepository.GenerateMock <ISmsService>(); var smsQueued = new SmsQueued("12"); var smsSent = new SmsSent(new SmsConfirmationData("r", DateTime.Now, .44m)); smsService.Expect(s => s.Send(sendOneMessageNow)).Return(smsQueued); smsService.Expect(s => s.CheckStatus(smsQueued.Sid)).Return(smsSent); Test.Initialize(); Test.Saga <SmsActioner.SmsActioner>() .WithExternalDependencies(a => a.SmsService = smsService) .ExpectTimeoutToBeSetIn <SmsPendingTimeout>((timeoutMessage, timespan) => timespan == TimeSpan.FromSeconds(10)) .When(a => a.Handle(sendOneMessageNow)) .ExpectPublish <MessageSent>() .ExpectReplyToOriginator <MessageSuccessfullyDelivered>() .ExpectSendLocal <MessageSuccessfullyDelivered>() .WhenSagaTimesOut() .AssertSagaCompletionIs(true); }
public void SendSingleSmsNowQueuedThenFail() { var sendOneMessageNow = new SendOneMessageNow(); var smsService = MockRepository.GenerateMock <ISmsService>(); const string sid = "12"; var smsQueued = new SmsQueued(sid); var smsFailed = new SmsFailed(sid, "c", "m", "m", "s"); smsService.Expect(s => s.Send(sendOneMessageNow)).Return(smsQueued); smsService.Expect(s => s.CheckStatus(smsQueued.Sid)).Return(smsFailed); Test.Initialize(); Test.Saga <SmsActioner.SmsActioner>() .WithExternalDependencies(a => a.SmsService = smsService) .ExpectTimeoutToBeSetIn <SmsPendingTimeout>((timeoutMessage, timespan) => timespan == TimeSpan.FromSeconds(10)) .When(a => a.Handle(sendOneMessageNow)) .ExpectNotPublish <MessageSent>() .ExpectReplyToOriginator <MessageFailedSending>() .ExpectSendLocal <MessageFailedSending>() .WhenSagaTimesOut() .AssertSagaCompletionIs(true); }