vcloud-core 0.0.8 → 0.0.9

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.0.9 (2014-03-10)
+
+Features:
+
+  - adds a configuration loader and a configuration validator
+
 ## 0.0.8 (2014-03-04)
 
 Bugfix:

data/lib/vcloud/core.rb

@@ -3,6 +3,8 @@ require 'vcloud/fog'
 
 require 'vcloud/core/version'
 
+require 'vcloud/core/config_loader'
+require 'vcloud/core/config_validator'
 require 'vcloud/core/entity'
 require 'vcloud/core/metadata_helper'
 require 'vcloud/core/compute_metadata'

data/lib/vcloud/core/config_loader.rb

@@ -0,0 +1,26 @@
+module Vcloud
+  module Core
+    class ConfigLoader
+
+      def load_config(config_file, schema = nil)
+        input_config = YAML::load(File.open(config_file))
+
+        # There is no way in YAML or Ruby to symbolize keys in a hash
+        json_string = JSON.generate(input_config)
+        config = JSON.parse(json_string, :symbolize_names => true)
+
+        if schema
+          validation = Core::ConfigValidator.validate(:base, config, schema)
+          unless validation.valid?
+            validation.errors.each do |error|
+              Vcloud::Core.logger.fatal(error)
+            end
+            raise("Supplied configuration does not match supplied schema")
+          end
+        end
+        config
+      end
+
+    end
+  end
+end

data/lib/vcloud/core/config_validator.rb

@@ -0,0 +1,208 @@
+require 'ipaddr'
+
+module Vcloud
+  module Core
+    class ConfigValidator
+  
+      attr_reader :key, :data, :schema, :type, :errors
+  
+      VALID_ALPHABETICAL_VALUES_FOR_IP_RANGE = %w(Any external internal)
+  
+      def initialize(key, data, schema)
+        raise "Nil schema" unless schema
+        raise "Invalid schema" unless schema.key?(:type)
+        @type = schema[:type].to_s.downcase
+        @errors = []
+        @data   = data
+        @schema = schema
+        @key    = key
+        validate
+      end
+  
+      def valid?
+        @errors.empty?
+      end
+  
+      def self.validate(key, data, schema)
+        new(key, data, schema)
+      end
+  
+      private
+  
+      def validate
+        self.send("validate_#{type}".to_sym)
+      end
+  
+      def validate_string
+        unless @data.is_a? String
+          errors << "#{key}: #{@data} is not a string"
+          return
+        end
+        return unless check_emptyness_ok
+        return unless check_matcher_matches
+      end
+  
+      def validate_string_or_number
+        unless data.is_a?(String) || data.is_a?(Numeric)
+          @errors << "#{key}: #{@data} is not a string_or_number"
+          return
+        end
+      end
+  
+      def validate_ip_address
+        unless data.is_a?(String)
+          @errors << "#{key}: #{@data} is not a valid ip_address"
+          return
+        end
+        @errors << "#{key}: #{@data} is not a valid ip_address" unless valid_ip_address?(data)
+      end
+  
+      def validate_ip_address_range
+        unless data.is_a?(String)
+          @errors << "#{key}: #{@data} is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'."
+          return
+        end
+        valid = valid_cidr_or_ip_address? || valid_alphabetical_ip_range? || valid_ip_range?
+        @errors << "#{key}: #{@data} is not a valid IP address range. Valid values can be IP address, CIDR, IP range, 'Any','internal' and 'external'." unless valid
+      end
+  
+      def valid_cidr_or_ip_address?
+        begin
+          ip = IPAddr.new(data)
+          ip.ipv4?
+        rescue ArgumentError
+          false
+        end
+      end
+  
+      def valid_alphabetical_ip_range?
+        VALID_ALPHABETICAL_VALUES_FOR_IP_RANGE.include?(data)
+      end
+  
+      def valid_ip_address? ip_address
+        begin
+          #valid formats recognized by IPAddr are : “address”, “address/prefixlen” and “address/mask”.
+          # Attribute like member_ip in case of load-balancer is an "address"
+          # and we should not accept “address/prefixlen” and “address/mask” for such fields.
+          ip = IPAddr.new(ip_address)
+          ip.ipv4? && !ip_address.include?('/')
+        rescue ArgumentError
+          false
+        end
+      end
+  
+      def valid_ip_range?
+        range_parts = data.split('-')
+        return false if range_parts.size != 2
+        start_address = range_parts.first
+        end_address = range_parts.last
+        valid_ip_address?(start_address) &&  valid_ip_address?(end_address) &&
+          valid_start_and_end_address_combination?(end_address, start_address)
+      end
+  
+      def valid_start_and_end_address_combination?(end_address, start_address)
+        IPAddr.new(start_address) < IPAddr.new(end_address)
+      end
+  
+      def validate_hash
+        unless data.is_a? Hash
+          @errors << "#{key}: is not a hash"
+          return
+        end
+        return unless check_emptyness_ok
+        check_for_unknown_parameters
+        if schema.key?(:internals)
+          internals = schema[:internals]
+          internals.each do |param_key,param_schema|
+            check_hash_parameter(param_key, param_schema)
+          end
+        end
+      end
+  
+      def validate_array
+        unless data.is_a? Array
+          @errors << "#{key} is not an array"
+          return
+        end
+        return unless check_emptyness_ok
+        if schema.key?(:each_element_is)
+          element_schema = schema[:each_element_is]
+          data.each do |element|
+            sub_validator = ConfigValidator.validate(key, element, element_schema)
+            unless sub_validator.valid?
+              @errors = errors + sub_validator.errors
+            end
+          end
+        end
+      end
+  
+      def validate_enum
+        unless (acceptable_values = schema[:acceptable_values]) && acceptable_values.is_a?(Array)
+          raise "Must set :acceptable_values for type 'enum'"
+        end
+        unless acceptable_values.include?(data)
+          acceptable_values_string = acceptable_values.collect {|v| "'#{v}'" }.join(', ')
+          @errors << "#{key}: #{@data} is not a valid value. Acceptable values are #{acceptable_values_string}."
+        end
+      end
+  
+      def validate_boolean
+        unless [true, false].include?(data)
+          @errors << "#{key}: #{data} is not a valid boolean value."
+        end
+      end
+  
+      def check_emptyness_ok
+        unless schema.key?(:allowed_empty) && schema[:allowed_empty]
+          if data.empty?
+            @errors << "#{key}: cannot be empty #{type}"
+            return false
+          end
+        end
+        true
+      end
+  
+      def check_matcher_matches
+        return unless regex = schema[:matcher]
+        raise "#{key}: #{regex} is not a Regexp" unless regex.is_a? Regexp
+        unless data =~ regex
+          @errors << "#{key}: #{data} does not match"
+          return false
+        end
+        true
+      end
+  
+      def check_hash_parameter(sub_key, sub_schema)
+        if sub_schema.key?(:required) && sub_schema[:required] == false
+          # short circuit out if we do not have the key, but it's not required.
+          return true unless data.key?(sub_key)
+        end
+        unless data.key?(sub_key)
+          @errors << "#{key}: missing '#{sub_key}' parameter"
+          return false
+        end
+        sub_validator = ConfigValidator.validate(
+          sub_key,
+          data[sub_key],
+          sub_schema
+        )
+        unless sub_validator.valid?
+          @errors = errors + sub_validator.errors
+        end
+      end
+  
+      def check_for_unknown_parameters
+        unless internals = schema[:internals]
+          # if there are no parameters specified, then assume all are ok.
+          return true
+        end
+        if schema[:permit_unknown_parameters]
+          return true
+        end
+        data.keys.each do |k|
+          @errors << "#{key}: parameter '#{k}' is invalid" unless internals[k]
+        end
+      end
+    end
+  end
+end

