private async Task <DicomDataset> PostDicomFileAsync(ResourceType resourceType, string studyInstanceUid, string seriesInstanceUid = null, string sopInstanceUid = null, DicomDataset dataSet = null)
{
DicomFile dicomFile = null;
switch (resourceType)
{
case ResourceType.Study:
dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid);
break;
case ResourceType.Series:
dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid, seriesInstanceUid);
break;
case ResourceType.Instance:
dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid, seriesInstanceUid, sopInstanceUid);
break;
}
if (dataSet != null)
{
dicomFile.Dataset.AddOrUpdate(dataSet);
}
using DicomWebResponse <DicomDataset> response = await _instancesManager.StoreAsync(new[] { dicomFile });
return(dicomFile.Dataset);
}
public async Task GivenSupportedAcceptHeaders_WhenRetrieveFrame_ThenServerShouldReturnExpectedContent(string testDataFolder, string mediaType, string transferSyntax)
{
TranscoderTestData transcoderTestData = TranscoderTestDataHelper.GetTestData(testDataFolder);
DicomFile inputDicomFile = await DicomFile.OpenAsync(transcoderTestData.InputDicomFile);
await EnsureFileIsStoredAsync(inputDicomFile);
var instanceId = inputDicomFile.Dataset.ToInstanceIdentifier();
_studiesToClean.Add(instanceId.StudyInstanceUid);
DicomFile outputDicomFile = DicomFile.Open(transcoderTestData.ExpectedOutputDicomFile);
DicomPixelData pixelData = DicomPixelData.Create(outputDicomFile.Dataset);
DicomWebResponse <IReadOnlyList <Stream> > response = await _client.RetrieveFramesAsync(instanceId.StudyInstanceUid, instanceId.SeriesInstanceUid, instanceId.SopInstanceUid, mediaType, transferSyntax, frames : new[] { 1 });
int frameIndex = 0;
foreach (Stream item in response.Value)
{
// TODO: verify media type once https://microsofthealth.visualstudio.com/Health/_workitems/edit/75185 is done
Assert.Equal(item.ToByteArray(), pixelData.GetFrame(frameIndex).Data);
frameIndex++;
}
}
public async Task GivenSupportedTransferSyntax_WhenSupportedWildcardTsIsSpecified_OriginalTsReturned()
{
var seriesInstanceUid = TestUidGenerator.Generate();
var studyInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFileWith8BitPixelData(
studyInstanceUid,
seriesInstanceUid,
transferSyntax: DicomTransferSyntax.DeflatedExplicitVRLittleEndian.UID.UID);
try
{
await _client.StoreAsync(new[] { dicomFile });
DicomWebResponse <IReadOnlyList <DicomFile> > retrieveResponse = await _client.RetrieveSeriesAsync(
studyInstanceUid,
seriesInstanceUid,
dicomTransferSyntax : "*");
Assert.Equal(HttpStatusCode.OK, retrieveResponse.StatusCode);
Assert.Equal(DicomTransferSyntax.DeflatedExplicitVRLittleEndian, retrieveResponse.Value.Single().Dataset.InternalTransferSyntax);
}
finally
{
await _client.DeleteSeriesAsync(studyInstanceUid, seriesInstanceUid);
}
}
public async Task GivenAnUnsupportedTransferSyntax_WhenWildCardTsSpecified_OriginalImageReturned()
{
var studyInstanceUid = TestUidGenerator.Generate();
var seriesInstanceUid = TestUidGenerator.Generate();
var sopInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFileWith8BitPixelData(
studyInstanceUid,
seriesInstanceUid,
sopInstanceUid,
transferSyntax: DicomTransferSyntax.HEVCH265Main10ProfileLevel51.UID.UID,
encode: false);
await _client.StoreAsync(new[] { dicomFile });
// Check for series
DicomWebResponse <IReadOnlyList <DicomFile> > seriesResponse = await _client.RetrieveSeriesAsync(
studyInstanceUid,
seriesInstanceUid,
"*");
Assert.Equal(HttpStatusCode.OK, seriesResponse.StatusCode);
Assert.Equal(DicomTransferSyntax.HEVCH265Main10ProfileLevel51, seriesResponse.Value.Single().Dataset.InternalTransferSyntax);
// Check for frame
DicomWebResponse <IReadOnlyList <Stream> > frameResponse = await _client.RetrieveFramesAsync(
studyInstanceUid,
seriesInstanceUid,
sopInstanceUid,
dicomTransferSyntax : "*",
frames : new[] { 1 });
Assert.Equal(HttpStatusCode.OK, frameResponse.StatusCode);
Assert.NotEqual(0, frameResponse.Value.Single().Length);
}
public async Task GivenSupported8bitTransferSyntax_WhenRetrievingStudyAndAskingForConversion_OKIsReturned(
string tsFrom,
string tsTo)
{
IEnumerable <DicomFile> dicomFiles = Samples.GetDicomFilesForTranscoding();
DicomFile dicomFile = dicomFiles.FirstOrDefault(f => (Path.GetFileNameWithoutExtension(f.File.Name) == tsFrom));
var dicomInstance = dicomFile.Dataset.ToInstanceIdentifier();
try
{
await _client.StoreAsync(new[] { dicomFile });
var expectedTransferSyntax = (DicomTransferSyntax)typeof(DicomTransferSyntax).GetField(tsTo).GetValue(null);
DicomWebResponse <IReadOnlyList <DicomFile> > retrieveResponse = await _client.RetrieveInstanceAsync(
dicomInstance.StudyInstanceUid, dicomInstance.SeriesInstanceUid, dicomInstance.SopInstanceUid, expectedTransferSyntax.UID.UID);
Assert.Equal(HttpStatusCode.OK, retrieveResponse.StatusCode);
Assert.Equal(expectedTransferSyntax, retrieveResponse.Value.Single().Dataset.InternalTransferSyntax);
Assert.NotNull(retrieveResponse.Value.Single());
}
finally
{
await _client.DeleteInstanceAsync(dicomInstance.StudyInstanceUid, dicomInstance.SeriesInstanceUid, dicomInstance.SopInstanceUid);
}
}
public async Task GivenStoredDicomFileWithNoContent_WhenRetrieved_TheFileIsRetrievedCorrectly()
{
var studyInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile1 = Samples.CreateRandomDicomFile(studyInstanceUid);
var dicomInstance = dicomFile1.Dataset.ToInstanceIdentifier();
DicomWebResponse <DicomDataset> response = await _client.StoreAsync(new[] { dicomFile1 }, studyInstanceUid);
DicomSequence successSequence = response.Value.GetSequence(DicomTag.ReferencedSOPSequence);
string studyRetrieveLocation = response.Value.GetSingleValue <string>(DicomTag.RetrieveURL);
string instanceRetrieveLocation = successSequence.Items[0].GetSingleValue <string>(DicomTag.RetrieveURL);
DicomWebResponse <IReadOnlyList <DicomFile> > studyByUrlRetrieve = await _client.RetrieveInstancesAsync(new Uri(studyRetrieveLocation));
ValidateRetrieveTransaction(studyByUrlRetrieve, HttpStatusCode.OK, DicomTransferSyntax.ExplicitVRLittleEndian, singleInstance: false, dicomFile1);
DicomWebResponse <IReadOnlyList <DicomFile> > instanceByUrlRetrieve = await _client.RetrieveInstancesAsync(new Uri(instanceRetrieveLocation), true);
ValidateRetrieveTransaction(instanceByUrlRetrieve, HttpStatusCode.OK, DicomTransferSyntax.ExplicitVRLittleEndian, singleInstance: true, dicomFile1);
DicomWebResponse <IReadOnlyList <DicomFile> > studyRetrieve = await _client.RetrieveStudyAsync(dicomInstance.StudyInstanceUid);
ValidateRetrieveTransaction(studyRetrieve, HttpStatusCode.OK, DicomTransferSyntax.ExplicitVRLittleEndian, singleInstance: false, dicomFile1);
DicomWebResponse <IReadOnlyList <DicomFile> > seriesRetrieve = await _client.RetrieveSeriesAsync(dicomInstance.StudyInstanceUid, dicomInstance.SeriesInstanceUid);
ValidateRetrieveTransaction(seriesRetrieve, HttpStatusCode.OK, DicomTransferSyntax.ExplicitVRLittleEndian, singleInstance: false, dicomFile1);
DicomWebResponse <IReadOnlyList <DicomFile> > instanceRetrieve = await _client.RetrieveInstanceAsync(dicomInstance.StudyInstanceUid, dicomInstance.SeriesInstanceUid, dicomInstance.SopInstanceUid);
ValidateRetrieveTransaction(instanceRetrieve, HttpStatusCode.OK, DicomTransferSyntax.ExplicitVRLittleEndian, singleInstance: true, dicomFile1);
}
public async Task GivenOneDifferentStudyInstanceUID_WhenStoringWithProvidedStudyInstanceUID_TheServerShouldReturnAccepted()
{
var studyInstanceUID1 = TestUidGenerator.Generate();
var studyInstanceUID2 = TestUidGenerator.Generate();
try
{
DicomFile dicomFile1 = Samples.CreateRandomDicomFile(studyInstanceUid: studyInstanceUID1);
DicomFile dicomFile2 = Samples.CreateRandomDicomFile(studyInstanceUid: studyInstanceUID2);
using DicomWebResponse <DicomDataset> response = await _instancesManager.StoreAsync(new[] { dicomFile1, dicomFile2 }, studyInstanceUid : studyInstanceUID1);
Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
DicomDataset dataset = await response.GetValueAsync();
Assert.NotNull(dataset);
Assert.True(dataset.Count() == 3);
Assert.EndsWith($"studies/{studyInstanceUID1}", dataset.GetSingleValue <string>(DicomTag.RetrieveURL));
await ValidateReferencedSopSequenceAsync(
response,
ConvertToReferencedSopSequenceEntry(dicomFile1.Dataset));
ValidationHelpers.ValidateFailedSopSequence(
dataset,
ConvertToFailedSopSequenceEntry(dicomFile2.Dataset, MismatchStudyInstanceUidFailureCode));
}
finally
{
await _client.DeleteStudyAsync(studyInstanceUID1);
}
}
private async Task <DicomDataset> PostDicomFileAsync(ResourceType resourceType, string studyInstanceUid, string seriesInstanceUid = null, string sopInstanceUid = null, DicomDataset dataSet = null)
{
DicomFile dicomFile = null;
switch (resourceType)
{
case ResourceType.Study:
dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid);
break;
case ResourceType.Series:
dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid, seriesInstanceUid);
break;
case ResourceType.Instance:
dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid, seriesInstanceUid, sopInstanceUid);
break;
}
if (dataSet != null)
{
dicomFile.Dataset.AddOrUpdate(dataSet);
}
using (DicomWebResponse <DicomDataset> response = await _client.StoreAsync(new[] { dicomFile }))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
return(dicomFile.Dataset);
}
public async Task GivenAnInstance_WhenRetrievingChangeFeedWithoutMetadata_ThenMetadataIsNotReturned()
{
var studyInstanceUid = TestUidGenerator.Generate();
var seriesInstanceUid = TestUidGenerator.Generate();
var sopInstanceUid = TestUidGenerator.Generate();
await CreateFile(studyInstanceUid, seriesInstanceUid, sopInstanceUid);
long initialSequence;
using (DicomWebResponse <ChangeFeedEntry> response = await _client.GetChangeFeedLatest("?includemetadata=false"))
{
ChangeFeedEntry changeFeedEntry = await response.GetValueAsync();
initialSequence = changeFeedEntry.Sequence;
Assert.Equal(studyInstanceUid, changeFeedEntry.StudyInstanceUid);
Assert.Equal(seriesInstanceUid, changeFeedEntry.SeriesInstanceUid);
Assert.Equal(sopInstanceUid, changeFeedEntry.SopInstanceUid);
Assert.Null(changeFeedEntry.Metadata);
}
using (DicomWebAsyncEnumerableResponse <ChangeFeedEntry> response = await _client.GetChangeFeed($"?offset={initialSequence - 1}&includemetadata=false"))
{
ChangeFeedEntry[] changeFeedResults = await response.ToArrayAsync();
Assert.Single(changeFeedResults);
Assert.Null(changeFeedResults[0].Metadata);
Assert.Equal(ChangeFeedState.Current, changeFeedResults[0].State);
}
}
public async Task GivenAMultipartRequestWithTypeParameterAndFirstSectionWithoutContentType_WhenStoring_TheServerShouldReturnOK()
{
var multiContent = new MultipartContent("related");
multiContent.Headers.ContentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("type", $"\"{DicomWebConstants.MediaTypeApplicationDicom.MediaType}\""));
string studyInstanceUID = TestUidGenerator.Generate();
try
{
DicomFile dicomFile = Samples.CreateRandomDicomFile(studyInstanceUID);
await using (MemoryStream stream = _recyclableMemoryStreamManager.GetStream())
{
await dicomFile.SaveAsync(stream);
var byteContent = new ByteArrayContent(stream.ToArray());
multiContent.Add(byteContent);
}
using DicomWebResponse <DicomDataset> response = await _instancesManager.StoreAsync(multiContent, instanceId : DicomInstanceId.FromDicomFile(dicomFile));
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
await ValidateReferencedSopSequenceAsync(
response,
ConvertToReferencedSopSequenceEntry(dicomFile.Dataset));
}
finally
{
await _client.DeleteStudyAsync(studyInstanceUID);
}
}
public async Task GivenUnsupportedTransferSyntax_WhenRetrieveFrameWithOriginalTransferSyntax_ThenOriginalContentReturned()
{
var studyInstanceUid = TestUidGenerator.Generate();
var seriesInstanceUid = TestUidGenerator.Generate();
var sopInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFileWith8BitPixelData(
studyInstanceUid,
seriesInstanceUid,
sopInstanceUid,
transferSyntax: DicomTransferSyntax.HEVCH265Main10ProfileLevel51.UID.UID,
encode: false);
await InternalStoreAsync(new[] { dicomFile });
// Check for series
DicomWebResponse <IReadOnlyList <Stream> > response = await _client.RetrieveFramesAsync(
studyInstanceUid,
seriesInstanceUid,
sopInstanceUid,
dicomTransferSyntax : "*",
frames : new[] { 1 });
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(response.Value[0].ToByteArray(), DicomPixelData.Create(dicomFile.Dataset).GetFrame(0).Data);
}
public async Task GivenSinglePartAcceptHeader_WhenRetrieveInstance_ThenServerShouldReturnExpectedContent(string testDataFolder, string transferSyntax)
{
TranscoderTestData transcoderTestData = TranscoderTestDataHelper.GetTestData(testDataFolder);
DicomFile inputDicomFile = DicomFile.Open(transcoderTestData.InputDicomFile);
var instanceId = RandomizeInstanceIdentifier(inputDicomFile.Dataset);
await _instancesManager.StoreAsync(new[] { inputDicomFile });
using DicomWebResponse <DicomFile> response = await _client.RetrieveInstanceAsync(instanceId.StudyInstanceUid, instanceId.SeriesInstanceUid, instanceId.SopInstanceUid, transferSyntax);
Assert.Equal(DicomWebConstants.ApplicationDicomMediaType, response.ContentHeaders.ContentType.MediaType);
var actual = await response.GetValueAsync();
var expected = DicomFile.Open(transcoderTestData.ExpectedOutputDicomFile);
Assert.Equal(expected, actual, new DicomFileEqualityComparer(
ignoredTags: new[]
{
DicomTag.ImplementationVersionName, // Version name is updated as we update fo-dicom
DicomTag.StudyInstanceUID,
DicomTag.SeriesInstanceUID,
DicomTag.SOPInstanceUID
}));
}
public async Task GivenMultipleInstances_WhenRetrieveSeries_ThenServerShouldReturnExpectedInstances()
{
var studyInstanceUid = TestUidGenerator.Generate();
var seriesInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile1 = Samples.CreateRandomDicomFileWith8BitPixelData(
studyInstanceUid,
seriesInstanceUid,
transferSyntax: DicomTransferSyntax.ExplicitVRLittleEndian.UID.UID);
DicomFile dicomFile2 = Samples.CreateRandomDicomFileWith8BitPixelData(
studyInstanceUid,
seriesInstanceUid,
transferSyntax: DicomTransferSyntax.ExplicitVRLittleEndian.UID.UID);
DicomFile dicomFile3 = Samples.CreateRandomDicomFileWith8BitPixelData(
studyInstanceUid,
TestUidGenerator.Generate(),
transferSyntax: DicomTransferSyntax.ExplicitVRLittleEndian.UID.UID);
await InternalStoreAsync(new[] { dicomFile1, dicomFile2, dicomFile3 });
DicomWebResponse <IReadOnlyList <DicomFile> > instancesInStudy = await _client.RetrieveSeriesAsync(studyInstanceUid, seriesInstanceUid);
Assert.Equal(2, instancesInStudy.Value.Count);
var actual = instancesInStudy.Value.Select(item => item.ToByteArray());
Assert.Contains(dicomFile1.ToByteArray(), actual);
Assert.Contains(dicomFile2.ToByteArray(), actual);
}
public async Task GivenExistingDataset_WhenStoring_TheServerShouldReturnConflict()
{
var studyInstanceUID = TestUidGenerator.Generate();
try
{
DicomFile dicomFile1 = Samples.CreateRandomDicomFile(studyInstanceUID);
using DicomWebResponse <DicomDataset> response = await _instancesManager.StoreAsync(new[] { dicomFile1 });
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
DicomDataset dataset = await response.GetValueAsync();
await ValidateReferencedSopSequenceAsync(
response,
ConvertToReferencedSopSequenceEntry(dicomFile1.Dataset));
Assert.False(dataset.TryGetSequence(DicomTag.FailedSOPSequence, out DicomSequence _));
DicomWebException exception = await Assert.ThrowsAsync <DicomWebException>(
() => _instancesManager.StoreAsync(new[] { dicomFile1 }));
Assert.Equal(HttpStatusCode.Conflict, exception.StatusCode);
ValidationHelpers.ValidateFailedSopSequence(
exception.ResponseDataset,
ConvertToFailedSopSequenceEntry(dicomFile1.Dataset, SopInstanceAlreadyExistsFailureCode));
}
finally
{
await _client.DeleteStudyAsync(studyInstanceUID);
}
}
public async Task GivenDatasetInstancesWithDifferentPartitions_WhenDeleted_OneDeletedAndOtherRemains()
{
var newPartition1 = TestUidGenerator.Generate();
var newPartition2 = TestUidGenerator.Generate();
string studyInstanceUID = TestUidGenerator.Generate();
string seriesInstanceUID = TestUidGenerator.Generate();
string sopInstanceUID = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFile(studyInstanceUID, seriesInstanceUID, sopInstanceUID);
using DicomWebResponse <DicomDataset> response1 = await _instancesManager.StoreAsync(new[] { dicomFile }, partitionName : newPartition1);
using DicomWebResponse <DicomDataset> response2 = await _instancesManager.StoreAsync(new[] { dicomFile }, partitionName : newPartition2);
using DicomWebResponse response3 = await _client.DeleteInstanceAsync(studyInstanceUID, seriesInstanceUID, sopInstanceUID, newPartition1);
Assert.True(response3.IsSuccessStatusCode);
await Assert.ThrowsAsync <DicomWebException>(() => _client.RetrieveInstanceAsync(studyInstanceUID, seriesInstanceUID, sopInstanceUID, partitionName: newPartition1));
using DicomWebResponse <DicomFile> response5 = await _client.RetrieveInstanceAsync(studyInstanceUID, seriesInstanceUID, sopInstanceUID, partitionName : newPartition2);
Assert.True(response5.IsSuccessStatusCode);
}
public async Task GivenMatchingStudiesInDifferentPartitions_WhenSearchForStudySeriesLevel_OnePartitionMatchesResult()
{
var newPartition1 = TestUidGenerator.Generate();
var newPartition2 = TestUidGenerator.Generate();
var studyUid = TestUidGenerator.Generate();
DicomFile file1 = Samples.CreateRandomDicomFile(studyUid);
file1.Dataset.AddOrUpdate(new DicomDataset()
{
{ DicomTag.Modality, "MRI" },
});
DicomFile file2 = Samples.CreateRandomDicomFile(studyUid);
file2.Dataset.AddOrUpdate(new DicomDataset()
{
{ DicomTag.Modality, "MRI" },
});
using DicomWebResponse <DicomDataset> response1 = await _instancesManager.StoreAsync(new[] { file1 }, partitionName : newPartition1);
using DicomWebResponse <DicomDataset> response2 = await _instancesManager.StoreAsync(new[] { file2 }, partitionName : newPartition2);
using DicomWebAsyncEnumerableResponse <DicomDataset> response = await _client.QueryStudySeriesAsync(studyUid, "Modality=MRI", newPartition1);
DicomDataset[] datasets = await response.ToArrayAsync();
Assert.Single(datasets);
ValidationHelpers.ValidateResponseDataset(QueryResource.StudySeries, file1.Dataset, datasets[0]);
}
public async Task GivenRetrieveInstanceMetadataRequest_WhenIfNoneMatchDoesnotMatchETag_ThenResponseMetadataIsReturnedWithNewETag()
{
string studyInstanceUid = TestUidGenerator.Generate();
string seriesInstanceUid = TestUidGenerator.Generate();
string sopInstanceUid = TestUidGenerator.Generate();
DicomDataset storedInstance = await PostDicomFileAsync(ResourceType.Instance, studyInstanceUid, seriesInstanceUid, sopInstanceUid, dataSet : GenerateNewDataSet());
DicomWebResponse <IReadOnlyList <DicomDataset> > response = await _client.RetrieveSeriesMetadataAsync(studyInstanceUid, seriesInstanceUid, sopInstanceUid);
string ifNoneMatch = null;
string eTag = GetEtagFromResponse(response);
if (!string.IsNullOrEmpty(eTag))
{
ifNoneMatch = string.Concat("1", eTag);
}
response = await _client.RetrieveInstanceMetadataAsync(studyInstanceUid, seriesInstanceUid, sopInstanceUid, ifNoneMatch);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("application/dicom+json", response.Content.Headers.ContentType.MediaType);
Assert.Single(response.Value);
ValidateResponseMetadataDataset(storedInstance, response.Value.First());
}
public async void StoreSinglepartWithStudyUID_ServerShouldReturnOK()
{
var studyInstanceUID = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid: studyInstanceUID);
DicomWebResponse <DicomDataset> response = await _client.StoreAsync(dicomFile, studyInstanceUID);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public async Task GivenStoredInstance_WhenRetrieveRequestForSeries_ThenServerShouldReturnInstancesInSeries()
{
(InstanceIdentifier identifier, DicomFile file) = await CreateAndStoreDicomFile();
DicomWebResponse <IReadOnlyList <DicomFile> > instancesInSeries = await _client.RetrieveSeriesAsync(identifier.StudyInstanceUid, identifier.SeriesInstanceUid);
ValidateRetrieveTransaction(instancesInSeries, HttpStatusCode.OK, DicomTransferSyntax.ExplicitVRLittleEndian, singleInstance: false, file);
}
public async Task GivenAMultipartRequestWithNoContent_WhenStoring_TheServerShouldReturnNoContent()
{
var multiContent = new MultipartContent("related");
multiContent.Headers.ContentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("type", $"\"{DicomWebConstants.MediaTypeApplicationDicom.MediaType}\""));
using DicomWebResponse response = await _instancesManager.StoreAsync(multiContent);
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
public async Task StoreSinglepartWithStudyUID_ServerShouldReturnOK()
{
var studyInstanceUID = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid: studyInstanceUID);
using DicomWebResponse <DicomDataset> response = await _instancesManager.StoreAsync(dicomFile, studyInstanceUid : studyInstanceUID);
Assert.Equal(KnownContentTypes.ApplicationDicomJson, response.ContentHeaders.ContentType.MediaType);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public async Task StoreSinglepart_ServerShouldReturnOK()
{
DicomFile dicomFile = Samples.CreateRandomDicomFile();
await using MemoryStream stream = _recyclableMemoryStreamManager.GetStream();
await dicomFile.SaveAsync(stream);
using DicomWebResponse <DicomDataset> response = await _client.StoreAsync(stream);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public async Task GivenInstanceWithoutPixelData_WhenRetrieveStudy_ThenThenServerShouldReturnExpectedContent()
{
var studyInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile1 = Samples.CreateRandomDicomFile(studyInstanceUid);
await InternalStoreAsync(new[] { dicomFile1 });
DicomWebResponse <IReadOnlyList <DicomFile> > studyRetrieve = await _client.RetrieveStudyAsync(studyInstanceUid, dicomTransferSyntax : "*");
Assert.Equal(dicomFile1.ToByteArray(), studyRetrieve.Value[0].ToByteArray());
}
public async Task GivenRetrieveStudyMetadataRequest_WhenIfNoneMatchIsNotPresent_ThenResponseMetadataIsReturnedWithETag()
{
string studyInstanceUid = TestUidGenerator.Generate();
DicomDataset firstStoredInstance = await PostDicomFileAsync(ResourceType.Study, studyInstanceUid, dataSet : GenerateNewDataSet());
DicomDataset secondStoredInstance = await PostDicomFileAsync(ResourceType.Study, studyInstanceUid, dataSet : GenerateNewDataSet());
DicomWebResponse <IReadOnlyList <DicomDataset> > response = await _client.RetrieveStudyMetadataAsync(studyInstanceUid);
ValidateResponseMetadataDataset(response, firstStoredInstance, secondStoredInstance);
}
public async Task GivenStoredDicomFile_WhenRetrievingMetadataForStudy_ThenMetadataIsRetrievedCorrectly()
{
string studyInstanceUid = TestUidGenerator.Generate();
DicomDataset firstStoredInstance = await PostDicomFileAsync(ResourceType.Study, studyInstanceUid, dataSet : GenerateNewDataSet());
DicomDataset secondStoredInstance = await PostDicomFileAsync(ResourceType.Study, studyInstanceUid, dataSet : GenerateNewDataSet());
DicomWebResponse <IReadOnlyList <DicomDataset> > response = await _client.RetrieveStudyMetadataAsync(studyInstanceUid);
ValidateResponseMetadataDataset(response, firstStoredInstance, secondStoredInstance);
}
public async Task GivenInstanceWithoutPixelData_WhenRetrieveInstance_ThenServerShouldReturnExpectedContent()
{
var studyInstanceUid = TestUidGenerator.Generate();
var seriesInstanceUid = TestUidGenerator.Generate();
var sopInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile1 = Samples.CreateRandomDicomFile(studyInstanceUid, seriesInstanceUid, sopInstanceUid);
await _instancesManager.StoreAsync(new[] { dicomFile1 });
using DicomWebResponse <DicomFile> instanceRetrieve = await _client.RetrieveInstanceAsync(studyInstanceUid, seriesInstanceUid, sopInstanceUid, dicomTransferSyntax : "*");
Assert.Equal(dicomFile1.ToByteArray(), (await instanceRetrieve.GetValueAsync()).ToByteArray());
}
public async Task StoreSinglepart_ServerShouldReturnOK()
{
DicomFile dicomFile = Samples.CreateRandomDicomFile();
await using MemoryStream stream = _recyclableMemoryStreamManager.GetStream();
await dicomFile.SaveAsync(stream);
using DicomWebResponse <DicomDataset> response = await _instancesManager.StoreAsync(stream, instanceId : DicomInstanceId.FromDicomFile(dicomFile));
Assert.Equal(KnownContentTypes.ApplicationDicomJson, response.ContentHeaders.ContentType.MediaType);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
/// <inheritdoc/>
public async Task <IReadOnlyList <ChangeFeedEntry> > RetrieveChangeFeedAsync(long offset, CancellationToken cancellationToken)
{
DicomWebResponse <IReadOnlyList <ChangeFeedEntry> > result = await _dicomWebClient.GetChangeFeed(
$"?offset={offset}&limit={DefaultLimit}&includeMetadata={true}",
cancellationToken);
if (result?.Value != null)
{
return(result.Value);
}
return(Array.Empty <ChangeFeedEntry>());
}
private async Task EnsureFileIsStoredAsync(DicomFile dicomFile)
{
var instanceId = dicomFile.Dataset.ToInstanceIdentifier();
DicomWebResponse <IEnumerable <DicomDataset> > tryQuery = await _client.QueryAsync(
$"/studies/{instanceId.StudyInstanceUid}/series/{instanceId.SeriesInstanceUid}/instances?SOPInstanceUID={instanceId.SopInstanceUid}");
if (tryQuery.StatusCode == HttpStatusCode.OK)
{
await _client.DeleteStudyAsync(instanceId.StudyInstanceUid);
}
await InternalStoreAsync(new[] { dicomFile });
}
public async Task GivenExistingStudy_WhenDeletingStudy_TheServerShouldReturnNoContentAndAllLevelsShouldBeRemoved()
{
var studyInstanceUid = TestUidGenerator.Generate();
var seriesInstanceUid = TestUidGenerator.Generate();
var sopInstanceUid = TestUidGenerator.Generate();
await CreateFile(studyInstanceUid, seriesInstanceUid, sopInstanceUid);
DicomWebResponse response = await _client.DeleteStudyAsync(studyInstanceUid);
Assert.Equal(HttpStatusCode.NoContent, response?.StatusCode);
await VerifyAllRemoval(studyInstanceUid, seriesInstanceUid, sopInstanceUid);
}