vcloud-edge_gateway 0.5.0 → 1.0.0

data/spec/integration/edge_gateway/{firewall_service_spec.rb → configure_firewall_spec.rb}

@@ -5,14 +5,8 @@ module Vcloud
   describe EdgeGateway::Configure do
 
     before(:all) do
-      IntegrationHelper.verify_env_vars
-      @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']
+      config_file = File.join(File.dirname(__FILE__), "../vcloud_tools_testing_config.yaml")
+      @test_data = Vcloud::Tools::Tester::TestParameters.new(config_file)
       @files_to_delete = []
     end
 
@@ -22,7 +16,7 @@ module Vcloud
         reset_edge_gateway
         @vars_config_file = generate_vars_file(edge_gateway_vars_hash)
         @initial_firewall_config_file = IntegrationHelper.fixture_file('firewall_config.yaml.mustache')
-        @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@edge_name)
+        @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@test_data.edge_gateway)
         @firewall_service = {}
       end
 
@@ -44,7 +38,10 @@ module Vcloud
 
         it "should only need to make one call to Core::EdgeGateway.update_configuration" do
           expect_any_instance_of(Core::EdgeGateway).to receive(:update_configuration).exactly(1).times.and_call_original
-          EdgeGateway::Configure.new(@initial_firewall_config_file, @vars_config_file).update
+          diff = EdgeGateway::Configure.new(@initial_firewall_config_file, @vars_config_file).update
+
+          expect(diff.keys).to eq([:FirewallService])
+          expect(diff[:FirewallService]).to have_at_least(1).items
         end
 
         it "should have configured at least one firewall rule" do
@@ -60,32 +57,9 @@ module Vcloud
 
         it "and then should not configure the firewall service if updated again with the same configuration (idempotency)" do
           expect(Vcloud::Core.logger).to receive(:info).with('EdgeGateway::Configure.update: Configuration is already up to date. Skipping.')
-          EdgeGateway::Configure.new(@initial_firewall_config_file, @vars_config_file).update
-        end
+          diff = EdgeGateway::Configure.new(@initial_firewall_config_file, @vars_config_file).update
 
-        it "ConfigurationDiffer should return empty if local and remote firewall configs match" do
-          remote_vcloud_config = @edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration][:FirewallService]
-          differ = EdgeGateway::ConfigurationDiffer.new(@local_vcloud_config, remote_vcloud_config)
-          diff_output = differ.diff
-          expect(diff_output).to eq([])
-        end
-
-        it "should highlight a difference if local firewall config has been updated" do
-          local_config = Core::ConfigLoader.new.load_config(
-            IntegrationHelper.fixture_file('firewall_config_updated_rule.yaml.mustache'),
-            Vcloud::EdgeGateway::Schema::EDGE_GATEWAY_SERVICES,
-            @vars_config_file
-          )
-          local_firewall_config = EdgeGateway::ConfigurationGenerator::FirewallService.new.generate_fog_config(local_config[:firewall_service])
-
-          edge_gateway = Core::EdgeGateway.get_by_name local_config[:gateway]
-          remote_config = edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration]
-          remote_firewall_config = remote_config[:FirewallService]
-
-          differ = EdgeGateway::ConfigurationDiffer.new(local_firewall_config, remote_firewall_config)
-          diff_output = differ.diff
-
-          expect(diff_output.empty?).to be_false
+          expect(diff).to eq({})
         end
 
       end
@@ -151,14 +125,11 @@ module Vcloud
       end
 
       after(:all) do
-        reset_edge_gateway unless ENV['VCLOUD_NO_RESET_VSE_AFTER']
-        @files_to_delete.each { |f|
-          f.unlink
-        }
+        IntegrationHelper.remove_temp_config_files(@files_to_delete)
       end
 
       def reset_edge_gateway
-        edge_gateway = Core::EdgeGateway.get_by_name @edge_name
+        edge_gateway = Core::EdgeGateway.get_by_name @test_data.edge_gateway
         edge_gateway.update_configuration({
           FirewallService: {IsEnabled: false, FirewallRule: []},
         })
@@ -175,9 +146,9 @@ module Vcloud
 
       def edge_gateway_vars_hash
         {
-          :edge_gateway_name => @edge_name,
-          :edge_gateway_ext_network_id => @ext_net_id,
-          :edge_gateway_ext_network_ip => @ext_net_ip,
+          :edge_gateway_name => @test_data.edge_gateway,
+          :edge_gateway_ext_network_id => @test_data.provider_network_id,
+          :edge_gateway_ext_network_ip => @test_data.provider_network_ip,
         }
       end
 

data/spec/integration/edge_gateway/{load_balancer_service_spec.rb → configure_load_balancer_spec.rb}

@@ -5,14 +5,8 @@ module Vcloud
   describe EdgeGateway::Configure do
 
     before(:all) do
-      IntegrationHelper.verify_env_vars
-      @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']
+      config_file = File.join(File.dirname(__FILE__), "../vcloud_tools_testing_config.yaml")
+      @test_data = Vcloud::Tools::Tester::TestParameters.new(config_file)
       @files_to_delete = []
     end
 
@@ -22,7 +16,7 @@ module Vcloud
         reset_edge_gateway
         @vars_config_file = generate_vars_file(edge_gateway_vars_hash)
         @initial_load_balancer_config_file = IntegrationHelper.fixture_file('load_balancer_config.yaml.mustache')
-        @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@edge_name)
+        @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@test_data.edge_gateway)
       end
 
       context "Check update is functional" do
@@ -48,8 +42,11 @@ module Vcloud
         it "should only make one EdgeGateway update task, to minimise EdgeGateway reload events" do
           start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
-          EdgeGateway::Configure.new(@initial_load_balancer_config_file, @vars_config_file).update
+          diff = EdgeGateway::Configure.new(@initial_load_balancer_config_file, @vars_config_file).update
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
+
+          expect(diff.keys).to eq([:LoadBalancerService])
+          expect(diff[:LoadBalancerService]).to have_at_least(1).items
           expect(task_list_after_update.size - task_list_before_update.size).to be(1)
         end
 
@@ -79,18 +76,12 @@ module Vcloud
             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::Core.logger).
-            to receive(:info).with('EdgeGateway::Configure.update: Configuration is already up to date. Skipping.')
-          EdgeGateway::Configure.new(@initial_load_balancer_config_file, @vars_config_file).update
+          expect(Vcloud::Core.logger).to receive(:info).
+            with('EdgeGateway::Configure.update: Configuration is already up to date. Skipping.')
+          diff = EdgeGateway::Configure.new(@initial_load_balancer_config_file, @vars_config_file).update
+
+          expect(diff).to eq({})
         end
 
       end
@@ -99,18 +90,24 @@ module Vcloud
 
         it "should be able to configure with no pools and virtual_servers" do
           config_file = IntegrationHelper.fixture_file('load_balancer_empty.yaml.mustache')
-          EdgeGateway::Configure.new(config_file, @vars_config_file).update
+          diff = EdgeGateway::Configure.new(config_file, @vars_config_file).update
           edge_config = @edge_gateway.vcloud_attributes[:Configuration]
           remote_vcloud_config = edge_config[:EdgeGatewayServiceConfiguration][:LoadBalancerService]
+
+          expect(diff.keys).to eq([:LoadBalancerService])
+          expect(diff[:LoadBalancerService]).to have_at_least(1).items
           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 = IntegrationHelper.fixture_file('load_balancer_single_pool.yaml.mustache')
-          EdgeGateway::Configure.new(config_file, @vars_config_file).update
+          diff = EdgeGateway::Configure.new(config_file, @vars_config_file).update
           edge_config = @edge_gateway.vcloud_attributes[:Configuration]
           remote_vcloud_config = edge_config[:EdgeGatewayServiceConfiguration][:LoadBalancerService]
+
+          expect(diff.keys).to eq([:LoadBalancerService])
+          expect(diff[:LoadBalancerService]).to have_at_least(1).items
           expect(remote_vcloud_config[:Pool].size).to be == 1
         end
 
@@ -131,14 +128,11 @@ module Vcloud
       end
 
       after(:all) do
-        reset_edge_gateway unless ENV['VCLOUD_NO_RESET_VSE_AFTER']
-        @files_to_delete.each { |f|
-          f.unlink
-        }
+        IntegrationHelper.remove_temp_config_files(@files_to_delete)
       end
 
       def reset_edge_gateway
