protected Task WaitForJobCancellation(List <string> jobIDs, DocumentTranslationClient client) { if (Mode == RecordedTestMode.Playback) { return(Task.CompletedTask); } using (Recording.DisableRecording()) { var options = new GetTranslationStatusesOptions(); foreach (var result in jobIDs) { options.Ids.Add(result); } bool cancellationHasPropagated = false; // flag for successful cancelling return(TestRetryHelper.RetryAsync(async() => { var statuses = await client.GetTranslationStatusesAsync(options: options).ToEnumerableAsync(); cancellationHasPropagated = statuses.TrueForAll(status => status.Status == DocumentTranslationStatus.Canceled); if (!cancellationHasPropagated) { throw new InvalidOperationException("Cancellation not propagated to all documents"); } else { return (Response)null; } }, maxIterations: 100, delay: TimeSpan.FromSeconds(5))); } }
public async Task TimeSeriesInsightsClient_ModelSettingsTest() { TimeSeriesInsightsClient client = GetClient(); TimeSeriesInsightsModelSettings modelSettingsClient = client.GetModelSettingsClient(); TimeSeriesInsightsTypes typesClient = client.GetTypesClient(); // GET model settings Response <TimeSeriesModelSettings> currentSettings = await modelSettingsClient.GetAsync().ConfigureAwait(false); currentSettings.GetRawResponse().Status.Should().Be((int)HttpStatusCode.OK); string testName = "testModel"; // UPDATE model settings string typeId = await createTimeSeriesTypeAsync(client).ConfigureAwait(false); string defaultTypeId = await getDefaultTypeIdAsync(modelSettingsClient).ConfigureAwait(false); try { Response <TimeSeriesModelSettings> updatedSettingsName = await modelSettingsClient.UpdateNameAsync(testName).ConfigureAwait(false); updatedSettingsName.GetRawResponse().Status.Should().Be((int)HttpStatusCode.OK); updatedSettingsName.Value.Name.Should().Be(testName); await TestRetryHelper.RetryAsync <Response <TimeSeriesModelSettings> >(async() => { Response <TimeSeriesModelSettings> updatedSettingsId = await modelSettingsClient.UpdateDefaultTypeIdAsync(typeId).ConfigureAwait(false); updatedSettingsId.Value.DefaultTypeId.Should().Be(typeId); // update it back to the default Type Id updatedSettingsId = await modelSettingsClient.UpdateDefaultTypeIdAsync(defaultTypeId).ConfigureAwait(false); updatedSettingsId.Value.DefaultTypeId.Should().Be(defaultTypeId); return(null); }, MaxNumberOfRetries, s_retryDelay); } finally { // clean up try { Response <TimeSeriesOperationError[]> deleteTypesResponse = await typesClient .DeleteByIdAsync(new string[] { typeId }) .ConfigureAwait(false); // Assert that the response array does not have any error object set deleteTypesResponse.Value.Should().OnlyContain((errorResult) => errorResult == null); } catch (Exception ex) { Console.WriteLine($"Test clean up failed: {ex.Message}"); throw; } } }
protected Task PollForCertificate(string name) { if (Mode == RecordedTestMode.Playback) { return(Task.CompletedTask); } using (Recording.DisableRecording()) { return(TestRetryHelper.RetryAsync(async() => await Client.GetCertificateAsync(name), delay: PollingInterval)); } }
protected Task WaitForSecret(string name) { if (Mode == RecordedTestMode.Playback) { return(Task.CompletedTask); } using (Recording.DisableRecording()) { return(TestRetryHelper.RetryAsync(async() => await Client.GetSecretAsync(name).ConfigureAwait(false), delay: PollingInterval)); } }
protected Task WaitForDeletedCertificate(string name) { if (Mode == RecordedTestMode.Playback) { return(Task.CompletedTask); } using (Recording.DisableRecording()) { return(TestRetryHelper.RetryAsync(async() => await Client.GetDeletedCertificateAsync(name))); } }
protected Task WaitForDeletedKey(string name) { if (Mode == RecordedTestMode.Playback) { return(Task.CompletedTask); } using (Recording.DisableRecording()) { return(TestRetryHelper.RetryAsync(async() => await KeyClient.GetDeletedKeyAsync(name), delay: PollingInterval)); } }
public async Task RecognizeHealthcareEntitiesBatchWithCancellation() { TextAnalyticsClient client = GetClient(); string document = @"RECORD #333582770390100 | MH | 85986313 | | 054351 | 2/14/2001 12:00:00 AM | CORONARY ARTERY DISEASE | Signed | DIS |"; var batchDocuments = new List <string>(); for (var i = 0; i < 10; i++) { batchDocuments.Add(document); } AnalyzeHealthcareEntitiesOperation operation = default; await TestRetryHelper.RetryAsync(async() => { try { operation = await client.StartAnalyzeHealthcareEntitiesAsync(batchDocuments, "en"); await operation.CancelAsync(); await operation.WaitForCompletionAsync(); } catch (Exception e) { Assert.AreEqual(typeof(RequestFailedException), e.GetType()); Assert.IsTrue(e.Message.Contains("The operation was canceled so no value is available.")); return((Response)null); } // If we get here, that means that the operation completed successfully and didn't cancel. throw new InvalidOperationException("StartAnalyzeHealthcareEntitiesAsync operation did not get cancelled."); }, maxIterations : 15, delay : TimeSpan.FromSeconds(1)); Assert.IsTrue(operation.HasCompleted); Assert.IsFalse(operation.HasValue); Assert.AreEqual(200, operation.GetRawResponse().Status); Assert.AreEqual(TextAnalyticsOperationStatus.Cancelled, operation.Status); try { Assert.IsNull(operation.Value); } catch (RequestFailedException exception) { Assert.IsTrue(exception.Message.Contains("The operation was canceled so no value is available.")); } }
protected Task WaitForDeletedSecret(string name) { if (Mode == RecordedTestMode.Playback) { return(Task.CompletedTask); } using (Recording.DisableRecording()) { return(TestRetryHelper.RetryAsync(async() => { try { return await Client.GetDeletedSecretAsync(name).ConfigureAwait(false); } catch (RequestFailedException ex) when(ex.Status == 404) { throw new InconclusiveException($"Timed out while waiting for secret '{name}' to be deleted"); } }, delay: PollingInterval)); } }
protected Task WaitForPurgedSecret(string name) { if (Mode == RecordedTestMode.Playback) { return(Task.CompletedTask); } using (Recording.DisableRecording()) { return(TestRetryHelper.RetryAsync(async() => { try { await Client.GetDeletedSecretAsync(name).ConfigureAwait(false); throw new InvalidOperationException($"Secret {name} still exists"); } catch (RequestFailedException ex) when(ex.Status == 404) { return (Response)null; } }, delay: PollingInterval)); } }
protected Task WaitForPurgedCertificate(string name) { if (Mode == RecordedTestMode.Playback) { return(Task.CompletedTask); } using (Recording.DisableRecording()) { return(TestRetryHelper.RetryAsync(async() => { try { await Client.GetDeletedCertificateAsync(name); throw new InvalidOperationException("Key still exists"); } catch { return (Response)null; } })); } }
public async Task GetDeletedSecrets() { string secretName = Recording.GenerateId(); List <KeyVaultSecret> deletedSecrets = new List <KeyVaultSecret>(); for (int i = 0; i < PagedSecretCount; i++) { KeyVaultSecret secret = await Client.SetSecretAsync(secretName + i, i.ToString()); RegisterForCleanup(secret.Name); deletedSecrets.Add(secret); await TestRetryHelper.RetryAsync(async() => { // Try a few times since it sometimes fails when trying to delete right away. return(await Client.StartDeleteSecretAsync(secret.Name)); }, maxIterations : 3); } List <Task> deletingSecrets = new List <Task>(); foreach (KeyVaultSecret deletedSecret in deletedSecrets) { // WaitForDeletedSecret disables recording, so we can wait concurrently. deletingSecrets.Add(WaitForDeletedSecret(deletedSecret.Name)); } await Task.WhenAll(deletingSecrets); List <DeletedSecret> allSecrets = await Client.GetDeletedSecretsAsync().ToEnumerableAsync(); foreach (KeyVaultSecret deletedSecret in deletedSecrets) { KeyVaultSecret returnedSecret = allSecrets.Single(s => s.Name == deletedSecret.Name); AssertSecretPropertiesEqual(deletedSecret.Properties, returnedSecret.Properties, compareId: false); } }
public async Task TimeSeriesInsightsHierarchies_Lifecycle() { // Arrange TimeSeriesInsightsClient client = GetClient(); TimeSeriesInsightsHierarchies hierarchiesClient = client.GetHierarchiesClient(); var tsiHiearchyNamePrefix = "hierarchy"; var tsiSourceNamePrefix = "hierarchySource"; var tsiHierarchyName = Recording.GenerateAlphaNumericId(tsiHiearchyNamePrefix); var hierarchyNames = new List <string> { tsiHierarchyName }; var hierarchySource = new TimeSeriesHierarchySource(); hierarchySource.InstanceFieldNames.Add(Recording.GenerateAlphaNumericId(tsiSourceNamePrefix)); var tsiHierarchy = new TimeSeriesHierarchy(tsiHierarchyName, hierarchySource); tsiHierarchy.Id = Recording.GenerateId(); var timeSeriesHierarchies = new List <TimeSeriesHierarchy> { tsiHierarchy }; // Act and assert try { // Create Time Series hierarchies Response <TimeSeriesHierarchyOperationResult[]> createHierarchiesResult = await hierarchiesClient .CreateOrReplaceAsync(timeSeriesHierarchies) .ConfigureAwait(false); // Assert that the result error array does not contain any object that is set createHierarchiesResult.Value.Should().OnlyContain((errorResult) => errorResult.Error == null); Response <TimeSeriesHierarchyOperationResult[]> getHierarchiesByNamesResult; // This retry logic was added as the TSI hierarchies are not immediately available after creation await TestRetryHelper.RetryAsync <Response <TimeSeriesHierarchyOperationResult[]> >(async() => { // Get the created hierarchies by names getHierarchiesByNamesResult = await hierarchiesClient .GetByNameAsync(new List <string>() { tsiHierarchyName }) .ConfigureAwait(false); getHierarchiesByNamesResult.Value.Should().OnlyContain((errorResult) => errorResult.Error == null); getHierarchiesByNamesResult.Value.Length.Should().Be(timeSeriesHierarchies.Count); foreach (TimeSeriesHierarchyOperationResult hierarchiesResult in getHierarchiesByNamesResult.Value) { hierarchiesResult.Error.Should().BeNull(); hierarchiesResult.Hierarchy.Should().NotBeNull(); hierarchiesResult.Hierarchy.Id.Should().NotBeNullOrEmpty(); } return(null); }, MaxNumberOfRetries, s_retryDelay); // Update hierarchies with adding a source and set Id var updateTsiName = Recording.GenerateAlphaNumericId(tsiHiearchyNamePrefix); hierarchyNames.Add(updateTsiName); hierarchySource.InstanceFieldNames.Add(Recording.GenerateAlphaNumericId(tsiSourceNamePrefix)); var tsiHierarchyToAdd = new TimeSeriesHierarchy(updateTsiName, hierarchySource); tsiHierarchyToAdd.Id = Recording.GenerateId(); timeSeriesHierarchies.Add(tsiHierarchyToAdd); Response <TimeSeriesHierarchyOperationResult[]> updateHierarchiesResult = await hierarchiesClient .CreateOrReplaceAsync(timeSeriesHierarchies) .ConfigureAwait(false); updateHierarchiesResult.Value.Should().OnlyContain((errorResult) => errorResult.Error == null); updateHierarchiesResult.Value.Length.Should().Be(timeSeriesHierarchies.Count); // This retry logic was added as the TSI hierarchies are not immediately available after creation await TestRetryHelper.RetryAsync <Response <TimeSeriesHierarchyOperationResult[]> >(async() => { // Get hierarchy by Id Response <TimeSeriesHierarchyOperationResult[]> getHierarchyByIdResult = await hierarchiesClient .GetByIdAsync(new string[] { tsiHierarchy.Id }) .ConfigureAwait(false); getHierarchyByIdResult.Value.Length.Should().Be(1); foreach (TimeSeriesHierarchyOperationResult hierarchyOperationResult in getHierarchyByIdResult.Value) { hierarchyOperationResult.Hierarchy.Should().NotBeNull(); hierarchyOperationResult.Error.Should().BeNull(); hierarchyOperationResult.Hierarchy.Name.Should().StartWith(tsiHiearchyNamePrefix); hierarchyOperationResult.Hierarchy.Id.Should().Be(tsiHierarchy.Id); } return(null); }, MaxNumberOfRetries, s_retryDelay); // Get all Time Series hierarchies in the environment AsyncPageable <TimeSeriesHierarchy> getAllHierarchies = hierarchiesClient.GetAsync(); await foreach (TimeSeriesHierarchy hierarchy in getAllHierarchies) { hierarchy.Should().NotBeNull(); } } finally { // clean up try { Response <TimeSeriesOperationError[]> deleteHierarchiesResponse = await hierarchiesClient .DeleteByNameAsync(hierarchyNames) .ConfigureAwait(false); // Assert that the response array does not have any error object set deleteHierarchiesResponse.Value.Should().OnlyContain((errorResult) => errorResult == null); } catch (Exception ex) { Console.WriteLine($"Test clean up failed: {ex.Message}"); throw; } } }
public async Task TimeSeriesInsightsTypes_Lifecycle() { // Arrange TimeSeriesInsightsClient client = GetClient(); var timeSeriesTypes = new List <TimeSeriesType>(); var tsiTypeNamePrefix = "type"; int numOfTypesCreated = 0; var timeSeriesTypesProperties = new Dictionary <string, string> { { Recording.GenerateAlphaNumericId(tsiTypeNamePrefix), Recording.GenerateId() }, { Recording.GenerateAlphaNumericId(tsiTypeNamePrefix), Recording.GenerateId() } }; // Build aggregate variable var countExpression = new TimeSeriesExpression("count()"); var aggregateVariable = new AggregateVariable(countExpression); var variables = new Dictionary <string, TimeSeriesVariable>(); var variableNamePrefix = "aggregateVariable"; variables.Add(Recording.GenerateAlphaNumericId(variableNamePrefix), aggregateVariable); foreach (var property in timeSeriesTypesProperties) { var type = new TimeSeriesType(property.Key, variables); type.Id = property.Value; timeSeriesTypes.Add(type); numOfTypesCreated++; } // Act and assert try { // Get all Time Series types in the environment AsyncPageable <TimeSeriesType> getAllTypesResponse = client.GetTimeSeriesTypesAsync(); await foreach (TimeSeriesType tsiType in getAllTypesResponse) { tsiType.Should().NotBeNull(); } // Create Time Series types Response <TimeSeriesOperationError[]> createTypesResult = await client .CreateOrReplaceTimeSeriesTypesAsync(timeSeriesTypes) .ConfigureAwait(false); // Assert that the result error array does not contain any object that is set createTypesResult.Value.Should().OnlyContain((errorResult) => errorResult == null); Response <TimeSeriesTypeOperationResult[]> getTypesByNamesResult; // This retry logic was added as the TSI types are not immediately available after creation await TestRetryHelper.RetryAsync <Response <TimeSeriesTypeOperationResult[]> >(async() => { // Get the created types by names getTypesByNamesResult = await client .GetTimeSeriesTypesByNamesAsync(timeSeriesTypesProperties.Keys) .ConfigureAwait(false); getTypesByNamesResult.Value.Should().OnlyContain((errorResult) => errorResult.Error == null); getTypesByNamesResult.Value.Length.Should().Be(timeSeriesTypes.Count); foreach (TimeSeriesTypeOperationResult typesResult in getTypesByNamesResult.Value) { typesResult.Error.Should().BeNull(); typesResult.TimeSeriesType.Should().NotBeNull(); typesResult.TimeSeriesType.Id.Should().NotBeNullOrEmpty(); typesResult.TimeSeriesType.Variables.Count.Should().Be(1); typesResult.TimeSeriesType.Variables.IsSameOrEqualTo(variables); } return(null); }, MaxNumberOfRetries, s_retryDelay); // Update variables with adding a new variable foreach (var type in timeSeriesTypes) { type.Description = "Description"; } Response <TimeSeriesOperationError[]> updateTypesResult = await client .CreateOrReplaceTimeSeriesTypesAsync(timeSeriesTypes) .ConfigureAwait(false); updateTypesResult.Value.Should().OnlyContain((errorResult) => errorResult == null); updateTypesResult.Value.Length.Should().Be(timeSeriesTypes.Count); // This retry logic was added as the TSI types are not immediately available after creation await TestRetryHelper.RetryAsync <Response <TimeSeriesTypeOperationResult[]> >(async() => { // Get type by Id Response <TimeSeriesTypeOperationResult[]> getTypeByIdResult = await client .GetTimeSeriesTypesByIdAsync(timeSeriesTypesProperties.Values) .ConfigureAwait(false); getTypeByIdResult.Value.Length.Should().Be(numOfTypesCreated); foreach (TimeSeriesTypeOperationResult typeOperationResult in getTypeByIdResult.Value) { typeOperationResult.TimeSeriesType.Should().NotBeNull(); typeOperationResult.Error.Should().BeNull(); typeOperationResult.TimeSeriesType.Name.Should().StartWith(tsiTypeNamePrefix); typeOperationResult.TimeSeriesType.Id.Should().NotBeNull(); } return(null); }, MaxNumberOfRetries, s_retryDelay); } finally { // clean up try { Response <TimeSeriesOperationError[]> deleteTypesResponse = await client .DeleteTimeSeriesTypesbyIdAsync(timeSeriesTypesProperties.Values) .ConfigureAwait(false); // Assert that the response array does not have any error object set deleteTypesResponse.Value.Should().OnlyContain((errorResult) => errorResult == null); } catch (Exception ex) { Console.WriteLine($"Test clean up failed: {ex.Message}"); throw; } } }
public async Task TimeSeriesId_CreateInstanceWith3Keys() { // Arrange TimeSeriesInsightsClient client = GetClient(); TimeSeriesInsightsInstances instancesClient = client.GetInstancesClient(); // Create a Time Series Id with 3 keys. Middle key is a null var idWithNull = new TimeSeriesId( Recording.GenerateAlphaNumericId(string.Empty, 5), null, Recording.GenerateAlphaNumericId(string.Empty, 5)); var timeSeriesInstances = new List <TimeSeriesInstance> { new TimeSeriesInstance(idWithNull, DefaultType), }; // Act and assert try { // Create TSI instances Response <TimeSeriesOperationError[]> createInstancesResult = await instancesClient .CreateOrReplaceAsync(timeSeriesInstances) .ConfigureAwait(false); // Assert that the result error array does not contain any object that is set createInstancesResult.Value.Should().OnlyContain((errorResult) => errorResult == null); // This retry logic was added as the TSI instance are not immediately available after creation await TestRetryHelper.RetryAsync <Response <InstancesOperationResult[]> >(async() => { // Get the instance with a null item in its Id Response <InstancesOperationResult[]> getInstanceWithNullInId = await instancesClient .GetByIdAsync(new List <TimeSeriesId> { idWithNull }) .ConfigureAwait(false); getInstanceWithNullInId.Value.Length.Should().Be(1); InstancesOperationResult resultItem = getInstanceWithNullInId.Value.First(); resultItem.Instance.Should().NotBeNull(); resultItem.Instance.TimeSeriesId.ToStringArray().Length.Should().Be(3); resultItem.Instance.TimeSeriesId.ToStringArray()[1].Should().BeNull(); return(null); }, MaxNumberOfRetries, s_retryDelay); } finally { // clean up try { Response <TimeSeriesOperationError[]> deleteInstancesResponse = await instancesClient .DeleteByIdAsync(timeSeriesInstances.Select((instance) => instance.TimeSeriesId)) .ConfigureAwait(false); // Assert that the response array does not have any error object set deleteInstancesResponse.Value.Should().OnlyContain((errorResult) => errorResult == null); } catch (Exception ex) { Console.WriteLine($"Test clean up failed: {ex.Message}"); throw; } } }
public async Task TimeSeriesInsightsInstances_Lifecycle() { // Arrange TimeSeriesInsightsClient client = GetClient(); int numOfIdProperties = 3; int numOfInstancesToSetup = 2; var timeSeriesInstances = new List <TimeSeriesInstance>(); string defaultTypeId = await getDefaultTypeIdAsync(client).ConfigureAwait(false); for (int i = 0; i < numOfInstancesToSetup; i++) { TimeSeriesId id = await GetUniqueTimeSeriesInstanceIdAsync(client, numOfIdProperties) .ConfigureAwait(false); var instance = new TimeSeriesInstance(id, defaultTypeId) { Name = Recording.GenerateAlphaNumericId("instance"), }; timeSeriesInstances.Add(instance); } IEnumerable <TimeSeriesId> timeSeriesInstancesIds = timeSeriesInstances.Select((instance) => instance.TimeSeriesId); // Act and assert try { await TestRetryHelper.RetryAsync <Response <InstancesOperationResult[]> >(async() => { // Create TSI instances Response <TimeSeriesOperationError[]> createInstancesResult = await client .Instances .CreateOrReplaceAsync(timeSeriesInstances) .ConfigureAwait(false); // Assert that the result error array does not contain any object that is set createInstancesResult.Value.Should().OnlyContain((errorResult) => errorResult == null); // Get the created instances by Ids Response <InstancesOperationResult[]> getInstancesByIdsResult = await client .Instances .GetAsync(timeSeriesInstancesIds) .ConfigureAwait(false); getInstancesByIdsResult.Value.Length.Should().Be(timeSeriesInstances.Count); foreach (InstancesOperationResult instanceResult in getInstancesByIdsResult.Value) { instanceResult.Instance.Should().NotBeNull(); instanceResult.Error.Should().BeNull(); instanceResult.Instance.TimeSeriesId.ToArray().Length.Should().Be(numOfIdProperties); instanceResult.Instance.TypeId.Should().Be(defaultTypeId); instanceResult.Instance.HierarchyIds.Count.Should().Be(0); instanceResult.Instance.InstanceFields.Count.Should().Be(0); } return(null); }, MaxNumberOfRetries, s_retryDelay); // Update the instances by adding descriptions to them timeSeriesInstances.ForEach((timeSeriesInstance) => timeSeriesInstance.Description = "Description"); Response <InstancesOperationResult[]> replaceInstancesResult = await client .Instances .ReplaceAsync(timeSeriesInstances) .ConfigureAwait(false); replaceInstancesResult.Value.Length.Should().Be(timeSeriesInstances.Count); replaceInstancesResult.Value.Should().OnlyContain((errorResult) => errorResult.Error == null); // This retry logic was added as the TSI instance are not immediately available after creation await TestRetryHelper.RetryAsync <Response <InstancesOperationResult[]> >(async() => { // Get instances by name Response <InstancesOperationResult[]> getInstancesByNameResult = await client .Instances .GetAsync(timeSeriesInstances.Select((instance) => instance.Name)) .ConfigureAwait(false); getInstancesByNameResult.Value.Length.Should().Be(timeSeriesInstances.Count); foreach (InstancesOperationResult instanceResult in getInstancesByNameResult.Value) { instanceResult.Instance.Should().NotBeNull(); instanceResult.Error.Should().BeNull(); instanceResult.Instance.TimeSeriesId.ToArray().Length.Should().Be(numOfIdProperties); instanceResult.Instance.TypeId.Should().Be(defaultTypeId); instanceResult.Instance.HierarchyIds.Count.Should().Be(0); instanceResult.Instance.InstanceFields.Count.Should().Be(0); } return(null); }, MaxNumberOfRetries, s_retryDelay); // Get all Time Series instances in the environment AsyncPageable <TimeSeriesInstance> getAllInstancesResponse = client.Instances.GetAsync(); int numOfInstances = 0; await foreach (TimeSeriesInstance tsiInstance in getAllInstancesResponse) { numOfInstances++; tsiInstance.Should().NotBeNull(); } numOfInstances.Should().BeGreaterOrEqualTo(numOfInstancesToSetup); // Get search suggestions for the first instance TimeSeriesId timeSeriesIdToSuggest = timeSeriesInstances.First().TimeSeriesId; string suggestionString = timeSeriesIdToSuggest.ToArray().First(); Response <SearchSuggestion[]> searchSuggestionResponse = await TestRetryHelper.RetryAsync(async() => { Response <SearchSuggestion[]> searchSuggestions = await client .Instances .GetSearchSuggestionsAsync(suggestionString) .ConfigureAwait(false); if (searchSuggestions.Value.Length == 0) { throw new Exception($"Unable to find a search suggestion for string {suggestionString}."); } return(searchSuggestions); }, MaxNumberOfRetries, s_retryDelay); searchSuggestionResponse.Value.Length.Should().Be(1); } finally { // clean up try { Response <TimeSeriesOperationError[]> deleteInstancesResponse = await client .Instances .DeleteAsync(timeSeriesInstancesIds) .ConfigureAwait(false); // Assert that the response array does not have any error object set deleteInstancesResponse.Value.Should().OnlyContain((errorResult) => errorResult == null); } catch (Exception ex) { Console.WriteLine($"Test clean up failed: {ex.Message}"); throw; } } }