Add new properties for express route resources

src/SDKs/Network/Management.Network/Microsoft.Azure.Management.Network.csproj

@@ -4,7 +4,7 @@
     <PackageId>Microsoft.Azure.Management.Network</PackageId>
     <Description>Provides management capabilities for Network services.</Description>
     <AssemblyName>Microsoft.Azure.Management.Network</AssemblyName>
-    <VersionPrefix>10.1.1-preview</VersionPrefix>
+    <VersionPrefix>11.0.0-preview</VersionPrefix>
     <PackageTags>Microsoft Azure Network management;Network;Network management;windowsazureofficial</PackageTags>    
   </PropertyGroup>
   <PropertyGroup>

src/SDKs/Network/Management.Network/Properties/AssemblyInfo.cs

@@ -7,8 +7,8 @@
 [assembly: AssemblyTitle("Microsoft Azure Network Management Library")]
 [assembly: AssemblyDescription("Provides Microsoft Azure Network management functions for managing the Microsoft Azure Network service.")]
 
-[assembly: AssemblyVersion("10.1.2.0")]
-[assembly: AssemblyFileVersion("10.1.2.0")]
+[assembly: AssemblyVersion("11.0.0.0")]
+[assembly: AssemblyFileVersion("11.0.0.0")]
 
 [assembly: AssemblyCompany("Microsoft")]
 [assembly: AssemblyProduct("Microsoft Azure .NET SDK")]

src/SDKs/Network/Network.Tests/Tests/ExpressRouteTests.cs

@@ -0,0 +1,134 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+namespace Networks.Tests
+{
+    using System;
+    using System.Linq;
+    using Microsoft.Rest.ClientRuntime.Azure.TestFramework;
+    using SubResource = Microsoft.Azure.Management.Network.Models.SubResource;
+    using System.Collections.Generic;
+    using System.Net;
+    using Microsoft.Azure.Management.Network;
+    using Microsoft.Azure.Management.Network.Models;
+    using Microsoft.Azure.Management.Resources;
+    using Microsoft.Azure.Management.Resources.Models;
+    using Microsoft.Azure.Test;
+    using Networks.Tests.Helpers;
+    using ResourceGroups.Tests;
+    using Xunit;
+
+    public class ExpressRouteTests
+    {
+        public const string MS_PrimaryPrefix = "199.168.200.0/30";
+        public const string MS_SecondaryPrefix = "199.168.202.0/30";
+        public const string MS_PeerASN = "1000";
+        public const string MS_PublicPrefix = "12.2.3.4/30";
+
+        public const string Circuit_Provider = "bvtazureixp01";
+        public const string Circuit_Location = "boydton 1 dc";
+        public const string Circuit_BW = "200";
+        public const string MS_VlanId = "400";
+
+        public const string Filter_Commmunity = "12076:5010";
+        public const string Filter_Access = "allow";
+        public const string Filter_Type = "Community";
+
+        public const string Peering_Microsoft = "MicrosoftPeering";
+        [Fact]
+        public void BGPCommunityApiTest()
+        {
+            var handler1 = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK };
+            var handler2 = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK };
+
+            using (MockContext context = MockContext.Start(this.GetType().FullName))
+            {
+                var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(context, handler1);
+                var networkManagementClient = NetworkManagementTestUtilities.GetNetworkManagementClientWithHandler(context, handler2);
+                var location = NetworkManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/routefilters");
+
+                var communities = networkManagementClient.BgpServiceCommunities.List();
+
+                Assert.NotNull(communities);
+                Assert.True(communities.First().BgpCommunities.First().IsAuthorizedToUse);
+            }
+        }
+
+        [Fact]
+        public void RouteFilterApiTest()
+        {
+            var handler1 = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK };
+            var handler2 = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK };
+
+            using (MockContext context = MockContext.Start(this.GetType().FullName))
+            {
+                var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(context, handler1);
+                var networkManagementClient = NetworkManagementTestUtilities.GetNetworkManagementClientWithHandler(context, handler2);
+                var location = NetworkManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/routefilters");
+
+                string resourceGroupName = TestUtilities.GenerateName("csmrg");
+                resourcesClient.ResourceGroups.CreateOrUpdate(
+                    resourceGroupName,
+                    new ResourceGroup
+                    {
+                        Location = location
+                    });
+
+                // Create route filter 
+                string filterName = "filter";
+                string ruleName = "rule";
+
+                var filter = TestHelper.CreateDefaultRouteFilter(resourceGroupName,
+                    filterName, location, networkManagementClient);
+
+                Assert.Equal(filter.Name, filterName);
+
+                // Update filter with rules
+                var rule = TestHelper.CreateDefaultRouteFilterRule(resourceGroupName,
+                    filterName, ruleName, location, networkManagementClient);
+
+                // Delete resource group
+                resourcesClient.ResourceGroups.Delete(resourceGroupName);
+            }
+        }
+
+        [Fact]
+        public void ExpressRouteMicrosoftPeeringApiTest()
+        {
+            var handler1 = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK };
+            var handler2 = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK };
+
+            using (MockContext context = MockContext.Start(this.GetType().FullName))
+            {
+                var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(context, handler1);
+                var networkManagementClient = NetworkManagementTestUtilities.GetNetworkManagementClientWithHandler(context, handler2);
+                var location = "westus" ;
+
+                string resourceGroupName = TestUtilities.GenerateName("csmrg");
+                resourcesClient.ResourceGroups.CreateOrUpdate(
+                    resourceGroupName,
+                    new ResourceGroup
+                    {
+                        Location = location
+                    });
+
+                string circuitName = "circuit";                           
+
+                var circuit = TestHelper.CreateDefaultExpressRouteCircuit(resourceGroupName,
+                    circuitName, location, networkManagementClient);
+
+                Assert.Equal(circuit.Name, circuitName);
+                Assert.Equal(circuit.ServiceProviderProperties.BandwidthInMbps, Convert.ToInt32(Circuit_BW));
+
+                circuit = TestHelper.UpdateDefaultExpressRouteCircuitWithMicrosoftPeering(resourceGroupName,
+                    circuitName, networkManagementClient);
+
+                Assert.Equal(circuit.Name, circuitName);
+                Assert.Equal(circuit.ServiceProviderProperties.BandwidthInMbps, Convert.ToInt32(Circuit_BW));
+                Assert.NotNull(circuit.Peerings);
+
+                resourcesClient.ResourceGroups.Delete(resourceGroupName);
+            }
+        }
+    }
+}