-        edge_gateway = Core::EdgeGateway.get_by_name @edge_name
+        edge_gateway = Core::EdgeGateway.get_by_name @test_data.edge_gateway
         edge_gateway.update_configuration({
           LoadBalancerService: {
             IsEnabled: "false",
@@ -159,9 +153,9 @@ module Vcloud
 
       def edge_gateway_vars_hash
         {
-          :edge_gateway_name => @edge_name,
-          :edge_gateway_ext_network_id => @ext_net_id,
-          :edge_gateway_ext_network_ip => @ext_net_ip,
+          :edge_gateway_name => @test_data.edge_gateway,
+          :edge_gateway_ext_network_id => @test_data.provider_network_id,
+          :edge_gateway_ext_network_ip => @test_data.provider_network_ip,
         }
       end
 
@@ -170,7 +164,7 @@ module Vcloud
         q = Vcloud::Core::QueryRunner.new
         q.run('task',
           :filter =>
-            "name==networkConfigureEdgeGatewayServices;objectName==#{@edge_name};startDate=ge=#{vcloud_time}",
+            "name==networkConfigureEdgeGatewayServices;objectName==#{@test_data.edge_gateway};startDate=ge=#{vcloud_time}",
           :sortDesc => 'startDate',
         )
       end

data/spec/integration/edge_gateway/{nat_service_spec.rb → configure_nat_spec.rb}

@@ -5,14 +5,8 @@ module Vcloud
   describe EdgeGateway::Configure do
 
     before(:all) do
-      IntegrationHelper.verify_env_vars
-      @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']
+      config_file = File.join(File.dirname(__FILE__), "../vcloud_tools_testing_config.yaml")
+      @test_data = Vcloud::Tools::Tester::TestParameters.new(config_file)
       @files_to_delete = []
     end
 
@@ -22,7 +16,7 @@ module Vcloud
         reset_edge_gateway
         @vars_config_file = generate_vars_file(edge_gateway_vars_hash)
         @initial_nat_config_file = IntegrationHelper.fixture_file('nat_config.yaml.mustache')
-        @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@edge_name)
+        @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@test_data.edge_gateway)
       end
 
       context "Check update is functional" do
@@ -47,8 +41,11 @@ module Vcloud
         it "should only make one EdgeGateway update task, to minimise EdgeGateway reload events" do
           start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
-          EdgeGateway::Configure.new(@initial_nat_config_file, @vars_config_file).update
+          diff = EdgeGateway::Configure.new(@initial_nat_config_file, @vars_config_file).update
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
+
+          expect(diff.keys).to eq([:NatService])
+          expect(diff[:NatService]).to have_at_least(1).items
           expect(task_list_after_update.size - task_list_before_update.size).to be(1)
         end
 
@@ -63,16 +60,11 @@ module Vcloud
             to eq(@local_vcloud_config[:NatRule].size)
         end
 
-        it "ConfigurationDiffer should return empty if local and remote nat configs match" do
-          remote_vcloud_config = @edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration][:NatService]
-          differ = EdgeGateway::ConfigurationDiffer.new(@local_vcloud_config, remote_vcloud_config)
-          diff_output = differ.diff
-          expect(diff_output).to eq([])
-        end
-
         it "and then should not configure the firewall service if updated again with the same configuration (idempotency)" do
           expect(Vcloud::Core.logger).to receive(:info).with('EdgeGateway::Configure.update: Configuration is already up to date. Skipping.')
-          EdgeGateway::Configure.new(@initial_nat_config_file, @vars_config_file).update
+          diff = EdgeGateway::Configure.new(@initial_nat_config_file, @vars_config_file).update
+
+          expect(diff).to eq({})
         end
 
       end
@@ -88,8 +80,8 @@ module Vcloud
           expect(dnat_rule[:RuleType]).to eq('DNAT')
           expect(dnat_rule[:Id]).to eq('65537')
           expect(dnat_rule[:IsEnabled]).to eq('true')
-          expect(dnat_rule[:GatewayNatRule][:Interface][:href]).to include(@ext_net_id)
-          expect(dnat_rule[:GatewayNatRule][:OriginalIp]).to eq(@ext_net_ip)
+          expect(dnat_rule[:GatewayNatRule][:Interface][:href]).to include(@test_data.provider_network_id)
+          expect(dnat_rule[:GatewayNatRule][:OriginalIp]).to eq(@test_data.provider_network_ip)
           expect(dnat_rule[:GatewayNatRule][:OriginalPort]).to eq('3412')
           expect(dnat_rule[:GatewayNatRule][:TranslatedIp]).to eq('10.10.1.2-10.10.1.3')
           expect(dnat_rule[:GatewayNatRule][:TranslatedPort]).to eq('3412')
