vcloud-core 0.5.0 → 0.6.0

data/spec/integration/core/vapp_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+describe Vcloud::Core::Vapp do
+
+  let(:uuid_matcher) { "[-0-9a-f]+" }
+
+  before(:all) do
+    config_file = File.join(File.dirname(__FILE__), "../vcloud_tools_testing_config.yaml")
+    required_user_params = [
+      "catalog",
+      "network_1",
+      "network_2",
+      "vapp_template",
+      "vdc_1_name",
+    ]
+
+    @test_params = Vcloud::Tools::Tester::TestSetup.new(config_file, required_user_params).test_params
+    @vapp_name_prefix = "vcloud-core-vapp-tests"
+    quantity_of_test_case_vapps = 1
+    @network_names = [ @test_params.network_1, @test_params.network_2 ]
+    @test_case_vapps = IntegrationHelper.create_test_case_vapps(
+      quantity_of_test_case_vapps,
+      @test_params.vdc_1_name,
+      @test_params.catalog,
+      @test_params.vapp_template,
+      @network_names,
+      @vapp_name_prefix
+    )
+    @vapp = @test_case_vapps.first
+  end
+
+  subject(:fixture_vapp) { @vapp }
+
+  context "before the integration tests run" do
+
+    it "ensures we have a valid vApp fixture, for subsequent tests to run against" do
+      expect(fixture_vapp).to be_instance_of(Vcloud::Core::Vapp)
+    end
+
+  end
+
+  describe "#vcloud_attributes" do
+
+    it "has a :href element containing the expected vApp id" do
+      expect(fixture_vapp.vcloud_attributes[:href].split('/').last).to eq(fixture_vapp.id)
+    end
+
+  end
+
+  describe "#id" do
+
+    it "returns the a valid vApp id" do
+      expect(fixture_vapp.id).to match(/^vapp-#{uuid_matcher}$/)
+    end
+
+  end
+
+  describe "#name" do
+
+    it "returns the name of the vApp" do
+      expect(fixture_vapp.name).to include(@vapp_name_prefix)
+    end
+
+  end
+
+  describe "#vdc_id" do
+
+    it "returns a valid uuid" do
+      expect(fixture_vapp.vdc_id).to match(/^#{uuid_matcher}$/)
+    end
+
+  end
+
+  describe "#networks" do
+
+    it "returns hashes for each network, plus the 'none' placeholder network" do
+      network_output = fixture_vapp.networks
+      # The API return a 'placeholder' network hash as well as
+      # any configured networks, for any VMs that have disconnected interfaces.
+      # This has the :ovf_name of 'none'. So, we expect our @network_names, plus 'none'.
+      #
+      expect(network_output.map { |network| network[:ovf_name] }).
+        to match_array(@network_names + ["none"])
+    end
+
+  end
+
+  describe "#power_on" do
+
+    it "powers up a powered down Vapp" do
+      expect(Integer(fixture_vapp.vcloud_attributes[:status])).to eq(Vcloud::Core::Vapp::STATUS::POWERED_OFF)
+      expect(fixture_vapp.power_on).to be_true
+      expect(Integer(fixture_vapp.vcloud_attributes[:status])).to eq(Vcloud::Core::Vapp::STATUS::RUNNING)
+    end
+
+  end
+
+  describe ".get_by_name" do
+
+    it "can find our fixture vApp by its name" do
+      retrieved_vapp = Vcloud::Core::Vapp.get_by_name(fixture_vapp.name)
+      expect(retrieved_vapp.id).to eq(fixture_vapp.id)
+    end
+
+    it "raises an error if it cannot find the named vApp" do
+      bogus_vapp_name = "bogus-vapp-name-wefoiuhwef"
+      expect {
+        Vcloud::Core::Vapp.get_by_name(bogus_vapp_name)
+      }.to raise_error("vApp #{bogus_vapp_name} not found")
+    end
+
+  end
+
+  describe ".instantiate" do
+
+    let(:vapp_template) {
+      Vcloud::Core::VappTemplate.get(@test_params.vapp_template, @test_params.catalog)
+    }
+
+    let(:vapp_name) { "#{@vapp_name_prefix}-instantiate-#{Time.new.to_i}" }
+
+    it "can create a vApp with no networks assigned" do
+      new_vapp = Vcloud::Core::Vapp.instantiate(
+        vapp_name,
+        [],
+        vapp_template.id,
+        @test_params.vdc_1_name
+      )
+      @test_case_vapps << new_vapp
+      expect(new_vapp.name).to eq(vapp_name)
+      expect(sanitize_networks_output(new_vapp.networks).size).to eq(0)
+    end
+
+    it "can create a vApp with one networks assigned" do
+      new_vapp = Vcloud::Core::Vapp.instantiate(
+        vapp_name,
+        [ @test_params.network_1 ],
+        vapp_template.id,
+        @test_params.vdc_1_name
+      )
+      @test_case_vapps << new_vapp
+      expect(new_vapp.name).to eq(vapp_name)
+      expect(sanitize_networks_output(new_vapp.networks).size).to eq(1)
+    end
+
+    it "can create a vApp with two networks assigned" do
+      new_vapp = Vcloud::Core::Vapp.instantiate(
+        vapp_name,
+        [ @test_params.network_1, @test_params.network_2 ],
+        vapp_template.id,
+        @test_params.vdc_1_name
+      )
+      @test_case_vapps << new_vapp
+      expect(new_vapp.name).to eq(vapp_name)
+      expect(sanitize_networks_output(new_vapp.networks).size).to eq(2)
+    end
+
+    it "raises a Fog error if the vAppTemplate id refers to a non-existent template" do
+      expect {
+        Vcloud::Core::Vapp.instantiate(
+          vapp_name,
+          [],
+          "vAppTemplate-12345678-1234-1234-1234-1234567890ab",
+          @test_params.vdc_1_name
+        )
+      }.to raise_error(Fog::Compute::VcloudDirector::Forbidden, "Access is forbidden")
+    end
+
+    it "raises a Fog error if the vAppTemplate id is invalid" do
+      expect {
+        Vcloud::Core::Vapp.instantiate(
+          vapp_name,
+          [],
+          "invalid-vapp-template-id",
+          @test_params.vdc_1_name
+        )
+      }.to raise_error(Fog::Compute::VcloudDirector::Forbidden, "This operation is denied.")
+    end
+
+    it "raises a Fog error if the vAppTemplate id is nil" do
+      expect {
+        Vcloud::Core::Vapp.instantiate(
+          vapp_name,
+          [],
+          nil,
+          @test_params.vdc_1_name
+        )
+      }.to raise_error(Fog::Compute::VcloudDirector::BadRequest)
+    end
+
+    it "raises an error if we try to instantiate into a non-existent vDC" do
+      bogus_vdc_name = "NonExistentVdc asnfiuqwf"
+      expect {
+        Vcloud::Core::Vapp.instantiate(
+          vapp_name,
+          [],
+          vapp_template.id,
+          bogus_vdc_name
+        )
+      }.to raise_error("vdc #{bogus_vdc_name} cannot be found")
+    end
+
+    it "raises an error if the vDC name is nil" do
+      expect {
+        Vcloud::Core::Vapp.instantiate(
+          vapp_name,
+          [],
+          vapp_template.id,
+          nil
+        )
+      }.to raise_error("vdc  cannot be found")
+    end
+
+    it "skips bogus network names specified in the network_names array" do
+      new_vapp = Vcloud::Core::Vapp.instantiate(
+        vapp_name,
+        ['bogus-network-name-ijwioewiwego', 'bogus-network-name-asofijqweof'],
+        vapp_template.id,
+        @test_params.vdc_1_name
+      )
+      @test_case_vapps << new_vapp
+      expect(new_vapp.networks).to eq({
+        :ovf_name => "none",
+        :"ovf:Description" =>
+          "This is a special place-holder used for disconnected network interfaces."
+      })
+    end
+
+  end
+
+  after(:all) do
+    IntegrationHelper.delete_vapps(@test_case_vapps)
+  end
+
+  def sanitize_networks_output(networks_output)
+    if networks_output.is_a?(Hash)
+      # Fog currently has a bug (https://github.com/fog/fog/issues/2927) that
+      # means the output from Vapp#networks can be a hash or array.
+      # Work around this by converting to a single element Array.
+      networks_output = [ networks_output ]
+    end
+    new_output = []
+    networks_output.each do |network_hash|
+      new_output << network_hash unless network_hash[:ovf_name] == 'none'
+    end
+    new_output
+  end
+
+end

data/spec/integration/core/vdc_spec.rb

@@ -6,7 +6,9 @@ describe Vcloud::Core::Vdc do
 
   before(:all) do
     config_file = File.join(File.dirname(__FILE__), "../vcloud_tools_testing_config.yaml")
-    @test_data = Vcloud::Tools::Tester::TestParameters.new(config_file)
+    required_user_params = %w{ vdc_1_name }
+
+    @test_params = Vcloud::Tools::Tester::TestSetup.new(config_file, required_user_params).test_params
   end
 
   describe ".get_by_name" do
@@ -15,7 +17,7 @@ describe Vcloud::Core::Vdc do
 
     context "when looking up a valid vDC name" do
 
-      let(:name) { @test_data.vdc_1_name }
+      let(:name) { @test_params.vdc_1_name }
 
       it "returns a Vcloud::Core::Vdc object" do
         expect(subject).to be_instance_of(Vcloud::Core::Vdc)
@@ -49,7 +51,7 @@ describe Vcloud::Core::Vdc do
 
     context "when instantiating with a valid ID" do
 
-      let(:vdc_id) { Vcloud::Core::Vdc.get_by_name(@test_data.vdc_1_name).id }
+      let(:vdc_id) { Vcloud::Core::Vdc.get_by_name(@test_params.vdc_1_name).id }
 
       it "returns a valid Vdc object" do
         expect(subject).to be_instance_of(Vcloud::Core::Vdc)
@@ -60,7 +62,7 @@ describe Vcloud::Core::Vdc do
       end
 
       it "has our expected #name" do
-        expect(subject.name).to eq(@test_data.vdc_1_name)
+        expect(subject.name).to eq(@test_params.vdc_1_name)
       end
 
     end

data/spec/integration/core/vm_spec.rb

@@ -4,17 +4,29 @@ describe Vcloud::Core::Vm do
 
   before(:all) do
     config_file = File.join(File.dirname(__FILE__), "../vcloud_tools_testing_config.yaml")
-    @test_data = Vcloud::Tools::Tester::TestParameters.new(config_file)
-    @network_names = [ @test_data.network_1, @test_data.network_2 ]
+    required_user_params = [
+      "catalog",
+      "default_storage_profile_name",
+      "network_1",
+      "network_1_ip",
+      "network_2",
+      "network_2_ip",
+      "storage_profile",
+      "vapp_template",
+      "vdc_1_name",
+    ]
+
+    @test_params = Vcloud::Tools::Tester::TestSetup.new(config_file, required_user_params).test_params
+    @network_names = [ @test_params.network_1, @test_params.network_2 ]
     @network_ips = {
-      @test_data.network_1 => @test_data.network_1_ip,
-      @test_data.network_2 => @test_data.network_2_ip,
+      @test_params.network_1 => @test_params.network_1_ip,
+      @test_params.network_2 => @test_params.network_2_ip,
     }
     @test_case_vapps = IntegrationHelper.create_test_case_vapps(
       1,
-      @test_data.vdc_1_name,
-      @test_data.catalog,
-      @test_data.vapp_template,
+      @test_params.vdc_1_name,
+      @test_params.catalog,
+      @test_params.vapp_template,
       @network_names,
       "vcloud-core-vm-tests"
     )
@@ -224,15 +236,15 @@ describe Vcloud::Core::Vm do
     it "can update the storage profile of a VM" do
       available_storage_profiles = Vcloud::Core::QueryRunner.new.run(
         'orgVdcStorageProfile',
-        filter: "vdcName==#{@test_data.vdc_1_name}"
+        filter: "vdcName==#{@test_params.vdc_1_name}"
       )
       if available_storage_profiles.size == 1
-        pending("There is only one StorageProfile in vDC #{@test_data.vdc_1_name}: cannot test.")
+        pending("There is only one StorageProfile in vDC #{@test_params.vdc_1_name}: cannot test.")
       end
       original_storage_profile_name = @vm.vcloud_attributes[:StorageProfile][:name]
-      expect(original_storage_profile_name).to eq(@test_data.default_storage_profile_name)
-      @vm.update_storage_profile(@test_data.storage_profile)
-      expect(@vm.vcloud_attributes[:StorageProfile][:name]).to eq(@test_data.storage_profile)
+      expect(original_storage_profile_name).to eq(@test_params.default_storage_profile_name)
+      @vm.update_storage_profile(@test_params.storage_profile)
+      expect(@vm.vcloud_attributes[:StorageProfile][:name]).to eq(@test_params.storage_profile)
     end
 
   end

data/spec/spec_helper.rb

@@ -1,13 +1,22 @@
+# SimpleCov must run _first_ according to its README
 if ENV['COVERAGE']
   require 'simplecov'
 
-  SimpleCov.profiles.define 'gem' do
+  # monkey-patch to prevent SimpleCov from reporting coverage percentage
+  class SimpleCov::Formatter::HTMLFormatter
+    def output_message(_message)
+      nil
+    end
+  end
+
+  SimpleCov.adapters.define 'gem' do
     add_filter '/spec/'
     add_filter '/vendor/'
 
     add_group 'Libraries', '/lib/'
   end
 
+  SimpleCov.minimum_coverage(84)
   SimpleCov.start 'gem'
 end
 
@@ -17,14 +26,16 @@ 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 < 81
-      print "ERROR::BAD_COVERAGE\n"
-      print "Coverage is less than acceptable limit(81%). Please add more tests to improve the coverage"
-      exit(1)
-    end
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
   end
 end
+
+# To enable Fog Mock mode use FOG_CREDENTIAL=fog_mock and FOG_MOCK=true
+# If you do not have configuration for fog_mock in your vcloud_tools_testing_config.yaml,
+# the test data is defined here: https://github.com/fog/fog/blob/master/lib/fog/vcloud_director/compute.rb#L483-L733
+# 
+if ENV['FOG_MOCK']
+  Fog.mock!
+end

data/spec/support/integration_helper.rb

@@ -25,8 +25,35 @@ module IntegrationHelper
   def self.delete_vapps(vapp_list)
     fsi = Vcloud::Fog::ServiceInterface.new()
     vapp_list.each do |vapp|
+      if Integer(vapp.vcloud_attributes[:status]) == Vcloud::Core::Vapp::STATUS::RUNNING
+        fsi.post_undeploy_vapp(vapp.id)
+      end
       fsi.delete_vapp(vapp.id)
     end
   end
 
+  def self.reset_edge_gateway(edge_gateway)
+    configuration = {
+        :FirewallService =>
+            {
+                :IsEnabled        => "false",
+                :FirewallRule     => [],
+                :DefaultAction    => "drop",
+                :LogDefaultAction => "false",
+            },
+        :LoadBalancerService =>
+            {
+                :IsEnabled      => "false",
+                :Pool           => [],
+                :VirtualServer  => [],
+            },
+        :NatService =>
+            {
+                :IsEnabled  => "false",
+                :NatRule    => [],
+            },
+    }
+
+    edge_gateway.update_configuration(configuration)
+  end
 end

data/spec/vcloud/core/config_loader_spec.rb

@@ -13,21 +13,21 @@ module Vcloud
           input_file = "#{@data_dir}/working.json"
           loader = ConfigLoader.new
           actual_config = loader.load_config(input_file)
-          valid_config.should eq(actual_config)
+          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)
-          valid_config.should eq(actual_config)
+          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)
-          valid_config['vapps'].should eq(actual_config['vapps'])
+          expect(valid_config['vapps']).to eq(actual_config['vapps'])
         end
       end
 
