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);
}
}
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 GivenAnExistingDicomInstance_WhenStatusIsUpdated_ThenStatusShouldBeUpdated()
{
string studyInstanceUid = TestUidGenerator.Generate();
string seriesInstanceUid = TestUidGenerator.Generate();
string sopInstanceUid = TestUidGenerator.Generate();
DicomDataset dataset = Samples.CreateRandomDicomFile(studyInstanceUid, seriesInstanceUid, sopInstanceUid).Dataset;
long version = await _indexDataStore.BeginCreateInstanceIndexAsync(DefaultPartition.Key, dataset);
Instance instance = await _testHelper.GetInstanceAsync(studyInstanceUid, seriesInstanceUid, sopInstanceUid, version);
Assert.NotNull(instance);
DateTimeOffset lastStatusUpdatedDate = instance.LastStatusUpdatedDate;
// Make sure there is delay between.
await Task.Delay(50);
await _indexDataStore.EndCreateInstanceIndexAsync(DefaultPartition.Key, dataset, version);
IReadOnlyList <Instance> instances = await _testHelper.GetInstancesAsync(studyInstanceUid, seriesInstanceUid, sopInstanceUid);
Assert.NotNull(instances);
Assert.Single(instances);
Instance updatedInstance = instances[0];
Assert.Equal((byte)IndexStatus.Created, updatedInstance.Status);
Assert.True(updatedInstance.LastStatusUpdatedDate > lastStatusUpdatedDate);
}
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);
}
}
private static DicomDataset CreateTestDicomDataset(string studyInstanceUid = null, string seriesInstanceUid = null, string sopInstanceUid = null)
{
if (string.IsNullOrEmpty(studyInstanceUid))
{
studyInstanceUid = TestUidGenerator.Generate();
}
if (string.IsNullOrEmpty(seriesInstanceUid))
{
seriesInstanceUid = TestUidGenerator.Generate();
}
if (string.IsNullOrEmpty(sopInstanceUid))
{
sopInstanceUid = TestUidGenerator.Generate();
}
DicomDataset dataset = Samples.CreateRandomDicomFile(studyInstanceUid, seriesInstanceUid, sopInstanceUid).Dataset;
dataset.Remove(DicomTag.PatientID);
dataset.Add(DicomTag.PatientID, "pid");
dataset.Add(DicomTag.PatientName, "pname");
dataset.Add(DicomTag.ReferringPhysicianName, "rname");
dataset.Add(DicomTag.StudyDate, "20200301");
dataset.Add(DicomTag.StudyDescription, "sd");
dataset.Add(DicomTag.AccessionNumber, "an");
dataset.Add(DicomTag.Modality, "M");
dataset.Add(DicomTag.PerformedProcedureStepStartDate, "20200302");
return(dataset);
}
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 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 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);
}
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 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);
}
private async Task <InstanceIdentifier> CreateDicomFileAndGetInstanceIdentifierAsync()
{
string studyInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid);
InstanceIdentifier dicomInstance = dicomFile.Dataset.ToInstanceIdentifier();
await _client.StoreAsync(new[] { dicomFile }, studyInstanceUid);
return(dicomInstance);
}
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 GivenAPendingDicomInstance_WhenAdded_ThenPendingDicomInstanceExceptionShouldBeThrown()
{
string studyInstanceUid = TestUidGenerator.Generate();
string seriesInstanceUid = TestUidGenerator.Generate();
string sopInstanceUid = TestUidGenerator.Generate();
DicomDataset dataset = Samples.CreateRandomDicomFile(studyInstanceUid, seriesInstanceUid, sopInstanceUid).Dataset;
await _indexDataStore.CreateInstanceIndexAsync(dataset);
await Assert.ThrowsAsync <PendingInstanceException>(() => _indexDataStore.CreateInstanceIndexAsync(dataset));
}
public async Task GivenStoreRequest_WhenStoringUsingStudyInstanceUid_ThenAuditLogEntriesShouldBeCreated()
{
string studyInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid);
InstanceIdentifier dicomInstance = dicomFile.Dataset.ToInstanceIdentifier();
await ExecuteAndValidate(
() => _client.StoreAsync(new[] { dicomFile }, studyInstanceUid),
AuditEventSubType.Store,
$"studies/{dicomInstance.StudyInstanceUid}",
HttpStatusCode.OK);
}
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);
}
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());
}
private async Task <DicomDataset> PostDicomFileAsync(DicomDataset metadataItems = null)
{
DicomFile dicomFile1 = Samples.CreateRandomDicomFile();
if (metadataItems != null)
{
dicomFile1.Dataset.AddOrUpdate(metadataItems);
}
await _instancesManager.StoreAsync(new[] { dicomFile1 });
return(dicomFile1.Dataset);
}
public async Task GivenAnExistingDicomInstance_WhenAdded_ThenDicomInstanceAlreadyExistsExceptionShouldBeThrown()
{
string studyInstanceUid = TestUidGenerator.Generate();
string seriesInstanceUid = TestUidGenerator.Generate();
string sopInstanceUid = TestUidGenerator.Generate();
DicomDataset dataset = Samples.CreateRandomDicomFile(studyInstanceUid, seriesInstanceUid, sopInstanceUid).Dataset;
long version = await _indexDataStore.BeginCreateInstanceIndexAsync(DefaultPartition.Key, dataset);
await _indexDataStore.EndCreateInstanceIndexAsync(DefaultPartition.Key, dataset, version);
await Assert.ThrowsAsync <InstanceAlreadyExistsException>(() => _indexDataStore.BeginCreateInstanceIndexAsync(DefaultPartition.Key, dataset));
}
public async Task GivenDatasetWithInvalidUid_WhenStoring_TheServerShouldReturnConflict(string studyInstanceUID)
{
DicomFile dicomFile1 = Samples.CreateRandomDicomFile(studyInstanceUID, validateItems: false);
DicomWebException exception = await Assert.ThrowsAsync <DicomWebException>(() => _instancesManager.StoreAsync(new[] { dicomFile1 }));
Assert.Equal(HttpStatusCode.Conflict, exception.StatusCode);
Assert.False(exception.ResponseDataset.TryGetSequence(DicomTag.ReferencedSOPSequence, out DicomSequence _));
ValidationHelpers.ValidateFailedSopSequence(
exception.ResponseDataset,
ConvertToFailedSopSequenceEntry(dicomFile1.Dataset, ValidationFailedFailureCode));
}
public async Task GivenInstanceWithoutPixelData_WhenRetrieveStudy_ThenThenServerShouldReturnExpectedContent()
{
var studyInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile1 = Samples.CreateRandomDicomFile(studyInstanceUid);
await _instancesManager.StoreAsync(new[] { dicomFile1 });
using DicomWebAsyncEnumerableResponse <DicomFile> response = await _client.RetrieveStudyAsync(studyInstanceUid, dicomTransferSyntax : "*");
DicomFile[] studyRetrieve = await response.ToArrayAsync();
Assert.Equal(
new[] { dicomFile1.ToByteArray() },
studyRetrieve.Select(item => item.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 void GivenDatasetWithDuplicateIdentifiers_WhenStoring_TheServerShouldReturnConflict()
{
var studyInstanceUID = TestUidGenerator.Generate();
DicomFile dicomFile1 = Samples.CreateRandomDicomFile(studyInstanceUID, studyInstanceUID);
DicomWebException <DicomDataset> exception = await Assert.ThrowsAsync <DicomWebException <DicomDataset> >(
() => _client.StoreAsync(new[] { dicomFile1 }));
Assert.Equal(HttpStatusCode.Conflict, exception.StatusCode);
Assert.False(exception.Value.TryGetSequence(DicomTag.ReferencedSOPSequence, out DicomSequence _));
ValidationHelpers.ValidateFailedSopSequence(
exception.Value,
ConvertToFailedSopSequenceEntry(dicomFile1.Dataset, ValidationFailedFailureCode));
}
public async Task GivenAnExistingDicomInstance_WhenAdded_ThenDicomInstanceAlreadyExistsExceptionShouldBeThrown()
{
string studyInstanceUid = TestUidGenerator.Generate();
string seriesInstanceUid = TestUidGenerator.Generate();
string sopInstanceUid = TestUidGenerator.Generate();
DicomDataset dataset = Samples.CreateRandomDicomFile(studyInstanceUid, seriesInstanceUid, sopInstanceUid).Dataset;
long version = await _indexDataStore.CreateInstanceIndexAsync(dataset);
await _indexDataStore.UpdateInstanceIndexStatusAsync(
dataset.ToVersionedInstanceIdentifier(version),
IndexStatus.Created);
await Assert.ThrowsAsync <InstanceAlreadyExistsException>(() => _indexDataStore.CreateInstanceIndexAsync(dataset));
}
public async void GivenAMultipartRequestWithAnInvalidMultipartSection_WhenStoring_TheServerShouldReturnAccepted()
{
var request = new HttpRequestMessage(HttpMethod.Post, "studies");
request.Headers.Add(HeaderNames.Accept, DicomWebClient.MediaTypeApplicationDicomJson.MediaType);
var multiContent = new MultipartContent("related");
multiContent.Headers.ContentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("type", $"\"{DicomWebClient.MediaTypeApplicationDicom.MediaType}\""));
var byteContent = new ByteArrayContent(Array.Empty <byte>());
byteContent.Headers.ContentType = DicomWebClient.MediaTypeApplicationDicom;
multiContent.Add(byteContent);
string studyInstanceUID = TestUidGenerator.Generate();
try
{
DicomFile validFile = Samples.CreateRandomDicomFile(studyInstanceUID);
await using (MemoryStream stream = _recyclableMemoryStreamManager.GetStream())
{
await validFile.SaveAsync(stream);
var validByteContent = new ByteArrayContent(stream.ToArray());
validByteContent.Headers.ContentType = DicomWebClient.MediaTypeApplicationDicom;
multiContent.Add(validByteContent);
}
request.Content = multiContent;
DicomWebResponse <DicomDataset> response = await _client.PostMultipartContentAsync(multiContent, "studies");
Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
ValidationHelpers.ValidateReferencedSopSequence(
response.Value,
ConvertToReferencedSopSequenceEntry(validFile.Dataset));
}
finally
{
await _client.DeleteStudyAsync(studyInstanceUID);
}
}
public async void GivenAllDifferentStudyInstanceUIDs_WhenStoringWithProvidedStudyInstanceUID_TheServerShouldReturnConflict()
{
DicomFile dicomFile1 = Samples.CreateRandomDicomFile();
DicomFile dicomFile2 = Samples.CreateRandomDicomFile();
var studyInstanceUID = TestUidGenerator.Generate();
DicomWebException <DicomDataset> exception = await Assert.ThrowsAsync <DicomWebException <DicomDataset> >(() => _client.StoreAsync(
new[] { dicomFile1, dicomFile2 }, studyInstanceUID));
Assert.Equal(HttpStatusCode.Conflict, exception.StatusCode);
Assert.NotNull(exception.Value);
Assert.True(exception.Value.Count() == 1);
ValidationHelpers.ValidateFailedSopSequence(
exception.Value,
ConvertToFailedSopSequenceEntry(dicomFile1.Dataset, MismatchStudyInstanceUidFailureCode),
ConvertToFailedSopSequenceEntry(dicomFile2.Dataset, MismatchStudyInstanceUidFailureCode));
}
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 GivenDatasetWithInvalidUid_WhenStoring_TheServerShouldReturnConflict(string studyInstanceUID)
{
#pragma warning disable CS0618 // Type or member is obsolete
DicomValidation.AutoValidation = false;
#pragma warning restore CS0618 // Type or member is obsolete
DicomFile dicomFile1 = Samples.CreateRandomDicomFile(studyInstanceUID);
#pragma warning disable CS0618 // Type or member is obsolete
DicomValidation.AutoValidation = true;
#pragma warning restore CS0618 // Type or member is obsolete
DicomWebException exception = await Assert.ThrowsAsync <DicomWebException>(() => _client.StoreAsync(new[] { dicomFile1 }));
Assert.Equal(HttpStatusCode.Conflict, exception.StatusCode);
Assert.False(exception.ResponseDataset.TryGetSequence(DicomTag.ReferencedSOPSequence, out DicomSequence _));
ValidationHelpers.ValidateFailedSopSequence(
exception.ResponseDataset,
ConvertToFailedSopSequenceEntry(dicomFile1.Dataset, ValidationFailedFailureCode));
}