@@ -102,9 +94,9 @@ module Vcloud
           expect(snat_rule[:RuleType]).to eq('SNAT')
           expect(snat_rule[:Id]).to eq('65538')
           expect(snat_rule[:IsEnabled]).to eq('true')
-          expect(snat_rule[:GatewayNatRule][:Interface][:href]).to include(@ext_net_id)
+          expect(snat_rule[:GatewayNatRule][:Interface][:href]).to include(@test_data.provider_network_id)
           expect(snat_rule[:GatewayNatRule][:OriginalIp]).to eq('10.10.1.2-10.10.1.3')
-          expect(snat_rule[:GatewayNatRule][:TranslatedIp]).to eq(@ext_net_ip)
+          expect(snat_rule[:GatewayNatRule][:TranslatedIp]).to eq(@test_data.provider_network_ip)
         end
 
       end
@@ -113,17 +105,20 @@ module Vcloud
 
         it "and then should configure hairpin NATting with orgVdcNetwork" do
           vars_file = generate_vars_file({
-            edge_gateway_name: @edge_name,
-            org_vdc_network_id: @int_net_id,
-            original_ip: @int_net_ip,
+            edge_gateway_name: @test_data.edge_gateway,
+            org_vdc_network_id: @test_data.network_1_id,
+            original_ip: @test_data.network_1_ip,
           })
 
-          EdgeGateway::Configure.new(
+          diff = EdgeGateway::Configure.new(
             IntegrationHelper.fixture_file('hairpin_nat_config.yaml.mustache'),
             vars_file
           ).update
 
-          edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@edge_name)
+          expect(diff.keys).to eq([:NatService])
+          expect(diff[:NatService]).to have_at_least(1).items
+
+          edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@test_data.edge_gateway)
           nat_service = edge_gateway.vcloud_attributes[:Configuration][:EdgeGatewayServiceConfiguration][:NatService]
           expected_rule = nat_service[:NatRule].first
           expect(expected_rule).not_to be_nil
@@ -131,8 +126,8 @@ module Vcloud
           expect(expected_rule[:Id]).to eq('65537')
           expect(expected_rule[:RuleType]).to eq('DNAT')
           expect(expected_rule[:IsEnabled]).to eq('true')
-          expect(expected_rule[:GatewayNatRule][:Interface][:name]).to eq(@int_net_name)
-          expect(expected_rule[:GatewayNatRule][:OriginalIp]).to eq(@int_net_ip)
+          expect(expected_rule[:GatewayNatRule][:Interface][:name]).to eq(@test_data.network_1)
+          expect(expected_rule[:GatewayNatRule][:OriginalIp]).to eq(@test_data.network_1_ip)
           expect(expected_rule[:GatewayNatRule][:OriginalPort]).to eq('3412')
           expect(expected_rule[:GatewayNatRule][:TranslatedIp]).to eq('10.10.1.2')
           expect(expected_rule[:GatewayNatRule][:TranslatedPort]).to eq('3412')
