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 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 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);
}
}
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 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 _client.StoreAsync(StudiesUri, multiContent);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
ValidationHelpers.ValidateReferencedSopSequence(
await response.GetValueAsync(),
ConvertToReferencedSopSequenceEntry(dicomFile.Dataset));
}
finally
{
await _client.DeleteStudyAsync(studyInstanceUID);
}
}
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 GivenDatasetWithNewPartitionName_WhenStoringWithStudyUid_TheServerShouldReturnWithNewPartition()
{
var newPartition = TestUidGenerator.Generate();
var studyInstanceUID = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid: studyInstanceUID);
using DicomWebResponse <DicomDataset> response = await _instancesManager.StoreAsync(dicomFile, studyInstanceUID, newPartition);
Assert.True(response.IsSuccessStatusCode);
ValidationHelpers.ValidateReferencedSopSequence(
await response.GetValueAsync(),
ConvertToReferencedSopSequenceEntry(dicomFile.Dataset, newPartition));
}
public async Task GivenASetOfDicomInstances_WhenRetrievingChangeFeed_ThenTheExpectedInstanceAreReturned()
{
var studyInstanceUid = TestUidGenerator.Generate();
var seriesInstanceUid = TestUidGenerator.Generate();
var sopInstanceUids = Enumerable.Range(1, 10).Select(x => TestUidGenerator.Generate()).ToArray();
long initialSequence = -1;
for (int i = 0; i < 10; i++)
{
await CreateFile(studyInstanceUid, seriesInstanceUid, sopInstanceUids[i]);
if (initialSequence == -1)
{
using DicomWebResponse <ChangeFeedEntry> latestResponse = await _client.GetChangeFeedLatest();
ChangeFeedEntry result = await latestResponse.GetValueAsync();
initialSequence = result.Sequence;
Assert.Equal(studyInstanceUid, result.StudyInstanceUid);
Assert.Equal(seriesInstanceUid, result.SeriesInstanceUid);
Assert.Equal(sopInstanceUids[i], result.SopInstanceUid);
Assert.Equal(ChangeFeedAction.Create, result.Action);
Assert.Equal(ChangeFeedState.Current, result.State);
}
}
using (DicomWebAsyncEnumerableResponse <ChangeFeedEntry> response = await _client.GetChangeFeed())
{
Assert.Equal(10, await response.CountAsync());
}
using (DicomWebAsyncEnumerableResponse <ChangeFeedEntry> response = await _client.GetChangeFeed($"?offset={initialSequence - 1}"))
{
ChangeFeedEntry[] changeFeedResults = await response.ToArrayAsync();
Assert.Equal(10, changeFeedResults.Length);
for (int i = 0; i < 10; i++)
{
Assert.Equal(studyInstanceUid, changeFeedResults[i].StudyInstanceUid);
Assert.Equal(seriesInstanceUid, changeFeedResults[i].SeriesInstanceUid);
Assert.Equal(sopInstanceUids[i], changeFeedResults[i].SopInstanceUid);
Assert.NotNull(changeFeedResults[i].Metadata);
}
}
}
public async Task <OperationStatus> AddTagsAsync(IEnumerable <AddExtendedQueryTagEntry> entries, CancellationToken cancellationToken = default)
{
EnsureArg.IsNotNull(entries, nameof(entries));
foreach (AddExtendedQueryTagEntry entry in entries)
{
_tags.Add(entry.Path);
}
DicomWebResponse <OperationReference> response = await _dicomWebClient.AddExtendedQueryTagAsync(entries, cancellationToken);
OperationReference operation = await response.GetValueAsync();
return(await GetOperationStatusRetryPolicy.ExecuteAsync(async() =>
{
var operationStatus = await _dicomWebClient.GetOperationStatusAsync(operation.Id);
return await operationStatus.GetValueAsync();
}));
}
public async Task GivenUnsupportedInternalTransferSyntax_WhenRetrieveInstanceWithOriginalTransferSyntax_ThenServerShouldReturnOriginalContent()
{
var studyInstanceUid = TestUidGenerator.Generate();
var seriesInstanceUid = TestUidGenerator.Generate();
var sopInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFileWith8BitPixelData(
studyInstanceUid,
seriesInstanceUid,
sopInstanceUid,
transferSyntax: DicomTransferSyntax.MPEG2.UID.UID,
encode: false);
await InternalStoreAsync(new[] { dicomFile });
using DicomWebResponse <DicomFile> instancesInStudy = await _client.RetrieveInstanceAsync(studyInstanceUid, seriesInstanceUid, sopInstanceUid, dicomTransferSyntax : "*");
Assert.Equal(dicomFile.ToByteArray(), (await instancesInStudy.GetValueAsync()).ToByteArray());
}
public async Task GivenSupportedAcceptHeaders_WhenRetrieveInstance_ThenServerShouldReturnExpectedContent(string testDataFolder, string transferSyntax)
{
TranscoderTestData transcoderTestData = TranscoderTestDataHelper.GetTestData(testDataFolder);
DicomFile inputDicomFile = DicomFile.Open(transcoderTestData.InputDicomFile);
await EnsureFileIsStoredAsync(inputDicomFile);
var instanceId = inputDicomFile.Dataset.ToInstanceIdentifier();
using DicomWebResponse <DicomFile> response = await _client.RetrieveInstanceAsync(instanceId.StudyInstanceUid, instanceId.SeriesInstanceUid, instanceId.SopInstanceUid, transferSyntax);
Assert.Equal(DicomWebConstants.ApplicationDicomMediaType, response.ContentHeaders.ContentType.MediaType);
DicomFile actual = await response.GetValueAsync();
DicomFile expected = DicomFile.Open(transcoderTestData.ExpectedOutputDicomFile);
Assert.Equal(expected, actual, new DicomFileEqualityComparer());
}
public async Task WhenRetrievingPartitions_TheServerShouldReturnAllPartitions()
{
var newPartition1 = TestUidGenerator.Generate();
var newPartition2 = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFile();
using DicomWebResponse <DicomDataset> response1 = await _instancesManager.StoreAsync(new[] { dicomFile }, partitionName : newPartition1);
using DicomWebResponse <DicomDataset> response2 = await _instancesManager.StoreAsync(new[] { dicomFile }, partitionName : newPartition2);
using DicomWebResponse <IEnumerable <PartitionEntry> > response3 = await _client.GetPartitionsAsync();
Assert.True(response3.IsSuccessStatusCode);
IEnumerable <PartitionEntry> values = await response3.GetValueAsync();
Assert.Contains(values, x => x.PartitionName == newPartition1);
Assert.Contains(values, x => x.PartitionName == newPartition2);
}
public async Task GivenAnInstance_WhenRetrievingChangeFeedWithPartition_ThenPartitionNameIsReturned()
{
var newPartition = 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 : newPartition);
Assert.True(response1.IsSuccessStatusCode);
long initialSequence;
using (DicomWebResponse <ChangeFeedEntry> response = await _client.GetChangeFeedLatest("?includemetadata=false"))
{
ChangeFeedEntry changeFeedEntry = await response.GetValueAsync();
initialSequence = changeFeedEntry.Sequence;
Assert.Equal(newPartition, changeFeedEntry.PartitionName);
Assert.Equal(studyInstanceUID, changeFeedEntry.StudyInstanceUid);
Assert.Equal(seriesInstanceUID, changeFeedEntry.SeriesInstanceUid);
Assert.Equal(sopInstanceUID, changeFeedEntry.SopInstanceUid);
}
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(newPartition, changeFeedResults[0].PartitionName);
Assert.Equal(ChangeFeedState.Current, changeFeedResults[0].State);
}
}