vcloud-edge_gateway 0.0.2 → 0.1.0

data/spec/integration/edge_gateway/load_balancer_service_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+module Vcloud
+  describe EdgeGatewayServices do
+
+    required_env = {
+      'VCLOUD_EDGE_GATEWAY' => 'to name of VSE',
+      'VCLOUD_PROVIDER_NETWORK_ID' => 'to ID of VSE external network',
+      'VCLOUD_PROVIDER_NETWORK_IP' => 'to an available IP on VSE external network',
+      'VCLOUD_NETWORK1_ID' => 'to the ID of a VSE internal network',
+      'VCLOUD_NETWORK1_NAME' => 'to the name of the VSE internal network',
+      'VCLOUD_NETWORK1_IP' => 'to an ID on the VSE internal network',
+    }
+
+    error = false
+    required_env.each do |var,message|
+      unless ENV[var]
+        puts "Must set #{var} #{message}" unless ENV[var]
+        error = true
+      end
+    end
+    Kernel.exit(2) if error
+
+    before(:all) do
+      @edge_name = ENV['VCLOUD_EDGE_GATEWAY']
+      @ext_net_id = ENV['VCLOUD_PROVIDER_NETWORK_ID']
+      @ext_net_ip = ENV['VCLOUD_PROVIDER_NETWORK_IP']
+      @ext_net_name = ENV['VCLOUD_PROVIDER_NETWORK_NAME']
+      @int_net_id = ENV['VCLOUD_NETWORK1_ID']
+      @int_net_ip = ENV['VCLOUD_NETWORK1_IP']
+      @int_net_name = ENV['VCLOUD_NETWORK1_NAME']
+      @files_to_delete = []
+    end
+
+    context "Test LoadBalancerService specifics of EdgeGatewayServices" do
+
+      before(:all) do
+        reset_edge_gateway
+        @initial_load_balancer_config_file =
+          generate_input_config_file('load_balancer_config.yaml.erb', edge_gateway_erb_input)
+        @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@edge_name)
+      end
+
+      context "Check update is functional" do
+
+        before(:all) do
+          local_config = ConfigLoader.new.load_config(
+            @initial_load_balancer_config_file,
+            Vcloud::Schema::EDGE_GATEWAY_SERVICES
+          )
+          @local_vcloud_config  = EdgeGateway::ConfigurationGenerator::LoadBalancerService.new(
+            @edge_name
+          ).generate_fog_config(local_config[:load_balancer_service])
+        end
+
+        it "should be starting our tests from an empty LoadBalancerService" do
+          edge_service_config = @edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration]
+          remote_vcloud_config = edge_service_config[:LoadBalancerService]
+          expect(remote_vcloud_config[:Pool].empty?).to be_true
+          expect(remote_vcloud_config[:VirtualServer].empty?).to be_true
+        end
+
+        it "should only make one EdgeGateway update task, to minimise EdgeGateway reload events" do
+          start_time = DateTime.now()
+          task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
+          EdgeGatewayServices.new.update(@initial_load_balancer_config_file)
+          task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
+          expect(task_list_after_update.size - task_list_before_update.size).to be(1)
+        end
+
+        it "should have configured at least one LoadBancer Pool entry" do
+          edge_service_config = @edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration]
+          remote_vcloud_config = edge_service_config[:LoadBalancerService]
+          expect(remote_vcloud_config[:Pool].empty?).to be_false
+        end
+
+        it "should have configured at least one LoadBancer VirtualServer entry" do
+          edge_service_config = @edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration]
+          remote_vcloud_config = edge_service_config[:LoadBalancerService]
+          expect(remote_vcloud_config[:VirtualServer].empty?).to be_false
+        end
+
+        it "should have configured the same number of Pools as in our configuration" do
+          edge_service_config = @edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration]
+          remote_vcloud_config = edge_service_config[:LoadBalancerService]
+          expect(remote_vcloud_config[:Pool].size).
+            to eq(@local_vcloud_config[:Pool].size)
+        end
+
+        it "should have configured the same number of VirtualServers as in our configuration" do
+          edge_service_config = @edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration]
+          remote_vcloud_config = edge_service_config[:LoadBalancerService]
+          expect(remote_vcloud_config[:VirtualServer].size).
+            to eq(@local_vcloud_config[:VirtualServer].size)
+        end
+
+        it "ConfigurationDiffer should return empty if local and remote LoadBalancer configs match" do
+          edge_service_config = @edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration]
+          remote_vcloud_config = edge_service_config[:LoadBalancerService]
+          differ = EdgeGateway::LoadBalancerConfigurationDiffer.new(@local_vcloud_config, remote_vcloud_config)
+          diff_output = differ.diff
+          expect(diff_output).to eq([])
+        end
+
+        it "should not then configure the LoadBalancerService if updated again with the same configuration" do
+          expect(Vcloud::EdgeGateway.logger).
+            to receive(:info).with('EdgeGatewayServices.update: Configuration is already up to date. Skipping.')
+          EdgeGatewayServices.new.update(@initial_load_balancer_config_file)
+        end
+
+      end
+
+      context "Check specific LoadBalancerService update cases" do
+
+        it "should be able to configure with no pools and virtual_servers" do
+          config_file = generate_input_config_file(
+            'load_balancer_empty.yaml.erb',
+            edge_gateway_erb_input
+          )
+          EdgeGatewayServices.new.update(config_file)
+          edge_config = @edge_gateway.vcloud_attributes[:Configuration]
+          remote_vcloud_config = edge_config[:EdgeGatewayServiceConfiguration][:LoadBalancerService]
+          expect(remote_vcloud_config[:Pool].size).to be == 0
+          expect(remote_vcloud_config[:VirtualServer].size).to be == 0
+        end
+
+        it "should be able to configure with a single Pool and no VirtualServers" do
+          config_file = generate_input_config_file(
+            'load_balancer_single_pool.yaml.erb',
+            edge_gateway_erb_input
+          )
+          EdgeGatewayServices.new.update(config_file)
+          edge_config = @edge_gateway.vcloud_attributes[:Configuration]
+          remote_vcloud_config = edge_config[:EdgeGatewayServiceConfiguration][:LoadBalancerService]
+          expect(remote_vcloud_config[:Pool].size).to be == 1
+        end
+
+        it "should raise an error when trying configure with a single VirtualServer, and no pool mentioned" do
+          config_file = generate_input_config_file(
+            'load_balancer_single_virtual_server_missing_pool.yaml.erb',
+            edge_gateway_erb_input
+          )
+          expect { EdgeGatewayServices.new.update(config_file) }.
+            to raise_error('Supplied configuration does not match supplied schema')
+        end
+
+        it "should raise an error when trying configure with a single VirtualServer, with an unconfigured pool" do
+          config_file = generate_input_config_file(
+            'load_balancer_single_virtual_server_invalid_pool.yaml.erb',
+            edge_gateway_erb_input
+          )
+          expect { EdgeGatewayServices.new.update(config_file) }.
+            to raise_error(
+              'Load balancer virtual server integration-test-vs-1 does not have a valid backing pool.'
+            )
+        end
+
+      end
+
+      after(:all) do
+        reset_edge_gateway unless ENV['VCLOUD_NO_RESET_VSE_AFTER']
+        FileUtils.rm(@files_to_delete)
+      end
+
+      def reset_edge_gateway
+        edge_gateway = Core::EdgeGateway.get_by_name @edge_name
+        edge_gateway.update_configuration({
+          LoadBalancerService: {
+            IsEnabled: "false",
+            Pool: [],
+            VirtualServer: []
+          }
+        })
+      end
+
+      def generate_input_config_file(data_file, erb_input)
+        config_erb = File.expand_path("data/#{data_file}", File.dirname(__FILE__))
+        output_file = ErbHelper.convert_erb_template_to_yaml(erb_input, config_erb)
+        @files_to_delete << output_file
+        output_file
+      end
+
+      def edge_gateway_erb_input
+        {
+          :edge_gateway_name => @edge_name,
+          :edge_gateway_ext_network_id => @ext_net_id,
+          :edge_gateway_ext_network_ip => @ext_net_ip,
+        }
+      end
+
+      def get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(timestamp)
+        vcloud_time = timestamp.strftime('%FT%T.000Z')
+        q = Query.new('task',
+          :filter =>
+            "name==networkConfigureEdgeGatewayServices;objectName==#{@edge_name};startDate=ge=#{vcloud_time}",
+          :sortDesc => 'startDate',
+        )
+        q.get_all_results
+      end
+
+    end
+
+  end
+end