@@ -142,9 +137,9 @@ module Vcloud
         it "should raise error if network provided in rule does not exist" do
           random_network_id = SecureRandom.uuid
           vars_file = generate_vars_file({
-            edge_gateway_name: @edge_name,
+            edge_gateway_name: @test_data.edge_gateway,
             network_id: random_network_id,
-            original_ip: @int_net_ip,
+            original_ip: @test_data.network_1_ip,
           })
 
           expect {
@@ -157,18 +152,11 @@ module Vcloud
       end
 
       after(:all) do
-        reset_edge_gateway unless ENV['VCLOUD_NO_RESET_VSE_AFTER']
-        remove_temp_config_files
-      end
-
-      def remove_temp_config_files
-        @files_to_delete.each { |f|
-          f.unlink
-        }
+        IntegrationHelper.remove_temp_config_files(@files_to_delete)
       end
 
       def reset_edge_gateway
-        edge_gateway = Core::EdgeGateway.get_by_name @edge_name
+        edge_gateway = Core::EdgeGateway.get_by_name @test_data.edge_gateway
         edge_gateway.update_configuration({
           NatService: {:IsEnabled => "true", :NatRule => []},
         })
@@ -185,9 +173,9 @@ module Vcloud
 
       def edge_gateway_vars_hash
         {
-          :edge_gateway_name => @edge_name,
-          :network_id => @ext_net_id,
-          :original_ip => @ext_net_ip,
+          :edge_gateway_name => @test_data.edge_gateway,
+          :network_id => @test_data.provider_network_id,
+          :original_ip => @test_data.provider_network_ip,
         }
       end
 
@@ -195,7 +183,7 @@ module Vcloud
         vcloud_time = timestamp.strftime('%FT%T.000Z')
         q = Vcloud::Core::QueryRunner.new
         q.run('task',
-          :filter => "name==networkConfigureEdgeGatewayServices;objectName==#{@edge_name};startDate=ge=#{vcloud_time}",
+          :filter => "name==networkConfigureEdgeGatewayServices;objectName==#{@test_data.edge_gateway};startDate=ge=#{vcloud_time}",
           :sortDesc => 'startDate',
         )
       end

data/spec/integration/edge_gateway/{edge_gateway_services_spec.rb → configure_services_spec.rb}

@@ -5,14 +5,8 @@ module Vcloud
   describe EdgeGateway::Configure do
 
     before(:all) do
-      IntegrationHelper.verify_env_vars
-      @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']
+      config_file = File.join(File.dirname(__FILE__), "../vcloud_tools_testing_config.yaml")
+      @test_data = Vcloud::Tools::Tester::TestParameters.new(config_file)
       @files_to_delete = []
     end
 
@@ -23,7 +17,7 @@ module Vcloud
         @vars_config_file = generate_vars_file(edge_gateway_vars_hash)
         @initial_config_file = IntegrationHelper.fixture_file('nat_and_firewall_config.yaml.mustache')
         @adding_load_balancer_config_file = IntegrationHelper.fixture_file('nat_and_firewall_plus_load_balancer_config.yaml.mustache')
-        @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@edge_name)
+        @edge_gateway = Vcloud::Core::EdgeGateway.get_by_name(@test_data.edge_gateway)
       end
 
       context "Check update is functional" do
@@ -39,8 +33,12 @@ module Vcloud
         it "should only create one edgeGateway update task when updating the configuration" do
           start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
-          EdgeGateway::Configure.new(@initial_config_file, @vars_config_file).update
+          diff = EdgeGateway::Configure.new(@initial_config_file, @vars_config_file).update
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
+
+          expect(diff.keys).to eq([:FirewallService, :NatService])
+          expect(diff[:FirewallService]).to have_at_least(1).items
+          expect(diff[:NatService]).to      have_at_least(1).items
           expect(task_list_after_update.size - task_list_before_update.size).to be(1)
         end
 
@@ -55,42 +53,42 @@ module Vcloud
         it "should not update the EdgeGateway again if the config hasn't changed" do
           start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
-          EdgeGateway::Configure.new(@initial_config_file, @vars_config_file).update
+          diff = EdgeGateway::Configure.new(@initial_config_file, @vars_config_file).update
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
+
+          expect(diff).to eq({})
           expect(task_list_after_update.size - task_list_before_update.size).to be(0)
         end
 
         it "should only create one additional edgeGateway update task when adding the LoadBalancer config" do
           start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
-          EdgeGateway::Configure.new(@adding_load_balancer_config_file, @vars_config_file).update
+          diff = EdgeGateway::Configure.new(@adding_load_balancer_config_file, @vars_config_file).update
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
+
+          expect(diff.keys).to eq([:LoadBalancerService])
+          expect(diff[:LoadBalancerService]).to have_at_least(1).items
           expect(task_list_after_update.size - task_list_before_update.size).to be(1)
         end
 
         it "should not update the EdgeGateway again if we reapply the 'adding load balancer' config" do
           start_time = Time.now.getutc
           task_list_before_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
-          EdgeGateway::Configure.new(@adding_load_balancer_config_file, @vars_config_file).update
+          diff = EdgeGateway::Configure.new(@adding_load_balancer_config_file, @vars_config_file).update
           task_list_after_update = get_all_edge_gateway_update_tasks_ordered_by_start_date_since_time(start_time)
+
+          expect(diff).to eq({})
           expect(task_list_after_update.size - task_list_before_update.size).to be(0)
         end
 
       end
 
       after(:all) do
