vcloud-core 0.3.0 → 0.4.0

data/.gitignore

@@ -1,3 +1,5 @@
 /Gemfile.lock
 /coverage/
 .idea
+spec/integration/vcloud_tools_testing_config.yaml
+.bundle

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## 0.4.0 (2014-05-23)
+
+Features:
+
+  - Add a 'warnings' variable/method to ConfigValidator.
+  - Support simple parameter deprecations in ConfigValidator.
+  - Log schema warnings encountered in ConfigLoader.
+
+API changes:
+
+  - Breaking changes to the order and name of arguments for VappTemplate#get
+  - Remove unused methods Vcloud::Fog::ServiceInterface#get_catalog and
+    Vcloud::Fog::ServiceInterface#get_catalog_item, plus associated
+    Vcloud::Fog::ContentTypes constants.
+  - Restrict variable scope available to preamble ERB templates so that they
+    cannot access or modify the Vm object.
+
 ## 0.3.0 (2014-05-13)
 
 Features:

data/README.md

@@ -153,18 +153,9 @@ Run the integration tests (slower and requires a real environment):
 
     bundle exec rake integration
 
-### setting up and describing your environment for test runs
-
-You need access to a suitable vCloud Director organization to run the integration tests - it also needs some basic
-configuration: an Edge Gateway, and a routed network.
-It is not necessarily safe to run them against an existing environment, unless care is taken with the entities being
-tested.
-
-A number of ENV vars specifying items under test in the environment need to be set for the tests to run successfully.
-
-- `VCLOUD_EDGE_GATEWAY`: _name of edge gateway under test_
-- `VCLOUD_NETWORK1_ID`: _Id of network under test_
-- `VCLOUD_PROVIDER_NETWORK_ID`: _Id of the uplink network (or external network) of the VCLOUD_EDGE_GATEWAY under test_
+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.
 
 ## Contributing
 

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rspec/core/rake_task'
 require 'cucumber/rake/task'
 
-task :default => [:spec, :features]
+task :default => [:rubocop, :spec, :features]
 
 RSpec::Core::RakeTask.new(:spec) do |task|
   # Set a bogus Fog credential, otherwise it's possible for the unit

data/jenkins.sh

@@ -1,11 +1,14 @@
 #!/bin/bash -x
 set -e
 
-rm -f Gemfile.lock
-git clean -fdx
-
+git clean -ffdx
 bundle install --path "${HOME}/bundles/${JOB_NAME}"
 
+# Obtain the integration test parameters
+git clone git@github.gds:gds/vcloud-tools-testing-config.git
+mv vcloud-tools-testing-config/vcloud_tools_testing_config.yaml spec/integration/
+rm -rf vcloud-tools-testing-config
+
 bundle exec rake
 RUBYOPT="-r ./tools/fog_credentials" bundle exec rake integration
 bundle exec rake publish_gem

data/jenkins_integration_tests.sh

@@ -1,4 +1,12 @@
 #!/bin/bash -x
 set -e
+
+git clean -ffdx
 bundle install --path "${HOME}/bundles/${JOB_NAME}"
+
+# Obtain the integration test parameters
+git clone git@github.gds:gds/vcloud-tools-testing-config.git
+mv vcloud-tools-testing-config/vcloud_tools_testing_config.yaml spec/integration/
+rm -rf vcloud-tools-testing-config
+
 RUBYOPT="-r ./tools/fog_credentials" bundle exec rake integration

data/lib/vcloud/core/config_loader.rb

@@ -21,6 +21,9 @@ module Vcloud
 
         if schema
           validation = Core::ConfigValidator.validate(:base, config, schema)
+          validation.warnings.each do |warning|
+            Vcloud::Core.logger.warn(warning)
+          end
           unless validation.valid?
             validation.errors.each do |error|
               Vcloud::Core.logger.fatal(error)

data/lib/vcloud/core/config_validator.rb

@@ -1,18 +1,42 @@
 require 'ipaddr'
 