data/spec/integration/edge_gateway/nat_service_spec.rb

@@ -49,8 +49,13 @@ module Vcloud
       context "Check update is functional" do
 
         before(:all) do
-          local_config = ConfigLoader.new.load_config(@initial_nat_config_file, Vcloud::Schema::EDGE_GATEWAY_SERVICES)
-          @local_vcloud_config  = EdgeGateway::ConfigurationGenerator::NatService.new(@edge_name, local_config[:nat_service]).generate_fog_config
+          local_config = ConfigLoader.new.load_config(
+            @initial_nat_config_file, Vcloud::Schema::EDGE_GATEWAY_SERVICES
+          )
+          @local_vcloud_config  = EdgeGateway::ConfigurationGenerator::NatService.new(
+            local_config[:nat_service],
+            @edge_gateway.interfaces
+          ).generate_fog_config
         end
 
         it "should be starting our tests from an empty NatService" do

data/spec/vcloud/edge_gateway/configuration_generator/data/load_balancer_http-output.yaml

@@ -24,7 +24,7 @@
           HealthCheckPort: '',
           HealthCheck:
             {
-              Mode: "SSL", HealthThreshold: '2', UnhealthThreshold: '3', Interval: '5', Timeout: '15'
+              Mode: "SSL", Uri: '', HealthThreshold: '2', UnhealthThreshold: '3', Interval: '5', Timeout: '15'
             }
         },
         {
@@ -35,7 +35,7 @@
           HealthCheckPort: '',
           HealthCheck:
             {
-              Mode: "TCP", HealthThreshold: '2', UnhealthThreshold: '3', Interval: '5', Timeout: '15'
+              Mode: "TCP", Uri: '', HealthThreshold: '2', UnhealthThreshold: '3', Interval: '5', Timeout: '15'
             }
         }
       ],

