vcloud-edge_gateway 0.2.2 → 0.2.3

data/spec/vcloud/edge_gateway/configuration_differ_spec.rb

@@ -1,131 +1,14 @@
 require 'spec_helper'
+require_relative 'configuration_differ_shared_examples'
 
 module Vcloud
   module EdgeGateway
-    describe ConfigurationDiffer do
-
-      test_cases = [
-        {
-          title: 'should return an empty array for two identical empty Hashes',
-          src:    { },
-          dest:   { },
-          output: [],
-        },
-
-        {
-          title: 'should return an empty array for two identical simple Hashes',
-          src:    { testing: 'testing', one: 1, two: 'two', three: "3" },
-          dest:   { testing: 'testing', one: 1, two: 'two', three: "3" },
-          output: [],
-        },
-
-        {
-          title: 'should return an empty array for two identical deep Hashes',
-          src:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          dest:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [],
-        },
-
-        {
-          title: 'should highlight a simple addition',
-          src:    { foo: '1' },
-          dest:   { foo: '1', bar: '2' },
-          output: [["+", "bar", "2"]],
-        },
-
-        {
-          title: 'should highlight a simple subtraction',
-          src:    { foo: '1', bar: '2' },
-          dest:   { foo: '1' },
-          output: [["-", "bar", "2"]],
-        },
-
-        {
-          title: 'should highlight a deep addition',
-          src:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          dest:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5, 6 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [["+", "deep[0].deeper[5]", 6]],
-        },
-
-        {
-          title: 'should highlight a deep subtraction',
-          src:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          dest:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 3, 2 ] },
-          ]},
-          output: [["-", "deep[1].deeper[2]", 4]],
-        },
 
-        {
-          title: 'should return an empty array when hash params are reordered',
-          src:    { one: 1, testing: 'testing', deep: [
-            { deeper: [ 1, 2, 3, 4, 5 ], foo: 'bar' },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          dest:   { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [],
-        },
-
-        {
-          title: 'should highlight when array elements are reordered',
-          src:    { testing: 'testing', one: 1, deep: [
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-          ]},
-          dest:   { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [
-            ["+", "deep[0]", {:foo=>"bar", :deeper=>[1, 2, 3, 4, 5]}],
-            ["-", "deep[2]", {:foo=>"bar", :deeper=>[1, 2, 3, 4, 5]}],
-          ]
-        },
-
-        {
-          title: 'should highlight when deep array elements are reordered',
-          src:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 5, 6, 4, 3, 2 ] },
-          ]},
-          dest:   { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [
-            ["+", "deep[1].deeper[0]", 6],
-            ["-", "deep[1].deeper[2]", 6]
-          ]
-        },
-
-      ]
-
-      test_cases.each do |test_case|
-        it "#{test_case[:title]}" do
-          differ = ConfigurationDiffer.new(test_case[:src], test_case[:dest])
-          expect(differ.diff).to eq(test_case[:output])
-        end
+    describe ConfigurationDiffer do
+      it_behaves_like "a configuration differ" do
+        let(:config_differ) { ConfigurationDiffer }
       end
-
     end
+
   end
 end

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

@@ -66,11 +66,8 @@ module Vcloud
 
         context "firewall config generation" do
 
-          test_cases = [
-
-            {
-              title: 'disabled firewall with a disabled rule',
-              input: {
+          it 'should have disabled firewall with a disabled rule' do
+            input = {
                 enabled: 'false',
                 policy: 'allow',
                 log_default_action: 'true',
@@ -89,8 +86,8 @@ module Vcloud
                     enable_logging: 'true',
                   }
                 ]
-              },
-              output: {
+            }
+            output = {
                 IsEnabled: 'false',
                 DefaultAction: "allow",
                 LogDefaultAction: 'true',
@@ -111,12 +108,13 @@ module Vcloud
                     EnableLogging: 'true',
                   }
                 ]
-              }
-            },
+            }
+            generated_config = FirewallService.new.generate_fog_config(input)
+            expect(generated_config).to eq(output)
+          end
 