+##
+# self::validate is entry point; this class method is called to
+# instantiate ConfigValidator. For example:
+#
+# Core::ConfigValidator.validate(key, data, schema)
+#
+# = Recursion in this class
+#
+#   Note that this class will recursively call itself in order to validate deep
+#   hash and array structures.
+#
+#   The +data+ variable is usually either an array or hash and so will pass
+#   through the ConfigValidator#validate_array and
+#   ConfigValidator#validate_hash methods respectively.
+#
+#   These methods then recursively instantiate this class by calling
+#   ConfigValidator::validate again (ConfigValidator#validate_hash calls this
+#   indirectly via the ConfigValidator#check_hash_parameter method).
+
 module Vcloud
   module Core
     class ConfigValidator
 
-      attr_reader :key, :data, :schema, :type, :errors
+      attr_reader :key, :data, :schema, :type, :errors, :warnings
 
       VALID_ALPHABETICAL_VALUES_FOR_IP_RANGE = %w(Any external internal)
 
+      def self.validate(key, data, schema)
+        new(key, data, schema)
+      end
+
       def initialize(key, data, schema)
         raise "Nil schema" unless schema
         raise "Invalid schema" unless schema.key?(:type)
         @type = schema[:type].to_s.downcase
-        @errors = []
+        @errors   = []
+        @warnings = []
         @data   = data
         @schema = schema
         @key    = key
@@ -23,47 +47,147 @@ module Vcloud
         @errors.empty?
       end
 
-      def self.validate(key, data, schema)
-        new(key, data, schema)
-      end
-
       private
 
+      # Call the corresponding function in this class (dependant on schema[:type])
       def validate
         self.send("validate_#{type}".to_sym)
       end
 
-      def validate_string
-        unless @data.is_a? String
-          errors << "#{key}: #{@data} is not a string"
+      def validate_array
+        unless data.is_a? Array
+          @errors << "#{key} is not an array"
           return
         end
         return unless check_emptyness_ok
-        return unless check_matcher_matches
+        if schema.key?(:each_element_is)
+          element_schema = schema[:each_element_is]
+          data.each do |element|
+            sub_validator = ConfigValidator.validate(key, element, element_schema)
+            @warnings = warnings + sub_validator.warnings
+            unless sub_validator.valid?
+              @errors = errors + sub_validator.errors
+            end
+          end
+        end
       end
 
-      def validate_string_or_number
-        unless data.is_a?(String) || data.is_a?(Numeric)
-          @errors << "#{key}: #{@data} is not a string_or_number"
+      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)
+          check_for_invalid_deprecations
+          deprecations_used = get_deprecations_used
+          warn_on_deprecations_used(deprecations_used)
+
+          schema[:internals].each do |param_key,param_schema|
+            ignore_required = (
+              param_schema[:deprecated_by] ||
+              deprecations_used.key?(param_key)
+            )
+            check_hash_parameter(param_key, param_schema, ignore_required)
+          end
+        end
       end
 
-      def validate_ip_address
-        unless data.is_a?(String)
-          @errors << "#{key}: #{@data} is not a valid ip_address"
-          return
+      # Return a hash of deprecated params referenced in @data. Where the
+      # structure is: `{ :deprecator => :deprecatee }`
+      def get_deprecations_used
+        used = {}
+        schema[:internals].each do |param_key,param_schema|
+          deprecated_by = param_schema[:deprecated_by]
+          if deprecated_by && data[param_key]
+            used[deprecated_by.to_sym] = param_key
+          end
         end
-        @errors << "#{key}: #{@data} is not a valid ip_address" unless valid_ip_address?(data)
+
+        used
       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