-        reset_edge_gateway unless ENV['VCLOUD_NO_RESET_VSE_AFTER']
-        remove_temp_config_files
-      end
-
-      def remove_temp_config_files
-        @files_to_delete.each { |f|
-          f.unlink
-        }
+        IntegrationHelper.remove_temp_config_files(@files_to_delete)
       end
 
       def reset_edge_gateway
-        edge_gateway = Core::EdgeGateway.get_by_name @edge_name
+        edge_gateway = Core::EdgeGateway.get_by_name @test_data.edge_gateway
         edge_gateway.update_configuration({
                                             FirewallService: {IsEnabled: false, FirewallRule: []},
                                             NatService: {:IsEnabled => "true", :NatRule => []},
@@ -113,11 +111,11 @@ module Vcloud
 
       def edge_gateway_vars_hash
         {
-          edge_gateway_name: @edge_name,
-          network_id: @ext_net_id,
-          original_ip: @ext_net_ip,
-          edge_gateway_ext_network_id: @ext_net_id,
-          edge_gateway_ext_network_ip: @ext_net_ip,
+          edge_gateway_name: @test_data.edge_gateway,
+          network_id: @test_data.provider_network_id,
+          original_ip: @test_data.provider_network_ip,
+          edge_gateway_ext_network_id: @test_data.provider_network_id,
+          edge_gateway_ext_network_ip: @test_data.provider_network_ip,
         }
       end
 
@@ -127,7 +125,7 @@ module Vcloud
 
         q.run('task',
           :filter =>
-            "name==networkConfigureEdgeGatewayServices;objectName==#{@edge_name};startDate=ge=#{vcloud_time}",
+            "name==networkConfigureEdgeGatewayServices;objectName==#{@test_data.edge_gateway};startDate=ge=#{vcloud_time}",
           :sortDesc => 'startDate',
         )
       end

data/spec/integration/vcloud_tools_testing_config.yaml.template

@@ -0,0 +1,8 @@
+default:
+  network_1:
+  network_1_id:
+  network_1_ip:
+  edge_gateway:
+  provider_network:
+  provider_network_id:
+  provider_network_ip:

data/spec/spec_helper.rb

@@ -1,26 +1,37 @@
-require 'simplecov'
 require 'support/integration_helper'
 
-SimpleCov.profiles.define 'gem' do
-  add_filter '/spec/'
-  add_filter '/features/'
-  add_filter '/vendor/'
+if ENV['COVERAGE']
+  require 'simplecov'
 
-  add_group 'Libraries', '/lib/'
-end
+  SimpleCov.profiles.define 'gem' do
+    add_filter '/spec/'
+    add_filter '/features/'
+    add_filter '/vendor/'
+
+    add_group 'Libraries', '/lib/'
+  end
 
-SimpleCov.start 'gem'
+  SimpleCov.start 'gem'
+end
 
 require 'bundler/setup'
 require 'vcloud/edge_gateway'
+require 'vcloud/tools/tester'
 
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
 
-SimpleCov.at_exit do
-  SimpleCov.result.format!
-  # do not change the coverage percentage, instead add more unit tests to fix coverage failures.
-  if SimpleCov.result.covered_percent < 90
-    print "ERROR::BAD_COVERAGE\n"
-    print "Coverage is less than acceptable limit(90%). Please add more tests to improve the coverage\n"
-    exit(1)
+if ENV['COVERAGE']
+  SimpleCov.at_exit do
+    SimpleCov.result.format!
+    # do not change the coverage percentage, instead add more unit tests to fix coverage failures.
+    if SimpleCov.result.covered_percent < 90
+      print "ERROR::BAD_COVERAGE\n"
+      print "Coverage is less than acceptable limit(90%). Please add more tests to improve the coverage\n"
+      exit(1)
+    end
   end
 end

data/spec/support/integration_helper.rb

@@ -1,24 +1,4 @@
 module IntegrationHelper
-  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',
-  }
-
-  def self.verify_env_vars
-    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
-  end
-
   def self.fixture_path
     File.expand_path("../integration/edge_gateway/data", File.dirname(__FILE__))
   end
@@ -26,4 +6,12 @@ module IntegrationHelper
   def self.fixture_file(path)
     File.join(self.fixture_path, path)
   end
+
+  def self.remove_temp_config_files(files_to_delete)
+    files_to_delete.each { |f|
+      f.unlink
+    }
+  end
+
+
 end