public void UpdateRulesTest()
{
AlertRuleResource resource = GetRuleResourceCollection().FirstOrDefault();
resource.IsEnabled = false;
resource.Tags = new Dictionary <string, string>()
{
{ "key2", "val2" }
};
var handler = new RecordedDelegatingHandler();
var monitorManagementClient = GetMonitorManagementClient(handler);
var serializedObject = Microsoft.Rest.Serialization.SafeJsonConvert.SerializeObject(resource, monitorManagementClient.SerializationSettings);
serializedObject = serializedObject.Replace("{", "{\"name\":\"" + resource.Name + "\",\"id\":\"" + resource.Id + "\",");
var expectedResponse = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(serializedObject)
};
handler = new RecordedDelegatingHandler(expectedResponse);
monitorManagementClient = GetMonitorManagementClient(handler);
AlertRuleResourcePatch pathResource = new AlertRuleResourcePatch(
name: resource.Name,
isEnabled: false,
tags: new Dictionary <string, string>()
{
{ "key2", "val2" }
},
actions: resource.Actions,
condition: resource.Condition,
description: resource.Description,
lastUpdatedTime: resource.LastUpdatedTime
);
var actualResponse = monitorManagementClient.AlertRules.Update(resourceGroupName: "rg1", ruleName: resource.Name, alertRulesResource: pathResource);
Utilities.AreEqual(resource, actualResponse);
}
public void MetricBasedRule()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
MonitorManagementClient insightsClient = GetMonitorManagementClient(context, handler);
this.VerifyExistenceOrCreateResourceGroup(resourceGroupName: ResourceGroupName, location: Location);
AlertRuleResource expectedParameters = GetCreateOrUpdateRuleParameter(insightsClient.SubscriptionId);
AlertRuleResource result = insightsClient.AlertRules.CreateOrUpdate(
resourceGroupName: ResourceGroupName,
ruleName: RuleName,
parameters: expectedParameters);
if (!this.IsRecording)
{
Check(result);
}
AlertRuleResource retrievedRule = insightsClient.AlertRules.Get(
resourceGroupName: ResourceGroupName,
ruleName: RuleName);
if (!this.IsRecording)
{
Check(retrievedRule);
Utilities.AreEqual(result, retrievedRule);
}
IEnumerable <AlertRuleResource> enumOfRules = insightsClient.AlertRules.ListByResourceGroup(
resourceGroupName: ResourceGroupName);
if (!this.IsRecording)
{
var listOfRules = enumOfRules.ToList();
var selected = listOfRules.Where(r => string.Equals(r.Id, retrievedRule.Id, StringComparison.OrdinalIgnoreCase)).ToList();
Assert.NotNull(selected);
Assert.NotEmpty(selected);
Assert.True(selected.Count == 1);
Utilities.AreEqual(retrievedRule, selected[0]);
}
var newTags = new Dictionary <string, string>()
{
{ "key2", "val2" }
};
// TODO: Update is requiring 'location', but it was not specified so.
AlertRuleResourcePatch pathResource = new AlertRuleResourcePatch(
name: retrievedRule.Name,
isEnabled: !retrievedRule.IsEnabled,
tags: newTags,
actions: retrievedRule.Actions,
condition: retrievedRule.Condition,
description: retrievedRule.Description,
lastUpdatedTime: retrievedRule.LastUpdatedTime
);
AlertRuleResource updatedRule = null;
Assert.Throws <ErrorResponseException>(
() => updatedRule = insightsClient.AlertRules.Update(
resourceGroupName: ResourceGroupName,
ruleName: RuleName,
alertRulesResource: pathResource));
if (!this.IsRecording && updatedRule != null)
{
Check(updatedRule);
Assert.NotEqual(retrievedRule.Tags, updatedRule.Tags);
Assert.True(retrievedRule.IsEnabled = !updatedRule.IsEnabled);
Assert.Equal(retrievedRule.Name, updatedRule.Name);
Assert.Equal(retrievedRule.Location, updatedRule.Location);
Assert.Equal(retrievedRule.Id, updatedRule.Id);
}
AlertRuleResource retrievedUpdatedRule = insightsClient.AlertRules.Get(
resourceGroupName: ResourceGroupName,
ruleName: RuleName);
if (!this.IsRecording && updatedRule != null)
{
Check(retrievedRule);
Utilities.AreEqual(updatedRule, retrievedUpdatedRule);
}
insightsClient.AlertRules.Delete(
resourceGroupName: ResourceGroupName,
ruleName: RuleName);
Assert.Throws <ErrorResponseException>(
() => insightsClient.AlertRules.Get(
resourceGroupName: ResourceGroupName,
ruleName: RuleName));
}
}
/// <summary>
/// Updates an existing AlertRuleResource. To update other fields use the
/// CreateOrUpdate method.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='ruleName'>
/// The name of the rule.
/// </param>
/// <param name='alertRulesResource'>
/// Parameters supplied to the operation.
/// </param>
public static AlertRuleResource Update(this IAlertRulesOperations operations, string resourceGroupName, string ruleName, AlertRuleResourcePatch alertRulesResource)
{
return(operations.UpdateAsync(resourceGroupName, ruleName, alertRulesResource).GetAwaiter().GetResult());
}
/// <summary>
/// Updates an existing AlertRuleResource. To update other fields use the
/// CreateOrUpdate method.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='ruleName'>
/// The name of the rule.
/// </param>
/// <param name='alertRulesResource'>
/// Parameters supplied to the operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <AlertRuleResource> UpdateAsync(this IAlertRulesOperations operations, string resourceGroupName, string ruleName, AlertRuleResourcePatch alertRulesResource, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.UpdateWithHttpMessagesAsync(resourceGroupName, ruleName, alertRulesResource, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public virtual Response <AlertRuleResource> Update(string resourceGroupName, string ruleName, AlertRuleResourcePatch alertRulesResource, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("AlertRulesOperations.Update");
scope.Start();
try
{
return(RestClient.Update(resourceGroupName, ruleName, alertRulesResource, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
