Add floating ip integration tests

Author: carolynvs

src/testing/integration/Networking/v2/Layer3/Layer3ExtensionTests.cs

@@ -1,21 +1,84 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Diagnostics;
 using System.Threading.Tasks;
+using OpenStack.Compute.v2_1;
+using Xunit;
+using Xunit.Abstractions;
 
 namespace OpenStack.Networking.v2.Layer3
 {
-    public class Layer3ExtensionTests
+    public class Layer3ExtensionTests : IDisposable
     {
-/*
-1. Make an internal network and subnet.
-2. Make an external network and submit.
-3. Make a router on the external network.
-4. Attach the router to the internal network.
-5. Make a floating ip on the external network.
-6. Make a server on the internal network.
-7. Associate the floating ip to the server.
-*/
+        private readonly NetworkingService _networkingService;
+        private readonly NetworkingTestDataManager _testData;
+        private readonly ComputeTestDataManager _computeTestData;
+
+        public Layer3ExtensionTests(ITestOutputHelper testLog)
+        {
+            var testOutput = new XunitTraceListener(testLog);
+            Trace.Listeners.Add(testOutput);
+            OpenStackNet.Tracing.Http.Listeners.Add(testOutput);
+
+            // The operator identity is necessary to create external networks
+            var authenticationProvider = TestIdentityProvider.GetOperatorIdentity();
+            _networkingService = new NetworkingService(authenticationProvider, "RegionOne");
+
+            _testData = new NetworkingTestDataManager(_networkingService);
+            var compute = new ComputeService(authenticationProvider, "RegionOne");
+            _computeTestData = new ComputeTestDataManager(compute);
+        }
+
+        public void Dispose()
+        {
+            _computeTestData.Dispose();
+            _testData.Dispose();
+
+            Trace.Listeners.Clear();
+            OpenStackNet.Tracing.Http.Listeners.Clear();
+        }
+
+        [Fact]
+        public async Task AssignFloatingIP()
+        {
+            // 1. Make an internal network and subnet.
+            var internalNetwork = await _testData.CreateNetwork();
+            var internalSubnet = await _testData.CreateSubnet(internalNetwork);
+
+            // 2. Make an external network and subnet.
+            Operator.NetworkDefinition externalNetworkDefinition = _testData.BuildNetwork();
+            externalNetworkDefinition.IsExternal = true;
+            var externalNetwork = await _testData.CreateNetwork(externalNetworkDefinition);
+            var externalSubnet = await _testData.CreateSubnet(externalNetwork);
+
+            // 3. Make a router on the external network.
+            var routerDefinition = new RouterCreateDefinition
+            {
+                Name = TestData.GenerateName(),
+                ExternalGateway = new ExternalGatewayDefinition(externalNetwork.Id)
+            };
+            var router = await _networkingService.CreateRouterAsync(routerDefinition);
+            _testData.Register(router);
+
+            // 4. Attach the router to the internal network.
+            var internalPortId = await router.AttachSubnetAsync(internalSubnet.Id);
+            _testData.Register(new Port {Id = internalPortId});
+            
+            // 5. Make a floating ip on the external network.
+            var floatingIPDefinition = new FloatingIPCreateDefinition(externalNetwork.Id);
+            var floatingIP = await _networkingService.CreateFloatingIPAsync(floatingIPDefinition);
+            _testData.Register(floatingIP);
+
+            // 6. Make a server on the internal network.
+            var serverDefinition = _computeTestData.BuildServer();
+            serverDefinition.Networks.Add(new ServerNetworkDefinition {NetworkId = internalNetwork.Id });
+            var server = await _computeTestData.CreateServer(serverDefinition);
+            await server.WaitUntilActiveAsync();
+
+            // 7.Associate the floating ip to the server.
+            await server.AssociateFloatingIPAsync(new AssociateFloatingIPRequest(floatingIP.FloatingIPAddress));
+
+            // 8. Disassociate the floating ip from the server
+            await server.DisassociateFloatingIPAsync(floatingIP.FloatingIPAddress);
+        }
     }
 }

src/testing/integration/Networking/v2/NetworkingTestDataManager.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using OpenStack.Networking.v2.Layer3;
 
 namespace OpenStack.Networking.v2
 {
@@ -32,6 +33,19 @@ public void Register(object testItem)
         public void Dispose()
         {
             var errors = new List<Exception>();
+
+            try
+            {
+                DeleteFloatingIPs(_testData.OfType<FloatingIP>());
+            }
+            catch (AggregateException ex) { errors.AddRange(ex.InnerExceptions); }
+
+            try
+            {
+                DeleteRouters(_testData.OfType<Router>());
+            }
+            catch (AggregateException ex) { errors.AddRange(ex.InnerExceptions); }
+
             try
             {
                 DeletePorts(_testData.OfType<Port>());
@@ -55,9 +69,9 @@ public void Dispose()
         }
 
         #region Networks
-        public NetworkDefinition BuildNetwork()
+        public Operator.NetworkDefinition BuildNetwork()
         {
-            return new NetworkDefinition
+            return new Operator.NetworkDefinition
             {
                 Name = TestData.GenerateName()
             };
@@ -101,7 +115,7 @@ public void DeleteNetworks(IEnumerable<Network> networks)
 
         public SubnetCreateDefinition BuildSubnet(Network network)
         {
-            var cidr = string.Format("192.168.{0}.0/24", _subnetCounter++);
+            var cidr = $"192.168.{_subnetCounter++}.0/24";
             return new SubnetCreateDefinition(network.Id, IPVersion.IPv4, cidr)
             {
                 Name = TestData.GenerateName()
@@ -182,5 +196,23 @@ public void DeletePorts(IEnumerable<Port> ports)
             Task.WaitAll(deletes);
         }
         #endregion
+
+        #region Routers
+        
+        public void DeleteRouters(IEnumerable<Router> routers)
+        {
+            Task[] deletes = routers.Select(x => _networkingService.DeleteRouterAsync(x.Id)).ToArray();
+            Task.WaitAll(deletes);
+        }
+        #endregion
+
+        #region Floating IPs
+
+        public void DeleteFloatingIPs(IEnumerable<FloatingIP> floatingIPs)
+        {
+            Task[] deletes = floatingIPs.Select(x => _networkingService.DeleteFloatingIPAsync(x.Id)).ToArray();
+            Task.WaitAll(deletes);
+        }
+        #endregion
     }
 }

src/testing/integration/OpenStack.IntegrationTests.csproj

@@ -121,6 +121,7 @@
     <Compile Include="ContentDeliveryNetworks\v1\ContentDeliveryNetworkServiceTests.cs" />
     <Compile Include="ContentDeliveryNetworks\v1\ServiceTests.cs" />
     <Compile Include="Identity\v2\IdentityTests.cs" />
+    <Compile Include="Networking\v2\Layer3\Layer3ExtensionTests.cs" />
     <Compile Include="Networking\v2\NetworkingTestDataManager.cs" />
     <Compile Include="Networking\v2\NetworkingServiceTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />