public async Task GivenNoMatchingResources_WhenRunningReindexJob_ThenJobIsCompleted()
{
var searchParam = _supportedSearchParameterDefinitionManager.GetSearchParameter(new Uri("http://hl7.org/fhir/SearchParameter/Measure-name"));
searchParam.IsSearchable = false;
var request = new CreateReindexRequest();
CreateReindexResponse response = await _createReindexRequestHandler.Handle(request, CancellationToken.None);
Assert.NotNull(response);
Assert.False(string.IsNullOrWhiteSpace(response.Job.JobRecord.Id));
_reindexJobWorker = new ReindexJobWorker(
() => _scopedOperationDataStore,
Options.Create(_jobConfiguration),
InitializeReindexJobTask,
_searchParameterOperations,
NullLogger <ReindexJobWorker> .Instance);
await _reindexJobWorker.Handle(new SearchParametersInitializedNotification(), CancellationToken.None);
var cancellationTokenSource = new CancellationTokenSource();
try
{
await PerformReindexingOperation(response, OperationStatus.Completed, cancellationTokenSource);
Assert.True(searchParam.IsSearchable);
}
finally
{
cancellationTokenSource.Cancel();
searchParam.IsSearchable = true;
}
}
public async Task GivenNoSupportedSearchParameters_WhenRunningReindexJob_ThenJobIsCanceled()
{
var request = new CreateReindexRequest();
CreateReindexResponse response = await _createReindexRequestHandler.Handle(request, CancellationToken.None);
Assert.NotNull(response);
Assert.False(string.IsNullOrWhiteSpace(response.Job.JobRecord.Id));
_reindexJobWorker = new ReindexJobWorker(
() => _scopedOperationDataStore,
Options.Create(_jobConfiguration),
InitializeReindexJobTask,
_searchParameterOperations,
NullLogger <ReindexJobWorker> .Instance);
await _reindexJobWorker.Handle(new SearchParametersInitializedNotification(), CancellationToken.None);
var cancellationTokenSource = new CancellationTokenSource();
try
{
await PerformReindexingOperation(response, OperationStatus.Canceled, cancellationTokenSource);
}
finally
{
cancellationTokenSource.Cancel();
}
}
public ReindexJobWorkerBackgroundService(ReindexJobWorker reindexJobWorker, IOptions <ReindexJobConfiguration> reindexJobConfiguration)
{
EnsureArg.IsNotNull(reindexJobWorker, nameof(reindexJobWorker));
EnsureArg.IsNotNull(reindexJobConfiguration?.Value, nameof(reindexJobConfiguration));
_reindexJobWorker = reindexJobWorker;
_reindexJobConfiguration = reindexJobConfiguration.Value;
}
private async Task <CreateReindexResponse> SetUpForReindexing()
{
var request = new CreateReindexRequest();
CreateReindexResponse response = await _createReindexRequestHandler.Handle(request, CancellationToken.None);
Assert.NotNull(response);
Assert.False(string.IsNullOrWhiteSpace(response.Job.JobRecord.Id));
_reindexJobWorker = new ReindexJobWorker(
() => _scopedOperationDataStore,
Options.Create(_jobConfiguration),
InitializeReindexJobTask,
NullLogger <ReindexJobWorker> .Instance);
return(response);
}
public async Task GivenNoMatchingResources_WhenRunningReindexJob_ThenJobIsCompleted()
{
var searchParam = _supportedSearchParameterDefinitionManager.GetSearchParameter(new Uri("http://hl7.org/fhir/SearchParameter/Measure-name"));
searchParam.IsSearchable = false;
var request = new CreateReindexRequest();
CreateReindexResponse response = await _createReindexRequestHandler.Handle(request, CancellationToken.None);
Assert.NotNull(response);
Assert.False(string.IsNullOrWhiteSpace(response.Job.JobRecord.Id));
_reindexJobWorker = new ReindexJobWorker(
() => _scopedOperationDataStore,
Options.Create(_jobConfiguration),
InitializeReindexJobTask,
NullLogger <ReindexJobWorker> .Instance);
var cancellationTokenSource = new CancellationTokenSource();
try
{
var reindexWorkerTask = _reindexJobWorker.ExecuteAsync(cancellationTokenSource.Token);
var reindexJobWrapper = await _fhirOperationDataStore.GetReindexJobByIdAsync(response.Job.JobRecord.Id, cancellationTokenSource.Token);
int delayCount = 0;
while (reindexJobWrapper.JobRecord.Status != OperationStatus.Completed &&
delayCount < 10)
{
await Task.Delay(1000);
delayCount++;
reindexJobWrapper = await _fhirOperationDataStore.GetReindexJobByIdAsync(response.Job.JobRecord.Id, cancellationTokenSource.Token);
}
Assert.True(delayCount <= 9);
Assert.True(searchParam.IsSearchable);
}
finally
{
cancellationTokenSource.Cancel();
searchParam.IsSearchable = true;
}
}
public ReindexJobWorkerTests()
{
_reindexJobConfiguration.MaximumNumberOfConcurrentJobsAllowed = DefaultMaximumNumberOfConcurrentJobAllowed;
_reindexJobConfiguration.JobHeartbeatTimeoutThreshold = DefaultJobHeartbeatTimeoutThreshold;
_reindexJobConfiguration.JobPollingFrequency = DefaultJobPollingFrequency;
_reindexJobTaskFactory().Returns(_task);
var scopedOperationDataStore = Substitute.For <IScoped <IFhirOperationDataStore> >();
scopedOperationDataStore.Value.Returns(_fhirOperationDataStore);
_reindexJobWorker = new ReindexJobWorker(
() => scopedOperationDataStore,
Options.Create(_reindexJobConfiguration),
_reindexJobTaskFactory,
NullLogger <ReindexJobWorker> .Instance);
_cancellationToken = _cancellationTokenSource.Token;
}
private async Task <CreateReindexResponse> SetUpForReindexing(CreateReindexRequest request = null)
{
if (request == null)
{
request = new CreateReindexRequest(new List <string>());
}
CreateReindexResponse response = await _createReindexRequestHandler.Handle(request, CancellationToken.None);
Assert.NotNull(response);
Assert.False(string.IsNullOrWhiteSpace(response.Job.JobRecord.Id));
_reindexJobWorker = new ReindexJobWorker(
() => _scopedOperationDataStore,
Options.Create(_jobConfiguration),
InitializeReindexJobTask,
_searchParameterOperations,
NullLogger <ReindexJobWorker> .Instance);
await _reindexJobWorker.Handle(new SearchParametersInitializedNotification(), CancellationToken.None);
return(response);
}
public async Task GivenNewSearchParam_WhenReindexJobCompleted_ThenParamIsSearchable()
{
var searchParamName = "foo";
var searchParamCode = "fooCode";
var searchParam = new SearchParameterInfo(
name: searchParamName,
code: searchParamCode,
searchParamType: ValueSets.SearchParamType.String,
url: new Uri("http://hl7.org/fhir/SearchParameter/Patient-foo"),
components: null,
expression: "Patient.name",
targetResourceTypes: null,
baseResourceTypes: new List <string>()
{
"Patient"
})
{
IsSupported = true,
IsSearchable = false,
};
_searchParameterDefinitionManager.UrlLookup.TryAdd(searchParam.Url, searchParam);
_searchParameterDefinitionManager.TypeLookup["Patient"].TryAdd(searchParamCode, searchParam);
await UpsertPatientData("searchIndicesPatient1");
await UpsertPatientData("searchIndicesPatient2");
var queryParams = new List <Tuple <string, string> >()
{
new Tuple <string, string>("fooCode", "searchIndicesPatient1")
};
var searchResults = await _searchService.Value.SearchAsync("Patient", queryParams, CancellationToken.None);
Assert.Equal(searchParamCode, searchResults.UnsupportedSearchParameters.FirstOrDefault().Item1);
Assert.Equal(2, searchResults.Results.Count());
var searchIndexValues1 = new List <SearchIndexEntry>();
searchIndexValues1.Add(new SearchIndexEntry(searchParam, new StringSearchValue("searchIndicesPatient1")));
_searchIndexer.Extract(Arg.Is <ResourceElement>(r => r.Id.Equals("searchIndicesPatient1"))).Returns(searchIndexValues1);
var searchIndexValues2 = new List <SearchIndexEntry>();
searchIndexValues2.Add(new SearchIndexEntry(searchParam, new StringSearchValue("searchIndicesPatient2")));
_searchIndexer.Extract(Arg.Is <ResourceElement>(r => r.Id.Equals("searchIndicesPatient2"))).Returns(searchIndexValues2);
var request = new CreateReindexRequest();
CreateReindexResponse response = await _createReindexRequestHandler.Handle(request, CancellationToken.None);
Assert.NotNull(response);
Assert.False(string.IsNullOrWhiteSpace(response.Job.JobRecord.Id));
_reindexJobWorker = new ReindexJobWorker(
() => _scopedOperationDataStore,
Options.Create(_jobConfiguration),
InitializeReindexJobTask,
NullLogger <ReindexJobWorker> .Instance);
var cancellationTokenSource = new CancellationTokenSource();
try
{
var reindexWorkerTask = _reindexJobWorker.ExecuteAsync(cancellationTokenSource.Token);
var reindexJobWrapper = await _fhirOperationDataStore.GetReindexJobByIdAsync(response.Job.JobRecord.Id, cancellationTokenSource.Token);
int delayCount = 0;
while (reindexJobWrapper.JobRecord.Status != OperationStatus.Completed &&
delayCount < 10)
{
await Task.Delay(1000);
delayCount++;
reindexJobWrapper = await _fhirOperationDataStore.GetReindexJobByIdAsync(response.Job.JobRecord.Id, cancellationTokenSource.Token);
}
Assert.True(delayCount <= 9);
searchResults = await _searchService.Value.SearchAsync("Patient", queryParams, CancellationToken.None);
Assert.Single(searchResults.Results);
var patient = searchResults.Results.FirstOrDefault().Resource;
Assert.Contains("searchIndicesPatient1", patient.RawResource.Data);
}
finally
{
cancellationTokenSource.Cancel();
}
}