public async Task GetHooksWithOptionalNameFilter()
{
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
string hookName = Recording.GenerateAlphaNumericId("hook");
string hookNameFilter = hookName.Substring(1, hookName.Length - 3);
var hookToCreate = new WebNotificationHook()
{
Name = hookName, Endpoint = "http://contoso.com"
};
await using var disposableHook = await DisposableNotificationHook.CreateHookAsync(adminClient, hookToCreate);
var options = new GetHooksOptions()
{
HookNameFilter = hookNameFilter
};
var hookCount = 0;
await foreach (NotificationHook hook in adminClient.GetHooksAsync(options))
{
Assert.That(hook.Id, Is.Not.Null.And.Not.Empty);
Assert.That(hook.Name, Is.Not.Null.And.Not.Empty);
Assert.That(hook.Name.Contains(hookNameFilter));
Assert.That(hook.Administrators, Is.Not.Null.And.Not.Empty);
Assert.That(hook.Administrators.Any(admin => admin == null || admin == string.Empty), Is.False);
Assert.That(hook.Description, Is.Not.Null);
Assert.That(hook.ExternalLink, Is.Not.Null);
if (hook is EmailNotificationHook)
{
var emailHook = hook as EmailNotificationHook;
Assert.That(emailHook.EmailsToAlert, Is.Not.Null);
}
else
{
var webHook = hook as WebNotificationHook;
Assert.That(webHook, Is.Not.Null);
Assert.That(webHook.CertificateKey, Is.Not.Null);
Assert.That(webHook.CertificatePassword, Is.Not.Null);
Assert.That(webHook.Username, Is.Not.Null);
Assert.That(webHook.Password, Is.Not.Null);
Assert.That(webHook.Headers, Is.Not.Null);
Assert.That(webHook.Headers.Values.Any(value => value == null), Is.False);
}
if (++hookCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(hookCount, Is.GreaterThan(0));
}
public async Task UpdateWebNotificationHookWithEveryMemberAndGetInstance()
{
// Create a hook.
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
string hookName = Recording.GenerateAlphaNumericId("hook");
var endpoint = new Uri("http://contoso.com/");
var description = "This hook was created to test the .NET client.";
var headers = new Dictionary <string, string>()
{
{ "key1", "value1" },
{ "key2", "value2" }
};
var hookToCreate = new WebNotificationHook()
{
Name = hookName, Endpoint = endpoint
};
await using var disposableHook = await DisposableNotificationHook.CreateHookAsync(adminClient, hookToCreate);
// Update the created hook.
var hookToUpdate = disposableHook.Hook as WebNotificationHook;
hookToUpdate.Description = description;
hookToUpdate.ExternalLink = new Uri("http://fake.endpoint.com/");
// TODO: add certificate key validation (https://github.com/Azure/azure-sdk-for-net/issues/17485)
hookToUpdate.CertificatePassword = "******";
hookToUpdate.Username = "******";
hookToUpdate.Password = "******";
foreach (var header in headers)
{
hookToUpdate.Headers.Add(header);
}
var updatedWebHook = (await adminClient.UpdateHookAsync(hookToUpdate)).Value as WebNotificationHook;
// Check if updates are in place.
Assert.That(updatedWebHook.Id, Is.EqualTo(hookToUpdate.Id));
Assert.That(updatedWebHook.Name, Is.EqualTo(hookName));
Assert.That(updatedWebHook.Description, Is.EqualTo(description));
Assert.That(updatedWebHook.ExternalLink.AbsoluteUri, Is.EqualTo("http://fake.endpoint.com/"));
Assert.That(updatedWebHook.AdministratorsEmails, Is.Not.Null);
Assert.That(updatedWebHook.AdministratorsEmails.Single(), Is.Not.Null.And.Not.Empty);
Assert.That(updatedWebHook.Endpoint, Is.EqualTo(endpoint));
// TODO: add certificate key validation (https://github.com/Azure/azure-sdk-for-net/issues/17485)
Assert.That(updatedWebHook.CertificatePassword, Is.EqualTo("certPassword"));
Assert.That(updatedWebHook.Username, Is.EqualTo("fakeUsername"));
Assert.That(updatedWebHook.Password, Is.EqualTo("fakePassword"));
Assert.That(updatedWebHook.Headers, Is.EquivalentTo(headers));
}
public void CreateHookValidatesArguments()
{
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
var name = "hookName";
var endpoint = "http://fakeendpoint.com";
var genericHook = new NotificationHook()
{
Name = name
};
var emailHook = new EmailNotificationHook()
{
Name = null, EmailsToAlert = { "*****@*****.**" }
};
var webHook = new WebNotificationHook()
{
Name = null, Endpoint = endpoint
};
Assert.That(() => adminClient.CreateHookAsync(null), Throws.InstanceOf <ArgumentNullException>());
Assert.That(() => adminClient.CreateHook(null), Throws.InstanceOf <ArgumentNullException>());
Assert.That(() => adminClient.CreateHookAsync(emailHook), Throws.InstanceOf <ArgumentNullException>());
Assert.That(() => adminClient.CreateHook(emailHook), Throws.InstanceOf <ArgumentNullException>());
emailHook.Name = "";
Assert.That(() => adminClient.CreateHookAsync(emailHook), Throws.InstanceOf <ArgumentException>());
Assert.That(() => adminClient.CreateHook(emailHook), Throws.InstanceOf <ArgumentException>());
emailHook.Name = name;
emailHook.EmailsToAlert.Clear();
Assert.That(() => adminClient.CreateHookAsync(emailHook), Throws.InstanceOf <ArgumentException>());
Assert.That(() => adminClient.CreateHook(emailHook), Throws.InstanceOf <ArgumentException>());
Assert.That(() => adminClient.CreateHookAsync(webHook), Throws.InstanceOf <ArgumentNullException>());
Assert.That(() => adminClient.CreateHook(webHook), Throws.InstanceOf <ArgumentNullException>());
webHook.Name = "";
Assert.That(() => adminClient.CreateHookAsync(webHook), Throws.InstanceOf <ArgumentException>());
Assert.That(() => adminClient.CreateHook(webHook), Throws.InstanceOf <ArgumentException>());
webHook.Name = name;
webHook.Endpoint = null;
Assert.That(() => adminClient.CreateHookAsync(webHook), Throws.InstanceOf <ArgumentNullException>());
Assert.That(() => adminClient.CreateHook(webHook), Throws.InstanceOf <ArgumentNullException>());
webHook.Endpoint = "";
Assert.That(() => adminClient.CreateHookAsync(webHook), Throws.InstanceOf <ArgumentException>());
Assert.That(() => adminClient.CreateHook(webHook), Throws.InstanceOf <ArgumentException>());
Assert.That(() => adminClient.CreateHookAsync(genericHook), Throws.InstanceOf <ArgumentException>());
Assert.That(() => adminClient.CreateHook(genericHook), Throws.InstanceOf <ArgumentException>());
}
public async Task CreateAndGetWebNotificationHookWithOptionalMembers()
{
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
string hookName = Recording.GenerateAlphaNumericId("hook");
var endpoint = new Uri("http://contoso.com/");
var description = "This hook was created to test the .NET client.";
var headers = new Dictionary <string, string>()
{
{ "key1", "value1" },
{ "key2", "value2" }
};
var hookToCreate = new WebNotificationHook()
{
Name = hookName,
Endpoint = endpoint,
Description = description,
ExternalLink = new Uri("http://fake.endpoint.com/"),
// TODO: add CertificateKey validation (https://github.com/Azure/azure-sdk-for-net/issues/17485)
CertificatePassword = "******",
Username = "******",
Password = "******"
};
foreach (var header in headers)
{
hookToCreate.Headers.Add(header);
}
await using var disposableHook = await DisposableNotificationHook.CreateHookAsync(adminClient, hookToCreate);
NotificationHook createdHook = disposableHook.Hook;
Assert.That(createdHook.Id, Is.Not.Null.And.Not.Empty);
Assert.That(createdHook.Name, Is.EqualTo(hookName));
Assert.That(createdHook.Description, Is.EqualTo(description));
Assert.That(createdHook.ExternalLink.AbsoluteUri, Is.EqualTo("http://fake.endpoint.com/"));
Assert.That(createdHook.AdministratorsEmails, Is.Not.Null);
Assert.That(createdHook.AdministratorsEmails.Single(), Is.Not.Null.And.Not.Empty);
var createdWebHook = createdHook as WebNotificationHook;
Assert.That(createdWebHook, Is.Not.Null);
Assert.That(createdWebHook.Endpoint, Is.EqualTo(endpoint));
// TODO: add CertificateKey validation (https://github.com/Azure/azure-sdk-for-net/issues/17485)
Assert.That(createdWebHook.CertificatePassword, Is.EqualTo("certPassword"));
Assert.That(createdWebHook.Username, Is.EqualTo("fakeUsername"));
Assert.That(createdWebHook.Password, Is.EqualTo("fakePassword"));
Assert.That(createdWebHook.Headers, Is.EquivalentTo(headers));
}
public async Task GetHooksWithMinimumSetup(bool useTokenCredential)
{
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient(useTokenCredential);
string hookName = Recording.GenerateAlphaNumericId("hook");
var hookToCreate = new WebNotificationHook()
{
Name = hookName, Endpoint = new Uri("http://contoso.com/")
};
await using var disposableHook = await DisposableNotificationHook.CreateHookAsync(adminClient, hookToCreate);
var hookCount = 0;
await foreach (NotificationHook hook in adminClient.GetHooksAsync())
{
Assert.That(hook.Id, Is.Not.Null.And.Not.Empty);
Assert.That(hook.Name, Is.Not.Null.And.Not.Empty);
Assert.That(hook.AdministratorsEmails, Is.Not.Null.And.Not.Empty);
Assert.That(hook.AdministratorsEmails.Any(admin => admin == null || admin == string.Empty), Is.False);
Assert.That(hook.Description, Is.Not.Null);
if (hook is EmailNotificationHook)
{
var emailHook = hook as EmailNotificationHook;
Assert.That(emailHook.EmailsToAlert, Is.Not.Null);
}
else
{
var webHook = hook as WebNotificationHook;
Assert.That(webHook, Is.Not.Null);
Assert.That(webHook.CertificateKey, Is.Not.Null);
Assert.That(webHook.CertificatePassword, Is.Not.Null);
Assert.That(webHook.Username, Is.Not.Null);
Assert.That(webHook.Password, Is.Not.Null);
Assert.That(webHook.Headers, Is.Not.Null);
Assert.That(webHook.Headers.Values.Any(value => value == null), Is.False);
}
if (++hookCount >= MaximumSamplesCount)
{
break;
}
}
Assert.That(hookCount, Is.GreaterThan(0));
}
public async Task HookOperations()
{
var adminClient = GetMetricsAdvisorAdministrationClient();
var emailHook = new EmailNotificationHook(Recording.GenerateAlphaNumericId("test"), new List <string> {
"*****@*****.**"
})
{
Description = $"{nameof(EmailNotificationHook)} description"
};
string createdEmailHookId = await adminClient.CreateHookAsync(emailHook).ConfigureAwait(false);
EmailNotificationHook getEmailHook = (await adminClient.GetHookAsync(createdEmailHookId).ConfigureAwait(false)).Value as EmailNotificationHook;
getEmailHook.Description = "updated description";
getEmailHook.EmailsToAlert.Add($"{Recording.GenerateAlphaNumericId("user")}@contoso.com");
await adminClient.UpdateHookAsync(getEmailHook.Id, getEmailHook).ConfigureAwait(false);
var webHook = new WebNotificationHook(Recording.GenerateAlphaNumericId("test"), "http://contoso.com")
{
Description = $"{nameof(WebNotificationHook)} description"
};
string createdWebHookId = await adminClient.CreateHookAsync(webHook).ConfigureAwait(false);
webHook.Description = "updated description";
await adminClient.UpdateHookAsync(createdEmailHookId, emailHook).ConfigureAwait(false);
WebNotificationHook getWebHook = (await adminClient.GetHookAsync(createdWebHookId).ConfigureAwait(false)).Value as WebNotificationHook;
getWebHook.Description = "updated description";
getWebHook.CertificateKey = Recording.GenerateAlphaNumericId("key");
List <NotificationHook> hooks = await adminClient.GetHooksAsync(new GetHooksOptions { HookNameFilter = getWebHook.Name }).ToEnumerableAsync().ConfigureAwait(false);
Assert.That(getEmailHook.Id, Is.EqualTo(createdEmailHookId));
Assert.That(getEmailHook.Name, Is.EqualTo(emailHook.Name));
Assert.That(hooks, Is.Not.Empty);
Assert.That(hooks.Any(h => h.Name == getWebHook.Name), $"hooks should contain name {emailHook.Name}, but contained names: {string.Join(",", hooks.Select(h => h.Name))}");
await adminClient.DeleteHookAsync(createdEmailHookId).ConfigureAwait(false);
}
public async Task UpdateWebNotificationHookWithMinimumSetupAndNewInstance()
{
// Create a hook.
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
string hookName = Recording.GenerateAlphaNumericId("hook");
var endpoint = "http://contoso.com";
var hookToCreate = new WebNotificationHook()
{
Name = hookName, Endpoint = endpoint
};
await using var disposableHook = await DisposableNotificationHook.CreateHookAsync(adminClient, hookToCreate);
// Update the created hook.
var hookToUpdate = new WebNotificationHook()
{
Endpoint = endpoint, Username = "******"
};
await adminClient.UpdateHookAsync(disposableHook.Id, hookToUpdate);
// Get the hook and check if updates are in place.
var updatedWebHook = (await adminClient.GetHookAsync(disposableHook.Id)).Value as WebNotificationHook;
Assert.That(updatedWebHook.Id, Is.EqualTo(disposableHook.Id));
Assert.That(updatedWebHook.Name, Is.EqualTo(hookName));
Assert.That(updatedWebHook.Description, Is.Empty);
Assert.That(updatedWebHook.ExternalLink, Is.Empty);
Assert.That(updatedWebHook.Administrators, Is.Not.Null);
Assert.That(updatedWebHook.Administrators.Single(), Is.Not.Null.And.Not.Empty);
Assert.That(updatedWebHook.Endpoint, Is.EqualTo(endpoint));
Assert.That(updatedWebHook.CertificateKey, Is.Empty);
Assert.That(updatedWebHook.CertificatePassword, Is.Empty);
Assert.That(updatedWebHook.Username, Is.EqualTo("fakeUsername"));
Assert.That(updatedWebHook.Password, Is.Empty);
Assert.That(updatedWebHook.Headers, Is.Not.Null.And.Empty);
}
public async Task GetHookAsync()
{
string endpoint = MetricsAdvisorUri;
string subscriptionKey = MetricsAdvisorSubscriptionKey;
string apiKey = MetricsAdvisorApiKey;
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var adminClient = new MetricsAdvisorAdministrationClient(new Uri(endpoint), credential);
string hookId = HookId;
Response <NotificationHook> response = await adminClient.GetHookAsync(hookId);
NotificationHook hook = response.Value;
Console.WriteLine($"Hook name: {hook.Name}");
Console.WriteLine($"Hook description: {hook.Description}");
Console.WriteLine($"Hook administrators emails:");
foreach (string admin in hook.AdministratorsEmails)
{
Console.WriteLine($" - {admin}");
}
if (hook.HookType == HookType.Email)
{
EmailNotificationHook emailHook = hook as EmailNotificationHook;
Console.WriteLine("Emails to alert:");
foreach (string email in emailHook.EmailsToAlert)
{
Console.WriteLine($" - {email}");
}
}
else if (hook.HookType == HookType.Webhook)
{
WebNotificationHook webHook = hook as WebNotificationHook;
Console.WriteLine($"Username: {webHook.Username}");
}
}
public async Task UpdateWebNotificationHookWithMinimumSetup()
{
// Create a hook.
MetricsAdvisorAdministrationClient adminClient = GetMetricsAdvisorAdministrationClient();
string hookName = Recording.GenerateAlphaNumericId("hook");
var hookToCreate = new WebNotificationHook(hookName, new Uri("http://contoso.com/"));
await using var disposableHook = await DisposableNotificationHook.CreateHookAsync(adminClient, hookToCreate);
// Update the created hook.
var hookToUpdate = disposableHook.Hook as WebNotificationHook;
hookToUpdate.Username = "******";
var updatedWebHook = (await adminClient.UpdateHookAsync(hookToUpdate)).Value as WebNotificationHook;
// Check if updates are in place.
Assert.That(updatedWebHook.Id, Is.EqualTo(hookToUpdate.Id));
Assert.That(updatedWebHook.Name, Is.EqualTo(hookName));
Assert.That(updatedWebHook.Description, Is.Empty);
Assert.That(updatedWebHook.ExternalUri, Is.Null);
Assert.That(updatedWebHook.Administrators, Is.Not.Null);
Assert.That(updatedWebHook.Administrators.Single(), Is.Not.Null.And.Not.Empty);
Assert.That(updatedWebHook.Endpoint.AbsoluteUri, Is.EqualTo("http://contoso.com/"));
Assert.That(updatedWebHook.CertificateKey, Is.Empty);
Assert.That(updatedWebHook.CertificatePassword, Is.Empty);
Assert.That(updatedWebHook.Username, Is.EqualTo("fakeUsername"));
Assert.That(updatedWebHook.Password, Is.Empty);
Assert.That(updatedWebHook.Headers, Is.Not.Null.And.Empty);
}
