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