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);
}
