public void PauseMessageSetsSchedulePauseFlag_Data()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {SmsData = new SmsData("1", "2")};
var data = new ScheduledSmsData
{
OriginalMessage = scheduleSmsForSendingLater,
OriginalMessageData = new OriginalMessageData(scheduleSmsForSendingLater)
};
var scheduleId = Guid.NewGuid();
var pauseScheduledMessageIndefinitely = new PauseScheduledMessageIndefinitely(scheduleId);
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => { a.Data = data; })
.WhenReceivesMessageFrom("place")
.ExpectSendLocal<ScheduleStatusChanged>(s =>
{
return s.Status == MessageStatus.Paused &&
s.ScheduleId == pauseScheduledMessageIndefinitely.ScheduleMessageId &&
s.RequestTimeUtc == pauseScheduledMessageIndefinitely.MessageRequestTimeUtc;
})
.When(s => s.Handle(pauseScheduledMessageIndefinitely));
Assert.IsTrue(data.SchedulingPaused);
}
public void ScheduleValidCountryCodeReplacementNotSetSendsMessageReturnsToDetails()
{
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(new CountryCodeReplacement());
var controller = new ScheduleController { ControllerContext = new ControllerContext(), Bus = bus, RavenDocStore = ravenDocStore };
var scheduledTime = DateTime.Now.AddHours(1);
var sendNowModel = new ScheduleModel { Number = "number", MessageBody = "m", ScheduledTime = scheduledTime };
var scheduledMessage = new ScheduleSmsForSendingLater();
bus.Expect(b => b.Send(Arg<ScheduleSmsForSendingLater>.Is.NotNull))
.WhenCalled(a => scheduledMessage = ((ScheduleSmsForSendingLater)((object[])a.Arguments[0])[0]));
var result = (RedirectToRouteResult)controller.Create(sendNowModel);
Assert.That(result.RouteValues["action"], Is.EqualTo("Details"));
Assert.That(scheduledMessage.SendMessageAtUtc.ToString(), Is.EqualTo(scheduledTime.ToUniversalTime().ToString()));
Assert.That(scheduledMessage.SmsData.Mobile, Is.EqualTo(sendNowModel.Number));
Assert.That(scheduledMessage.SmsData.Message, Is.EqualTo(sendNowModel.MessageBody));
}
public ActionResult Create(ScheduleModel schedule)
{
if (schedule.ScheduledTime < DateTime.Now)
ModelState.AddModelError("ScheduledTime", "Schedule time must be in the future");
var isValid = TryValidateModel(schedule);
if (isValid)
{
if (schedule.MessageBody.Length > 160)
schedule.MessageBody = schedule.MessageBody.Substring(0, 160);
var scheduleMessage = new ScheduleSmsForSendingLater
{
SendMessageAtUtc = schedule.ScheduledTime.ToUniversalTime(),
SmsData = new SmsData(schedule.Number, schedule.MessageBody),
ScheduleMessageId = Guid.NewGuid(),
SmsMetaData = new SmsMetaData
{
Tags = string.IsNullOrWhiteSpace(schedule.Tags) ? null : schedule.Tags.Split(',').ToList(),
Topic = schedule.Topic
},
ConfirmationEmail = schedule.ConfirmationEmail
};
Bus.Send(scheduleMessage);
return RedirectToAction("Details", "Schedule", new { scheduleId = scheduleMessage.ScheduleMessageId.ToString() });
}
return View("Create", schedule);
}
public ActionResult Create(ScheduleModel schedule)
{
if (schedule.ScheduledTime < DateTime.Now)
ModelState.AddModelError("ScheduledTime", "Schedule time must be in the future");
var isValid = TryValidateModel(schedule);
if (isValid)
{
if (schedule.MessageBody.Length > 160)
schedule.MessageBody = schedule.MessageBody.Substring(0, 160);
CountryCodeReplacement countryCodeReplacement;
using (var session = RavenDocStore.GetStore().OpenSession("Configuration"))
{
countryCodeReplacement = session.Load<CountryCodeReplacement>("CountryCodeConfig");
}
var cleanInternationalNumber = countryCodeReplacement != null ? countryCodeReplacement.CleanAndInternationaliseNumber(schedule.Number) : schedule.Number.Trim();
var scheduleMessage = new ScheduleSmsForSendingLater
{
SendMessageAtUtc = schedule.ScheduledTime.ToUniversalTime(),
SmsData = new SmsData(cleanInternationalNumber, schedule.MessageBody),
ScheduleMessageId = Guid.NewGuid(),
SmsMetaData = new SmsMetaData
{
Tags = string.IsNullOrWhiteSpace(schedule.Tags) ? null : schedule.Tags.Split(',').ToList(),
Topic = schedule.Topic
},
ConfirmationEmail = schedule.ConfirmationEmail
};
Bus.Send(scheduleMessage);
return RedirectToAction("Details", "Schedule", new { scheduleId = scheduleMessage.ScheduleMessageId.ToString() });
}
return View("Create", schedule);
}
public void ReschedulePausedSchedule_Data()
{
var sagaId = Guid.NewGuid();
var scheduleMessageId = Guid.NewGuid();
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData(), SendMessageAtUtc = DateTime.Now};
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
ScheduleMessageId = scheduleMessageId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = scheduleSmsForSendingLater,
OriginalMessageData = new OriginalMessageData(scheduleSmsForSendingLater)
};
Test.Initialize();
var rescheduleMessage = new RescheduleScheduledMessageWithNewTime(scheduleMessageId, new DateTime(2040, 4, 4, 4,4,4, DateTimeKind.Utc));
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; })
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, span) => span == rescheduleMessage.NewScheduleTimeUtc)
.ExpectPublish<MessageRescheduled>()
.When(s => s.Handle(rescheduleMessage));
Assert.IsFalse(scheduledSmsData.SchedulingPaused);
}
public void OriginalMessageGetsSavedToSaga_Data()
{
var data = new ScheduledSmsData();
var originalMessage = new ScheduleSmsForSendingLater { SendMessageAtUtc = DateTime.Now };
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => { a.Data = data; })
.WhenReceivesMessageFrom("address")
.ExpectPublish<SmsScheduled>(m => m.CoordinatorId == data.Id && m.ScheduleMessageId == originalMessage.ScheduleMessageId)
.When(s => s.Handle(originalMessage));
Assert.That(data.OriginalMessage, Is.EqualTo(originalMessage));
}
public void ScheduleValidSendsMessageReturnsToDetails()
{
var bus = MockRepository.GenerateMock<IBus>();
var controller = new ScheduleController { ControllerContext = new ControllerContext(), Bus = bus};
var scheduledTime = DateTime.Now.AddHours(1);
var sendNowModel = new ScheduleModel { Number = "number", MessageBody = "m", ScheduledTime = scheduledTime };
var scheduledMessage = new ScheduleSmsForSendingLater();
bus.Expect(b => b.Send(Arg<ScheduleSmsForSendingLater>.Is.NotNull))
.WhenCalled(a => scheduledMessage = ((ScheduleSmsForSendingLater)((object[])a.Arguments[0])[0]));
var result = (RedirectToRouteResult)controller.Create(sendNowModel);
Assert.That(result.RouteValues["action"], Is.EqualTo("Details"));
Assert.That(scheduledMessage.SendMessageAtUtc.ToString(), Is.EqualTo(scheduledTime.ToUniversalTime().ToString()));
Assert.That(scheduledMessage.SmsData.Mobile, Is.EqualTo(sendNowModel.Number));
Assert.That(scheduledMessage.SmsData.Message, Is.EqualTo(sendNowModel.MessageBody));
}
public void OriginalMessageGetsSavedToSaga_Data()
{
var data = new ScheduledSmsData();
var originalMessage = new ScheduleSmsForSendingLater { SendMessageAtUtc = DateTime.Now };
StoreDocument(new ScheduleTrackingData { ScheduleId = originalMessage.ScheduleMessageId, MessageStatus = MessageStatus.WaitingForScheduling}, originalMessage.ScheduleMessageId.ToString());
var ravenDocStore = MockRepository.GenerateMock<IRavenDocStore>();
ravenDocStore.Expect(r => r.GetStore().OpenSession("SmsTracking")).Return(DocumentStore.OpenSession());
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => { a.Data = data; a.RavenDocStore = ravenDocStore; })
.WhenReceivesMessageFrom("address")
.ExpectPublish<SmsScheduled>(m => m.CoordinatorId == data.Id && m.ScheduleMessageId == originalMessage.ScheduleMessageId)
.When(s => s.Handle(originalMessage));
Assert.That(data.OriginalMessage, Is.EqualTo(originalMessage));
var schedule = GetSchedule(originalMessage.ScheduleMessageId.ToString());
Assert.That(schedule.MessageStatus, Is.EqualTo(MessageStatus.Scheduled));
}
public void ScheduleSmsForSendingLater()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater { SendMessageAtUtc = DateTime.Now.AddDays(1), ScheduleMessageId = Guid.NewGuid() };
var sagaId = Guid.NewGuid();
var messageSent = new MessageSent { ConfirmationData = new SmsConfirmationData("a", DateTime.Now, 3), SmsData = new SmsData("1", "2") };
var ravenDocStore = MockRepository.GenerateMock<IRavenDocStore>();
ravenDocStore.Expect(r => r.GetStore().OpenSession("SmsTracking")).Return(DocumentStore.OpenSession());
StoreDocument(new ScheduleTrackingData { ScheduleId = scheduleSmsForSendingLater.ScheduleMessageId, MessageStatus = MessageStatus.WaitingForScheduling }, scheduleSmsForSendingLater.ScheduleMessageId.ToString());
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData() }
};
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; a.RavenDocStore = ravenDocStore; })
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc)
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectSend<SendOneMessageNow>()
.WhenSagaTimesOut()
.ExpectPublish<ScheduledSmsSent>()
.When(s => s.Handle(messageSent))
.AssertSagaCompletionIs(true);
var scheduleTrackingData = GetSchedule(scheduleSmsForSendingLater.ScheduleMessageId.ToString());
Assert.That(scheduleTrackingData.MessageStatus, Is.EqualTo(MessageStatus.Sent));
}
public void ScheduleSmsForSendingLater()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater { SendMessageAtUtc = DateTime.Now.AddDays(1) };
var sagaId = Guid.NewGuid();
var messageSent = new MessageSent { ConfirmationData = new SmsConfirmationData("a", DateTime.Now, 3), SmsData = new SmsData("1", "2") };
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData() }
};
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => a.Data = scheduledSmsData)
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc)
//.ExpectSend<ScheduleCreated>()
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectSend<SendOneMessageNow>()
.WhenSagaTimesOut()
.ExpectPublish<ScheduledSmsSent>()
//.ExpectSend<ScheduleComplete>()
.When(s => s.Handle(messageSent))
.AssertSagaCompletionIs(true);
}
public void TimeoutSendingPausedNoAction_Data()
{
var bus = MockRepository.GenerateStrictMock<IBus>();
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, SchedulingPaused = true };
var scheduleSms = new ScheduleSms { Bus = bus, Data = data };
var timeoutMessage = new ScheduleSmsTimeout();
scheduleSms.Timeout(timeoutMessage);
bus.VerifyAllExpectations();
}
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 void ScheduleSmsForSendingLaterButIsPausedThenResumedOutOfOrderAndSent()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater { SendMessageAtUtc = DateTime.Now.AddDays(1), SmsData = new SmsData("1", "2") };
var sagaId = Guid.NewGuid();
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData() }
};
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => a.Data = scheduledSmsData)
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc && state.TimeoutCounter == 0)
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => state.TimeoutCounter == 1)
.ExpectPublish<MessageRescheduled>()
.When(s => s.Handle(new ResumeScheduledMessageWithOffset(Guid.Empty, new TimeSpan()) { MessageRequestTimeUtc = DateTime.Now }))
.When(s => s.Handle(new PauseScheduledMessageIndefinitely(Guid.Empty) { MessageRequestTimeUtc = DateTime.Now.AddMinutes(-10)}))
.ExpectSend<SendOneMessageNow>()
.When(s => s.Timeout(new ScheduleSmsTimeout { TimeoutCounter = 1}))
.ExpectPublish<ScheduledSmsSent>()
.When(s => s.Handle(new MessageSent { ConfirmationData = new SmsConfirmationData("a", DateTime.Now, 3), SmsData = new SmsData("1", "2") }))
.AssertSagaCompletionIs(true);
}
public void ScheduleSmsForSendingLaterButIsPaused()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater { SendMessageAtUtc = DateTime.Now.AddDays(1), SmsData = new SmsData("1", "2")};
var sagaId = Guid.NewGuid();
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = "one",
OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData() }
};
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => a.Data = scheduledSmsData)
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc)
//.ExpectSend<ScheduleCreated>()
.When(s => s.Handle(scheduleSmsForSendingLater))
//.ExpectSend<SchedulePaused>()
.ExpectPublish<MessageSchedulePaused>()
.When(s => s.Handle(new PauseScheduledMessageIndefinitely(Guid.Empty)))
.ExpectNotSend<SendOneMessageNow>(now => false)
.WhenSagaTimesOut();
}
public void ScheduleSmsForSendingLaterButIsPausedThenResumedOutOfOrderAndSent()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater { SendMessageAtUtc = DateTime.Now.AddDays(1), SmsData = new SmsData("1", "2"), ScheduleMessageId = Guid.NewGuid()};
var sagaId = Guid.NewGuid();
var ravenDocStore = MockRepository.GenerateMock<IRavenDocStore>();
ravenDocStore.Expect(r => r.GetStore().OpenSession("SmsTracking")).Return(DocumentStore.OpenSession());
StoreDocument(new ScheduleTrackingData { ScheduleId = scheduleSmsForSendingLater.ScheduleMessageId, MessageStatus = MessageStatus.WaitingForScheduling }, scheduleSmsForSendingLater.ScheduleMessageId.ToString());
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData() }
};
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; a.RavenDocStore = ravenDocStore; })
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc && state.TimeoutCounter == 0)
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => state.TimeoutCounter == 1)
.ExpectPublish<MessageRescheduled>()
.When(s => s.Handle(new ResumeScheduledMessageWithOffset(Guid.Empty, new TimeSpan()) { MessageRequestTimeUtc = DateTime.Now }))
.When(s => s.Handle(new PauseScheduledMessageIndefinitely(Guid.Empty) { MessageRequestTimeUtc = DateTime.Now.AddMinutes(-10)}))
.ExpectSend<SendOneMessageNow>()
.When(s => s.Timeout(new ScheduleSmsTimeout { TimeoutCounter = 1}))
.ExpectPublish<ScheduledSmsSent>()
.When(s => s.Handle(new MessageSent { ConfirmationData = new SmsConfirmationData("a", DateTime.Now, 3), SmsData = new SmsData("1", "2") }))
.AssertSagaCompletionIs(true);
var scheduleTrackingData = GetSchedule(scheduleSmsForSendingLater.ScheduleMessageId.ToString());
Assert.That(scheduleTrackingData.MessageStatus, Is.EqualTo(MessageStatus.Sent));
}
public void ResumePausedSchedule_Data()
{
var sagaId = Guid.NewGuid();
var scheduleMessageId = Guid.NewGuid();
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData(), SendMessageAtUtc = DateTime.Now};
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
ScheduleMessageId = scheduleMessageId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = scheduleSmsForSendingLater,
OriginalMessageData = new OriginalMessageData(scheduleSmsForSendingLater)
};
Test.Initialize();
var rescheduleMessage = new ResumeScheduledMessageWithOffset(scheduleMessageId, new TimeSpan(0, 1, 0, 0));
var rescheduledTime = scheduledSmsData.OriginalMessage.SendMessageAtUtc.Add(rescheduleMessage.Offset);
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; })
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, span) => span == rescheduledTime)
.ExpectPublish<MessageRescheduled>()
.When(s => s.Handle(rescheduleMessage));
}
public void ScheduleSmsForSendingLaterButIsPaused()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater { SendMessageAtUtc = DateTime.Now.AddDays(1), SmsData = new SmsData("1", "2"), ScheduleMessageId = Guid.NewGuid()};
var sagaId = Guid.NewGuid();
var ravenDocStore = MockRepository.GenerateMock<IRavenDocStore>();
ravenDocStore.Expect(r => r.GetStore().OpenSession("SmsTracking")).Return(DocumentStore.OpenSession());
StoreDocument(new ScheduleTrackingData { ScheduleId = scheduleSmsForSendingLater.ScheduleMessageId, MessageStatus = MessageStatus.WaitingForScheduling }, scheduleSmsForSendingLater.ScheduleMessageId.ToString());
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = "one",
OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData() }
};
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; a.RavenDocStore = ravenDocStore; })
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc)
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectPublish<MessageSchedulePaused>()
.When(s => s.Handle(new PauseScheduledMessageIndefinitely(Guid.Empty)))
.ExpectNotSend<SendOneMessageNow>(now => false)
.WhenSagaTimesOut();
var scheduleTrackingData = GetSchedule(scheduleSmsForSendingLater.ScheduleMessageId.ToString());
Assert.That(scheduleTrackingData.MessageStatus, Is.EqualTo(MessageStatus.Paused));
}
public void ScheduleSmsForSendingLaterButFails()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater { SendMessageAtUtc = DateTime.Now.AddDays(1), ScheduleMessageId = Guid.NewGuid()};
var sagaId = Guid.NewGuid();
var messageFailed = new MessageFailedSending { SmsData = new SmsData("1", "2"), SmsFailed = new SmsFailed(string.Empty, string.Empty, string.Empty, string.Empty, string.Empty) };
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData() }
};
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; })
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc)
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectSend<SendOneMessageNow>()
.WhenSagaTimesOut()
.ExpectPublish<ScheduledSmsFailed>()
.ExpectSendLocal<ScheduleFailed>()
.When(s => s.Handle(messageFailed))
.AssertSagaCompletionIs(true);
}
public void ScheduleSmsForSendingLaterButIsPausedThenResumedAndSent()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater { SendMessageAtUtc = DateTime.Now.AddDays(1), SmsData = new SmsData("1", "2") };
var sagaId = Guid.NewGuid();
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData() }
};
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; })
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc && state.TimeoutCounter == 0)
.ExpectSendLocal<ScheduleCreated>()
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectPublish<MessageSchedulePaused>()
.ExpectSendLocal<ScheduleStatusChanged>(s => s.Status == MessageStatus.Paused)
.When(s => s.Handle(new PauseScheduledMessageIndefinitely(Guid.Empty)))
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, timeout) => state.TimeoutCounter == 1)
.ExpectPublish<MessageRescheduled>()
.ExpectSendLocal<ScheduleStatusChanged>(s => s.Status == MessageStatus.Scheduled)
.When(s => s.Handle(new ResumeScheduledMessageWithOffset(Guid.Empty, new TimeSpan())))
.ExpectNotSend<SendOneMessageNow>(now => false)
.When(s => s.Timeout(new ScheduleSmsTimeout { TimeoutCounter = 0 }))
.ExpectSend<SendOneMessageNow>()
.When(s => s.Timeout(new ScheduleSmsTimeout { TimeoutCounter = 1 }))
.ExpectPublish<ScheduledSmsSent>()
.ExpectSendLocal<ScheduleSucceeded>()
.When(s => s.Handle(new MessageSuccessfullyDelivered { ConfirmationData = new SmsConfirmationData("a", DateTime.Now, 3), SmsData = new SmsData("1", "2") }))
.AssertSagaCompletionIs(true);
}
