public static ResourceGroupExtended[] GetResourceGroups( SubscriptionCloudCredentials creds )
        {
            var resourceMgmtClient = new ResourceManagementClient( creds );
            var resourceGroupsResponse = resourceMgmtClient.ResourceGroups.ListAsync( new ResourceGroupListParameters( ) ).Result;

            int currentGroup = 0, resourceGroupsCount = resourceGroupsResponse.ResourceGroups.Count;
            ResourceGroupExtended[] resourceGroups = new ResourceGroupExtended[ resourceGroupsCount ];
            foreach( var group in resourceGroupsResponse.ResourceGroups )
            {
                resourceGroups[ currentGroup++ ] = group;
            }

            return resourceGroups;
        }
        public static ZoneCreateOrUpdateResponse CreateZone(DnsManagementClient dnsClient, string zoneName, string location, ResourceGroupExtended resourceGroup)
        {
            ZoneCreateOrUpdateResponse response = dnsClient.Zones.CreateOrUpdate(
                resourceGroup.Name,
                zoneName,
                new ZoneCreateOrUpdateParameters
                {
                    Zone = new Microsoft.Azure.Management.Dns.Models.Zone
                    {
                        Location = location,
                        Name = zoneName,
                        ETag = null,
                        Properties = new Microsoft.Azure.Management.Dns.Models.ZoneProperties
                        {
                        }
                    }
                });

            return response;
        }
        public void GetsResourceGroupsFilteredByTagsWithDetails()
        {
            Dictionary<string, string> tag1 = new Dictionary<string, string> { { "tag1", "val1" }, { "tag2", "val2" } };
            Dictionary<string, string> tag2 = new Dictionary<string, string> { { "tag1", "valx" } };
            Dictionary<string, string> tag3 = new Dictionary<string, string> { { "tag2", "" } };

            ResourceGroupExtended resourceGroup1 = new ResourceGroupExtended() { Name = resourceGroupName + 1, Location = resourceGroupLocation, Tags = tag1 };
            ResourceGroupExtended resourceGroup2 = new ResourceGroupExtended() { Name = resourceGroupName + 2, Location = resourceGroupLocation, Tags = tag2 };
            ResourceGroupExtended resourceGroup3 = new ResourceGroupExtended() { Name = resourceGroupName + 3, Location = resourceGroupLocation, Tags = tag3 };
            ResourceGroupExtended resourceGroup4 = new ResourceGroupExtended() { Name = resourceGroupName + 4, Location = resourceGroupLocation };
            resourceGroupMock.Setup(f => f.ListAsync(null, new CancellationToken()))
                .Returns(Task.Factory.StartNew(() => new ResourceGroupListResult
                {
                    ResourceGroups = new List<ResourceGroupExtended>() { resourceGroup1, resourceGroup2, resourceGroup3, resourceGroup4 }
                }));
            SetupListForResourceGroupAsync(resourceGroup1.Name, new List<GenericResourceExtended>() { new GenericResourceExtended() { Name = "resource" } });
            SetupListForResourceGroupAsync(resourceGroup2.Name, new List<GenericResourceExtended>() { new GenericResourceExtended() { Name = "resource" } });
            SetupListForResourceGroupAsync(resourceGroup3.Name, new List<GenericResourceExtended>() { new GenericResourceExtended() { Name = "resource" } });
            SetupListForResourceGroupAsync(resourceGroup4.Name, new List<GenericResourceExtended>() { new GenericResourceExtended() { Name = "resource" } });

            List<PSResourceGroup> groups1 = resourcesClient.FilterResourceGroups(null,
                new Hashtable(new Dictionary<string, string> { { "Name", "tag1" } }), true);

            Assert.Equal(2, groups1.Count);
            Assert.Equal(resourceGroup1.Name, groups1[0].ResourceGroupName);
            Assert.Equal(resourceGroup2.Name, groups1[1].ResourceGroupName);
            Assert.Equal(1, groups1[0].Resources.Count());
            Assert.Equal(1, groups1[1].Resources.Count());

            List<PSResourceGroup> groups2 = resourcesClient.FilterResourceGroups(null,
                new Hashtable(new Dictionary<string, string> { { "Name", "tag2" } }), true);

            Assert.Equal(2, groups2.Count);
            Assert.Equal(resourceGroup1.Name, groups2[0].ResourceGroupName);
            Assert.Equal(resourceGroup3.Name, groups2[1].ResourceGroupName);
            Assert.Equal(1, groups2[0].Resources.Count());
            Assert.Equal(1, groups2[1].Resources.Count());

            List<PSResourceGroup> groups3 = resourcesClient.FilterResourceGroups(null,
                new Hashtable(new Dictionary<string, string> { { "Name", "tag3" } }), true);

            Assert.Equal(0, groups3.Count);

            List<PSResourceGroup> groups4 = resourcesClient.FilterResourceGroups(null,
                new Hashtable(new Dictionary<string, string> { { "Name", "TAG1" }, { "Value", "val1" } }), true);

            Assert.Equal(1, groups4.Count);
            Assert.Equal(resourceGroup1.Name, groups4[0].ResourceGroupName);
            Assert.Equal(1, groups4[0].Resources.Count());
        }
        public void GetsAllResourceGroupsWithDetails()
        {
            ResourceGroupExtended resourceGroup1 = new ResourceGroupExtended() { Name = resourceGroupName + 1, Location = resourceGroupLocation };
            ResourceGroupExtended resourceGroup2 = new ResourceGroupExtended() { Name = resourceGroupName + 2, Location = resourceGroupLocation };
            ResourceGroupExtended resourceGroup3 = new ResourceGroupExtended() { Name = resourceGroupName + 3, Location = resourceGroupLocation };
            ResourceGroupExtended resourceGroup4 = new ResourceGroupExtended() { Name = resourceGroupName + 4, Location = resourceGroupLocation };
            resourceGroupMock.Setup(f => f.ListAsync(null, new CancellationToken()))
                .Returns(Task.Factory.StartNew(() => new ResourceGroupListResult
                {
                    ResourceGroups = new List<ResourceGroupExtended>() { resourceGroup1, resourceGroup2, resourceGroup3, resourceGroup4 }
                }));
            SetupListForResourceGroupAsync(resourceGroup1.Name, new List<GenericResourceExtended>() { new GenericResourceExtended() { Name = "resource" } });
            SetupListForResourceGroupAsync(resourceGroup2.Name, new List<GenericResourceExtended>() { new GenericResourceExtended() { Name = "resource" } });
            SetupListForResourceGroupAsync(resourceGroup3.Name, new List<GenericResourceExtended>() { new GenericResourceExtended() { Name = "resource" } });
            SetupListForResourceGroupAsync(resourceGroup4.Name, new List<GenericResourceExtended>() { new GenericResourceExtended() { Name = "resource" } });

            List<PSResourceGroup> actual = resourcesClient.FilterResourceGroups(null, null, true);

            Assert.Equal(4, actual.Count);
            Assert.Equal(resourceGroup1.Name, actual[0].ResourceGroupName);
            Assert.Equal(resourceGroup2.Name, actual[1].ResourceGroupName);
            Assert.Equal(resourceGroup3.Name, actual[2].ResourceGroupName);
            Assert.Equal(resourceGroup4.Name, actual[3].ResourceGroupName);
            Assert.Equal(1, actual[0].Resources.Count());
            Assert.Equal(1, actual[1].Resources.Count());
            Assert.Equal(1, actual[2].Resources.Count());
            Assert.Equal(1, actual[3].Resources.Count());
        }
        public void GetsSpecificResourceGroup()
        {
            string name = resourceGroupName;
            GenericResourceExtended resource1 = new GenericResourceExtended() { Id = "/subscriptions/abc123/resourceGroups/group1/providers/Microsoft.Test/servers/r12345sql/db/r45678db", Location = resourceGroupLocation, Name = resourceName };
            GenericResourceExtended resource2 = new GenericResourceExtended() { Id = "/subscriptions/abc123/resourceGroups/group1/providers/Microsoft.Test/servers/r12345sql/db/r45678db", Location = resourceGroupLocation, Name = resourceName + "2" };
            ResourceGroupExtended resourceGroup = new ResourceGroupExtended() { Name = name, Location = resourceGroupLocation, ProvisioningState = "Succeeded" };
            resourceGroupMock.Setup(f => f.GetAsync(name, new CancellationToken()))
                .Returns(Task.Factory.StartNew(() => new ResourceGroupGetResult
                {
                    ResourceGroup = resourceGroup,
                }));
            SetupListForResourceGroupAsync(name, new List<GenericResourceExtended>() { resource1, resource2 });

            List<PSResourceGroup> actual = resourcesClient.FilterResourceGroups(name, null, true);

            Assert.Equal(1, actual.Count);
            Assert.Equal(name, actual[0].ResourceGroupName);
            Assert.Equal(resourceGroupLocation, actual[0].Location);
            Assert.Equal(2, actual[0].Resources.Count);
            Assert.Equal("Succeeded", actual[0].ProvisioningState);
            Assert.True(!string.IsNullOrEmpty(actual[0].ResourcesTable));
        }
 public static void DeleteZones(DnsManagementClient dnsClient, ResourceGroupExtended resourceGroup, string[] zoneNames)
 {
     foreach (string zoneName in zoneNames)
     {
         dnsClient.Zones.Delete(resourceGroup.Name, zoneName, new ZoneDeleteParameters());
     }
 }
        public static void CreateZones(DnsManagementClient dnsClient, ResourceGroupExtended resourceGroup, string[] zoneNames)
        {
            string location = ResourceGroupHelper.GetResourceLocation(ResourceGroupHelper.GetResourcesClient(), "microsoft.network/dnszones");

            foreach (string zoneName in zoneNames)
            {
                ResourceGroupHelper.CreateZone(dnsClient, zoneName, location, resourceGroup);
            }
        }
 public static void DeleteZones(DnsManagementClient dnsClient, ResourceGroupExtended resourceGroup, string[] zoneNames)
 {
     foreach (string zoneName in zoneNames)
     {
         dnsClient.Zones.Delete(resourceGroup.Name, zoneName, ifMatch: null, ifNoneMatch: null);
     }
 }