@@ -37,7 +37,7 @@ module Vcloud
           vars_file = "#{@data_dir}/working_variables.yaml"
           loader = ConfigLoader.new
           actual_config = loader.load_config(input_file, nil, vars_file)
-          valid_config.should eq(actual_config)
+          expect(valid_config).to eq(actual_config)
         end
       end
 
@@ -47,13 +47,13 @@ module Vcloud
           loader = ConfigLoader.new
           schema = vapp_config_schema
           actual_config = loader.load_config(input_file, schema)
-          valid_config['vapps'].should eq(actual_config['vapps'])
+          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
-          Vcloud::Core.logger.should_receive(:fatal).with("vapps: is not a hash")
+          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
@@ -62,7 +62,7 @@ module Vcloud
           input_file = "#{@data_dir}/working_with_defaults.yaml"
           loader = ConfigLoader.new
 
-          Vcloud::Core.logger.should_not_receive(:warn)
+          expect(Vcloud::Core.logger).not_to receive(:warn)
           loader.load_config(input_file, vapp_config_schema)
         end
 
@@ -70,7 +70,7 @@ module Vcloud
           input_file = "#{@data_dir}/working_with_defaults.yaml"
           loader = ConfigLoader.new
 
-          Vcloud::Core.logger.should_receive(:warn).with("vapps: is deprecated by 'vapps_new'")
+          expect(Vcloud::Core.logger).to receive(:warn).with("vapps: is deprecated by 'vapps_new'")
           loader.load_config(input_file, deprecated_schema)
         end
 
@@ -78,8 +78,8 @@ module Vcloud
           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(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