data/spec/vcloud/edge_gateway/configuration_generator/data/load_balancer_https-output.yaml

@@ -23,6 +23,7 @@
     :HealthCheckPort: ''
     :HealthCheck:
       :Mode: SSL
+      :Uri: ''
       :HealthThreshold: '2'
       :UnhealthThreshold: '3'
       :Interval: '5'
@@ -34,6 +35,7 @@
     :HealthCheckPort: ''
     :HealthCheck:
       :Mode: TCP
+      :Uri: ''
       :HealthThreshold: '2'
       :UnhealthThreshold: '3'
       :Interval: '5'

data/spec/vcloud/edge_gateway/configuration_generator/data/load_balancer_mixed_complex-output.yaml

@@ -34,6 +34,7 @@
     :HealthCheckPort: ''
     :HealthCheck:
       :Mode: TCP
+      :Uri: ''
       :HealthThreshold: '2'
       :UnhealthThreshold: '3'
       :Interval: '5'

data/spec/vcloud/edge_gateway/configuration_generator/load_balancer_service_spec.rb

@@ -142,6 +142,7 @@ module Vcloud
                   :HealthCheckPort=>"",
                   :HealthCheck=>{
                     :Mode=>"SSL",
+                    :Uri=>"",
                     :HealthThreshold=>"2",
                     :UnhealthThreshold=>"3",
                     :Interval=>"5",
@@ -156,6 +157,7 @@ module Vcloud
                   :HealthCheckPort=>"",
                   :HealthCheck=>{
                     :Mode=>"TCP",
+                    :Uri=>"",
                     :HealthThreshold=>"2",
                     :UnhealthThreshold=>"3",
                     :Interval=>"5",

data/spec/vcloud/edge_gateway/configuration_generator/nat_service_spec.rb

@@ -6,18 +6,20 @@ module Vcloud
       describe NatService do
 
         before(:each) do
-          @edge_id = '1111111-7b54-43dd-9eb1-631dd337e5a7'
-          @mock_edge_gateway = double(
-            :edge_gateway,
-            :vcloud_gateway_interface_by_id => {
-              Network: {
-                name: 'ane012345',
-                href: 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
-              }
-            }
+          @base_nat_id = ID_RANGES::NAT_SERVICE[:min]
+          mock_uplink_interface = double(
+            :mock_uplink,
+            :network_name => "ane012345",
+            :network_id   => "2ad93597-7b54-43dd-9eb1-631dd337e5a7",
+            :network_href   => "https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7",
+          )
+          mock_internal_interface = double(
+            :mock_uplink,
+            :network_name => "internal_interface",
+            :network_id   => "12346788-1234-1234-1234-123456789000",
+            :network_href => "https://vmware.api.net/api/admin/network/12346788-1234-1234-1234-123456789000",
           )
-          expect(Vcloud::Core::EdgeGateway).to receive(:get_by_name).with(@edge_id)
-                                               .and_return(@mock_edge_gateway)
+          @edge_gw_interface_list = [ mock_internal_interface, mock_uplink_interface ]
         end
 
         context "SNAT rule defaults" do
@@ -29,7 +31,7 @@ module Vcloud
               original_ip: "192.0.2.2",
               translated_ip: "10.10.20.20",
             }]} # minimum NAT configuration with a rule
