public async Task WaitForJobsToCompleteWithJobsFailed_ReturnsFalse(bool useServiceBus)
{
IJobsApiClient jobsApiClient = Substitute.For <IJobsApiClient>();
JobManagementResiliencePolicies policies = new JobManagementResiliencePolicies
{
JobsApiClient = Policy.NoOpAsync()
};
IMessengerService messengerService = null;
if (useServiceBus)
{
messengerService = Substitute.For <IMessengerService, IServiceBusService>();
}
else
{
messengerService = Substitute.For <IMessengerService, IQueueService>();
}
ILogger logger = Substitute.For <ILogger>();
JobManagement jobManagement = new JobManagement(jobsApiClient, logger, policies, messengerService);
string jobId = "3456";
jobsApiClient
.GetLatestJobsForSpecification("specificationId", Arg.Is <string[]>(_ => _.Single() == "PopulateScopedProviders"))
.Returns(new ApiResponse <IDictionary <string, JobSummary> >(HttpStatusCode.OK, new Dictionary <string, JobSummary> {
{ string.Empty, new JobSummary {
RunningStatus = RunningStatus.Completed, CompletionStatus = CompletionStatus.Failed, JobId = jobId
} }
}));
messengerService
.ReceiveMessage("topic/Subscriptions/correlationId", Arg.Any <Predicate <JobSummary> >(), TimeSpan.FromMilliseconds(600000))
.Returns(new JobSummary
{
CompletionStatus = CompletionStatus.Failed
});
//Act
bool jobsComplete = await jobManagement.QueueJobAndWait(async() => await Task.Run(() => { return(true); }), "PopulateScopedProviders", "specificationId", "correlationId", "topic");
//Assert
if (useServiceBus)
{
await((IServiceBusService)messengerService)
.Received(1)
.CreateSubscription("topic", "correlationId", Arg.Is <TimeSpan>(_ => _.Days == 1));
await messengerService
.Received(1)
.ReceiveMessage("topic/Subscriptions/correlationId", Arg.Any <Predicate <JobSummary> >(), TimeSpan.FromMilliseconds(600000));
}
jobsComplete
.Should()
.BeFalse();
}
private static void MockReceiveMessages(IMessengerService messengerService, string uniqueId, string entityPathBase, string queueName)
{
messengerService.ReceiveMessages <string>(queueName,
_timeout)
.Returns(new string[] { uniqueId });
messengerService.ReceiveMessage <SmokeResponse>(entityPathBase,
Arg.Any <Predicate <SmokeResponse> >(),
_timeout)
.Returns(new SmokeResponse {
InvocationId = uniqueId
});
}
public async Task <bool> QueueJobAndWait(Func <Task <bool> > queueJob, string jobType, string specificationId, string correlationId, string jobNotificationTopic, double pollTimeout = 600000, double pollInterval = 120000)
{
if (IsServiceBusService)
{
await((IServiceBusService)_messengerService).CreateSubscription(jobNotificationTopic, correlationId, new TimeSpan(1, 0, 0, 0));
}
bool jobQueued = await queueJob();
try
{
if (jobQueued)
{
if (IsServiceBusService)
{
JobSummary scopedJob = await _messengerService.ReceiveMessage <JobSummary>($"{jobNotificationTopic}/Subscriptions/{correlationId}", _ =>
{
return(_?.JobType == jobType &&
_.SpecificationId == specificationId &&
(_.CompletionStatus == CompletionStatus.Succeeded || _.CompletionStatus == CompletionStatus.Failed));
},
TimeSpan.FromMilliseconds(pollTimeout));
return(scopedJob?.CompletionStatus == CompletionStatus.Succeeded);
}
else
{
return(await WaitForJobToComplete(jobType, specificationId, pollTimeout, pollInterval));
}
}
else
{
// if job not queued then return true
return(true);
}
}
finally
{
if (IsServiceBusService)
{
await((IServiceBusService)_messengerService).DeleteSubscription(jobNotificationTopic, correlationId);
}
}
}
private async Task <SmokeResponse> RunSmokeTest(IMessengerService messengerService,
string queueName,
Func <Message, Task> action,
string topicName,
bool useSession)
{
Guard.IsNullOrWhiteSpace(queueName, nameof(queueName));
Guard.ArgumentNotNull(action, nameof(action));
string uniqueId = Guid.NewGuid().ToString();
IDictionary <string, string> properties = new Dictionary <string, string> {
{ "smoketest", uniqueId }
};
string entityPathBase = !IsDevelopment ? $"{ServiceBusConstants.TopicNames.SmokeTest}/Subscriptions/{uniqueId}" : uniqueId;
if (_useMocking)
{
MockReceiveMessages(messengerService, uniqueId, entityPathBase, queueName);
}
try
{
if (!IsDevelopment)
{
await((IServiceBusService)messengerService).CreateSubscription("smoketest", uniqueId, new TimeSpan(1, 0, 0, 0));
}
if (!IsDevelopment && topicName != null)
{
if (useSession)
{
await messengerService.SendToTopic(topicName,
uniqueId,
properties,
sessionId : uniqueId);
}
else
{
await messengerService.SendToTopic(topicName,
uniqueId,
properties);
}
}
else
{
if (useSession)
{
await messengerService.SendToQueue(queueName,
uniqueId,
properties,
sessionId : uniqueId);
}
else
{
await messengerService.SendToQueue(queueName,
uniqueId,
properties);
}
}
if (IsDevelopment)
{
IEnumerable <string> smokeResponsesFromFunction = await messengerService.ReceiveMessages <string>(queueName,
_timeout);
Message message = new Message();
message.UserProperties.Add("smoketest", smokeResponsesFromFunction?.FirstOrDefault(_ => _ == uniqueId));
action = _useMocking ? async(msg) =>
{
await Task.FromResult(msg.UserProperties["smoketest"].Equals(uniqueId));
}
: action;
await action(message);
}
return(await messengerService.ReceiveMessage <SmokeResponse>(entityPathBase, _ => _.InvocationId == uniqueId,
_timeout));
}
finally
{
if (!IsDevelopment)
{
await((IServiceBusService)messengerService).DeleteSubscription("smoketest", uniqueId);
}
else
{
await((IQueueService)messengerService).DeleteQueue(uniqueId);
}
if (_useMocking)
{
CheckServiceBusCalls(messengerService, uniqueId, queueName, topicName, entityPathBase, useSession);
}
}
}