-            {
-              title: 'id should be auto generated if not provided',
-              input: {
+          it 'id should be auto generated if not provided' do
+            input = {
                 firewall_rules: [
                   {
                     description: "rule 1",
@@ -131,8 +129,8 @@ module Vcloud
                     source_ip: "192.0.2.2",
                   }
                 ]
-              },
-              output: {
+            }
+            output = {
                 IsEnabled: 'true',
                 DefaultAction: "drop",
                 LogDefaultAction: 'false',
@@ -168,12 +166,13 @@ module Vcloud
                     EnableLogging: 'false',
                   }
                 ]
-              }
-            },
+            }
+            generated_config = FirewallService.new.generate_fog_config(input)
+            expect(generated_config).to eq(output)
+          end
 
-            {
-              title: 'should send port as -1 if destination/source_port_ranges are ranges',
-              input: {
+          it 'should send port as -1 if destination/source_port_ranges are ranges' do
+            input = {
                 firewall_rules: [
                   {
                     description: "rule 1",
@@ -183,8 +182,8 @@ module Vcloud
                     source_ip: "192.0.2.2",
                   }
                 ]
-              },
-              output: {
+            }
+            output = {
                 IsEnabled: 'true',
                 DefaultAction: "drop",
                 LogDefaultAction: 'false',
@@ -205,12 +204,13 @@ module Vcloud
                     EnableLogging: 'false',
                   }
                 ]
-              }
-            },
+            }
+            generated_config = FirewallService.new.generate_fog_config(input)
+            expect(generated_config).to eq(output)
+          end
 
-            {
-              title: 'should send port same as destination/source_port_range if destination/source_port_range are decimals and not ranges',
-              input: {
+          it 'should send port same as destination/source_port_range if destination/source_port_range are decimals and not ranges' do
+            input = {
                 firewall_rules: [
                   {
                     description: "rule 1",
@@ -220,8 +220,8 @@ module Vcloud
                     source_ip: "192.0.2.2",
                   }
                 ]
-              },
-              output: {
+            }
+            output = {
                 IsEnabled: 'true',
                 DefaultAction: "drop",
                 LogDefaultAction: 'false',
@@ -242,12 +242,13 @@ module Vcloud
                     EnableLogging: 'false',
                   }
                 ]
-              },
-            },
+            }
+            generated_config = FirewallService.new.generate_fog_config(input)
+            expect(generated_config).to eq(output)
+          end
 
-            {
-              title: 'should handle a rule specifiying "any" protocols',
-              input: {
+          it 'should handle a rule specifiying "any" protocols' do
+            input = {
                 firewall_rules: [
                   {
                     description: "allow any protocol",
@@ -256,8 +257,8 @@ module Vcloud
                     source_ip: "192.0.2.2",
                   }
                 ]
-              },
-              output: {
+            }
+            output = {
                 IsEnabled: 'true',
                 DefaultAction: "drop",
                 LogDefaultAction: 'false',
@@ -278,12 +279,13 @@ module Vcloud
                     EnableLogging: 'false',
                   }
                 ]
-              },
-            },
+            }
+            generated_config = FirewallService.new.generate_fog_config(input)
+            expect(generated_config).to eq(output)
+          end
 
-            {
-              title: 'output rule order should be same as the input rule order',
-              input: {
+          it 'output rule order should be same as the input rule order' do
+            input = {
                 firewall_rules: [
                   {
                     description: "rule 1",
@@ -316,8 +318,8 @@ module Vcloud
                     source_ip: "Any",
                   },
                 ],
-              },
-              output: {
+            }
+            output = {
                 IsEnabled: 'true',
                 DefaultAction: "drop",
                 LogDefaultAction: 'false',
@@ -398,17 +400,9 @@ module Vcloud
                     EnableLogging: 'false',
                   }
                 ]
-              }
             }
-
-          ]
-
-          test_cases.each do |test_case|
-            it "#{test_case[:title]}" do
-              generated_config = FirewallService.new.generate_fog_config test_case[:input]
-              expect(generated_config).to eq(test_case[:output])
-            end
-
+            generated_config = FirewallService.new.generate_fog_config(input)
+            expect(generated_config).to eq(output)
           end
 
         end

