public void SendSingleSmsNow_SendingThenFail() { var sendOneMessageNow = new SendOneMessageNow(); var smsService = MockRepository.GenerateMock<ISmsService>(); var timeoutCalculator = MockRepository.GenerateMock<ITimeoutCalculator>(); const string sid = "12"; var smsSending = new SmsSending(sid, 0.06m); var smsFailed = new SmsFailed(sid, "c", "m"); smsService.Expect(s => s.Send(sendOneMessageNow)).Return(smsSending); smsService.Expect(s => s.CheckStatus(smsSending.Sid)).Return(smsFailed); var timeoutTimespan = new TimeSpan(); timeoutCalculator.Expect(t => t.RequiredTimeout(Arg<int>.Is.Anything)).Return(timeoutTimespan); Test.Initialize(); Test.Saga<SmsActioner.SmsActioner>() .WithExternalDependencies(a => { a.SmsService = smsService; a.TimeoutCalculator = timeoutCalculator; }) .ExpectTimeoutToBeSetIn<SmsPendingTimeout>((timeoutMessage, timespan) => timespan == timeoutTimespan) .When(a => a.Handle(sendOneMessageNow)) .ExpectNotPublish<MessageSent>() .WhenSagaTimesOut() .AssertSagaCompletionIs(true); }
public void SendOneMessageNow_SmsSendingSetsPriceAndId() { var sendOneMessageNow = new SendOneMessageNow(); var smsService = MockRepository.GenerateMock<ISmsService>(); var timeoutCalculator = MockRepository.GenerateMock<ITimeoutCalculator>(); var smsSending = new SmsSending("id", 0.06m); var data = new SmsActionerData(); smsService .Expect(s => s.Send(sendOneMessageNow)) .Return(smsSending); var timeoutRequested = new TimeSpan(); timeoutCalculator.Expect(t => t.RequiredTimeout(data.NumberOfTimeoutRequests)).Return(timeoutRequested); Test.Initialize(); Test.Saga<SmsActioner.SmsActioner>() .WithExternalDependencies(a => { a.SmsService = smsService; a.Data = data; a.TimeoutCalculator = timeoutCalculator; }) .WhenReceivesMessageFrom("somewhere") .ExpectTimeoutToBeSetIn<SmsPendingTimeout>((timeoutMessage, timespan) => timespan == timeoutRequested) .When(a => a.Handle(sendOneMessageNow)); Assert.That(data.SmsRequestId, Is.EqualTo(smsSending.Sid)); Assert.That(data.Price, Is.EqualTo(smsSending.Price)); Assert.That(data.OriginalMessage, Is.EqualTo(sendOneMessageNow)); Assert.That(data.NumberOfTimeoutRequests, Is.EqualTo(1)); smsService.VerifyAllExpectations(); timeoutCalculator.VerifyAllExpectations(); }
public void ValidNullCountryConfigSendsMessageReturnsToDetails() { var bus = MockRepository.GenerateMock<IBus>(); var ravenDocStore = MockRepository.GenerateMock<IRavenDocStore>(); var docStore = MockRepository.GenerateMock<IDocumentStore>(); var docSession = MockRepository.GenerateMock<IDocumentSession>(); ravenDocStore.Expect(r => r.GetStore()).Return(docStore); docStore.Expect(d => d.OpenSession("Configuration")).Return(docSession); docSession.Expect(d => d.Load<CountryCodeReplacement>("CountryCodeConfig")).Return(null); var sentMessage = new SendOneMessageNow(); bus.Expect(b => b.Send(Arg<SendOneMessageNow>.Is.NotNull)) .WhenCalled(a => sentMessage = ((SendOneMessageNow)((object[])a.Arguments[0])[0])); var controller = new SendNowController { ControllerContext = new ControllerContext(), Bus = bus, RavenDocStore = ravenDocStore }; var sendNowModel = new SendNowModel { MessageBody = "asdflj", Number = "number" , ConfirmationEmail = "sdakflj" }; var result = (RedirectToRouteResult)controller.Create(sendNowModel); Assert.That(result.RouteValues["action"], Is.EqualTo("Details")); Assert.That(sentMessage.SmsData.Mobile, Is.EqualTo(sendNowModel.Number)); Assert.That(sentMessage.SmsData.Message, Is.EqualTo(sendNowModel.MessageBody)); Assert.That(sentMessage.ConfirmationEmailAddress, Is.EqualTo(sendNowModel.ConfirmationEmail)); bus.VerifyAllExpectations(); }
public ActionResult Create(SendNowModel model) { var isValid = TryValidateModel(model); if(isValid) { model.MessageId = Guid.NewGuid(); if (model.MessageBody.Length > 160) model.MessageBody = model.MessageBody.Substring(0, 160); CountryCodeReplacement countryCodeReplacement; using (var session = RavenDocStore.GetStore().OpenSession("Configuration")) { countryCodeReplacement = session.Load<CountryCodeReplacement>("CountryCodeConfig"); } var cleanInternationalNumber = countryCodeReplacement != null ? countryCodeReplacement.CleanAndInternationaliseNumber(model.Number) : model.Number.Trim(); var sendOneMessageNow = new SendOneMessageNow { CorrelationId = model.MessageId, SmsData = new SmsData(cleanInternationalNumber, model.MessageBody), ConfirmationEmailAddress = model.ConfirmationEmail, SmsMetaData = new SmsMetaData { Tags = string.IsNullOrEmpty(model.Tags) ? null : model.Tags.Split(',').ToList().Select(t => t.Trim()).ToList(), Topic = model.Topic } }; Bus.Send(sendOneMessageNow); return RedirectToAction("Details", "SendNow", new { requestId = model.MessageId.ToString()}); } return View("Create", model); }
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 SmsServiceAuthenticationFailed() { var messageToSend = new SendOneMessageNow { SmsData = new SmsData("mobile", "message") }; var smsTechWrapper = MockRepository.GenerateMock<ISmsTechWrapper>(); var smsService = new SmsService { SmsTechWrapper = smsTechWrapper }; var smsMessageSending = new SendSmsResponse { Cost = (float)0.06, MessageId = 123456, Error = new Error { Code = "AUTH_FAILED", Description = "we don't know who you are!" } }; smsTechWrapper .Expect(t => t.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)) .Return(smsMessageSending); Assert.That(() => smsService.Send(messageToSend), Throws.Exception.TypeOf<SmsTechAuthenticationFailed>().With.Message.EqualTo(smsMessageSending.Error.Description)); }
/// <summary> /// This method will never get success / fail of message delivery - just that it is valid, and how much it will cost /// </summary> /// <param name="messageToSend"></param> /// <returns></returns> public SmsStatus Send(SendOneMessageNow messageToSend) { var createdSmsMessage = SmsTechWrapper.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message); if (createdSmsMessage.Error.Code.Equals("AUTH_FAILED")) throw new SmsTechAuthenticationFailed(createdSmsMessage.Error.Description); if (createdSmsMessage.Error.Code.Equals("LEDGER_ERROR")) throw new AccountOutOfMoneyException("Could not send message - account is currently out of money"); if (createdSmsMessage.Error.Code.Equals("RECIPIENTS_ERROR")) return new SmsFailed(createdSmsMessage.MessageId.ToString(), createdSmsMessage.Error.Code, createdSmsMessage.Error.Description); if (createdSmsMessage.Error.Code.Equals("SUCCESS")) return new SmsSending(createdSmsMessage.MessageId.ToString(), Convert.ToDecimal(createdSmsMessage.Cost)); throw new ArgumentException("Error code expected"); }
public void SmsServiceOutOfMoney() { var messageToSend = new SendOneMessageNow { SmsData = new SmsData("mobile", "message") }; var smsTechWrapper = MockRepository.GenerateMock<ISmsTechWrapper>(); var smsService = new SmsService { SmsTechWrapper = smsTechWrapper }; var smsMessageSending = new SendSmsResponse { Cost = (float)0.06, MessageId = 123456, Error = new Error { Code = "LEDGER_ERROR", Description = "can't send a message to those dudes!" } }; const string accountIsCurrentlyOutOfMoney = "Could not send message - account is currently out of money"; smsTechWrapper .Expect(t => t.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)) .Return(smsMessageSending); Assert.That(() => smsService.Send(messageToSend), Throws.Exception.TypeOf<AccountOutOfMoneyException>().With.Message.EqualTo(accountIsCurrentlyOutOfMoney)); }
public void SendSingleSmsNow_Failure() { var sendOneMessageNow = new SendOneMessageNow(); var smsService = MockRepository.GenerateMock<ISmsService>(); var smsSent = new SmsFailed("sid", "code", "message"); smsService.Expect(s => s.Send(sendOneMessageNow)).Return(smsSent); Test.Initialize(); Test.Saga<SmsActioner.SmsActioner>() .WithExternalDependencies(a => a.SmsService = smsService) .ExpectPublish<MessageFailedSending>() .When(a => a.Handle(sendOneMessageNow)) .AssertSagaCompletionIs(true); }
public void SmsServiceSending() { var messageToSend = new SendOneMessageNow { SmsData = new SmsData("mobile", "message") }; var twilioWrapper = MockRepository.GenerateMock<ITwilioWrapper>(); var smsService = new SmsService { TwilioWrapper = twilioWrapper }; var smsMessageSending = new SMSMessage { Status = "sending", Sid = "sidReceipt" }; twilioWrapper .Expect(t => t.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)) .Return(smsMessageSending); var response = smsService.Send(messageToSend); Assert.That(response, Is.TypeOf(typeof (SmsSending))); Assert.That(response.Sid, Is.EqualTo(smsMessageSending.Sid)); twilioWrapper.VerifyAllExpectations(); }
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 SendSingleSmsNow_QueuedReturnedIsInvalid_HasNoPrice() { var sendOneMessageNow = new SendOneMessageNow(); var smsService = MockRepository.GenerateMock<ISmsService>(); var smsQueued = new SmsQueued("sid"); smsService.Expect(s => s.Send(sendOneMessageNow)).Return(smsQueued); Test.Initialize(); Assert.That(() => Test.Saga<SmsActioner.SmsActioner>() .WithExternalDependencies(a => a.SmsService = smsService) .ExpectPublish<MessageSent>() .When(a => a.Handle(sendOneMessageNow)), Throws.Exception.With.Message.Contains("SmsQueued type is invalid - followup is required to get delivery status") ); }
public void SendOneMessageNow_SmsQueued_InvalidThrowsException() { var sendOneMessageNow = new SendOneMessageNow(); var smsService = MockRepository.GenerateMock<ISmsService>(); var smsQueued = new SmsQueued("sid"); smsService .Expect(s => s.Send(sendOneMessageNow)) .Return(smsQueued); var smsActioner = new SmsActioner.SmsActioner { SmsService = smsService }; Assert.That(() => smsActioner.Handle(sendOneMessageNow), Throws.Exception.With.Message.Contains("SmsQueued type is invalid - followup is required to get delivery status")); }
public void ValidSendsMessageReturnsToDetails() { var bus = MockRepository.GenerateMock<IBus>(); var sentMessage = new SendOneMessageNow(); bus.Expect(b => b.Send(Arg<SendOneMessageNow>.Is.NotNull)) .WhenCalled(a => sentMessage = ((SendOneMessageNow)((object[])a.Arguments[0])[0])); var controller = new SendNowController { ControllerContext = new ControllerContext(), Bus = bus }; var sendNowModel = new SendNowModel { MessageBody = "asdflj", Number = "number" , ConfirmationEmail = "sdakflj" }; var result = (RedirectToRouteResult)controller.Create(sendNowModel); Assert.That(result.RouteValues["action"], Is.EqualTo("Details")); Assert.That(sentMessage.SmsData.Mobile, Is.EqualTo(sendNowModel.Number)); Assert.That(sentMessage.SmsData.Message, Is.EqualTo(sendNowModel.MessageBody)); Assert.That(sentMessage.ConfirmationEmailAddress, Is.EqualTo(sendNowModel.ConfirmationEmail)); bus.VerifyAllExpectations(); }
public void SmsServiceSending() { var messageToSend = new SendOneMessageNow { SmsData = new SmsData("mobile", "message") }; var smsTechWrapper = MockRepository.GenerateMock<ISmsTechWrapper>(); var smsService = new SmsService { SmsTechWrapper = smsTechWrapper }; var smsMessageSending = new SendSmsResponse {Cost = (float) 0.06, MessageId = 123456, Error = new Error { Code = "SUCCESS"} }; smsTechWrapper .Expect(t => t.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)) .Return(smsMessageSending); var response = smsService.Send(messageToSend); Assert.That(response, Is.TypeOf(typeof (SmsSending))); Assert.That(response.Sid, Is.EqualTo(smsMessageSending.MessageId.ToString())); var smsSending = response as SmsSending; Assert.That(smsSending.Price, Is.EqualTo(smsMessageSending.Cost)); smsTechWrapper.VerifyAllExpectations(); }
public void SmsServiceInvalidNumber() { var messageToSend = new SendOneMessageNow { SmsData = new SmsData("mobile", "message") }; var smsTechWrapper = MockRepository.GenerateMock<ISmsTechWrapper>(); var smsService = new SmsService { SmsTechWrapper = smsTechWrapper }; var smsMessageSending = new SendSmsResponse { Cost = (float)0.06, MessageId = 123456, Error = new Error { Code = "RECIPIENTS_ERROR", Description = "can't send a message to those dudes!"} }; smsTechWrapper .Expect(t => t.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)) .Return(smsMessageSending); var response = smsService.Send(messageToSend); Assert.That(response, Is.TypeOf(typeof(SmsFailed))); Assert.That(response.Sid, Is.EqualTo(smsMessageSending.MessageId.ToString())); var smsFailed = response as SmsFailed; Assert.That(smsFailed.Code, Is.EqualTo(smsMessageSending.Error.Code)); Assert.That(smsFailed.Message, Is.EqualTo(smsMessageSending.Error.Description)); smsTechWrapper.VerifyAllExpectations(); }
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>() .WithExternalDependencies(a => a.SmsService = smsService) .ExpectTimeoutToBeSetIn<SmsPendingTimeout>((timeoutMessage, timespan) => timespan == TimeSpan.FromSeconds(10)) .When(a => a.Handle(sendOneMessageNow)) .ExpectPublish<MessageSent>() .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>() .WithExternalDependencies(a => a.SmsService = smsService) .ExpectTimeoutToBeSetIn<SmsPendingTimeout>((timeoutMessage, timespan) => timespan == TimeSpan.FromSeconds(10)) .When(a => a.Handle(sendOneMessageNow)) .ExpectNotPublish<MessageSent>() .WhenSagaTimesOut() .AssertSagaCompletionIs(true); }
public void SmsServiceSendingFails() { var messageToSend = new SendOneMessageNow { SmsData = new SmsData("mobile", "message") }; var twilioWrapper = MockRepository.GenerateMock<ITwilioWrapper>(); var smsService = new SmsService { TwilioWrapper = twilioWrapper }; var smsMessageSending = new SMSMessage { Status = "failed", Sid = "sidReceipt", RestException = new RestException {Code = "code", Message = "message", MoreInfo = "moreInfo", Status = "status"}}; twilioWrapper .Expect(t => t.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)) .Return(smsMessageSending); var response = smsService.Send(messageToSend); Assert.That(response, Is.TypeOf(typeof(SmsFailed))); Assert.That(response.Sid, Is.EqualTo(smsMessageSending.Sid)); var smsFailed = response as SmsFailed; Assert.That(smsFailed.Status, Is.EqualTo(smsMessageSending.RestException.Status)); Assert.That(smsFailed.Code, Is.EqualTo(smsMessageSending.RestException.Code)); Assert.That(smsFailed.Message, Is.EqualTo(smsMessageSending.RestException.Message)); Assert.That(smsFailed.MoreInfo, Is.EqualTo(smsMessageSending.RestException.MoreInfo)); twilioWrapper.VerifyAllExpectations(); }
public void SendOneMessageNow_SmsFailed() { var sendOneMessageNow = new SendOneMessageNow { ConfirmationEmailAddress = "*****@*****.**", CorrelationId = Guid.NewGuid(), SmsData = new SmsData("mobile", "message"), SmsMetaData = new SmsMetaData { Tags = new List<string> { "tag1", "tag2" }, Topic = "topic" } }; var smsService = MockRepository.GenerateMock<ISmsService>(); var smsFailed = new SmsFailed("sid", "faile", "why why why"); smsService .Expect(s => s.Send(sendOneMessageNow)) .Return(smsFailed); var data = new SmsActionerData(); Test.Initialize(); Test.Saga<SmsActioner.SmsActioner>() .WithExternalDependencies(a => { a.SmsService = smsService; a.Data = data; }) .WhenReceivesMessageFrom("somewhere") .ExpectPublish<MessageFailedSending>(message => message.ConfirmationEmailAddress == sendOneMessageNow.ConfirmationEmailAddress && message.CorrelationId == sendOneMessageNow.CorrelationId && message.SmsData == sendOneMessageNow.SmsData && message.SmsMetaData == sendOneMessageNow.SmsMetaData && message.SmsFailed == smsFailed ) .When(a => a.Handle(sendOneMessageNow)) .AssertSagaCompletionIs(true); smsService.VerifyAllExpectations(); }
public ActionResult Create(SendNowModel model) { var isValid = TryValidateModel(model); if(isValid) { model.MessageId = Guid.NewGuid(); if (model.MessageBody.Length > 160) model.MessageBody = model.MessageBody.Substring(0, 160); var sendOneMessageNow = new SendOneMessageNow { CorrelationId = model.MessageId, SmsData = new SmsData(model.Number, model.MessageBody), ConfirmationEmailAddress = model.ConfirmationEmail, SmsMetaData = new SmsMetaData { Tags = string.IsNullOrEmpty(model.Tags) ? null : model.Tags.Split(',').ToList().Select(t => t.Trim()).ToList(), Topic = model.Topic } }; Bus.Send(sendOneMessageNow); return RedirectToAction("Details", "SendNow", new { requestId = model.MessageId.ToString()}); } return View("Create", model); }
public void TimeoutHandle_CheckStatus_SmsQueued_RequestsTimeout() { var timeout = new SmsPendingTimeout(); var sendOneMessageNow = new SendOneMessageNow(); var data = new SmsActionerData { Id = Guid.NewGuid(), OriginalMessage = sendOneMessageNow, Price = 0.06m, SmsRequestId = "123", NumberOfTimeoutRequests = 1 }; var smsService = MockRepository.GenerateMock<ISmsService>(); var timeoutCalculator = MockRepository.GenerateMock<ITimeoutCalculator>(); var smsQueued = new SmsQueued(data.SmsRequestId); smsService .Expect(s => s.CheckStatus(data.SmsRequestId)) .Return(smsQueued); var timeoutTimespan = new TimeSpan(); timeoutCalculator.Expect(t => t.RequiredTimeout(data.NumberOfTimeoutRequests)).Return(timeoutTimespan); Test.Initialize(); Test.Saga<SmsActioner.SmsActioner>() .WithExternalDependencies(a => { a.SmsService = smsService; a.Data = data; a.TimeoutCalculator = timeoutCalculator; }) .WhenReceivesMessageFrom("somewhere") .ExpectTimeoutToBeSetIn<SmsPendingTimeout>((timeoutMessage, timespan) => timespan == timeoutTimespan) .When(a => a.Timeout(timeout)) .AssertSagaCompletionIs(false); Assert.That(data.NumberOfTimeoutRequests, Is.EqualTo(2)); smsService.VerifyAllExpectations(); timeoutCalculator.VerifyAllExpectations(); }
public void SmsServiceSuccess() { var messageToSend = new SendOneMessageNow { SmsData = new SmsData("mobile", "message")}; var twilioWrapper = MockRepository.GenerateMock<ITwilioWrapper>(); var smsService = new SmsService { TwilioWrapper = twilioWrapper }; var smsMessage = new SMSMessage { Status = "sent", Sid = "sidReceipt", DateSent = DateTime.Now, Price = 3 }; twilioWrapper .Expect(t => t.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)) .Return(smsMessage); var response = smsService.Send(messageToSend); Assert.That(response, Is.TypeOf(typeof(SmsSent))); Assert.That(response.Sid, Is.EqualTo(smsMessage.Sid)); var smsSent = response as SmsSent; Assert.That(smsSent.SmsConfirmationData.Receipt, Is.EqualTo(smsMessage.Sid)); Assert.That(smsSent.SmsConfirmationData.SentAtUtc, Is.EqualTo(smsMessage.DateSent)); Assert.That(smsSent.SmsConfirmationData.Price, Is.EqualTo(smsMessage.Price)); twilioWrapper.VerifyAllExpectations(); }
public void SendSingleSmsNowQueuedTwiceThenSuccess() { var sendOneMessageNow = new SendOneMessageNow(); var smsService = MockRepository.GenerateMock<ISmsService>(); const string sid = "12"; var smsQueued = new SmsQueued(sid); var smsSuccess = new SmsSent(new SmsConfirmationData("r", DateTime.Now, 3.3m)); smsService.Expect(s => s.Send(sendOneMessageNow)).Return(smsQueued); smsService.Expect(s => s.CheckStatus(smsQueued.Sid)).Repeat.Once().Return(smsQueued); smsService.Expect(s => s.CheckStatus(smsQueued.Sid)).Return(smsSuccess); 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>() .ExpectTimeoutToBeSetIn<SmsPendingTimeout>((timeoutMessage, timespan) => timespan == TimeSpan.FromSeconds(10)) .WhenSagaTimesOut() .ExpectPublish<MessageSent>() .ExpectReplyToOriginator<MessageSuccessfullyDelivered>() .ExpectSendLocal<MessageSuccessfullyDelivered>() .WhenSagaTimesOut(); }
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 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)((object[])(i.Arguments[0]))[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 SmsStatus Send(SendOneMessageNow messageToSend) { var createdSmsMessage = TwilioWrapper.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message); return ProcessSms(createdSmsMessage); }
public void SmsServiceSending_WithoutERRORCode_ThrowsException() { var messageToSend = new SendOneMessageNow { SmsData = new SmsData("mobile", "message") }; var smsTechWrapper = MockRepository.GenerateMock<ISmsTechWrapper>(); var smsService = new SmsService { SmsTechWrapper = smsTechWrapper }; var smsMessageSending = new SendSmsResponse {Cost = (float) 0.06, MessageId = 123456, Error = new Error { Code = string.Empty } }; smsTechWrapper .Expect(t => t.SendSmsMessage(messageToSend.SmsData.Mobile, messageToSend.SmsData.Message)) .Return(smsMessageSending); Assert.That(() => smsService.Send(messageToSend), Throws.ArgumentException.With.Message.Contains("Error code expected")); smsTechWrapper.VerifyAllExpectations(); }
public void TimeoutHandle_CheckStatus_SmsSent() { var timeout = new SmsPendingTimeout(); var sendOneMessageNow = new SendOneMessageNow { ConfirmationEmailAddress = "*****@*****.**", CorrelationId = Guid.NewGuid(), SmsData = new SmsData("mobile", "message"), SmsMetaData = new SmsMetaData { Tags = new List<string> { "tag1", "tag2" }, Topic = "topic" } }; var data = new SmsActionerData { Id = Guid.NewGuid(), OriginalMessage = sendOneMessageNow, Price = 0.06m, SmsRequestId = "123" }; var smsService = MockRepository.GenerateMock<ISmsService>(); var smsSent = new SmsSent("doesn't matter", DateTime.Now); smsService .Expect(s => s.CheckStatus(data.SmsRequestId)) .Return(smsSent); Test.Initialize(); Test.Saga<SmsActioner.SmsActioner>() .WithExternalDependencies(a => { a.SmsService = smsService; a.Data = data; }) .WhenReceivesMessageFrom("somewhere") .ExpectPublish<MessageSent>(message => message.ConfirmationEmailAddress == sendOneMessageNow.ConfirmationEmailAddress && message.CorrelationId == sendOneMessageNow.CorrelationId && message.SmsData == sendOneMessageNow.SmsData && message.SmsMetaData == sendOneMessageNow.SmsMetaData && message.ConfirmationData.Price == data.Price && message.ConfirmationData.Receipt == data.SmsRequestId && message.ConfirmationData.SentAtUtc == smsSent.SentAtUtc ) .When(a => a.Timeout(timeout)) .AssertSagaCompletionIs(true); smsService.VerifyAllExpectations(); }