private static ManagementGroupResourceExtensionClient GetExtensionClient(ManagementGroupResource managementGroupResource)
{
return(managementGroupResource.GetCachedClient((client) =>
{
return new ManagementGroupResourceExtensionClient(client, managementGroupResource.Id);
}
));
}
public async Task Get()
{
ManagementGroupResource mgmtGroup = await Client.GetManagementGroups().GetAsync(_mgmtGroupName, cacheControl: "no-cache");
CompareMgmtGroups(_mgmtGroup, mgmtGroup);
RequestFailedException ex = Assert.ThrowsAsync <RequestFailedException>(async() => _ = await Client.GetManagementGroups().GetAsync("NotThere", cacheControl: "no-cache"));
Assert.AreEqual(403, ex.Status);
}
public async Task GetGlobalManagementGroup()
{
_mgmtGroupName = SessionRecording.GenerateAssetName("mgmt-group-");
var mgmtGroupCollection = GlobalClient.GetManagementGroups();
var mgmtOp = await mgmtGroupCollection.CreateOrUpdateAsync(WaitUntil.Completed, _mgmtGroupName, new CreateManagementGroupOptions());
_mgmtGroup = mgmtOp.Value;
_mgmtGroup = await _mgmtGroup.GetAsync();
await StopSessionRecordingAsync();
}
protected void CompareMgmtGroups(ManagementGroupResource expected, ManagementGroupResource actual)
{
Assert.AreEqual(expected.Data.DisplayName, actual.Data.DisplayName);
Assert.AreEqual(expected.Data.Id, actual.Data.Id);
Assert.AreEqual(expected.Data.Name, actual.Data.Name);
Assert.AreEqual(expected.Data.TenantId, actual.Data.TenantId);
Assert.AreEqual(expected.Data.ResourceType, actual.Data.ResourceType);
Assert.IsNotNull(actual.Data.Details, "Details were null");
Assert.IsNotNull(actual.Data.Children, "Children were null");
}
public async Task GetGlobalManagementGroup()
{
_mgmtGroupName = SessionRecording.GenerateAssetName("mgmt-group-");
var mgmtOp = await GlobalClient.GetManagementGroups().CreateOrUpdateAsync(WaitUntil.Started, _mgmtGroupName, new ManagementGroupCreateOrUpdateContent());
await mgmtOp.WaitForCompletionAsync();
_mgmtGroup = mgmtOp.Value;
_mgmtGroup = await _mgmtGroup.GetAsync();
await StopSessionRecordingAsync();
}
public async Task CreateOrUpdateAtMgmtGroup()
{
//This test uses a pre-created management group.
ManagementGroupResource mgmtGroup = await GetCreatedManagementGroup();
string policyAssignmentName = Recording.GenerateAssetName("polAssign-");
PolicyAssignmentResource policyAssignment = await CreatePolicyAssignment(mgmtGroup, policyAssignmentName);
Assert.AreEqual(policyAssignmentName, policyAssignment.Data.Name);
Assert.ThrowsAsync <ArgumentNullException>(async() => _ = await mgmtGroup.GetPolicyAssignments().CreateOrUpdateAsync(WaitUntil.Completed, null, policyAssignment.Data));
Assert.ThrowsAsync <ArgumentNullException>(async() => _ = await mgmtGroup.GetPolicyAssignments().CreateOrUpdateAsync(WaitUntil.Completed, policyAssignmentName, null));
}
public async Task StartCreateOrUpdate()
{
string mgmtGroupName = Recording.GenerateAssetName("mgmt-group-");
var mgmtGroupOp = await Client.GetManagementGroups().CreateOrUpdateAsync(WaitUntil.Started, mgmtGroupName, new CreateManagementGroupOptions());
ManagementGroupResource mgmtGroup = await mgmtGroupOp.WaitForCompletionAsync();
Assert.AreEqual($"/providers/Microsoft.Management/managementGroups/{mgmtGroupName}", mgmtGroup.Data.Id.ToString());
Assert.AreEqual(mgmtGroupName, mgmtGroup.Data.Name);
Assert.AreEqual(mgmtGroupName, mgmtGroup.Data.DisplayName);
Assert.AreEqual(ManagementGroupResource.ResourceType, mgmtGroup.Data.ResourceType);
}
public async Task GetDescendants()
{
ManagementGroupResource mgmtGroup = await Client.GetManagementGroupResource(_mgmtGroup.Id).GetAsync();
DescendantData descendant = null;
await foreach (var desc in mgmtGroup.GetDescendantsAsync())
{
descendant = desc;
break;
}
Assert.IsNull(descendant); //should have no descendants
}
public async Task Delete()
{
var mgmtGroupOp = await Client.GetManagementGroups().CreateOrUpdateAsync(WaitUntil.Started, Recording.GenerateAssetName("mgmt-group-"), new ManagementGroupCreateOrUpdateContent());
await mgmtGroupOp.WaitForCompletionAsync();
ManagementGroupResource mgmtGroup = mgmtGroupOp.Value;
await mgmtGroup.DeleteAsync(WaitUntil.Completed);
var ex = Assert.ThrowsAsync <RequestFailedException>(async() => await mgmtGroup.GetAsync());
Assert.AreEqual(404, ex.Status);
}
public async Task Update()
{
var mgmtGroupOp = await Client.GetManagementGroups()
.CreateOrUpdateAsync(WaitUntil.Started, Recording.GenerateAssetName("mgmt-group-"), new ManagementGroupCreateOrUpdateContent());
await mgmtGroupOp.WaitForCompletionAsync();
ManagementGroupResource mgmtGroup = mgmtGroupOp.Value;
ManagementGroupPatch patch = new ManagementGroupPatch();
patch.DisplayName = "New Display Name";
ManagementGroupResource patchedMgmtGroup = await mgmtGroup.UpdateAsync(patch);
Assert.AreEqual("New Display Name", patchedMgmtGroup.Data.DisplayName);
Assert.AreEqual(mgmtGroup.Data.Id, patchedMgmtGroup.Data.Id);
Assert.AreEqual(mgmtGroup.Data.Name, patchedMgmtGroup.Data.Name);
Assert.AreEqual(mgmtGroup.Data.TenantId, patchedMgmtGroup.Data.TenantId);
Assert.AreEqual(mgmtGroup.Data.ResourceType, patchedMgmtGroup.Data.ResourceType);
}
public async Task List()
{
var mgmtGroupCollection = Client.GetManagementGroups();
ManagementGroupResource mgmtGroup = null;
await foreach (var item in mgmtGroupCollection.GetAllAsync("no-cache"))
{
mgmtGroup = item;
break;
}
Assert.IsNotNull(mgmtGroup, "No management groups found in list");
Assert.IsNotNull(mgmtGroup.Data.DisplayName, "DisplayName was null");
Assert.IsNotNull(mgmtGroup.Data.Id, "Id was null");
Assert.IsNotNull(mgmtGroup.Data.Name, "Name was null");
Assert.IsNotNull(mgmtGroup.Data.TenantId, "TenantId was null");
Assert.IsNotNull(mgmtGroup.Data.ResourceType, "Type was null");
Assert.IsEmpty(mgmtGroup.Data.Children);
Assert.IsNull(mgmtGroup.Data.Details);
}
protected async Task <ManagementGroupPolicySetDefinitionResource> CreatePolicySetDefinitionAtMgmtGroup(ManagementGroupResource mgmtGroup, ManagementGroupPolicyDefinitionResource policyDefinition, string policySetDefinitionName)
{
PolicySetDefinitionData input = new PolicySetDefinitionData
{
DisplayName = $"Test ${policySetDefinitionName}",
PolicyDefinitions = { new PolicyDefinitionReference(policyDefinition.Id) }
};
ArmOperation <ManagementGroupPolicySetDefinitionResource> lro = await mgmtGroup.GetManagementGroupPolicySetDefinitions().CreateOrUpdateAsync(WaitUntil.Completed, policySetDefinitionName, input);
return(lro.Value);
}
protected async Task <ManagementGroupPolicyDefinitionResource> CreatePolicyDefinitionAtMgmtGroup(ManagementGroupResource mgmtGroup, string policyDefinitionName)
{
PolicyDefinitionData input = ConstructPolicyDefinitionData(policyDefinitionName);
ArmOperation <ManagementGroupPolicyDefinitionResource> lro = await mgmtGroup.GetManagementGroupPolicyDefinitions().CreateOrUpdateAsync(WaitUntil.Completed, policyDefinitionName, input);
return(lro.Value);
}
public static ArmDeploymentCollection GetArmDeployments(this ManagementGroupResource managementGroupResource)
{
return(GetExtensionClient(managementGroupResource).GetArmDeployments());
}
public virtual ManagementGroupResource GetManagementGroupResource(ResourceIdentifier id)
{
ManagementGroupResource.ValidateResourceId(id);
return(new ManagementGroupResource(this, id));
}
public static Response <ArmDeploymentResource> GetArmDeployment(this ManagementGroupResource managementGroupResource, string deploymentName, CancellationToken cancellationToken = default)
{
return(managementGroupResource.GetArmDeployments().Get(deploymentName, cancellationToken));
}
public static async Task <Response <ArmDeploymentResource> > GetArmDeploymentAsync(this ManagementGroupResource managementGroupResource, string deploymentName, CancellationToken cancellationToken = default)
{
return(await managementGroupResource.GetArmDeployments().GetAsync(deploymentName, cancellationToken).ConfigureAwait(false));
}