+      # Append warnings for any deprecations used. Takes the output of
+      # `#get_deprecations_used`.
+      def warn_on_deprecations_used(deprecations_used)
+        deprecations_used.each do |deprecator, deprecatee|
+          @warnings << "#{deprecatee}: is deprecated by '#{deprecator}'"
+        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
+
+      # Raise an exception if any `deprecated_by` params refer to params
+      # that don't exist in the schema.
+      def check_for_invalid_deprecations
+        schema[:internals].each do |param_key,param_schema|
+          deprecated_by = param_schema[:deprecated_by]
+          if deprecated_by && !schema[:internals].key?(deprecated_by.to_sym)
+            raise "#{param_key}: deprecated_by target '#{deprecated_by}' not found in schema"
+          end
+        end
+      end
+
+      def check_for_unknown_parameters
+        internals = schema[:internals]
+        # if there are no parameters specified, then assume all are ok.
+        return true unless internals
+        return true if schema[:permit_unknown_parameters]
+        data.keys.each do |k|
+          @errors << "#{key}: parameter '#{k}' is invalid" unless internals[k]
+        end
+      end
+
+      def check_hash_parameter(sub_key, sub_schema, ignore_required=false)
+        unless data.key?(sub_key)
+          if sub_schema[:required] == false || ignore_required
+            return true
+          end
+
+          @errors << "#{key}: missing '#{sub_key}' parameter"
+          return false
+        end
+
+        sub_validator = ConfigValidator.validate(
+          sub_key,
+          data[sub_key],
+          sub_schema
+        )
+        @warnings = warnings + sub_validator.warnings
+        unless sub_validator.valid?
+          @errors = errors + sub_validator.errors
+        end
+      end
+
+      def check_matcher_matches
+        regex = schema[:matcher]
+        return unless regex
+        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 valid_alphabetical_ip_range?
+        VALID_ALPHABETICAL_VALUES_FOR_IP_RANGE.include?(data)
+      end
+
+      def validate_boolean
+        unless [true, false].include?(data)
+          @errors << "#{key}: #{data} is not a valid boolean value."
         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?
@@ -75,8 +199,21 @@ module Vcloud
         end
       end
 
-      def valid_alphabetical_ip_range?
-        VALID_ALPHABETICAL_VALUES_FOR_IP_RANGE.include?(data)
+      def validate_enum
+        acceptable_values = schema[:acceptable_values]
+        raise "Must set :acceptable_values for type 'enum'" unless acceptable_values.is_a?(Array)
+        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_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 valid_ip_address? ip_address
@@ -91,6 +228,15 @@ module Vcloud
         end
       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_ip_range?
         range_parts = data.split('-')
         return false if range_parts.size != 2
@@ -104,101 +250,20 @@ module Vcloud
         IPAddr.new(start_address) < IPAddr.new(end_address)
       end
 
-      def validate_hash
-        unless data.is_a? Hash
-          @errors << "#{key}: is not a hash"
+      def validate_string
+        unless @data.is_a? String
+          errors << "#{key}: #{@data} is not a string"
           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
+        return unless check_matcher_matches
       end
 
-      def validate_array
-        unless data.is_a? Array
-          @errors << "#{key} is not an array"
+      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
-        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
-        acceptable_values = schema[:acceptable_values]
-        raise "Must set :acceptable_values for type 'enum'" unless acceptable_values.is_a?(Array)
-        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
-        regex = schema[:matcher]
-        return unless regex
-        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
-        internals = schema[:internals]
-        # if there are no parameters specified, then assume all are ok.
-        return true unless internals
-        return true if schema[:permit_unknown_parameters]
-        data.keys.each do |k|
-          @errors << "#{key}: parameter '#{k}' is invalid" unless internals[k]
-        end
       end
     end
   end

data/lib/vcloud/core/edge_gateway_interface.rb

@@ -6,7 +6,7 @@ module Vcloud
 
       def initialize(gateway_interface_hash)
         if gateway_interface_hash.nil?
-          raise "EdgeGatewayInterface: gateway_interface_hash cannot be nil" 
+          raise "EdgeGatewayInterface: gateway_interface_hash cannot be nil"
         end
         unless gateway_interface_hash[:Name] && gateway_interface_hash[:Network]
           raise "EdgeGatewayInterface: bad input: #{gateway_interface_hash}"

