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;
}
}
}
