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 ScheduleSmsForSendingLaterButIsPaused()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {
SendMessageAtUtc = DateTime.Now.AddDays(1), SmsData = new SmsData("1", "2"), ScheduleMessageId = Guid.NewGuid()
};
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)
.ExpectSendLocal <ScheduleCreated>()
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectPublish <MessageSchedulePaused>()
.ExpectSendLocal <ScheduleStatusChanged>(s => s.Status == MessageStatus.Paused)
.When(s => s.Handle(new PauseScheduledMessageIndefinitely(Guid.Empty)))
.ExpectNotSend <SendOneMessageNow>(now => false)
.WhenSagaTimesOut();
}
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 ResumePausedSchedule_Data()
{
var sagaId = Guid.NewGuid();
var scheduleMessageId = Guid.NewGuid();
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
ScheduleMessageId = scheduleMessageId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData(),SendMessageAtUtc = DateTime.Now }
};
Test.Initialize();
var rescheduleMessage = new ResumeScheduledMessageWithOffset(scheduleMessageId, new TimeSpan(0, 1, 0, 0));
var resheduledTime = scheduledSmsData.OriginalMessage.SendMessageAtUtc.Add(rescheduleMessage.Offset);
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => a.Data = scheduledSmsData)
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, span) => span == resheduledTime)
//.ExpectSend<ScheduleResumed>(s =>
//{
// return s.ScheduleId == scheduleMessageId &&
// s.RescheduledTime == resheduledTime;
//})
.ExpectPublish<MessageRescheduled>()
.When(s => s.Handle(rescheduleMessage));
}
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 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 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)((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 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 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 ScheduleSmsForSendingLater()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {
SendMessageAtUtc = DateTime.Now.AddDays(1), ScheduleMessageId = Guid.NewGuid()
};
var sagaId = Guid.NewGuid();
var messageSent = new MessageSuccessfullyDelivered {
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)
.ExpectSendLocal <ScheduleCreated>()
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectSend <SendOneMessageNow>()
.WhenSagaTimesOut()
.ExpectPublish <ScheduledSmsSent>()
.ExpectSendLocal <ScheduleSucceeded>(s => { return(s.ConfirmationData == messageSent.ConfirmationData && s.ScheduleId == scheduleSmsForSendingLater.ScheduleMessageId); })
.When(s => s.Handle(messageSent))
.AssertSagaCompletionIs(true);
}
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 PauseMessageSetsSchedulePauseFlag_Data()
{
var data = new ScheduledSmsData { OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "2")}};
var scheduleId = Guid.NewGuid();
var pauseScheduledMessageIndefinitely = new PauseScheduledMessageIndefinitely(scheduleId);
Test.Initialize();
Test.Saga<ScheduleSms>()
.WithExternalDependencies(a => a.Data = data)
.WhenReceivesMessageFrom("place")
//.ExpectSend<SchedulePaused>(s => s.ScheduleId == scheduleId)
.When(s => s.Handle(pauseScheduledMessageIndefinitely));
Assert.IsTrue(data.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 ScheduleSmsForSendingLaterButIsPausedThenResumedOutOfOrderAndSent()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {
SendMessageAtUtc = DateTime.Now.AddDays(1), SmsData = new SmsData("1", "2"), ScheduleMessageId = Guid.NewGuid()
};
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))
.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())
{
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>()
.ExpectSendLocal <ScheduleSucceeded>()
.When(s => s.Handle(new MessageSuccessfullyDelivered {
ConfirmationData = new SmsConfirmationData("a", DateTime.Now, 3), SmsData = new SmsData("1", "2")
}))
.AssertSagaCompletionIs(true);
}
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 PauseMessageSetsSchedulePauseFlag_Data()
{
var data = new ScheduledSmsData { OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "2")}};
var scheduleId = Guid.NewGuid();
var pauseScheduledMessageIndefinitely = new PauseScheduledMessageIndefinitely(scheduleId);
StoreDocument(new ScheduleTrackingData { ScheduleId = data.OriginalMessage.ScheduleMessageId, MessageStatus = MessageStatus.Scheduled}, data.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("place")
.When(s => s.Handle(pauseScheduledMessageIndefinitely));
Assert.IsTrue(data.SchedulingPaused);
var schedule = GetSchedule(data.OriginalMessage.ScheduleMessageId.ToString());
Assert.That(schedule.MessageStatus, Is.EqualTo(MessageStatus.Paused));
}
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 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 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 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 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 ReschedulePausedSchedule_Data()
{
var sagaId = Guid.NewGuid();
var scheduleMessageId = Guid.NewGuid();
StoreDocument(new ScheduleTrackingData { ScheduleId = scheduleMessageId, MessageStatus = MessageStatus.Paused }, scheduleMessageId.ToString());
var ravenDocStore = MockRepository.GenerateMock<IRavenDocStore>();
ravenDocStore.Expect(r => r.GetStore().OpenSession("SmsTracking")).Return(DocumentStore.OpenSession());
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
ScheduleMessageId = scheduleMessageId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater { SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData(),SendMessageAtUtc = DateTime.Now }
};
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; a.RavenDocStore = ravenDocStore; })
.ExpectTimeoutToBeSetAt<ScheduleSmsTimeout>((state, span) => span == rescheduleMessage.NewScheduleTimeUtc)
.ExpectPublish<MessageRescheduled>()
.When(s => s.Handle(rescheduleMessage));
var schedule = GetSchedule(scheduleMessageId.ToString());
Assert.That(schedule.MessageStatus, Is.EqualTo(MessageStatus.Scheduled));
Assert.That(schedule.ScheduleTimeUtc, Is.EqualTo(rescheduleMessage.NewScheduleTimeUtc));
}
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);
}