data/lib/vcloud/core/vapp_template.rb

@@ -33,11 +33,11 @@ module Vcloud
         end
       end
 
-      def self.get catalog_name, catalog_item_name
-        ids = self.get_ids_by_name_and_catalog(catalog_item_name, catalog_name)
+      def self.get vapp_template_name, catalog_name
+        ids = self.get_ids_by_name_and_catalog(vapp_template_name, catalog_name)
         raise 'Could not find template vApp' if ids.size == 0
         if ids.size > 1
-          raise "Template #{catalog_item_name} is not unique in catalog #{catalog_name}"
+          raise "Template #{vapp_template_name} is not unique in catalog #{catalog_name}"
         end
         return self.new(ids.first)
       end

data/lib/vcloud/core/version.rb

@@ -1,5 +1,5 @@
 module Vcloud
   module Core
-    VERSION = '0.3.0'
+    VERSION = '0.4.0'
   end
 end

data/lib/vcloud/core/vm.rb

@@ -112,15 +112,21 @@ module Vcloud
         Vcloud::Fog::ServiceInterface.new.put_guest_customization_section(id, name, interpolated_preamble)
       end
 
-      def generate_preamble(script_path, script_post_processor, vars)
-        script = ERB.new(File.read(File.expand_path(script_path)), nil, '>-').result(binding)
+      def generate_preamble(script_path, script_post_processor, preamble_vars)
+        erb_vars = OpenStruct.new({
+          vapp_name: vapp_name,
+          vars: preamble_vars
+        })
+        erb_vars_binding_object = erb_vars.instance_eval { binding }
+        erb_output = interpolate_erb_file(script_path, erb_vars_binding_object)
         if script_post_processor
-          script = Open3.capture2(File.expand_path(script_post_processor),
-                                  stdin_data: script).first
+          post_process_erb_output(erb_output, script_post_processor) if script_post_processor
+        else
+          erb_output
         end
-        script
       end
 