data/lib/vcloud/core/version.rb

@@ -1,5 +1,5 @@
 module Vcloud
   module Core
-    VERSION = '0.0.8'
+    VERSION = '0.0.9'
   end
 end

data/spec/vcloud/core/config_loader_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module Vcloud
+  module Core
+    describe ConfigLoader do
+
+      before(:all) do
+        @data_dir = File.join(File.dirname(__FILE__), "/data")
+      end
+
+      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)
+        valid_config.should 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)
+        valid_config.should 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)
+        valid_config['vapps'].should eq(actual_config['vapps'])
+      end
+
+      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)
+        valid_config['vapps'].should 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
+        Vcloud::Core.logger.should_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
+
+      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 valid_config
+        {
+          :vapps=>[{
+            :name=>"vapp-vcloud-tools-tests",
+            :vdc_name=>"VDC_NAME",
+            :catalog=>"CATALOG_NAME",
+            :catalog_item=>"CATALOG_ITEM",
+            :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
+  end
+end

data/spec/vcloud/core/config_validator_spec.rb

@@ -0,0 +1,572 @@
+require 'spec_helper'
+
+module Vcloud
+  module Core
+    describe ConfigValidator 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 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 = ConfigValidator.validate(:base, data, schema)
+          expect(v.valid?).to be_true
+        end
+
+      end
+
+      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 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 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 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 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 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 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 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
+
+      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
+
+        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 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 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 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 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 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 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 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 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
+
+      end
+
+      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 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 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 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 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 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
+
+      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
+
+        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
+
+      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
+
+        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
+
+      end
+
+      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 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 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
+
+      end
+
+      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 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 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
+
+      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
+
+        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
+
+        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 accept single ip address as range" do
+          data = '190.168.100.99'
+          schema = { type: 'ip_address_range' }
+          v = ConfigValidator.validate(:base, data, schema)
+          expect(v.valid?).to be_true
+          expect(v.errors).to eq([])
+        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 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
+
+        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
+      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
+
+        [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
+
+      end
+
+    end
+  end
+end

data/spec/vcloud/core/data/working.json

@@ -0,0 +1,21 @@
+{
+  "vapps":[{
+    "name":"vapp-vcloud-tools-tests",
+    "vdc_name":"VDC_NAME",
+    "catalog":"CATALOG_NAME",
+    "catalog_item":"CATALOG_ITEM",
+    "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":{}
+      }
+  }]
+}

data/spec/vcloud/core/data/working.yaml

@@ -0,0 +1,22 @@
+---
+vapps:
+- name: vapp-vcloud-tools-tests
+  vdc_name: VDC_NAME
+  catalog: CATALOG_NAME
+  catalog_item: CATALOG_ITEM
+  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: {}

data/spec/vcloud/core/data/working_with_defaults.yaml

@@ -0,0 +1,25 @@
+---
+anchors:
+- &VDC_NAME dcs-dev
+
+vapps:
+- name: vapp-vcloud-tools-tests
+  vdc_name: *VDC_NAME
+  catalog: CATALOG_NAME
+  catalog_item: CATALOG_ITEM
+  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: {}

data/spec/vcloud/core/vm_spec.rb

@@ -9,7 +9,7 @@ module Vcloud
         @vapp_id = 'vapp-4321'
         @vapp_name = 'test-vapp-1'
         @vm_name = 'test-vm-1'
-        @data_dir = File.join(File.dirname(__FILE__), "../data")
+        @data_dir = File.join(File.dirname(__FILE__), "/data")
         @mock_vm_memory_size = 1024
         @mock_metadata = {
             :foo => "bar",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vcloud-core
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-04 00:00:00.000000000 Z
+date: 2014-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -126,6 +126,8 @@ files:
 - jenkins.sh
 - lib/vcloud/core.rb
 - lib/vcloud/core/compute_metadata.rb
+- lib/vcloud/core/config_loader.rb
+- lib/vcloud/core/config_validator.rb
 - lib/vcloud/core/edge_gateway.rb
 - lib/vcloud/core/edge_gateway_interface.rb
 - lib/vcloud/core/entity.rb
@@ -146,6 +148,13 @@ files:
 - spec/integration/edge_gateway/edge_gateway_spec.rb
 - spec/spec_helper.rb
 - spec/support/stub_fog_interface.rb
+- spec/vcloud/core/config_loader_spec.rb
+- spec/vcloud/core/config_validator_spec.rb
+- spec/vcloud/core/data/basic_preamble_test.erb
+- spec/vcloud/core/data/basic_preamble_test.erb.OUT
+- spec/vcloud/core/data/working.json
+- spec/vcloud/core/data/working.yaml
+- spec/vcloud/core/data/working_with_defaults.yaml
 - spec/vcloud/core/edge_gateway_interface_spec.rb
 - spec/vcloud/core/edge_gateway_spec.rb
 - spec/vcloud/core/metadata_helper_spec.rb
@@ -155,8 +164,6 @@ files:
 - spec/vcloud/core/vapp_template_spec.rb
 - spec/vcloud/core/vdc_spec.rb
 - spec/vcloud/core/vm_spec.rb
-- spec/vcloud/data/basic_preamble_test.erb
-- spec/vcloud/data/basic_preamble_test.erb.OUT
 - spec/vcloud/fog/fog_model_interface_spec.rb
 - spec/vcloud/fog/service_interface_spec.rb
 - vcloud-core.gemspec
@@ -181,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4076622022301530583
+      hash: -3857077396882591731
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -193,6 +200,13 @@ test_files:
 - spec/integration/edge_gateway/edge_gateway_spec.rb
 - spec/spec_helper.rb
 - spec/support/stub_fog_interface.rb
+- spec/vcloud/core/config_loader_spec.rb
+- spec/vcloud/core/config_validator_spec.rb
+- spec/vcloud/core/data/basic_preamble_test.erb
+- spec/vcloud/core/data/basic_preamble_test.erb.OUT
+- spec/vcloud/core/data/working.json
+- spec/vcloud/core/data/working.yaml
+- spec/vcloud/core/data/working_with_defaults.yaml
 - spec/vcloud/core/edge_gateway_interface_spec.rb
 - spec/vcloud/core/edge_gateway_spec.rb
 - spec/vcloud/core/metadata_helper_spec.rb
@@ -202,7 +216,5 @@ test_files:
 - spec/vcloud/core/vapp_template_spec.rb
 - spec/vcloud/core/vdc_spec.rb
 - spec/vcloud/core/vm_spec.rb
-- spec/vcloud/data/basic_preamble_test.erb
-- spec/vcloud/data/basic_preamble_test.erb.OUT
 - spec/vcloud/fog/fog_model_interface_spec.rb
 - spec/vcloud/fog/service_interface_spec.rb