data/spec/vcloud/edge_gateway/firewall_configuration_differ_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require_relative 'configuration_differ_shared_examples.rb'
+
+module Vcloud
+  module EdgeGateway
+    describe FirewallConfigurationDiffer do
+
+      it_behaves_like "a configuration differ" do
+        let(:config_differ) { FirewallConfigurationDiffer }
+      end
+
+      it 'should ignore Id parameters in FirewallRule sections, when showing additions' do
+        local = { FirewallRule: [
+            { Id: '1', deeper: [ 1, 2, 3, 4, 5 ] },
+            { Id: '2', deeper: [ 5, 6, 4, 3, 2 ] },
+          ]}
+        remote = { FirewallRule: [
+            { Id: '1', deeper: [ 1, 1, 1, 1, 1 ] },
+            { Id: '2', deeper: [ 1, 2, 3, 4, 5 ] },
+            { Id: '3', deeper: [ 5, 6, 4, 3, 2 ] },
+          ]}
+        output = [
+            ["+", "FirewallRule[0]", {:deeper=>[1, 1, 1, 1, 1]}]
+          ]
+        differ = FirewallConfigurationDiffer.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should still highlight a reordering despite ignoring Id' do
+        local = { FirewallRule: [
+          { Id: '1', deeper: [ 1, 1, 1, 1, 1 ] },
+          { Id: '2', deeper: [ 1, 2, 3, 4, 5 ] },
+          { Id: '3', deeper: [ 5, 6, 4, 3, 2 ] },
+        ]}
+        remote = { FirewallRule: [
+          { Id: '1', deeper: [ 1, 2, 3, 4, 5 ] },
+          { Id: '2', deeper: [ 5, 6, 4, 3, 2 ] },
+          { Id: '3', deeper: [ 1, 1, 1, 1, 1 ] },
+        ]}
+        output = [
+          ["-", "FirewallRule[0]", {:deeper=>[1, 1, 1, 1, 1]}],
+          ["+", "FirewallRule[2]", {:deeper=>[1, 1, 1, 1, 1]}],
+        ]
+        differ = FirewallConfigurationDiffer.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+      it 'should not ignore Id parameter outside of a FirewallRule (just in case)' do
+        local = {
+         FirewallRule: [ { Id: '1', deeper: [ 1, 1, 1, 1, 1 ] } ],
+         Id: 'outside of firewall rule'
+        }
+        remote = {
+         FirewallRule: [ { Id: '1', deeper: [ 1, 1, 1, 1, 1 ] } ],
+        }
+        output = [
+         ["-", "Id", 'outside of firewall rule']
+        ]
+        differ = FirewallConfigurationDiffer.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
+
+    end
+  end
+end

data/spec/vcloud/edge_gateway/firewall_schema_validation_spec.rb

@@ -16,7 +16,7 @@ module Vcloud
           ]
 
         }
-        validator = ConfigValidator.validate(:base, config, Schema::FIREWALL_SERVICE)
+        validator = Vcloud::Core::ConfigValidator.validate(:base, config, Schema::FIREWALL_SERVICE)
         expect(validator.valid?).to be_false
         expect(validator.errors).to eq([
                                          "source_ip: 192.0 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'.",
@@ -37,7 +37,7 @@ module Vcloud
           ]
 
         }
-        validator = ConfigValidator.validate(:base, config, Schema::FIREWALL_SERVICE)
+        validator = Vcloud::Core::ConfigValidator.validate(:base, config, Schema::FIREWALL_SERVICE)
         expect(validator.valid?).to be_true
       end
     end

data/spec/vcloud/edge_gateway/load_balancer_configuration_differ_spec.rb

@@ -1,158 +1,43 @@
 require 'spec_helper'
+require_relative 'configuration_differ_shared_examples.rb'
 
 module Vcloud
   module EdgeGateway
     describe LoadBalancerConfigurationDiffer do
 