+
       def update_storage_profile storage_profile
         storage_profile_href = get_storage_profile_href_by_name(storage_profile, @vapp.name)
         Vcloud::Fog::ServiceInterface.new.put_vm(id, name, {
@@ -132,6 +138,18 @@ module Vcloud
       end
 
       private
+
+      def interpolate_erb_file(erb_file, binding_object)
+        ERB.new(File.read(File.expand_path(erb_file)), nil, '>-').result(binding_object)
+      end
+
+      def post_process_erb_output(data_to_process, post_processor_script)
+        # Open3.capture2, as we just need to return STDOUT of the post_processor_script
+        Open3.capture2(
+          File.expand_path(post_processor_script),
+          stdin_data: data_to_process).first
+      end
+
       def virtual_hardware_section
         vcloud_attributes[:'ovf:VirtualHardwareSection'][:'ovf:Item']
       end

data/lib/vcloud/fog/content_types.rb

@@ -1,10 +1,8 @@
 module Vcloud
   module Fog
     module ContentTypes
-      CATALOG = 'application/vnd.vmware.vcloud.catalog+xml'
       ORG = 'application/vnd.vmware.vcloud.org+xml'
       VDC = 'application/vnd.vmware.vcloud.vdc+xml'
-      CATALOG_ITEM = 'application/vnd.vmware.vcloud.catalogItem+xml'
       NETWORK = 'application/vnd.vmware.vcloud.network+xml'
       METADATA = 'application/vnd.vmware.vcloud.metadata.value+xml'
     end

data/lib/vcloud/fog/service_interface.rb

@@ -35,10 +35,6 @@ module Vcloud
           @vcloud.get_vapps_in_lease_from_query(options).body
         end
 
-        def get_catalog_item(id)
-          @vcloud.get_catalog_item(id).body
-        end
-
         def post_instantiate_vapp_template(vdc, template, name, params)
           Vcloud::Core.logger.debug("instantiating #{name} vapp in #{vdc[:name]}")
           vapp = @vcloud.post_instantiate_vapp_template(extract_id(vdc), template, name, params).body
@@ -151,10 +147,6 @@ module Vcloud
           @vcloud.process_task(task)
         end
 
-        def get_catalog(id)
-          @vcloud.get_catalog(id).body
-        end
-
         def put_vapp_metadata_value(id, k, v)
           Vcloud::Core.logger.debug("putting metadata pair '#{k}'=>'#{v}' to #{id}")
           # need to convert key to_s since Fog 0.17 borks on symbol key

data/spec/integration/README.md

@@ -0,0 +1,36 @@
+# Running vCloud Core Integration Tests
+
+## Prerequisites
+
+- Access to a suitable vCloud Director organisation.
+
+  **NB** It is not safe to run them against an environment that is in use
+  (e.g. production, preview) as many of the tests clear down all config at
+  the beginning and/or end to ensure the environment is as the tests expect.
+
+- A config file with the settings configured.
+
+  There is a [template file](spec/integration/vcloud_tools_testing_config.yaml.template) to
+  help with this. Copy the template file to `spec/integration/vcloud_tools_testing_config.yaml`
+  and update with parameters suitable for your environment.
+
+- You need to include the set-up for your testing environment in your
+  [fog file](https://github.com/alphagov/vcloud-core#credentials).
+
+- The tests use the [vCloud Tools Tester](http://rubygems.org/gems/vcloud-tools-tester) gem.
+  You do not need to install this, `bundler` will do this for you.
+
+## Parameters
+
+````
+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
+````
+
+## To run the tests
+
+  `FOG_CREDENTIAL=test_credential bundle exec integration`

data/spec/integration/{query → core}/query_runner_spec.rb

@@ -4,28 +4,12 @@ module Vcloud
   module Core
     describe QueryRunner do
 
-      required_env = {
-        'VCLOUD_VDC_NAME' =>
-           'to the name of an orgVdc to use to instantiate vApps into',
-        'VCLOUD_TEMPLATE_NAME' =>
-           'to the name of a vAppTemplate to use create vApps in tests',
-        'VCLOUD_CATALOG_NAME' =>
-           'to the name of the catalog that VCLOUD_VAPP_TEMPLATE_NAME is stored in',
-      }
-
-      error = false
-      required_env.each do |var,message|
-        unless ENV[var]
-          puts "Must set #{var} #{message}" unless ENV[var]
-          error = true
-        end
-      end
-      Kernel.exit(2) if error
-
       before(:all) do
-        @vapp_template_name = ENV['VCLOUD_TEMPLATE_NAME']
-        @vapp_template_catalog_name = ENV['VCLOUD_CATALOG_NAME']
-        @vdc_name = ENV['VCLOUD_VDC_NAME']
+        config_file = File.join(File.dirname(__FILE__), "../vcloud_tools_testing_config.yaml")
+        test_data = Vcloud::Tools::Tester::TestParameters.new(config_file)
+        @vapp_template_name = test_data.vapp_template
+        @vapp_template_catalog_name = test_data.catalog
+        @vdc_name = test_data.vdc_1_name
       end
 
       context "#available_query_types" do
@@ -92,11 +76,13 @@ module Vcloud
 
         before(:all) do
           @number_of_vapps_to_create = 2
-          @test_case_vapps = create_test_case_vapps(
+          @test_case_vapps = IntegrationHelper.create_test_case_vapps(
             @number_of_vapps_to_create,
             @vdc_name,
             @vapp_template_catalog_name,
             @vapp_template_name,
+            [],
+            "vcloud-core-query-tests"
           )
         end
 
@@ -194,27 +180,7 @@ module Vcloud
         end
 
         after(:all) do
-          fsi = Vcloud::Fog::ServiceInterface.new()
-          @test_case_vapps.each do |vapp|
-            fsi.delete_vapp(vapp.id)
-          end
-        end
-
-        def create_test_case_vapps(quantity, vdc_name, catalog_name, vapp_template_name)
-          vapp_template = VappTemplate.get(catalog_name, vapp_template_name)
-          timestamp_in_s = Time.new.to_i
-          base_vapp_name = "vcloud-core-query-tests-#{timestamp_in_s}-"
-          network_names = []
-          vapp_list = []
-          quantity.times do |index|
-            vapp_list << Vapp.instantiate(
-              base_vapp_name + index.to_s,
-              network_names,
-              vapp_template.id,
-              vdc_name
-            )
-          end
-          vapp_list
+          IntegrationHelper.delete_vapps(@test_case_vapps)
         end
 
       end

data/spec/integration/vcloud_tools_testing_config.yaml.template

@@ -0,0 +1,6 @@
+default:
+  vdc_1_name:
+  catalog:
+  vapp_template:
+  network_1:
+  network_1_ip:

data/spec/spec_helper.rb

@@ -14,15 +14,17 @@ end
 
 require 'bundler/setup'
 require 'vcloud/core'
+require 'vcloud/tools/tester'
 require 'support/stub_fog_interface.rb'
+require 'support/integration_helper'
 
 if ENV['COVERAGE']
   SimpleCov.at_exit do
     SimpleCov.result.format!
     # do not change the coverage percentage, instead add more unit tests to fix coverage failures.
-    if SimpleCov.result.covered_percent < 71
+    if SimpleCov.result.covered_percent < 81
       print "ERROR::BAD_COVERAGE\n"
-      print "Coverage is less than acceptable limit(71%). Please add more tests to improve the coverage"
+      print "Coverage is less than acceptable limit(81%). Please add more tests to improve the coverage"
       exit(1)
     end
   end

data/spec/support/integration_helper.rb

@@ -0,0 +1,32 @@
+module IntegrationHelper
+
+  def self.create_test_case_vapps(number_of_vapps,
+                                  vdc_name,
+                                  catalog_name,
+                                  vapp_template_name,
+                                  network_names = [],
+                                  prefix = "vcloud-core-tests"
+                                 )
+    vapp_template = Vcloud::Core::VappTemplate.get(vapp_template_name, catalog_name)
+    timestamp_in_s = Time.new.to_i
+    base_vapp_name = "#{prefix}-#{timestamp_in_s}-"
+    vapp_list = []
+    number_of_vapps.times do |index|
+      vapp_list << Vcloud::Core::Vapp.instantiate(
+        base_vapp_name + index.to_s,
+        network_names,
+        vapp_template.id,
+        vdc_name
+      )
+    end
+    vapp_list
+  end
+
+  def self.delete_vapps(vapp_list)
+    fsi = Vcloud::Fog::ServiceInterface.new()
+    vapp_list.each do |vapp|
+      fsi.delete_vapp(vapp.id)
+    end
+  end
+
+end

data/spec/support/stub_fog_interface.rb

@@ -31,7 +31,7 @@ class StubFogInterface
   end
 
   def get_edge_gateway(id)
-    { 
+    {
       :name => 'test-edgegw-1',
       :href => "/#{id}",
     }

data/spec/vcloud/core/config_loader_spec.rb

@@ -57,6 +57,32 @@ module Vcloud
           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
+
+          Vcloud::Core.logger.should_not_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
+
+          Vcloud::Core.logger.should_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
+
+          Vcloud::Core.logger.should_receive(:warn).with("vapps: is deprecated by 'vapps_new'")
+          Vcloud::Core.logger.should_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
@@ -84,13 +110,35 @@ module Vcloud
         }
       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",
-            :catalog_item=>"CATALOG_ITEM",
+            :vapp_template=>"VAPP_TEMPLATE",
             :vm=>{
               :hardware_config=>{:memory=>"4096", :cpu=>"2"},
               :extra_disks=>[{:size=>"8192"}],

data/spec/vcloud/core/config_validator_spec.rb

@@ -564,7 +564,125 @@ module Vcloud
             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 = 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
+
+        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
+
+        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
 
+        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
       end
 
     end

data/spec/vcloud/core/data/basic_preamble_test.erb

@@ -4,6 +4,10 @@
 
 (
 echo "in $*"
+echo "env_var: <%= ENV['TEST_INTERPOLATED_ENVVAR'] -%>"
 echo "vapp_name: <%= vapp_name -%>"
 echo "message: <%= vars[:message] -%>"
+<% vars[:array_test].each_with_index do |element, index| -%>
+echo "index<%= index -%>: <%= element -%>"
+<% end -%>
 ) >> /PREAMBLE_OUTPUT

data/spec/vcloud/core/data/basic_preamble_test.erb.OUT

@@ -4,6 +4,9 @@
 
 (
 echo "in $*"
+echo "env_var: test_interpolated_env"
 echo "vapp_name: test-vapp-1"
 echo "message: hello world"
+echo "index0: foo"
+echo "index1: bar"
 ) >> /PREAMBLE_OUTPUT

data/spec/vcloud/core/data/preamble_post_processor_test_input.erb

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+# This is a sample test file that is really just
+# to confirm that when we run this through a
+# postprocessor script, that the output is
+# consistent.
+

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

@@ -3,7 +3,7 @@
     "name":"vapp-vcloud-tools-tests",
     "vdc_name":"VDC_NAME",
     "catalog":"CATALOG_NAME",
-    "catalog_item":"CATALOG_ITEM",
+    "vapp_template":"VAPP_TEMPLATE",
     "vm":{
       "hardware_config":{"memory":"4096", "cpu":"2"},
       "extra_disks":[{"size":"8192"}],

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

@@ -3,7 +3,7 @@ vapps:
 - name: vapp-vcloud-tools-tests
   vdc_name: VDC_NAME
   catalog: CATALOG_NAME
-  catalog_item: CATALOG_ITEM
+  vapp_template: VAPP_TEMPLATE
   vm:
     hardware_config:
       memory: '4096'

data/spec/vcloud/core/data/working_template.yaml

@@ -3,7 +3,7 @@ vapps:
 - name: vapp-vcloud-tools-tests
   vdc_name: VDC_NAME
   catalog: CATALOG_NAME
-  catalog_item: CATALOG_ITEM
+  vapp_template: VAPP_TEMPLATE
   vm:
     hardware_config:
       memory: '4096'

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

@@ -6,7 +6,7 @@ vapps:
 - name: vapp-vcloud-tools-tests
   vdc_name: *VDC_NAME
   catalog: CATALOG_NAME
-  catalog_item: CATALOG_ITEM
+  vapp_template: VAPP_TEMPLATE
   vm:
     hardware_config:
       memory: '4096'

data/spec/vcloud/core/vapp_template_spec.rb

@@ -8,10 +8,6 @@ module Vcloud
         @id = 'vappTemplate-12345678-1234-1234-1234-000000234121'
         @mock_fog_interface = StubFogInterface.new
         Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
-        @test_config = {
-            :catalog => 'test_catalog',
-            :catalog_item => 'test_template'
-        }
       end
 
       context "Class public interface" do
@@ -55,7 +51,7 @@ module Vcloud
           mock_query.should_receive(:run).
             with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
             and_return(q_results)
-          expect { VappTemplate.get('test_catalog', 'test_template') }.
+          expect { VappTemplate.get('test_template', 'test_catalog') }.
             to raise_error('Could not find template vApp')
         end
 
@@ -71,7 +67,7 @@ module Vcloud
           mock_query.should_receive(:run).
             with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
             and_return(q_results)
-          expect { VappTemplate.get('test_catalog', 'test_template') }.
+          expect { VappTemplate.get('test_template', 'test_catalog') }.
             to raise_error('Template test_template is not unique in catalog test_catalog')
         end
 
@@ -85,7 +81,7 @@ module Vcloud
           mock_query.should_receive(:run).
             with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
             and_return(q_results)
-          test_template = VappTemplate.get('test_catalog', 'test_template')
+          test_template = VappTemplate.get('test_template', 'test_catalog')
           test_template.id.should == 'vappTemplate-12345678-90ab-cdef-0123-4567890abcde'
         end
 

data/spec/vcloud/core/vm_spec.rb

@@ -181,18 +181,26 @@ module Vcloud
       end
 
       context '#generate_preamble' do
-        it "should interpolate vars hash and vapp_name into template" do
-          vars = {:message => 'hello world'}
+        it "should interpolate vars hash, ENV, and vapp_name into template" do
+          vars = {
+            :message => 'hello world',
+            :array_test => [ 'foo', 'bar' ],
+          }
+          stub_const('ENV', {'TEST_INTERPOLATED_ENVVAR' => 'test_interpolated_env'})
           erbfile = "#{@data_dir}/basic_preamble_test.erb"
           expected_output = File.read("#{erbfile}.OUT")
           @vm.generate_preamble(erbfile, nil, vars).should == expected_output
         end
 
-        it "should interpolate vars hash and post-process template" do
-          vars = {:message => 'hello world'}
-          erbfile = "#{@data_dir}/basic_preamble_test.erb"
-          expected_output = File.read("#{erbfile}.OUT")
-          @vm.generate_preamble(erbfile, '/bin/cat', vars).should == expected_output
+        it "passes the output of ERB through an optional post-processor tool" do
+          # we use 'wc' as post processor since it will give us the character
+          # count in the file, which we can easily match on, and is common
+          # across most OSes.
+          vars = {}
+          erbfile = "#{@data_dir}/preamble_post_processor_test_input.erb"
+          characters_in_file = File.read(erbfile).size
+          expect(@vm.generate_preamble(erbfile, '/usr/bin/wc', vars)).
+            to match(/^\s+\d+\s+\d+\s+#{characters_in_file}\s/)
         end
       end
 

data/vcloud-core.gemspec

@@ -32,4 +32,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rubocop'
   s.add_development_dependency 'simplecov', '~> 0.8.2'
   s.add_development_dependency 'gem_publisher', '1.2.0'
+  s.add_development_dependency 'vcloud-tools-tester', '0.0.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vcloud-core
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-14 00:00:00.000000000 Z
+date: 2014-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -171,6 +171,22 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: vcloud-tools-tester
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
 description: Core tools for interacting with VMware vCloud Director. Includes VCloud
   Query, a light wrapper round the vCloud Query API.
 email:
@@ -213,15 +229,19 @@ files:
 - lib/vcloud/fog/model_interface.rb
 - lib/vcloud/fog/relation.rb
 - lib/vcloud/fog/service_interface.rb
+- spec/integration/README.md
+- spec/integration/core/query_runner_spec.rb
 - spec/integration/edge_gateway/configure_edge_gateway_services_spec.rb
 - spec/integration/edge_gateway/edge_gateway_spec.rb
-- spec/integration/query/query_runner_spec.rb
+- spec/integration/vcloud_tools_testing_config.yaml.template
 - spec/spec_helper.rb
+- spec/support/integration_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/preamble_post_processor_test_input.erb
 - spec/vcloud/core/data/working.json
 - spec/vcloud/core/data/working.yaml
 - spec/vcloud/core/data/working_template.yaml
@@ -262,7 +282,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2968796492213479520
+      hash: -2177023225627992680
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -272,15 +292,19 @@ summary: Core tools for interacting with VMware vCloud Director
 test_files:
 - features/support/env.rb
 - features/vcloud-query.feature
+- spec/integration/README.md
+- spec/integration/core/query_runner_spec.rb
 - spec/integration/edge_gateway/configure_edge_gateway_services_spec.rb
 - spec/integration/edge_gateway/edge_gateway_spec.rb
-- spec/integration/query/query_runner_spec.rb
+- spec/integration/vcloud_tools_testing_config.yaml.template
 - spec/spec_helper.rb
+- spec/support/integration_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/preamble_post_processor_test_input.erb
 - spec/vcloud/core/data/working.json
 - spec/vcloud/core/data/working.yaml
 - spec/vcloud/core/data/working_template.yaml