vcloud-core 1.0.0 → 1.0.1

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 1.0.1 (2015-01-29)
+
+Documentation:
+
+    - Update integration test details in README
+    - Update Gem ownership details
+
+Fixes:
+
+    - Tighten dependency on vcloud-tools-tester
+    - Refactored test namespacing
+
 ## 1.0.0 (2015-01-22)
 
   - Release 1.0.0 since the public API is now stable
@@ -12,7 +24,7 @@ Bugfixes:
 
 Features:
 
-  - New `vlcoud-logout` command line utility to revoke session tokens.
+  - New `vcloud-logout` command line utility to revoke session tokens.
   - New `Vcloud::Core::Fog.logout` method to revoke session tokens.
 
 ## 0.15.0 (2014-11-26)

data/README.md

@@ -137,14 +137,19 @@ Run the default suite of tests (e.g. lint, unit, features):
 
     bundle exec rake
 
-Run the integration tests (slower and requires a real environment):
-
-    bundle exec rake integration
-
-You need access to a suitable vCloud Director organization to run the
-integration tests. See the [integration tests README](/spec/integration/README.md) for
-further details.
-
+There are also integration tests. These are slower and require a real environment.
+See the [vCloud Tools website](http://gds-operations.github.io/vcloud-tools/testing/) for details of how to set up and run the integration tests.
+
+The parameters required to run the vCloud Core integration tests are:
+
+````
+default: # This is the fog credential that refers to your testing environment, e.g. `test_credential`
+  vdc_1_name: # The name of a VDC
+  catalog: # A catalog
+  vapp_template: # A vApp Template within that catalog
+  network_1: # The name of the primary network
+  network_1_ip: # The IP address of the primary network
+````
 ## Contributing
 
 1. Fork it

data/lib/vcloud/core/version.rb

@@ -1,5 +1,5 @@
 module Vcloud
   module Core
-    VERSION = '1.0.0'
+    VERSION = '1.0.1'
   end
 end

data/spec/vcloud/core/config_loader_spec.rb

@@ -1,164 +1,160 @@
 require 'spec_helper'
 
-module Vcloud
-  module Core
-    describe ConfigLoader do
-
-      before(:all) do
-        @data_dir = File.join(File.dirname(__FILE__), "/data")
-      end
-
-      describe 'basic config loading' do
-        it "should create a valid hash when input is JSON" do
-          input_file = "#{@data_dir}/working.json"
-          loader = ConfigLoader.new
-          actual_config = loader.load_config(input_file)
-          expect(valid_config).to eq(actual_config)
-        end
-
-        it "should create a valid hash when input is YAML" do
-          input_file = "#{@data_dir}/working.yaml"
-          loader = ConfigLoader.new
-          actual_config = loader.load_config(input_file)
-          expect(valid_config).to eq(actual_config)
-        end
-
-        it "should create a valid hash when input is YAML with anchor defaults" do
-          input_file = "#{@data_dir}/working_with_defaults.yaml"
-          loader = ConfigLoader.new
-          actual_config = loader.load_config(input_file)
-          expect(valid_config['vapps']).to eq(actual_config['vapps'])
-        end
-      end
-
-      describe 'config loading with variable interpolation' do
-        it "should create a valid hash when input is YAML with variable file" do
-          input_file = "#{@data_dir}/working_template.yaml"
-          vars_file = "#{@data_dir}/working_variables.yaml"
-          loader = ConfigLoader.new
-          actual_config = loader.load_config(input_file, nil, vars_file)
-          expect(valid_config).to eq(actual_config)
-        end
-      end
-
-      describe 'config loading with schema validation' do
-        it "should validate correctly against a schema" do
-          input_file = "#{@data_dir}/working_with_defaults.yaml"
-          loader = ConfigLoader.new
-          schema = vapp_config_schema
-          actual_config = loader.load_config(input_file, schema)
-          expect(valid_config['vapps']).to eq(actual_config['vapps'])
-        end
-
-        it "should raise an error if checked against an invalid schema" do
-          input_file = "#{@data_dir}/working_with_defaults.yaml"
-          loader = ConfigLoader.new
-          expect(Vcloud::Core.logger).to receive(:fatal).with("vapps: is not a hash")
-          expect { loader.load_config(input_file, invalid_schema) }.
-            to raise_error('Supplied configuration does not match supplied schema')
-        end
-
-        it "should not log warnings if there are none" do
-          input_file = "#{@data_dir}/working_with_defaults.yaml"
-          loader = ConfigLoader.new
-
-          expect(Vcloud::Core.logger).not_to receive(:warn)
-          loader.load_config(input_file, vapp_config_schema)
-        end
-
-        it "should log warnings if checked against a deprecated schema" do
-          input_file = "#{@data_dir}/working_with_defaults.yaml"
-          loader = ConfigLoader.new
-
-          expect(Vcloud::Core.logger).to receive(:warn).with("vapps: is deprecated by 'vapps_new'")
-          loader.load_config(input_file, deprecated_schema)
-        end
-
-        it "should log warning before raising error against an invalid and deprecated schema" do
-          input_file = "#{@data_dir}/working_with_defaults.yaml"
-          loader = ConfigLoader.new
-
-          expect(Vcloud::Core.logger).to receive(:warn).with("vapps: is deprecated by 'vapps_new'")
-          expect(Vcloud::Core.logger).to receive(:fatal).with("vapps: is not a hash")
-          expect { loader.load_config(input_file, invalid_and_deprecated_schema) }.
-            to raise_error('Supplied configuration does not match supplied schema')
-        end
-      end
-
-      def vapp_config_schema
-        {
-          type: 'hash',
-          allowed_empty: false,
-          permit_unknown_parameters: true,
-          internals: {
-            vapps: {
-              type: 'array',
-              required: false,
-              allowed_empty: true,
-            },
-          }
-        }
-      end
-
-      def invalid_schema
-        {
-          type: Hash,
-          permit_unknown_parameters: true,
-          internals: {
-            vapps: { type: Hash },
-          }
-        }
-      end
-
-      def invalid_and_deprecated_schema
-        {
-          type: 'hash',
-          permit_unknown_parameters: true,
-          internals: {
-            vapps: { type: Hash, deprecated_by: 'vapps_new' },
-            vapps_new: { type: 'array' },
-          }
-        }
-      end
-
-      def deprecated_schema
-        {
-          type: 'hash',
-          permit_unknown_parameters: true,
-          internals: {
-            vapps: { type: 'array', deprecated_by: 'vapps_new' },
-            vapps_new: { type: 'array' },
-          }
-        }
-      end
-
-      def valid_config
-        {
-          :vapps=>[{
-            :name=>"vapp-vcloud-tools-tests",
-            :vdc_name=>"VDC_NAME",
-            :catalog=>"CATALOG_NAME",
-            :vapp_template=>"VAPP_TEMPLATE",
-            :vm=>{
-              :hardware_config=>{:memory=>"4096", :cpu=>"2"},
-              :extra_disks=>[{:size=>"8192"}],
-              :network_connections=>[{
-                :name=>"Default",
-                :ip_address=>"192.168.2.10"
-                },
-                {
-                :name=>"NetworkTest2",
-                :ip_address=>"192.168.1.10"
-              }],
-              :bootstrap=>{
-                :script_path=>"spec/data/basic_preamble_test.erb",
-                :vars=>{:message=>"hello world"}
-              },
-              :metadata=>{}
-            }
-          }]
-        }
-      end
+describe Vcloud::Core::ConfigLoader do
+
+  before(:all) do
+    @data_dir = File.join(File.dirname(__FILE__), "/data")
+  end
+
+  describe 'basic config loading' do
+    it "should create a valid hash when input is JSON" do
+      input_file = "#{@data_dir}/working.json"
+      loader = Vcloud::Core::ConfigLoader.new
+      actual_config = loader.load_config(input_file)
+      expect(valid_config).to eq(actual_config)
+    end
+
+    it "should create a valid hash when input is YAML" do
+      input_file = "#{@data_dir}/working.yaml"
+      loader = Vcloud::Core::ConfigLoader.new
+      actual_config = loader.load_config(input_file)
+      expect(valid_config).to eq(actual_config)
+    end
+
+    it "should create a valid hash when input is YAML with anchor defaults" do
+      input_file = "#{@data_dir}/working_with_defaults.yaml"
+      loader = Vcloud::Core::ConfigLoader.new
+      actual_config = loader.load_config(input_file)
+      expect(valid_config['vapps']).to eq(actual_config['vapps'])
+    end
+  end
+
+  describe 'config loading with variable interpolation' do
+    it "should create a valid hash when input is YAML with variable file" do
+      input_file = "#{@data_dir}/working_template.yaml"
+      vars_file = "#{@data_dir}/working_variables.yaml"
+      loader = Vcloud::Core::ConfigLoader.new
+      actual_config = loader.load_config(input_file, nil, vars_file)
+      expect(valid_config).to eq(actual_config)
+    end
+  end
+
+  describe 'config loading with schema validation' do
+    it "should validate correctly against a schema" do
+      input_file = "#{@data_dir}/working_with_defaults.yaml"
+      loader = Vcloud::Core::ConfigLoader.new
+      schema = vapp_config_schema
+      actual_config = loader.load_config(input_file, schema)
+      expect(valid_config['vapps']).to eq(actual_config['vapps'])
+    end
+
+    it "should raise an error if checked against an invalid schema" do
+      input_file = "#{@data_dir}/working_with_defaults.yaml"
+      loader = Vcloud::Core::ConfigLoader.new
+      expect(Vcloud::Core.logger).to receive(:fatal).with("vapps: is not a hash")
+      expect { loader.load_config(input_file, invalid_schema) }.
+        to raise_error('Supplied configuration does not match supplied schema')
+    end
+
+    it "should not log warnings if there are none" do
+      input_file = "#{@data_dir}/working_with_defaults.yaml"
+      loader = Vcloud::Core::ConfigLoader.new
+
+      expect(Vcloud::Core.logger).not_to receive(:warn)
+      loader.load_config(input_file, vapp_config_schema)
     end
+
+    it "should log warnings if checked against a deprecated schema" do
+      input_file = "#{@data_dir}/working_with_defaults.yaml"
+      loader = Vcloud::Core::ConfigLoader.new
+
+      expect(Vcloud::Core.logger).to receive(:warn).with("vapps: is deprecated by 'vapps_new'")
+      loader.load_config(input_file, deprecated_schema)
+    end
+
+    it "should log warning before raising error against an invalid and deprecated schema" do
+      input_file = "#{@data_dir}/working_with_defaults.yaml"
+      loader = Vcloud::Core::ConfigLoader.new
+
+      expect(Vcloud::Core.logger).to receive(:warn).with("vapps: is deprecated by 'vapps_new'")
+      expect(Vcloud::Core.logger).to receive(:fatal).with("vapps: is not a hash")
+      expect { loader.load_config(input_file, invalid_and_deprecated_schema) }.
+        to raise_error('Supplied configuration does not match supplied schema')
+    end
+  end
+
+  def vapp_config_schema
+    {
+      type: 'hash',
+      allowed_empty: false,
+      permit_unknown_parameters: true,
+      internals: {
+      vapps: {
+      type: 'array',
+      required: false,
+      allowed_empty: true,
+    },
+    }
+    }
+  end
+
+  def invalid_schema
+    {
+      type: Hash,
+      permit_unknown_parameters: true,
+      internals: {
+      vapps: { type: Hash },
+    }
+    }
+  end
+
+  def invalid_and_deprecated_schema
+    {
+      type: 'hash',
+      permit_unknown_parameters: true,
+      internals: {
+      vapps: { type: Hash, deprecated_by: 'vapps_new' },
+      vapps_new: { type: 'array' },
+    }
+    }
+  end
+
+  def deprecated_schema
+    {
+      type: 'hash',
+      permit_unknown_parameters: true,
+      internals: {
+      vapps: { type: 'array', deprecated_by: 'vapps_new' },
+      vapps_new: { type: 'array' },
+    }
+    }
+  end
+
+  def valid_config
+    {
+      :vapps=>[{
+      :name=>"vapp-vcloud-tools-tests",
+      :vdc_name=>"VDC_NAME",
+      :catalog=>"CATALOG_NAME",
+      :vapp_template=>"VAPP_TEMPLATE",
+      :vm=>{
+      :hardware_config=>{:memory=>"4096", :cpu=>"2"},
+      :extra_disks=>[{:size=>"8192"}],
+      :network_connections=>[{
+      :name=>"Default",
+      :ip_address=>"192.168.2.10"
+    },
+      {
+      :name=>"NetworkTest2",
+      :ip_address=>"192.168.1.10"
+    }],
+      :bootstrap=>{
+      :script_path=>"spec/data/basic_preamble_test.erb",
+      :vars=>{:message=>"hello world"}
+    },
+      :metadata=>{}
+    }
+    }]
+    }
   end
 end

data/spec/vcloud/core/config_validator_spec.rb

@@ -1,697 +1,693 @@
 require 'spec_helper'
 
-module Vcloud
-  module Core
-    describe ConfigValidator do
+describe Vcloud::Core::ConfigValidator do
 
-      context "sanitize type" do
+  context "sanitize type" do
 
-        it "should be ok with type as bare String" do
-          data = "hello world"
-          schema = { type: String }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should be ok with type as bare String" do
+      data = "hello world"
+      schema = { type: String }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should be ok with type as string 'String'" do
-          data = "hello world"
-          schema = { type: 'String' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should be ok with type as string 'String'" do
+      data = "hello world"
+      schema = { type: 'String' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should be ok with type as string 'string'" do
-          data = "hello world"
-          schema = { type: 'string' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should be ok with type as string 'string'" do
+      data = "hello world"
+      schema = { type: 'string' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-      end
+  end
 
-      context "string validations" do
+  context "string validations" do
 
-        it "should validate a basic string" do
-          data = "hello world"
-          schema = { type: 'string' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should validate a basic string" do
+      data = "hello world"
+      schema = { type: 'string' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should not validate a number as a basic string" do
-          data = 42
-          schema = { type: 'string' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_false
-        end
+    it "should not validate a number as a basic string" do
+      data = 42
+      schema = { type: 'string' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_false
+    end
 
-        it "should log error with number as a basic string" do
-          data = 42
-          schema = { type: 'string' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([ 'base: 42 is not a string'] )
-        end
+    it "should log error with number as a basic string" do
+      data = 42
+      schema = { type: 'string' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([ 'base: 42 is not a string'] )
+    end
 
-        it "should return error with empty string (by default)" do
-          data = ""
-          schema = { type: 'string' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([ 'base: cannot be empty string'] )
-        end
+    it "should return error with empty string (by default)" do
+      data = ""
+      schema = { type: 'string' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([ 'base: cannot be empty string'] )
+    end
 
-        it "should return error with empty string with allowed_empty: false)" do
-          data = ""
-          schema = { type: 'string', allowed_empty: false }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([ 'base: cannot be empty string'] )
-        end
+    it "should return error with empty string with allowed_empty: false)" do
+      data = ""
+      schema = { type: 'string', allowed_empty: false }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([ 'base: cannot be empty string'] )
+    end
 
-        it "should validate ok with empty string with allowed_empty: true)" do
-          data = ""
-          schema = { type: 'string', allowed_empty: true }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should validate ok with empty string with allowed_empty: true)" do
+      data = ""
+      schema = { type: 'string', allowed_empty: true }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should return error for nil value with allowed_empty: true)" do
-          data = nil
-          schema = { type: 'string', allowed_empty: true }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([ 'base:  is not a string'] )
-        end
+    it "should return error for nil value with allowed_empty: true)" do
+      data = nil
+      schema = { type: 'string', allowed_empty: true }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([ 'base:  is not a string'] )
+    end
 
-        it "should validate ok with a :matcher regex specified" do
-          data = "name-1234"
-          schema = { type: 'string', matcher: /^name-\d+$/ }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should validate ok with a :matcher regex specified" do
+      data = "name-1234"
+      schema = { type: 'string', matcher: /^name-\d+$/ }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should return errror with a :matcher regex not matching" do
-          data = "name-123a"
-          schema = { type: 'string', matcher: /^name-\d+$/ }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq(['base: name-123a does not match'])
-        end
+    it "should return errror with a :matcher regex not matching" do
+      data = "name-123a"
+      schema = { type: 'string', matcher: /^name-\d+$/ }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq(['base: name-123a does not match'])
+    end
 
-      end
+  end
 
-      context "hash validations" do
-
-        it "should validate a basic hash" do
-          data = { name: "santa", address: "north pole" }
-          schema = {
-            type: "Hash",
-            internals: {
-              name: { type: 'string' },
-              address: { type: 'string' },
-            }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+  context "hash validations" do
+
+    it "should validate a basic hash" do
+      data = { name: "santa", address: "north pole" }
+      schema = {
+        type: "Hash",
+        internals: {
+        name: { type: 'string' },
+        address: { type: 'string' },
+      }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should not validate a bogus hash" do
-          data = { name: 42, address: 42 }
-          schema = {
-            type: "Hash",
-            internals: {
-              name: { type: "string" },
-              address: { type: "string" },
-            }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_false
-        end
+    it "should not validate a bogus hash" do
+      data = { name: 42, address: 42 }
+      schema = {
+        type: "Hash",
+        internals: {
+        name: { type: "string" },
+        address: { type: "string" },
+      }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_false
+    end
 
-        it "should return correct errors validating a bogus hash" do
-          data = { name: 42, address: 42 }
-          schema = {
-            type: "Hash",
-            internals: {
-              name: { type: "string" },
-              address: { type: "string" },
-            }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([
-            "name: 42 is not a string",
-            "address: 42 is not a string",
-          ])
-        end
+    it "should return correct errors validating a bogus hash" do
+      data = { name: 42, address: 42 }
+      schema = {
+        type: "Hash",
+        internals: {
+        name: { type: "string" },
+        address: { type: "string" },
+      }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([
+                             "name: 42 is not a string",
+                             "address: 42 is not a string",
+      ])
+    end
 
-        it "should return error with empty hash (by default)" do
-          data = {}
-          schema = { type: 'hash' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([ 'base: cannot be empty hash'] )
-        end
+    it "should return error with empty hash (by default)" do
+      data = {}
+      schema = { type: 'hash' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([ 'base: cannot be empty hash'] )
+    end
 
-        it "should return error with empty hash with allowed_empty: false)" do
-          data = {}
-          schema = { type: 'hash', allowed_empty: false }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([ 'base: cannot be empty hash'] )
-        end
+    it "should return error with empty hash with allowed_empty: false)" do
+      data = {}
+      schema = { type: 'hash', allowed_empty: false }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([ 'base: cannot be empty hash'] )
+    end
 
-        it "should validate ok with empty hash with allowed_empty: true)" do
-          data = {}
-          schema = { type: 'hash', allowed_empty: true }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should validate ok with empty hash with allowed_empty: true)" do
+      data = {}
+      schema = { type: 'hash', allowed_empty: true }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should validate ok with a missing parameter, when marked :required => false" do
-          data = {
-            name: 'hello'
-          }
-          schema = {
-            type: 'hash',
-            internals: {
-              name: { type: 'string' },
-              optional_param: { type: 'string', required: false },
-            }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should validate ok with a missing parameter, when marked :required => false" do
+      data = {
+        name: 'hello'
+      }
+      schema = {
+        type: 'hash',
+        internals: {
+        name: { type: 'string' },
+        optional_param: { type: 'string', required: false },
+      }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should return error with a missing :required => true param" do
-          data = {
-            name: 'hello'
-          }
-          schema = {
-            type: 'hash',
-            internals: {
-              name: { type: 'string' },
-              not_optional_param: { type: 'string', required: true },
-            }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq(["base: missing 'not_optional_param' parameter"])
-        end
+    it "should return error with a missing :required => true param" do
+      data = {
+        name: 'hello'
+      }
+      schema = {
+        type: 'hash',
+        internals: {
+        name: { type: 'string' },
+        not_optional_param: { type: 'string', required: true },
+      }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq(["base: missing 'not_optional_param' parameter"])
+    end
 
-        it "should return error if a bogus parameter is specified" do
-          data = {
-            name: 'hello',
-            bogus_parameter: [ 'wibble' ],
-            bogus_parameter2: 'hello',
-          }
-          schema = {
-            type: 'hash',
-            internals: {
-              name: { type: 'string' },
-            },
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([
-            "base: parameter 'bogus_parameter' is invalid",
-            "base: parameter 'bogus_parameter2' is invalid",
-          ])
-        end
+    it "should return error if a bogus parameter is specified" do
+      data = {
+        name: 'hello',
+        bogus_parameter: [ 'wibble' ],
+        bogus_parameter2: 'hello',
+      }
+      schema = {
+        type: 'hash',
+        internals: {
+        name: { type: 'string' },
+      },
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([
+                             "base: parameter 'bogus_parameter' is invalid",
+                             "base: parameter 'bogus_parameter2' is invalid",
+      ])
+    end
 
-        it "should validate ok if a bogus parameter is specified, when :permit_unknown_parameters is true" do
-          data = {
-            name: 'hello',
-            bogus_parameter: [ 'wibble' ],
-            bogus_parameter2: 'hello',
-          }
-          schema = {
-            type: 'hash',
-            permit_unknown_parameters: true,
-            internals: {
-              name: { type: 'string' },
-            },
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should validate ok if a bogus parameter is specified, when :permit_unknown_parameters is true" do
+      data = {
+        name: 'hello',
+        bogus_parameter: [ 'wibble' ],
+        bogus_parameter2: 'hello',
+      }
+      schema = {
+        type: 'hash',
+        permit_unknown_parameters: true,
+        internals: {
+        name: { type: 'string' },
+      },
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-      end
+  end
 
-      context "array validations" do
+  context "array validations" do
 
-        it "should validate a basic array" do
-          data = [ "santa", "north pole" ]
-          schema = {
-            type: "Array",
-            each_element_is: { type: "string" }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should validate a basic array" do
+      data = [ "santa", "north pole" ]
+      schema = {
+        type: "Array",
+        each_element_is: { type: "string" }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should validate a bogus array" do
-          data = [ 42, 43 ]
-          schema = {
-            type: "Array",
-            each_element_is: { type: "string" }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_false
-        end
+    it "should validate a bogus array" do
+      data = [ 42, 43 ]
+      schema = {
+        type: "Array",
+        each_element_is: { type: "string" }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_false
+    end
 
-        it "should return correct errors validating a bogus array" do
-          data = [ 42, 43 ]
-          schema = {
-            type: "Array",
-            each_element_is: { type: "string" }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([
-            "base: 42 is not a string",
-            "base: 43 is not a string",
-          ])
-        end
+    it "should return correct errors validating a bogus array" do
+      data = [ 42, 43 ]
+      schema = {
+        type: "Array",
+        each_element_is: { type: "string" }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([
+                             "base: 42 is not a string",
+                             "base: 43 is not a string",
+      ])
+    end
 
-        it "should return error with empty array (by default)" do
-          data = []
-          schema = { type: 'array' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([ 'base: cannot be empty array'] )
-        end
+    it "should return error with empty array (by default)" do
+      data = []
+      schema = { type: 'array' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([ 'base: cannot be empty array'] )
+    end
 
-        it "should return error with empty array with allowed_empty: false)" do
-          data = []
-          schema = { type: 'array', allowed_empty: false }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([ 'base: cannot be empty array'] )
-        end
+    it "should return error with empty array with allowed_empty: false)" do
+      data = []
+      schema = { type: 'array', allowed_empty: false }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([ 'base: cannot be empty array'] )
+    end
 
-        it "should validate ok with empty array with allowed_empty: true)" do
-          data = []
-          schema = { type: 'array', allowed_empty: true }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should validate ok with empty array with allowed_empty: true)" do
+      data = []
+      schema = { type: 'array', allowed_empty: true }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-      end
+  end
 
-      context "array of hashes validations" do
-
-        it "should validate an array of hashes" do
-          data = [
-            { name: "santa", address: "north pole" },
-            { name: "mole",  address: "1 hole street" },
-          ]
-          schema = {
-            type: "array",
-            each_element_is: {
-              type: "hash",
-              internals: {
-                name: { type: 'string' },
-                address: { type: 'string' },
-              }
-            }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+  context "array of hashes validations" do
+
+    it "should validate an array of hashes" do
+      data = [
+        { name: "santa", address: "north pole" },
+        { name: "mole",  address: "1 hole street" },
+      ]
+      schema = {
+        type: "array",
+        each_element_is: {
+        type: "hash",
+        internals: {
+        name: { type: 'string' },
+        address: { type: 'string' },
+      }
+      }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should correctly error on an invalid an array of hashes" do
-          data = [
-            { name: "santa", address: [] },
-            { name: 43,  address: "1 hole street" },
-          ]
-          schema = {
-            type: "array",
-            each_element_is: {
-              type: "hash",
-              internals: {
-                name: { type: 'string' },
-                address: { type: 'string' },
-              }
-            }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq([
-            "address: [] is not a string",
-            "name: 43 is not a string",
-          ])
-        end
+    it "should correctly error on an invalid an array of hashes" do
+      data = [
+        { name: "santa", address: [] },
+        { name: 43,  address: "1 hole street" },
+      ]
+      schema = {
+        type: "array",
+        each_element_is: {
+        type: "hash",
+        internals: {
+        name: { type: 'string' },
+        address: { type: 'string' },
+      }
+      }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq([
+                             "address: [] is not a string",
+                             "name: 43 is not a string",
+      ])
+    end
 
-      end
+  end
 
-      context "hash of arrays validations" do
-
-        it "should validate a hash of arrays" do
-          data = {
-            boys_names: [ 'bob', 'andrew', 'charlie', 'dave' ],
-            girls_names: [ 'alice', 'beth', 'carol', 'davina' ],
-          }
-          schema = {
-            type: "Hash",
-            internals: {
-              boys_names: {
-                type: "Array",
-                each_element_is: { type: 'String' }
-              },
-              girls_names: {
-                type: "Array",
-                each_element_is: { type: 'String' }
-              }
-            }
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+  context "hash of arrays validations" do
+
+    it "should validate a hash of arrays" do
+      data = {
+        boys_names: [ 'bob', 'andrew', 'charlie', 'dave' ],
+        girls_names: [ 'alice', 'beth', 'carol', 'davina' ],
+      }
+      schema = {
+        type: "Hash",
+        internals: {
+        boys_names: {
+        type: "Array",
+        each_element_is: { type: 'String' }
+      },
+        girls_names: {
+        type: "Array",
+        each_element_is: { type: 'String' }
+      }
+      }
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should correctly error on an invalid hash of arrays" do
-          data = {
-            boys_names: [ 'bob', 'andrew', 'charlie', 'dave' ],
-            girls_names: [ 'alice', 'beth', 'carol', 'davina' ],
-          }
-          schema = {
-            type: "Hash",
-            internals: {
-              boys_names: {
-                type: "Array",
-                each_element_is: { type: 'String' },
-              },
-              girls_names: {
-                type: "Array",
-                each_element_is: { type: 'String' },
-              }
-            },
-          }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should correctly error on an invalid hash of arrays" do
+      data = {
+        boys_names: [ 'bob', 'andrew', 'charlie', 'dave' ],
+        girls_names: [ 'alice', 'beth', 'carol', 'davina' ],
+      }
+      schema = {
+        type: "Hash",
+        internals: {
+        boys_names: {
+        type: "Array",
+        each_element_is: { type: 'String' },
+      },
+      girls_names: {
+        type: "Array",
+        each_element_is: { type: 'String' },
+      }
+      },
+      }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-      end
+  end
 
-      context "string_or_number validations" do
+  context "string_or_number validations" do
 
-        it "should correctly validate an Integer" do
-          data = 2
-          schema = { type: 'string_or_number' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should correctly validate an Integer" do
+      data = 2
+      schema = { type: 'string_or_number' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should correctly validate a String" do
-          data = '2'
-          schema = { type: 'string_or_number' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should correctly validate a String" do
+      data = '2'
+      schema = { type: 'string_or_number' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should correctly error if not a string or numeric" do
-          data = []
-          schema = { type: 'string_or_number' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq(["base: [] is not a string_or_number"])
-        end
+    it "should correctly error if not a string or numeric" do
+      data = []
+      schema = { type: 'string_or_number' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq(["base: [] is not a string_or_number"])
+    end
 
-      end
+  end
 
-      context "ip_address validations" do
+  context "ip_address validations" do
 
-        it "should correctly validate an IP address" do
-          data = '192.168.100.100'
-          schema = { type: 'ip_address' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+    it "should correctly validate an IP address" do
+      data = '192.168.100.100'
+      schema = { type: 'ip_address' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
 
-        it "should correctly error on an invalid IP address" do
-          data = '256.168.100.100'
-          schema = { type: 'ip_address' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq(['base: 256.168.100.100 is not a valid ip_address'])
-        end
+    it "should correctly error on an invalid IP address" do
+      data = '256.168.100.100'
+      schema = { type: 'ip_address' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq(['base: 256.168.100.100 is not a valid ip_address'])
+    end
 
-        it "should error if ip address have wrong octets" do
-          data = '192.168.100.100/33/33/33'
-          schema = { type: 'ip_address' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq(['base: 192.168.100.100/33/33/33 is not a valid ip_address'])
-        end
+    it "should error if ip address have wrong octets" do
+      data = '192.168.100.100/33/33/33'
+      schema = { type: 'ip_address' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq(['base: 192.168.100.100/33/33/33 is not a valid ip_address'])
+    end
 
+  end
+
+  context "ip_address_range validations" do
+    context "validate CIDR" do
+      it "should validate OK if CIDR is correct" do
+        data = '192.168.100.100/24'
+        schema = { type: 'ip_address_range' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_true
       end
 
-      context "ip_address_range validations" do
-        context "validate CIDR" do
-          it "should validate OK if CIDR is correct" do
-            data = '192.168.100.100/24'
-            schema = { type: 'ip_address_range' }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_true
-          end
-
-          it "should return error if network bit value is greater than 32" do
-            data = '192.168.100.100/33'
-            schema = { type: 'ip_address_range' }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_false
-            expect(v.errors).to eq(["base: 192.168.100.100/33 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
-          end
-
-          it "should return error if network bit value is less than 0" do
-            data = '192.168.100.100/33'
-            schema = { type: 'ip_address_range' }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_false
-            expect(v.errors).to eq(["base: 192.168.100.100/33 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
-          end
-
-          it "should return error if network IP address is incorrect" do
-            data = '192.168.100./33'
-            schema = { type: 'ip_address_range' }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_false
-            expect(v.errors).to eq(["base: 192.168.100./33 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
-          end
-        end
+      it "should return error if network bit value is greater than 32" do
+        data = '192.168.100.100/33'
+        schema = { type: 'ip_address_range' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_false
+        expect(v.errors).to eq(["base: 192.168.100.100/33 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
+      end
 
-        context "validate alphabetical values for IP range" do
-          %w(Any internal external).each do |data|
-            it "should validate OK if IP range is '#{data}'" do
-              schema = { type: 'ip_address_range' }
-              v = ConfigValidator.validate(:base, data, schema)
-              expect(v.valid?).to be_true
-              expect(v.errors).to be_empty
-            end
-          end
-
-          it "should error if IP range is a string but not a valid alphabetical value" do
-            data = 'invalid_ip_range_string'
-            schema = { type: 'ip_address_range' }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_false
-            expect(v.errors).to eq(["base: invalid_ip_range_string is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
-          end
-        end
+      it "should return error if network bit value is less than 0" do
+        data = '192.168.100.100/33'
+        schema = { type: 'ip_address_range' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_false
+        expect(v.errors).to eq(["base: 192.168.100.100/33 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
+      end
 
-        context "validate ranges specified using start and end addresses" do
-          it "should validate ok if the combination of start IP and end IP is correct" do
-            data = '192.168.100.100-192.168.100.110'
-            schema = { type: 'ip_address_range' }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_true
-            expect(v.errors).to be_empty
-          end
-
-          it "should error if start IP address is incorrect" do
-            data = '192.168.100-192.168.100.110'
-            schema = { type: 'ip_address_range' }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_false
-            expect(v.errors).to eq(["base: 192.168.100-192.168.100.110 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
-          end
-
-          it "should error if end IP address is incorrect" do
-            data = '192.168.100.110-192.168.100'
-            schema = { type: 'ip_address_range' }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_false
-            expect(v.errors).to eq(["base: 192.168.100.110-192.168.100 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
-          end
-
-          it "should error if the combination of start IP and end IP is incorrect" do
-            data = '200.168.100.99-192.168.100'
-            schema = { type: 'ip_address_range' }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_false
-            expect(v.errors).to eq(["base: 200.168.100.99-192.168.100 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
-          end
-
-          it "should error if the start and end IPS are not separated by -" do
-            data = '190.168.100.99:192.168.100'
-            schema = { type: 'ip_address_range' }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_false
-            expect(v.errors).to eq(["base: 190.168.100.99:192.168.100 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
-          end
-        end
+      it "should return error if network IP address is incorrect" do
+        data = '192.168.100./33'
+        schema = { type: 'ip_address_range' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_false
+        expect(v.errors).to eq(["base: 192.168.100./33 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
+      end
+    end
 
-        it "should accept single ip address as range" do
-          data = '190.168.100.99'
+    context "validate alphabetical values for IP range" do
+      %w(Any internal external).each do |data|
+        it "should validate OK if IP range is '#{data}'" do
           schema = { type: 'ip_address_range' }
-          v = ConfigValidator.validate(:base, data, schema)
+          v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
           expect(v.valid?).to be_true
-          expect(v.errors).to eq([])
+          expect(v.errors).to be_empty
         end
       end
 
-      context "enum validations" do
-        it "should error if enum value is not present in list" do
-          data = 'blah'
-          schema = { type: 'enum', required: false, acceptable_values: ['allow', 'decline', 'none']}
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq(["base: blah is not a valid value. Acceptable values are 'allow', 'decline', 'none'."])
-        end
+      it "should error if IP range is a string but not a valid alphabetical value" do
+        data = 'invalid_ip_range_string'
+        schema = { type: 'ip_address_range' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_false
+        expect(v.errors).to eq(["base: invalid_ip_range_string is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
+      end
+    end
 
-        it "should raise error if enum schema does not contain acceptable_values" do
-          data = 'blah'
-          schema = { type: 'enum', required: false}
-          expect{ ConfigValidator.validate(:base, data, schema) }.to raise_error("Must set :acceptable_values for type 'enum'")
-        end
+    context "validate ranges specified using start and end addresses" do
+      it "should validate ok if the combination of start IP and end IP is correct" do
+        data = '192.168.100.100-192.168.100.110'
+        schema = { type: 'ip_address_range' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_true
+        expect(v.errors).to be_empty
+      end
 
-        it "should validate ok if enum is acceptable" do
-          data = 'allow'
-          schema = { type: 'enum', required: false, acceptable_values: ['allow', 'decline', 'none']}
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.valid?).to be_true
-        end
+      it "should error if start IP address is incorrect" do
+        data = '192.168.100-192.168.100.110'
+        schema = { type: 'ip_address_range' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_false
+        expect(v.errors).to eq(["base: 192.168.100-192.168.100.110 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
       end
 
-      context "boolean validations" do
-        it "should error if boolean value is not valid" do
-          data = 'blah'
-          schema = { type: 'boolean' }
-          v = ConfigValidator.validate(:base, data, schema)
-          expect(v.errors).to eq(["base: blah is not a valid boolean value."])
-        end
+      it "should error if end IP address is incorrect" do
+        data = '192.168.100.110-192.168.100'
+        schema = { type: 'ip_address_range' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_false
+        expect(v.errors).to eq(["base: 192.168.100.110-192.168.100 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
+      end
 
-        [true, false].each do |boolean_value|
-          it "should validate ok if value is #{boolean_value}" do
-            schema = { type: 'boolean' }
-            v = ConfigValidator.validate(:base, boolean_value, schema)
-            expect(v.valid?).to be_true
-          end
-        end
+      it "should error if the combination of start IP and end IP is incorrect" do
+        data = '200.168.100.99-192.168.100'
+        schema = { type: 'ip_address_range' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_false
+        expect(v.errors).to eq(["base: 200.168.100.99-192.168.100 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
       end
 
-      context "deprecated_by" do
-        # For clarification:
-        #
-        # - deprecatee: is the old param with a `deprecated_by` field.
-        # - deprecator: is the new param listed in the `deprecated_by` field.
-        #
-        context "deprecatee is provided and deprecator is not" do
-          let(:data) {{ name: "santa" }}
-
-          it "should validate and warn when deprecator is required" do
-            schema = {
-              type: "Hash",
-              internals: {
-                name: { type: 'string', deprecated_by: 'full_name' },
-                full_name: { type: 'string', required: true },
-              }
-            }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_true
-            expect(v.warnings).to eq(["name: is deprecated by 'full_name'"])
-          end
-
-          it "should validate and warn when deprecator appears before deprecatee in schema" do
-            schema = {
-              type: "Hash",
-              internals: {
-                full_name: { type: 'string', required: true },
-                name: { type: 'string', deprecated_by: 'full_name' },
-              }
-            }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_true
-            expect(v.warnings).to eq(["name: is deprecated by 'full_name'"])
-          end
-
-          it "should warn about deprecatee even when both are not required" do
-            schema = {
-              type: "Hash",
-              internals: {
-                name: { type: 'string', required: false, deprecated_by: 'full_name' },
-                full_name: { type: 'string', required: false },
-              }
-            }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_true
-            expect(v.warnings).to eq(["name: is deprecated by 'full_name'"])
-          end
-        end
+      it "should error if the start and end IPS are not separated by -" do
+        data = '190.168.100.99:192.168.100'
+        schema = { type: 'ip_address_range' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_false
+        expect(v.errors).to eq(["base: 190.168.100.99:192.168.100 is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."])
+      end
+    end
 
-        context "neither deprecatee or deprecator are provided" do
-          let(:data) {{ bogus: "blah" }}
-
-          it "should return error for deprecator but not deprecatee if neither are set" do
-            schema = {
-              type: "Hash",
-              internals: {
-                name: { type: 'string', deprecated_by: 'full_name' },
-                full_name: { type: 'string', required: true },
-                bogus: { type: 'string' },
-              }
-            }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_false
-            expect(v.errors).to eq(["base: missing 'full_name' parameter"])
-          end
-
-          it "should raise exception if deprecator does not exist in schema" do
-            schema = {
-              type: "Hash",
-              internals: {
-                name: { type: 'string', deprecated_by: 'does_not_exist' },
-                bogus: { type: 'string' },
-              }
-            }
-            expect {
-              ConfigValidator.validate(:base, data, schema)
-            }.to raise_error("name: deprecated_by target 'does_not_exist' not found in schema")
-          end
-        end
+    it "should accept single ip address as range" do
+      data = '190.168.100.99'
+      schema = { type: 'ip_address_range' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+      expect(v.errors).to eq([])
+    end
+  end
 
-        context "deprecatee and deprecator are provided and of the wrong type" do
-          let(:data) {{ name: 123, full_name: 123 }}
-
-          it "should return an error for each and a warning for deprecatee" do
-            schema = {
-              type: "Hash",
-              internals: {
-                name: { type: 'string', deprecated_by: 'full_name' },
-                full_name: { type: 'string', required: true },
-              }
-            }
-            v = ConfigValidator.validate(:base, data, schema)
-            expect(v.valid?).to be_false
-            expect(v.errors).to eq([
-              "name: 123 is not a string",
-              "full_name: 123 is not a string",
-            ])
-            expect(v.warnings).to eq(["name: is deprecated by 'full_name'"])
-          end
-        end
+  context "enum validations" do
+    it "should error if enum value is not present in list" do
+      data = 'blah'
+      schema = { type: 'enum', required: false, acceptable_values: ['allow', 'decline', 'none']}
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq(["base: blah is not a valid value. Acceptable values are 'allow', 'decline', 'none'."])
+    end
 
-        it "should not honour deprecation across nested structures" do
-          data = { bogus: "blah" }
-          schema = {
-            type: "Hash",
-            internals: {
-              name: { type: 'string', deprecated_by: 'full_name' },
-              nested: { type: 'hash', internals: {
-                full_name: { type: 'string', required: true },
-              }},
-              bogus: { type: 'string' },
-            }
-          }
-          expect {
-            ConfigValidator.validate(:base, data, schema)
-          }.to raise_error("name: deprecated_by target 'full_name' not found in schema")
-        end
+    it "should raise error if enum schema does not contain acceptable_values" do
+      data = 'blah'
+      schema = { type: 'enum', required: false}
+      expect{ Vcloud::Core::ConfigValidator.validate(:base, data, schema) }.to raise_error("Must set :acceptable_values for type 'enum'")
+    end
+
+    it "should validate ok if enum is acceptable" do
+      data = 'allow'
+      schema = { type: 'enum', required: false, acceptable_values: ['allow', 'decline', 'none']}
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.valid?).to be_true
+    end
+  end
+
+  context "boolean validations" do
+    it "should error if boolean value is not valid" do
+      data = 'blah'
+      schema = { type: 'boolean' }
+      v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      expect(v.errors).to eq(["base: blah is not a valid boolean value."])
+    end
+
+    [true, false].each do |boolean_value|
+      it "should validate ok if value is #{boolean_value}" do
+        schema = { type: 'boolean' }
+        v = Vcloud::Core::ConfigValidator.validate(:base, boolean_value, schema)
+        expect(v.valid?).to be_true
+      end
+    end
+  end
+
+  context "deprecated_by" do
+    # For clarification:
+    #
+    # - deprecatee: is the old param with a `deprecated_by` field.
+    # - deprecator: is the new param listed in the `deprecated_by` field.
+    #
+    context "deprecatee is provided and deprecator is not" do
+      let(:data) {{ name: "santa" }}
+
+      it "should validate and warn when deprecator is required" do
+        schema = {
+          type: "Hash",
+          internals: {
+          name: { type: 'string', deprecated_by: 'full_name' },
+          full_name: { type: 'string', required: true },
+        }
+        }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_true
+        expect(v.warnings).to eq(["name: is deprecated by 'full_name'"])
+      end
+
+      it "should validate and warn when deprecator appears before deprecatee in schema" do
+        schema = {
+          type: "Hash",
+          internals: {
+          full_name: { type: 'string', required: true },
+          name: { type: 'string', deprecated_by: 'full_name' },
+        }
+        }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_true
+        expect(v.warnings).to eq(["name: is deprecated by 'full_name'"])
+      end
+
+      it "should warn about deprecatee even when both are not required" do
+        schema = {
+          type: "Hash",
+          internals: {
+          name: { type: 'string', required: false, deprecated_by: 'full_name' },
+          full_name: { type: 'string', required: false },
+        }
+        }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_true
+        expect(v.warnings).to eq(["name: is deprecated by 'full_name'"])
       end
+    end
+
+    context "neither deprecatee or deprecator are provided" do
+      let(:data) {{ bogus: "blah" }}
+
+      it "should return error for deprecator but not deprecatee if neither are set" do
+        schema = {
+          type: "Hash",
+          internals: {
+          name: { type: 'string', deprecated_by: 'full_name' },
+          full_name: { type: 'string', required: true },
+          bogus: { type: 'string' },
+        }
+        }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_false
+        expect(v.errors).to eq(["base: missing 'full_name' parameter"])
+      end
+
+      it "should raise exception if deprecator does not exist in schema" do
+        schema = {
+          type: "Hash",
+          internals: {
+          name: { type: 'string', deprecated_by: 'does_not_exist' },
+          bogus: { type: 'string' },
+        }
+        }
+        expect {
+          Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        }.to raise_error("name: deprecated_by target 'does_not_exist' not found in schema")
+      end
+    end
 
+    context "deprecatee and deprecator are provided and of the wrong type" do
+      let(:data) {{ name: 123, full_name: 123 }}
+
+      it "should return an error for each and a warning for deprecatee" do
+        schema = {
+          type: "Hash",
+          internals: {
+          name: { type: 'string', deprecated_by: 'full_name' },
+          full_name: { type: 'string', required: true },
+        }
+        }
+        v = Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+        expect(v.valid?).to be_false
+        expect(v.errors).to eq([
+                               "name: 123 is not a string",
+                               "full_name: 123 is not a string",
+        ])
+        expect(v.warnings).to eq(["name: is deprecated by 'full_name'"])
+      end
+    end
+
+    it "should not honour deprecation across nested structures" do
+      data = { bogus: "blah" }
+      schema = {
+        type: "Hash",
+        internals: {
+        name: { type: 'string', deprecated_by: 'full_name' },
+        nested: { type: 'hash', internals: {
+        full_name: { type: 'string', required: true },
+      }},
+      bogus: { type: 'string' },
+      }
+      }
+      expect {
+        Vcloud::Core::ConfigValidator.validate(:base, data, schema)
+      }.to raise_error("name: deprecated_by target 'full_name' not found in schema")
     end
   end
+
 end