public async Task Delete()
{
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
var credentialName = Recording.GenerateAlphaNumericId("credential");
var credentialToCreate = new ServicePrincipalCredentialEntity(credentialName, "clientId", "clientSecret", "tenantId");
string credentialId = null;
try
{
DataSourceCredentialEntity createdCredential = await adminClient.CreateDataSourceCredentialAsync(credentialToCreate);
credentialId = createdCredential.Id;
Assert.That(credentialId, Is.Not.Null.And.Not.Empty);
}
finally
{
if (credentialId != null)
{
await adminClient.DeleteDataSourceCredentialAsync(credentialId);
var errorCause = "credentialId is invalid";
Assert.That(async() => await adminClient.GetDataSourceCredentialAsync(credentialId), Throws.InstanceOf <RequestFailedException>().With.Message.Contains(errorCause));
}
}
}
private void ValidateTestCaseDataSourceCredentialEntity(DataSourceCredentialEntity credential)
{
if (credential is ServicePrincipalCredentialEntity spCredential)
{
Assert.That(spCredential.CredentialKind, Is.EqualTo(DataSourceCredentialKind.ServicePrincipal));
Assert.That(spCredential.ClientId, Is.EqualTo(ClientId));
Assert.That(spCredential.TenantId, Is.EqualTo(TenantId));
}
else if (credential is ServicePrincipalInKeyVaultCredentialEntity kvCredential)
{
Assert.That(kvCredential.CredentialKind, Is.EqualTo(DataSourceCredentialKind.ServicePrincipalInKeyVault));
Assert.That(kvCredential.Endpoint.AbsoluteUri, Is.EqualTo(Endpoint));
Assert.That(kvCredential.KeyVaultClientId, Is.EqualTo(ClientId));
Assert.That(kvCredential.TenantId, Is.EqualTo(TenantId));
Assert.That(kvCredential.SecretNameForClientId, Is.EqualTo(ClientIdSecretName));
Assert.That(kvCredential.SecretNameForClientSecret, Is.EqualTo(ClientSecretSecretName));
}
else if (credential is DataLakeSharedKeyCredentialEntity skCredential)
{
Assert.That(skCredential.CredentialKind, Is.EqualTo(DataSourceCredentialKind.DataLakeSharedKey));
}
else if (credential is SqlConnectionStringCredentialEntity csCredential)
{
Assert.That(csCredential.CredentialKind, Is.EqualTo(DataSourceCredentialKind.SqlConnectionString));
}
else
{
throw new Exception($"Unknown credential type: {credential.GetType()}");
}
}
public async Task CreateAndDeleteDataSourceCredentialAsync()
{
string endpoint = MetricsAdvisorUri;
string subscriptionKey = MetricsAdvisorSubscriptionKey;
string apiKey = MetricsAdvisorApiKey;
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var adminClient = new MetricsAdvisorAdministrationClient(new Uri(endpoint), credential);
#region Snippet:CreateDataSourceCredentialAsync
#if SNIPPET
string credentialName = "<credentialName>";
#else
string credentialName = GetUniqueName();
#endif
var credentialEntity = new ServicePrincipalCredentialEntity(credentialName, "<clientId>", "<clientSecret>", "<tenantId>");
Response <DataSourceCredentialEntity> response = await adminClient.CreateDataSourceCredentialAsync(credentialEntity);
DataSourceCredentialEntity createdCredentialEntity = response.Value;
Console.WriteLine($"Credential entity ID: {createdCredentialEntity.Id}");
#endregion
// Delete the created credential to clean up the Metrics Advisor resource. Do not perform this
// step if you intend to keep using the credential.
await adminClient.DeleteDataSourceCredentialAsync(createdCredentialEntity.Id);
}
internal static DataSourceCredentialList DeserializeDataSourceCredentialList(JsonElement element)
{
Optional <string> nextLink = default;
Optional <IReadOnlyList <DataSourceCredentialEntity> > value = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("@nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
if (property.NameEquals("value"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
List <DataSourceCredentialEntity> array = new List <DataSourceCredentialEntity>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(DataSourceCredentialEntity.DeserializeDataSourceCredentialEntity(item));
}
value = array;
continue;
}
}
return(new DataSourceCredentialList(nextLink.Value, Optional.ToList(value)));
}
/// <summary>
/// Creates a data source credential entity using the specified <see cref="MetricsAdvisorAdministrationClient"/>.
/// A <see cref="DisposableDataSourceCredentialEntity"/> instance is returned, from which the created credential can
/// be obtained. Except for the name, all of its required properties are initialized with mock values. Upon disposal,
/// the created credential will be deleted.
/// </summary>
/// <param name="adminClient">The client to use for creating and for deleting the data source credential entity.</param>
/// <param name="name">The name of the data source credential entity to be created.</param>
/// <param name="authenticationType">Specifies which type of <see cref="DataSourceCredentialEntity"/> should be created.</param>
/// <returns>A <see cref="DisposableDataSourceCredentialEntity"/> instance from which the created credential can be obtained.</returns>
public static async Task <DisposableDataSourceCredentialEntity> CreateDataSourceCredentialEntityAsync(MetricsAdvisorAdministrationClient adminClient, string name, string authenticationType)
{
DataSourceCredentialEntity credential = authenticationType switch
{
"ServicePrincipal" => new ServicePrincipalCredentialEntity(name, "mock", "mock", "mock"),
"ServicePrincipalInKeyVault" => new ServicePrincipalInKeyVaultCredentialEntity(name, new Uri("https://mock.com/"), "mock", "mock", "mock", "mock", "mock"),
"SharedKey" => new DataLakeSharedKeyCredentialEntity(name, "mock"),
"SqlConnectionString" => new SqlConnectionStringCredentialEntity(name, "mock"),
_ => throw new ArgumentOutOfRangeException($"Invalid data source credential type: {authenticationType}")
};
return(await CreateDataSourceCredentialEntityAsync(adminClient, credential).ConfigureAwait(false));
}
public async Task CreateAndGetWithDescription(string credentialTypeName)
{
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
string credentialName = Recording.GenerateAlphaNumericId("credential");
string expectedDescription = "This is a description";
DataSourceCredentialEntity credentialToCreate = GetDataSourceCredentialEntityTestCase(credentialTypeName, credentialName);
credentialToCreate.Description = expectedDescription;
await using var disposableCredential = await DisposableDataSourceCredentialEntity.CreateDataSourceCredentialEntityAsync(adminClient, credentialToCreate);
DataSourceCredentialEntity createdCredential = disposableCredential.Credential;
Assert.That(createdCredential.Description, Is.EqualTo(expectedDescription));
}
public async Task CreateAndGet(string credentialTypeName)
{
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
string credentialName = Recording.GenerateAlphaNumericId("credential");
DataSourceCredentialEntity credentialToCreate = GetDataSourceCredentialEntityTestCase(credentialTypeName, credentialName);
await using var disposableCredential = await DisposableDataSourceCredentialEntity.CreateDataSourceCredentialEntityAsync(adminClient, credentialToCreate);
DataSourceCredentialEntity createdCredential = disposableCredential.Credential;
Assert.That(createdCredential.Id, Is.Not.Empty.And.Not.Null);
Assert.That(createdCredential.Name, Is.EqualTo(credentialName));
Assert.That(createdCredential.Description, Is.Empty);
ValidateTestCaseDataSourceCredentialEntity(createdCredential);
}
public async Task UpdateCommonPropertiesWithNullSetsToDefault(string credentialKind)
{
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
string credentialName = Recording.GenerateAlphaNumericId("credential");
DataSourceCredentialEntity credentialToCreate = GetDataSourceCredentialEntityTestCase(credentialKind, credentialName);
await using var disposableCredential = await DisposableDataSourceCredentialEntity.CreateDataSourceCredentialEntityAsync(adminClient, credentialToCreate);
DataSourceCredentialEntity credentialToUpdate = disposableCredential.Credential;
credentialToUpdate.Description = null;
DataSourceCredentialEntity updatedCredential = await adminClient.UpdateDataSourceCredentialAsync(credentialToUpdate);
Assert.That(updatedCredential.Description, Is.Empty);
}
public async Task DataSourceCredentialEntitySendsSecretDuringCreation(DataSourceCredentialEntity credential, string expectedSubstring)
{
MockResponse createResponse = new MockResponse(201);
createResponse.AddHeader(new HttpHeader("Location", $"https://fakeresource.cognitiveservices.azure.com/metricsadvisor/v1.0/credentials/{FakeGuid}"));
MockResponse getResponse = new MockResponse(200);
getResponse.SetContent(DataSourceCredentialEntityResponseContent);
MockTransport mockTransport = new MockTransport(createResponse, getResponse);
MetricsAdvisorAdministrationClient adminClient = CreateInstrumentedAdministrationClient(mockTransport);
await adminClient.CreateDataSourceCredentialAsync(credential);
MockRequest request = mockTransport.Requests.First();
string content = ReadContent(request);
Assert.That(content, Contains.Substring(expectedSubstring));
}
public async Task GetDataSourceCredentialAsync()
{
string endpoint = MetricsAdvisorUri;
string subscriptionKey = MetricsAdvisorSubscriptionKey;
string apiKey = MetricsAdvisorApiKey;
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var adminClient = new MetricsAdvisorAdministrationClient(new Uri(endpoint), credential);
string credentialEntityId = CredentialEntityId;
Response <DataSourceCredentialEntity> response = await adminClient.GetDataSourceCredentialAsync(credentialEntityId);
DataSourceCredentialEntity credentialEntity = response.Value;
Console.WriteLine($"Credential name: {credentialEntity.Name}");
Console.WriteLine($"Credential description: {credentialEntity.Description}");
// You can access specific properties of your credential entity depending on its kind.
if (credentialEntity.CredentialKind == DataSourceCredentialKind.ServicePrincipal)
{
Console.WriteLine("Credential of kind Service Principal:");
var servicePrincipalEntity = credentialEntity as ServicePrincipalCredentialEntity;
Console.WriteLine($" Client ID: {servicePrincipalEntity.ClientId}");
Console.WriteLine($" Tenant ID: {servicePrincipalEntity.TenantId}");
}
else if (credentialEntity.CredentialKind == DataSourceCredentialKind.ServicePrincipalInKeyVault)
{
Console.WriteLine("Credential of kind Service Principal in Key Vault:");
var servicePrincipalEntity = credentialEntity as ServicePrincipalInKeyVaultCredentialEntity;
Console.WriteLine($"Name of secret for client ID: {servicePrincipalEntity.SecretNameForClientId}");
Console.WriteLine($"Name of secret for client secret: {servicePrincipalEntity.SecretNameForClientSecret}");
}
}
public async Task UpdateCommonProperties(string credentialTypeName)
{
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
string credentialName = Recording.GenerateAlphaNumericId("credential");
DataSourceCredentialEntity credentialToCreate = GetDataSourceCredentialEntityTestCase(credentialTypeName, credentialName);
await using var disposableCredential = await DisposableDataSourceCredentialEntity.CreateDataSourceCredentialEntityAsync(adminClient, credentialToCreate);
DataSourceCredentialEntity credentialToUpdate = disposableCredential.Credential;
string expectedName = Recording.GenerateAlphaNumericId("credential");
string expectedDescription = "This description was created by a .NET test";
credentialToUpdate.Name = expectedName;
credentialToUpdate.Description = expectedDescription;
DataSourceCredentialEntity updatedCredential = await adminClient.UpdateDataSourceCredentialAsync(credentialToUpdate);
Assert.That(updatedCredential.Id, Is.EqualTo(credentialToUpdate.Id));
Assert.That(updatedCredential.Name, Is.EqualTo(expectedName));
Assert.That(updatedCredential.Description, Is.EqualTo(expectedDescription));
}
public async Task UpdateDataSourceCredentialAsync()
{
string endpoint = MetricsAdvisorUri;
string subscriptionKey = MetricsAdvisorSubscriptionKey;
string apiKey = MetricsAdvisorApiKey;
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var adminClient = new MetricsAdvisorAdministrationClient(new Uri(endpoint), credential);
string credentialEntityId = CredentialEntityId;
Response <DataSourceCredentialEntity> response = await adminClient.GetDataSourceCredentialAsync(credentialEntityId);
DataSourceCredentialEntity credentialEntity = response.Value;
credentialEntity.Description = "This description was generated by a sample.";
// You can update specific properties of your credential entity depending on its kind.
if (credentialEntity.CredentialKind == DataSourceCredentialKind.ServicePrincipal)
{
var servicePrincipalEntity = credentialEntity as ServicePrincipalCredentialEntity;
servicePrincipalEntity.ClientId = "<newClientId>";
// Secrets can't be read and must be updated through specific methods.
servicePrincipalEntity.UpdateClientSecret("<newClientSecret>");
}
response = await adminClient.UpdateDataSourceCredentialAsync(credentialEntity);
DataSourceCredentialEntity updatedCredentialEntity = response.Value;
Console.WriteLine($"Updated description: {updatedCredentialEntity.Description}");
}
/// <summary>
/// Creates a data source credential entity using the specified <see cref="MetricsAdvisorAdministrationClient"/>.
/// A <see cref="DisposableDataSourceCredentialEntity"/> is returned, from which the created credential
/// can be obtained. Upon disposal, the created credential will be deleted.
/// </summary>
/// <param name="adminClient">The client to use for creating and for deleting the data source credential entity.</param>
/// <param name="credential">Specifies how the created <see cref="DataSourceCredentialEntity"/> should be configured.</param>
/// <returns>A <see cref="DisposableDataSourceCredentialEntity"/> instance from which the created credential entity can be obtained.</returns>
public static async Task <DisposableDataSourceCredentialEntity> CreateDataSourceCredentialEntityAsync(MetricsAdvisorAdministrationClient adminClient, DataSourceCredentialEntity credential)
{
DataSourceCredentialEntity createdCredential = await adminClient.CreateDataSourceCredentialAsync(credential);
return(new DisposableDataSourceCredentialEntity(adminClient, createdCredential));
}
/// <summary>
/// Initializes a new instance of the <see cref="DisposableDataSourceCredentialEntity"/> class.
/// </summary>
/// <param name="adminClient">The client to use for deleting the credential entity upon disposal.</param>
/// <param name="credential">The data source credential entity this instance is associated with.</param>
private DisposableDataSourceCredentialEntity(MetricsAdvisorAdministrationClient adminClient, DataSourceCredentialEntity credential)
{
_adminClient = adminClient;
Credential = credential;
}
