public async Task Should_handle_slightly_in_the_future_properly()
{
Task <ConsumeContext <A> > handler = SubscribeHandler <A>();
await QuartzEndpoint.ScheduleSend(Bus.Address, DateTime.UtcNow + TimeSpan.FromSeconds(2), new A { Name = "Joe" });
await handler;
}
public async Task Should_properly_send_the_message()
{
Task <ConsumeContext <A> > handler = SubscribeHandler <A>();
await QuartzEndpoint.ScheduleSend(Bus.Address, DateTime.UtcNow + TimeSpan.FromHours(-1), new A { Name = "Joe" });
await handler;
}
public async Task Should_handle_now_properly()
{
Task <ConsumeContext <A> > handler = SubscribeHandler <A>();
await QuartzEndpoint.ScheduleSend(Bus.Address, DateTime.UtcNow, new A { Name = "Joe" });
await handler;
}
public async void Should_handle_now_properly()
{
await QuartzEndpoint.ScheduleSend(InputQueueAddress, DateTime.UtcNow + TimeSpan.FromSeconds(20), new Done { Name = "Joe" });
await QuartzEndpoint.ScheduleRecurringSend(InputQueueAddress, new MySchedule(), new Interval { Name = "Joe" });
await _done;
Assert.AreEqual(8, _count, "Expected to see 8 interval messages");
}
public async Task Should_be_able_to_cancel_a_future_event()
{
Task <ConsumeContext <A> > handler = SubscribeHandler <A>();
var scheduledMessage = await QuartzEndpoint.ScheduleSend(Bus.Address, DateTime.UtcNow + TimeSpan.FromSeconds(120), new A { Name = "Joe" });
await Task.Delay(2000);
await QuartzEndpoint.CancelScheduledSend(scheduledMessage);
await Task.Delay(2000);
}
public async void Should_contain_additional_headers_that_provide_time_domain_context()
{
var scheduleId = Guid.NewGuid().ToString();
await QuartzEndpoint.ScheduleSend(InputQueueAddress, DateTime.UtcNow + TimeSpan.FromSeconds(10), new Done { Name = "Joe" });
var scheduledRecurringMessage = await QuartzEndpoint.ScheduleRecurringSend(InputQueueAddress, new MySchedule(), new Interval { Name = "Joe" });
await _done;
Assert.Greater(_count, 0, "Expected to see at least one interval");
Assert.IsNotNull(_lastInterval.Headers.Get <DateTimeOffset>(MessageHeaders.Quartz.Scheduled, null));
Assert.IsNotNull(_lastInterval.Headers.Get <DateTimeOffset>(MessageHeaders.Quartz.Sent, null));
//Assert.IsNotNull(_lastInterval.Headers.Get<DateTimeOffset>("NextFireTimeUtc", null));
Assert.IsNotNull(_lastInterval.Headers.Get <DateTimeOffset>(MessageHeaders.Quartz.PreviousSent, null));
}
public async Task Should_cancel_recurring_schedule()
{
var scheduleId = Guid.NewGuid().ToString();
await QuartzEndpoint.ScheduleSend(InputQueueAddress, DateTime.UtcNow + TimeSpan.FromSeconds(10), new Done { Name = "Joe" });
var scheduledRecurringMessage = await QuartzEndpoint.ScheduleRecurringSend(InputQueueAddress, new MyCancelableSchedule(scheduleId), new Interval { Name = "Joe" });
await _done;
var countBeforeCancel = _count;
Assert.AreEqual(8, _count, "Expected to see 8 interval messages");
await Bus.CancelScheduledRecurringMessage(scheduledRecurringMessage);
await QuartzEndpoint.ScheduleSend(InputQueueAddress, DateTime.UtcNow + TimeSpan.FromSeconds(10), new DoneAgain { Name = "Joe" });
await _doneAgain;
Assert.AreEqual(countBeforeCancel, _count, "Expected to see the count matches.");
}
public async Task Should_include_message_headers()
{
Task <ConsumeContext <A> > handler = SubscribeHandler <A>();
Guid requestId = Guid.NewGuid();
Guid correlationId = Guid.NewGuid();
Guid conversationId = Guid.NewGuid();
Guid initiatorId = Guid.NewGuid();
await QuartzEndpoint.ScheduleSend(Bus.Address, DateTime.UtcNow, new A { Name = "Joe" }, Pipe.Execute <SendContext>(x =>
{
x.FaultAddress = Bus.Address;
x.ResponseAddress = InputQueueAddress;
x.RequestId = requestId;
x.CorrelationId = correlationId;
x.ConversationId = conversationId;
x.InitiatorId = initiatorId;
x.Headers.Set("Hello", "World");
}));
ConsumeContext <A> context = await handler;
Assert.AreEqual(Bus.Address, context.FaultAddress);
Assert.AreEqual(InputQueueAddress, context.ResponseAddress);
Assert.IsTrue(context.RequestId.HasValue);
Assert.AreEqual(requestId, context.RequestId.Value);
Assert.IsTrue(context.CorrelationId.HasValue);
Assert.AreEqual(correlationId, context.CorrelationId.Value);
Assert.IsTrue(context.ConversationId.HasValue);
Assert.AreEqual(conversationId, context.ConversationId.Value);
Assert.IsTrue(context.InitiatorId.HasValue);
Assert.AreEqual(initiatorId, context.InitiatorId.Value);
object value;
Assert.IsTrue(context.Headers.TryGetHeader("Hello", out value));
Assert.AreEqual("World", value);
}
public async Task Should_reschedule()
{
var handler = SubscribeHandler <A>();
var id = NewId.NextGuid();
var expected = "Joe 2";
await QuartzEndpoint.ScheduleSend(Bus.Address, TimeSpan.FromSeconds(120), new A
{
Id = id,
Name = "Joe"
});
await Task.Delay(2000);
await QuartzEndpoint.ScheduleSend(Bus.Address, TimeSpan.FromSeconds(5), new A
{
Id = id,
Name = expected
});
ConsumeContext <A> result = await handler;
Assert.AreEqual(expected, result.Message.Name);
}