-      test_cases = [
-        {
-          title: 'should return an empty array for two identical empty Hashes',
-          src:    { },
-          dest:   { },
-          output: [],
-        },
-
-        {
-          title: 'should return an empty array for two identical simple Hashes',
-          src:    { testing: 'testing', one: 1, two: 'two', three: "3" },
-          dest:   { testing: 'testing', one: 1, two: 'two', three: "3" },
-          output: [],
-        },
-
-        {
-          title: 'should return an empty array for two identical deep Hashes',
-          src:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          dest:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [],
-        },
-
-        {
-          title: 'should highlight a simple addition',
-          src:    { foo: '1' },
-          dest:   { foo: '1', bar: '2' },
-          output: [["+", "bar", "2"]],
-        },
-
-        {
-          title: 'should highlight a simple subtraction',
-          src:    { foo: '1', bar: '2' },
-          dest:   { foo: '1' },
-          output: [["-", "bar", "2"]],
-        },
-
-        {
-          title: 'should highlight a deep addition',
-          src:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          dest:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5, 6 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [["+", "deep[0].deeper[5]", 6]],
-        },
-
-        {
-          title: 'should highlight a deep subtraction',
-          src:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          dest:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 3, 2 ] },
-          ]},
-          output: [["-", "deep[1].deeper[2]", 4]],
-        },
-
-        {
-          title: 'should return an empty array when hash params are reordered',
-          src:    { one: 1, testing: 'testing', deep: [
-            { deeper: [ 1, 2, 3, 4, 5 ], foo: 'bar' },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          dest:   { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [],
-        },
-
-        {
-          title: 'should highlight when array elements are reordered',
-          src:    { testing: 'testing', one: 1, deep: [
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-          ]},
-          dest:   { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [
-            ["+", "deep[0]", {:foo=>"bar", :deeper=>[1, 2, 3, 4, 5]}],
-            ["-", "deep[2]", {:foo=>"bar", :deeper=>[1, 2, 3, 4, 5]}],
-          ]
-        },
-
-        {
-          title: 'should highlight when deep array elements are reordered',
-          src:    { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 5, 6, 4, 3, 2 ] },
-          ]},
-          dest:   { testing: 'testing', one: 1, deep: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [
-            ["+", "deep[1].deeper[0]", 6],
-            ["-", "deep[1].deeper[2]", 6]
-          ]
-        },
-
-        {
-          title: 'should ignore remote config having additional :Operational keys in :Pool entries',
-          src:    { Pool: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 5, 6, 4, 3, 2 ] },
-          ]},
-          dest:   { Pool: [
-            { foo: 'bar', Operational: 'wibble', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', Operational: 'wobble', deeper: [ 5, 6, 4, 3, 2 ] },
-          ]},
-          output: []
-        },
-
-        {
-          title: 'should ignore remote config having additional :Operational keys in :Pool entries, yet still report other differences ',
-          src:    { Pool: [
-            { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', deeper: [ 5, 6, 4, 3, 2 ] },
-          ]},
-          dest:   { Pool: [
-            { foo: 'bar', Operational: 'wibble', deeper: [ 1, 2, 3, 4, 5 ] },
-            { baz: 'bop', Operational: 'wobble', deeper: [ 6, 5, 4, 3, 2 ] },
-          ]},
-          output: [
-            ["+", "Pool[1].deeper[0]", 6],
-            ["-", "Pool[1].deeper[2]", 6]
-          ]
-        },
+      it_behaves_like "a configuration differ" do
+        let(:config_differ) { LoadBalancerConfigurationDiffer }
+      end
 
-      ]
+      it 'should ignore remote config having additional :Operational keys in :Pool entries' do
+        local = { Pool: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 5, 6, 4, 3, 2 ] },
+        ]}
+        remote = { Pool: [
+          { foo: 'bar', Operational: 'wibble', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', Operational: 'wobble', deeper: [ 5, 6, 4, 3, 2 ] },
+        ]}
+        output =  []
+        differ = LoadBalancerConfigurationDiffer.new(local, remote)
+        expect(differ.diff).to eq(output)
+      end
 
-      test_cases.each do |test_case|
-        it "#{test_case[:title]}" do
-          differ = LoadBalancerConfigurationDiffer.new(test_case[:src], test_case[:dest])
-          expect(differ.diff).to eq(test_case[:output])
-        end
+      it 'should ignore remote config having additional :Operational keys in :Pool entries, yet still report other differences' do
+        local = { Pool: [
+          { foo: 'bar', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', deeper: [ 5, 6, 4, 3, 2 ] },
+        ]}
+        remote = { Pool: [
+          { foo: 'bar', Operational: 'wibble', deeper: [ 1, 2, 3, 4, 5 ] },
+          { baz: 'bop', Operational: 'wobble', deeper: [ 6, 5, 4, 3, 2 ] },
+        ]}
+        output =  [
+          ["+", "Pool[1].deeper[0]", 6],
+          ["-", "Pool[1].deeper[2]", 6]
+        ]
+        differ = LoadBalancerConfigurationDiffer.new(local, remote)
+        expect(differ.diff).to eq(output)
       end
 
     end