-            output = NatService.new(@edge_id, input).generate_fog_config
+            output = NatService.new(input, @edge_gw_interface_list).generate_fog_config
             @rule = output[:NatRule].first
           end
 
@@ -47,13 +49,14 @@ module Vcloud
 
           it 'should completely match our expected default rule' do
             expect(@rule).to eq({
-              :Id=>"65537",
+              :Id=>"#{@base_nat_id}",
               :IsEnabled=>"true",
               :RuleType=>"SNAT",
               :GatewayNatRule=>{
                 :Interface=>{
-                  :name=>"ane012345",
-                  :href=>"https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7"
+                  :type => 'application/vnd.vmware.admin.network+xml',
+                  :name => "ane012345",
+                  :href => "https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7"
                 },
               :OriginalIp=>"192.0.2.2",
               :TranslatedIp=>"10.10.20.20"}
@@ -74,7 +77,7 @@ module Vcloud
               translated_ip: "10.10.20.20",
               protocol: 'tcp',
             }]} # minimum NAT configuration with a rule
-            output = NatService.new(@edge_id, input).generate_fog_config
+            output = NatService.new(input, @edge_gw_interface_list).generate_fog_config
             @rule = output[:NatRule].first
           end
 
@@ -92,13 +95,14 @@ module Vcloud
 
           it 'should completely match our expected default rule' do
             expect(@rule).to eq({
-              :Id=>"65537",
+              :Id=>"#{@base_nat_id}",
               :IsEnabled=>"true",
               :RuleType=>"DNAT",
               :GatewayNatRule=>{
                 :Interface=>{
-                  :name=>"ane012345",
-                  :href=>"https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7"
+                  :type => 'application/vnd.vmware.admin.network+xml',
+                  :name => "ane012345",
+                  :href => "https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7"
                 },
                 :OriginalIp=>"192.0.2.2",
                 :TranslatedIp=>"10.10.20.20",
@@ -113,10 +117,8 @@ module Vcloud
 
         context "nat service config generation" do
 
-          test_cases = [
-            {
-              title: 'should generate config for enabled nat service with single disabled DNAT rule',
-              input: {
+          it 'should generate config for enabled nat service with single disabled DNAT rule' do
+              input = {
                 enabled: 'true',
                 nat_rules: [
                   {
@@ -131,8 +133,8 @@ module Vcloud
                     protocol: 'tcp',
                   }
                 ]
-              },
-              output: {
+              }
+              output = {
                 :IsEnabled => 'true',
                 :NatRule => [
                   {
@@ -142,6 +144,7 @@ module Vcloud
                     :GatewayNatRule => {
                       :Interface =>
                         {
+                          :type => 'application/vnd.vmware.admin.network+xml',
                           :name => 'ane012345',
                           :href => 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
                         },
@@ -154,11 +157,12 @@ module Vcloud
                   }
                 ]
               }
-            },
+            generated_config = NatService.new(input, @edge_gw_interface_list).generate_fog_config
+            expect(generated_config).to eq(output)
+          end
 
-            {
-              title: 'should handle specification of UDP based DNAT rules',
-              input: {
+          it 'should handle specification of UDP based DNAT rules' do
+              input = {
                 enabled: 'true',
                 nat_rules: [
                   {
@@ -171,17 +175,18 @@ module Vcloud
                     protocol: 'udp',
                   }
                 ]
-              },
-              output: {
+              }
+              output = {
                 :IsEnabled => 'true',
                 :NatRule => [
                   {
                     :RuleType => 'DNAT',
                     :IsEnabled => 'true',
-                    :Id => '65537',
+                    :Id => "#{@base_nat_id}",
                     :GatewayNatRule => {
                       :Interface =>
                         {
+                          :type => 'application/vnd.vmware.admin.network+xml',
                           :name => 'ane012345',
                           :href => 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
                         },
@@ -194,11 +199,12 @@ module Vcloud
                   }
                 ]
               }
-            },
+            generated_config = NatService.new(input, @edge_gw_interface_list).generate_fog_config
+            expect(generated_config).to eq(output)
+          end
 
-            {
-              title: 'should generate config for enabled nat service with single disabled SNAT rule',
-              input: {
+          it 'should generate config for enabled nat service with single disabled SNAT rule' do
+              input = {
                 enabled: 'true',
                 nat_rules: [
                   {
@@ -209,17 +215,18 @@ module Vcloud
                     translated_ip: "10.10.20.20",
                   }
                 ]
-              },
-              output: {
+              }
+              output = {
                 :IsEnabled => 'true',
                 :NatRule => [
                   {
                     :RuleType => 'SNAT',
                     :IsEnabled => 'false',
-                    :Id => '65537',
+                    :Id => "#{@base_nat_id}",
                     :GatewayNatRule => {
                       :Interface =>
                         {
+                          :type => 'application/vnd.vmware.admin.network+xml',
                           :name => 'ane012345',
                           :href => 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
                         },
@@ -229,11 +236,12 @@ module Vcloud
                   }
                 ]
               }
-            },
+            generated_config = NatService.new(input, @edge_gw_interface_list).generate_fog_config
+            expect(generated_config).to eq(output)
+          end
 
-            {
-              title: 'should auto generate rule id if not provided',
-              input: {
+          it 'should auto generate rule id if not provided' do
+              input = {
                 enabled: 'true',
                 nat_rules: [
                   {
@@ -247,17 +255,18 @@ module Vcloud
                     protocol: 'tcp',
                   }
                 ]
-              },
-              output: {
+              }
+              output = {
                 :IsEnabled => 'true',
                 :NatRule => [
                   {
                     :RuleType => 'DNAT',
                     :IsEnabled => 'false',
-                    :Id => '65537',
+                    :Id => "#{@base_nat_id}",
                     :GatewayNatRule => {
                       :Interface =>
                         {
+                          :type => 'application/vnd.vmware.admin.network+xml',
                           :name => 'ane012345',
                           :href => 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
                         },
@@ -270,11 +279,12 @@ module Vcloud
                   }
                 ]
               }
-            },
+            generated_config = NatService.new(input, @edge_gw_interface_list).generate_fog_config
+            expect(generated_config).to eq(output)
+          end
 
-            {
-              title: 'should use default values for optional fields if they are missing',
-              input: {
+          it 'should use default values for optional fields if they are missing' do
+              input = {
                 nat_rules: [
                   {
                     rule_type: 'DNAT',
@@ -285,17 +295,18 @@ module Vcloud
                     translated_ip: "10.10.20.20",
                   }
                 ]
-              },
-              output: {
+              }
+              output = {
                 :IsEnabled => 'true',
                 :NatRule => [
                   {
                     :RuleType => 'DNAT',
                     :IsEnabled => 'true',
-                    :Id => '65537',
+                    :Id => "#{@base_nat_id}",
                     :GatewayNatRule => {
                       :Interface =>
                         {
+                          :type => 'application/vnd.vmware.admin.network+xml',
                           :name => 'ane012345',
                           :href => 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
                         },
@@ -308,49 +319,142 @@ module Vcloud
                   }
                 ]
               }
-
-            }
-          ]
-
-          test_cases.each do |test_case|
-            it "#{test_case[:title]}" do
-              generated_config = NatService.new(@edge_id, test_case[:input]).generate_fog_config
-              expect(generated_config).to eq(test_case[:output])
-            end
+            generated_config = NatService.new(input, @edge_gw_interface_list).generate_fog_config
+            expect(generated_config).to eq(output)
           end
 
-          it "should only make a single API call per network specified" do
-            input = {
-              nat_rules: [
-                {
-                  rule_type: 'DNAT',
-                  network_id: '2ad93597-7b54-43dd-9eb1-631dd337e5a7',
-                  original_ip: "192.0.2.2",
-                  original_port: '8081',
-                  translated_port: '8081',
-                  translated_ip: "10.10.20.21",
-                },
-                {
-                  rule_type: 'DNAT',
-                  network_id: '2ad93597-7b54-43dd-9eb1-631dd337e5a7',
-                  original_ip: "192.0.2.2",
-                  original_port: '8082',
-                  translated_port: '8082',
-                  translated_ip: "10.10.20.22",
-                },
-                {
-                  rule_type: 'DNAT',
-                  network_id: '2ad93597-7b54-43dd-9eb1-631dd337e5a7',
-                  original_ip: "192.0.2.2",
-                  original_port: '8083',
-                  translated_port: '8083',
-                  translated_ip: "10.10.20.23",
-                },
-              ]
-            }
-            expect(@mock_edge_gateway).
-              to receive(:vcloud_gateway_interface_by_id).exactly(1).times
-            NatService.new(@edge_id, input).generate_fog_config
+          it 'output rule order should be same as the input rule order' do
+              input = {
+                nat_rules: [
+                  {
+                    rule_type: 'DNAT',
+                    network_id: '2ad93597-7b54-43dd-9eb1-631dd337e5a7',
+                    original_ip: "192.0.2.2",
+                    original_port: '8081',
+                    translated_port: '8080',
+                    translated_ip: "10.10.20.21",
+                  },
+                  {
+                    rule_type: 'SNAT',
+                    network_id: '2ad93597-7b54-43dd-9eb1-631dd337e5a7',
+                    original_ip: "192.0.2.2",
+                    translated_ip: "10.10.20.20",
+                  },
+                  {
+                    rule_type: 'DNAT',
+                    network_id: '2ad93597-7b54-43dd-9eb1-631dd337e5a7',
+                    original_ip: "192.0.2.2",
+                    original_port: '8082',
+                    translated_port: '8080',
+                    translated_ip: "10.10.20.22",
+                  },
+                  {
+                    rule_type: 'SNAT',
+                    network_id: '2ad93597-7b54-43dd-9eb1-631dd337e5a7',
+                    original_ip: "192.0.2.3",
+                    translated_ip: "10.10.20.21",
+                  },
+                  {
+                    rule_type: 'DNAT',
+                    network_id: '2ad93597-7b54-43dd-9eb1-631dd337e5a7',
+                    original_ip: "192.0.2.2",
+                    original_port: '8083',
+                    translated_port: '8080',
+                    translated_ip: "10.10.20.23",
+                  },
+                ],
+              }
+              output = {
+                IsEnabled: 'true',
+                NatRule: [
+                  {
+                    :Id => "#{@base_nat_id}",
+                    :IsEnabled => 'true',
+                    :RuleType => 'DNAT',
+                    :GatewayNatRule => {
+                      :Interface =>
+                        {
+                          :type => 'application/vnd.vmware.admin.network+xml',
+                          :name => 'ane012345',
+                          :href => 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
+                        },
+                      :OriginalIp => "192.0.2.2",
+                      :TranslatedIp => "10.10.20.21",
+                      :OriginalPort => '8081',
+                      :TranslatedPort => '8080',
+                      :Protocol => 'tcp',
+                    },
+                  },
+                  {
+                    :Id => "#{@base_nat_id + 1}",
+                    :IsEnabled => 'true',
+                    :RuleType => 'SNAT',
+                    :GatewayNatRule => {
+                      :Interface =>
+                        {
+                          :type => 'application/vnd.vmware.admin.network+xml',
+                          :name => 'ane012345',
+                          :href => 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
+                        },
+                      :OriginalIp => "192.0.2.2",
+                      :TranslatedIp => "10.10.20.20",
+                    },
+                  },
+                  {
+                    :Id => "#{@base_nat_id + 2}",
+                    :IsEnabled => 'true',
+                    :RuleType => 'DNAT',
+                    :GatewayNatRule => {
+                      :Interface =>
+                        {
+                          :type => 'application/vnd.vmware.admin.network+xml',
+                          :name => 'ane012345',
+                          :href => 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
+                        },
+                      :OriginalIp => "192.0.2.2",
+                      :TranslatedIp => "10.10.20.22",
+                      :OriginalPort => '8082',
+                      :TranslatedPort => '8080',
+                      :Protocol => 'tcp',
+                    },
+                  },
+                  {
+                    :Id => "#{@base_nat_id + 3}",
+                    :IsEnabled => 'true',
+                    :RuleType => 'SNAT',
+                    :GatewayNatRule => {
+                      :Interface =>
+                        {
+                          :type => 'application/vnd.vmware.admin.network+xml',
+                          :name => 'ane012345',
+                          :href => 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
+                        },
+                      :OriginalIp => "192.0.2.3",
+                      :TranslatedIp => "10.10.20.21",
+                    },
+                  },
+                  {
+                    :Id => "#{@base_nat_id + 4}",
+                    :IsEnabled => 'true',
+                    :RuleType => 'DNAT',
+                    :GatewayNatRule => {
+                      :Interface =>
+                        {
+                          :type => 'application/vnd.vmware.admin.network+xml',
+                          :name => 'ane012345',
+                          :href => 'https://vmware.api.net/api/admin/network/2ad93597-7b54-43dd-9eb1-631dd337e5a7'
+                        },
+                      :OriginalIp => "192.0.2.2",
+                      :TranslatedIp => "10.10.20.23",
+                      :OriginalPort => '8083',
+                      :TranslatedPort => '8080',
+                      :Protocol => 'tcp',
+                    },
+                  }
+                ]
+              }
+            generated_config = NatService.new(input, @edge_gw_interface_list).generate_fog_config
+            expect(generated_config).to eq(output)
           end
 
         end