src/SDKs/Network/Network.Tests/Tests/TestHelper.cs

@@ -13,6 +13,142 @@ namespace Networks.Tests
 
     public class TestHelper
     {
+        public static ExpressRouteCircuit CreateDefaultExpressRouteCircuit(string resourceGroupName, string circuitName, string location,
+            NetworkManagementClient nrpClient)
+        {
+            ExpressRouteCircuitSku sku = new ExpressRouteCircuitSku
+            {
+                Name = "Premium_MeteredData",
+                Tier = "Premium",
+                Family = "MeteredData"
+            };
+
+            ExpressRouteCircuitServiceProviderProperties provider = new ExpressRouteCircuitServiceProviderProperties
+            {
+                BandwidthInMbps = Convert.ToInt32(ExpressRouteTests.Circuit_BW),
+                PeeringLocation = ExpressRouteTests.Circuit_Location,
+                ServiceProviderName = ExpressRouteTests.Circuit_Provider
+            };
+
+            var circuit = new ExpressRouteCircuit()
+            {
+                Location = location,
+                Tags = new Dictionary<string, string>()
+                    {
+                       {"key","value"}
+                    } ,
+                Sku = sku,
+                ServiceProviderProperties = provider
+            };
+
+            // Put circuit
+            var circuitResponse = nrpClient.ExpressRouteCircuits.CreateOrUpdate(resourceGroupName, circuitName, circuit);
+            Assert.Equal("Succeeded", circuitResponse.ProvisioningState);
+            var getCircuitResponse = nrpClient.ExpressRouteCircuits.Get(resourceGroupName, circuitName);
+
+            return getCircuitResponse;
+        }
+
+        public static ExpressRouteCircuit UpdateDefaultExpressRouteCircuitWithMicrosoftPeering(string resourceGroupName, string circuitName,
+            NetworkManagementClient nrpClient)
+        {
+
+            var peering = new ExpressRouteCircuitPeering()
+            {
+                Name = ExpressRouteCircuitPeeringType.MicrosoftPeering.ToString(),
+                PeeringType = ExpressRouteCircuitPeeringType.MicrosoftPeering,
+                PeerASN = Convert.ToInt32(ExpressRouteTests.MS_PeerASN),
+                PrimaryPeerAddressPrefix = ExpressRouteTests.MS_PrimaryPrefix,
+                SecondaryPeerAddressPrefix = ExpressRouteTests.MS_SecondaryPrefix,
+                VlanId = Convert.ToInt32(ExpressRouteTests.MS_VlanId),
+                MicrosoftPeeringConfig = new ExpressRouteCircuitPeeringConfig()
+                {
+                    AdvertisedPublicPrefixes = new List<string>
+                    {
+                        ExpressRouteTests.MS_PublicPrefix
+                    },
+                    LegacyMode = Convert.ToInt32(true)
+                },                
+            };
+
+            var peerResponse = nrpClient.ExpressRouteCircuitPeerings.CreateOrUpdate(resourceGroupName, circuitName, 
+                ExpressRouteTests.Peering_Microsoft, peering);
+            Assert.Equal("Succeeded", peerResponse.ProvisioningState);
+            var getCircuitResponse = nrpClient.ExpressRouteCircuits.Get(resourceGroupName, circuitName);
+
+            return getCircuitResponse;
+        }
+
+        public static ExpressRouteCircuit UpdateDefaultExpressRouteCircuitWithMicrosoftPeering(string resourceGroupName, string circuitName, RouteFilter filter,
+            NetworkManagementClient nrpClient)
+        {
+
+            var peering = new ExpressRouteCircuitPeering()
+            {
+                Name = ExpressRouteCircuitPeeringType.MicrosoftPeering.ToString(),
+                PeeringType = ExpressRouteCircuitPeeringType.MicrosoftPeering,
+                PeerASN = Convert.ToInt32(ExpressRouteTests.MS_PeerASN),
+                PrimaryPeerAddressPrefix = ExpressRouteTests.MS_PrimaryPrefix,
+                SecondaryPeerAddressPrefix = ExpressRouteTests.MS_SecondaryPrefix,
+                VlanId = Convert.ToInt32(ExpressRouteTests.MS_VlanId),
+                MicrosoftPeeringConfig = new ExpressRouteCircuitPeeringConfig()
+                {
+                    AdvertisedPublicPrefixes = new List<string>
+                    {
+                        ExpressRouteTests.MS_PublicPrefix
+                    },
+                    LegacyMode = Convert.ToInt32(true)
+                },
+                RouteFilter = filter
+            };
+
+            var peerResponse = nrpClient.ExpressRouteCircuitPeerings.CreateOrUpdate(resourceGroupName, circuitName,
+                ExpressRouteTests.Peering_Microsoft, peering);
+            Assert.Equal("Succeeded", peerResponse.ProvisioningState);
+            var getCircuitResponse = nrpClient.ExpressRouteCircuits.Get(resourceGroupName, circuitName);
+
+            return getCircuitResponse;
+        }
+
+
+        public static RouteFilter CreateDefaultRouteFilter(string resourceGroupName, string filterName, string location, 
+            NetworkManagementClient nrpClient)
+        {
+            var filter = new RouteFilter()
+            {
+                Location = location,
+                Tags = new Dictionary<string, string>()
+                    {
+                       {"key","value"}
+                    }
+            };
+
+            // Put route filter 
+            var filterResponse = nrpClient.RouteFilters.CreateOrUpdate(resourceGroupName, filterName, filter);
+            Assert.Equal("Succeeded", filterResponse.ProvisioningState);
+            var getFilterResponse = nrpClient.RouteFilters.Get(resourceGroupName, filterName);
+
+            return getFilterResponse;
+        }
+
+        public static RouteFilter CreateDefaultRouteFilterRule(string resourceGroupName, string filterName, string ruleName, string location,
+            NetworkManagementClient nrpClient)
+        {
+            var rule = new RouteFilterRule()
+            {
+                Access = ExpressRouteTests.Filter_Access,
+                Communities = new List<string> { ExpressRouteTests.Filter_Commmunity },
+                Location = location
+            };                      
+
+            // Put route filter rule
+            var ruleResponse = nrpClient.RouteFilterRules.CreateOrUpdate(resourceGroupName, filterName, ruleName, rule);
+            Assert.Equal("Succeeded", ruleResponse.ProvisioningState);
+            var getFilterResponse = nrpClient.RouteFilters.Get(resourceGroupName, filterName);
+
+            return getFilterResponse;
+        }
+
         public static PublicIPAddress CreateDefaultPublicIpAddress(string name, string resourceGroupName, string domainNameLabel, string location,
             NetworkManagementClient nrpClient)
         {