vcloud-launcher 0.1.0 → 0.2.0

data/spec/integration/README.md

@@ -12,7 +12,7 @@
 
   There is a [template file](/spec/integration/vcloud_tools_testing_config.yaml.template) to help with this. Copy the template file to `/spec/integration` (i.e. next to the template file) and remove the `.template`. This file will now be ignored by Git and you can safely add the parameters relevant to your environment.
 
-- You need to include the set-up for your testing environment in your [fog file](https://github.com/alphagov/vcloud-launcher#credentials).
+- You need to include the set-up for your testing environment in your [fog file](https://github.com/gds-operations/vcloud-launcher#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.
 

data/spec/integration/launcher/data/storage_profile.yaml.erb

@@ -5,44 +5,14 @@ vapps:
     catalog_name: <%= catalog %>
     vapp_template_name: <%= vapp_template %>
     vm:
-      hardware_config: &hardware_config
-        memory: 4096
-        cpu: 2
-      bootstrap: &bootstrap
-        script_path: <%= bootstrap_script %>
-        vars:
-          message: hello world
       storage_profile: <%= storage_profile %>
   - name: <%= vapp_name_2 %>
     vdc_name: <%= vdc_2_name %>
     catalog_name: <%= catalog %>
     vapp_template_name: <%= vapp_template %>
     vm:
-      hardware_config:
-        <<: *hardware_config
-      bootstrap:
-        <<: *bootstrap
       storage_profile: <%= storage_profile %>
   - name: <%= vapp_name_3 %>
     vdc_name: <%= vdc_1_name %>
     catalog_name: <%= catalog %>
     vapp_template_name: <%= vapp_template %>
-    vm:
-      hardware_config:
-        <<: *hardware_config
-      metadata:
-        storage_profile_test_vm: true
-      bootstrap:
-        <<: *bootstrap
-  - name: <%= vapp_name_4 %>
-    vdc_name: <%= vdc_1_name %>
-    catalog_name: <%= catalog %>
-    vapp_template_name: <%= vapp_template %>
-    vm:
-      hardware_config:
-        <<: *hardware_config
-      metadata:
-        storage_profile_test_vm: true
-      bootstrap:
-        <<: *bootstrap
-      storage_profile: <%= nonsense_storage_profile %>

data/spec/integration/launcher/{vcloud_launcher_spec.rb → launch_spec.rb}

@@ -18,15 +18,15 @@ describe Vcloud::Launcher::Launch do
       @provisioned_vapp_id = vapp_query_result[:href].split('/').last
       provisioned_vapp = @fog_interface.get_vapp @provisioned_vapp_id
 
-      provisioned_vapp.should_not be_nil
-      provisioned_vapp[:name].should eq(test_data_1[:vapp_name])
-      provisioned_vapp[:Children][:Vm].count.should eq(1)
+      expect(provisioned_vapp).not_to be_nil
+      expect(provisioned_vapp[:name]).to eq(test_data_1[:vapp_name])
+      expect(provisioned_vapp[:Children][:Vm].count).to eq(1)
     end
 
     after(:each) do
       unless ENV['VCLOUD_TOOLS_RSPEC_NO_DELETE_VAPP']
         File.delete @minimum_data_yaml
-        @fog_interface.delete_vapp(@provisioned_vapp_id).should eq(true)
+        expect(@fog_interface.delete_vapp(@provisioned_vapp_id)).to eq(true)
       end
     end
   end
@@ -50,69 +50,69 @@ describe Vcloud::Launcher::Launch do
 
     context 'provision vapp' do
       it 'should create a vapp' do
-        @vapp[:name].should eq(@test_data[:vapp_name])
-        @vapp[:'ovf:NetworkSection'][:'ovf:Network'].count.should eq(2)
+        expect(@vapp[:name]).to eq(@test_data[:vapp_name])
+        expect(@vapp[:'ovf:NetworkSection'][:'ovf:Network'].count).to eq(2)
         vapp_networks = @vapp[:'ovf:NetworkSection'][:'ovf:Network'].collect { |connection| connection[:ovf_name] }
-        vapp_networks.should =~ [@test_data[:network_1], @test_data[:network_2]]
+        expect(vapp_networks).to match_array([@test_data[:network_1], @test_data[:network_2]])
       end
 
       it "should create vm within vapp" do
-        @vm.should_not be_nil
+        expect(@vm).not_to be_nil
       end
 
     end
 
     context "customize vm" do
       it "change cpu for given vm" do
-        extract_memory(@vm).should eq('8192')
-        extract_cpu(@vm).should eq('4')
+        expect(extract_memory(@vm)).to eq('8192')
+        expect(extract_cpu(@vm)).to eq('4')
       end
 
       it "should have added the right number of metadata values" do
-        @vm_metadata.count.should eq(6)
+        expect(@vm_metadata.count).to eq(6)
       end
 
       it "the metadata should be equivalent to our input" do
-        @vm_metadata[:is_true].should eq(true)
-        @vm_metadata[:is_integer].should eq(-999)
-        @vm_metadata[:is_string].should eq('Hello World')
+        expect(@vm_metadata[:is_true]).to eq(true)
+        expect(@vm_metadata[:is_integer]).to eq(-999)
+        expect(@vm_metadata[:is_string]).to eq('Hello World')
       end
 
       it "should attach extra hard disks to vm" do
         disks = extract_disks(@vm)
-        disks.count.should eq(3)
+        expect(disks.count).to eq(3)
         [{:name => 'Hard disk 2', :size => '1024'}, {:name => 'Hard disk 3', :size => '2048'}].each do |new_disk|
-          disks.should include(new_disk)
+          expect(disks).to include(new_disk)
         end
       end
 
       it "should configure the vm network interface" do
         vm_network_connection = @vm[:NetworkConnectionSection][:NetworkConnection]
-        vm_network_connection.should_not be_nil
-        vm_network_connection.count.should eq(2)
+        expect(vm_network_connection).not_to be_nil
+        expect(vm_network_connection.count).to eq(2)
 
 
         primary_nic = vm_network_connection.detect { |connection| connection[:network] == @test_data[:network_1] }
-        primary_nic[:network].should eq(@test_data[:network_1])
-        primary_nic[:NetworkConnectionIndex].should eq(@vm[:NetworkConnectionSection][:PrimaryNetworkConnectionIndex])
-        primary_nic[:IpAddress].should eq(@test_data[:network_1_ip])
-        primary_nic[:IpAddressAllocationMode].should eq('MANUAL')
+        expect(primary_nic[:network]).to eq(@test_data[:network_1])
+        expect(primary_nic[:NetworkConnectionIndex]).to eq(@vm[:NetworkConnectionSection][:PrimaryNetworkConnectionIndex])
+        expect(primary_nic[:IpAddress]).to eq(@test_data[:network_1_ip])
+        expect(primary_nic[:IpAddressAllocationMode]).to eq('MANUAL')
 
         second_nic = vm_network_connection.detect { |connection| connection[:network] == @test_data[:network_2] }
-        second_nic[:network].should eq(@test_data[:network_2])
-        second_nic[:NetworkConnectionIndex].should eq('1')
-        second_nic[:IpAddress].should eq(@test_data[:network_2_ip])
-        second_nic[:IpAddressAllocationMode].should eq('MANUAL')
+        expect(second_nic[:network]).to eq(@test_data[:network_2])
+        expect(second_nic[:NetworkConnectionIndex]).to eq('1')
+        expect(second_nic[:IpAddress]).to eq(@test_data[:network_2_ip])
+        expect(second_nic[:IpAddressAllocationMode]).to eq('MANUAL')
 
       end
 
       it 'should assign guest customization script to the VM' do
-        @vm[:GuestCustomizationSection][:CustomizationScript].should =~ /message: hello world/
-        @vm[:GuestCustomizationSection][:ComputerName].should eq(@test_data[:vapp_name])
+        expect(@vm[:GuestCustomizationSection][:CustomizationScript]).to match(/message: hello world/)
+        expect(@vm[:GuestCustomizationSection][:ComputerName]).to eq(@test_data[:vapp_name])
       end
 
       it "should assign storage profile to the VM" do
-        @vm[:StorageProfile][:name].should eq(@test_data[:storage_profile])
+        expect(@vm[:StorageProfile][:name]).to eq(@test_data[:storage_profile])
       end
 
     end
@@ -120,7 +120,7 @@ describe Vcloud::Launcher::Launch do
     after(:all) do
       unless ENV['VCLOUD_TOOLS_RSPEC_NO_DELETE_VAPP']
         File.delete @config_yaml
-        @fog_interface.delete_vapp(@vapp_id).should eq(true)
+        expect(@fog_interface.delete_vapp(@vapp_id)).to eq(true)
       end
     end
 
@@ -143,7 +143,18 @@ describe Vcloud::Launcher::Launch do
   def define_test_data
     config_file = File.join(File.dirname(__FILE__),
       "../vcloud_tools_testing_config.yaml")
-    parameters = Vcloud::Tools::Tester::TestParameters.new(config_file)
+    required_user_params = [
+      "vdc_1_name",
+      "catalog",
+      "vapp_template",
+      "storage_profile",
+      "network_1",
+      "network_2",
+      "network_1_ip",
+      "network_2_ip",
+    ]
+
+    parameters = Vcloud::Tools::Tester::TestSetup.new(config_file, required_user_params).test_params
     {
       vapp_name: "vapp-vcloud-tools-tests-#{Time.now.strftime('%s')}",
       vdc_name: parameters.vdc_1_name,

data/spec/integration/launcher/storage_profile_integration_spec.rb

@@ -24,58 +24,35 @@ describe Vcloud::Launcher::Launch do
       @vapp_3 = @fog_interface.get_vapp @vapp_id_3
       @vm_3 = @vapp_3[:Children][:Vm].first
 
-      @vapp_query_result_4 = @fog_interface.get_vapp_by_name_and_vdc_name(@test_data[:vapp_name_4], @test_data[:vdc_1_name])
-      @vapp_id_4 = @vapp_query_result_4[:href].split('/').last
-      @vapp_4 = @fog_interface.get_vapp @vapp_id_4
-      @vm_4 = @vapp_4[:Children][:Vm].first
     end
 
     it "vdc 1 should have a storage profile without the href being specified" do
-      @vm_1[:StorageProfile][:name].should eq(@test_data[:storage_profile])
+      expect(@vm_1[:StorageProfile][:name]).to eq(@test_data[:storage_profile])
     end
 
     it "vdc 1's storage profile should have the expected href" do
-      @vm_1[:StorageProfile][:href].should eq(@test_data[:vdc_1_sp_href])
+      expect(@vm_1[:StorageProfile][:href]).to eq(@test_data[:vdc_1_sp_href])
     end
 
     it "vdc 2 should have the same named storage profile as vdc 1" do
-      @vm_2[:StorageProfile][:name].should eq(@test_data[:storage_profile])
+      expect(@vm_2[:StorageProfile][:name]).to eq(@test_data[:storage_profile])
     end
 
     it "the storage profile in vdc 2 should have a different href to the storage profile in vdc 1" do
-      @vm_2[:StorageProfile][:href].should eq(@test_data[:vdc_2_sp_href])
+      expect(@vm_2[:StorageProfile][:href]).to eq(@test_data[:vdc_2_sp_href])
     end
 
-    it "when a storage profile is not specified, vm uses the default and continues" do
-      @vm_3[:StorageProfile][:name].should eq(@test_data[:default_storage_profile_name])
-      @vm_3[:StorageProfile][:href].should eq(@test_data[:default_storage_profile_href])
-    end
-
-    it "when a storage profile is not specified, customize continues with other customizations" do
-      @vm_3_id = @vm_3[:href].split('/').last
-      @vm_3_metadata = Vcloud::Core::Vm.get_metadata @vm_3_id
-      @vm_3_metadata[:storage_profile_test_vm].should eq(true)
-    end
-
-    it "when a storage profile specified does not exist, vm uses the default" do
-      @vm_4[:StorageProfile][:name].should eq(@test_data[:default_storage_profile_name])
-      @vm_4[:StorageProfile][:href].should eq(@test_data[:default_storage_profile_href])
-    end
-
-    # This is a bug - if it has failed customization it should let the user know
-    it "when storage profile specified doesn't exist, it errors and continues" do
-      @vm_4_id = @vm_4[:href].split('/').last
-      @vm_4_metadata = Vcloud::Core::Vm.get_metadata @vm_4_id
-      @vm_4_metadata[:storage_profile_test_vm].should be_nil
+    it "when a storage profile is not specified, vm uses the default" do
+      expect(@vm_3[:StorageProfile][:name]).to eq(@test_data[:default_storage_profile_name])
+      expect(@vm_3[:StorageProfile][:href]).to eq(@test_data[:default_storage_profile_href])
     end
 
     after(:all) do
       unless ENV['VCLOUD_TOOLS_RSPEC_NO_DELETE_VAPP']
         File.delete @config_yaml
-        @fog_interface.delete_vapp(@vapp_id_1).should eq(true)
-        @fog_interface.delete_vapp(@vapp_id_2).should eq(true)
-        @fog_interface.delete_vapp(@vapp_id_3).should eq(true)
-        @fog_interface.delete_vapp(@vapp_id_4).should eq(true)
+        expect(@fog_interface.delete_vapp(@vapp_id_1)).to eq(true)
+        expect(@fog_interface.delete_vapp(@vapp_id_2)).to eq(true)
+        expect(@fog_interface.delete_vapp(@vapp_id_3)).to eq(true)
       end
     end
 
@@ -86,12 +63,23 @@ end
 def define_test_data
   config_file = File.join(File.dirname(__FILE__),
     "../vcloud_tools_testing_config.yaml")
-  parameters = Vcloud::Tools::Tester::TestParameters.new(config_file)
+  required_user_parameters = [
+    "vdc_1_name",
+    "vdc_2_name",
+    "catalog",
+    "vapp_template",
+    "storage_profile",
+    "vdc_1_storage_profile_href",
+    "vdc_2_storage_profile_href",
+    "default_storage_profile_name",
+    "default_storage_profile_href",
+  ]
+
+  parameters = Vcloud::Tools::Tester::TestSetup.new(config_file, required_user_parameters).test_params
   {
     vapp_name_1: "vdc-1-sp-#{Time.now.strftime('%s')}",
     vapp_name_2: "vdc-2-sp-#{Time.now.strftime('%s')}",
     vapp_name_3: "vdc-3-sp-#{Time.now.strftime('%s')}",
-    vapp_name_4: "vdc-4-sp-#{Time.now.strftime('%s')}",
     vdc_1_name: parameters.vdc_1_name,
     vdc_2_name: parameters.vdc_2_name,
     catalog: parameters.catalog,

data/spec/spec_helper.rb

@@ -1,2 +1,31 @@
+# SimpleCov must run _first_ according to its README
+if ENV['COVERAGE']
+  require 'simplecov'
+
+  # 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 '/features/'
+    add_filter '/vendor/'
+
+    add_group 'Libraries', '/lib/'
+  end
+
+  SimpleCov.minimum_coverage(99)
+  SimpleCov.start 'gem'
+end
+
 require 'erb_helper'
 require 'vcloud/launcher'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/vcloud/launcher/cli_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+class CommandRun
+  attr_accessor :stdout, :stderr, :exitstatus
+
+  def initialize(args)
+    out = StringIO.new
+    err = StringIO.new
+
+    $stdout = out
+    $stderr = err
+
+    begin
+      Vcloud::Launcher::Cli.new(args).run
+      @exitstatus = 0
+    rescue SystemExit => e
+      # Capture exit(n) value.
+      @exitstatus = e.status
+    end
+
+    @stdout = out.string.strip
+    @stderr = err.string.strip
+
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+end
+
+describe Vcloud::Launcher::Cli do
+  subject { CommandRun.new(args) }
+
+  let(:mock_launch) {
+    double(:launch, :run => true)
+  }
+  let(:config_file) { 'config.yaml' }
+
+  describe "under normal usage" do
+    shared_examples "a good CLI command" do
+      it "passes the right CLI options and exits normally" do
+        expect(Vcloud::Launcher::Launch).to receive(:new).
+          and_return(mock_launch)
+        expect(mock_launch).to receive(:run).
+          with(config_file, cli_options)
+        expect(subject.exitstatus).to eq(0)
+      end
+    end
+
+    context "when given a single config file" do
+      let(:args) { [ config_file ] }
+      let(:cli_options) {
+        {
+          "dont-power-on"     => false,
+          "continue-on-error" => false,
+          "quiet"             => false,
+          "verbose"           => false,
+        }
+      }
+
+      it_behaves_like "a good CLI command"
+    end
+
+    context "when asked not to power VMs on" do
+      let(:args) { [ config_file, "--dont-power-on" ] }
+      let(:cli_options) {
+        {
+          "dont-power-on"     => true,
+          "continue-on-error" => false,
+          "quiet"             => false,
+          "verbose"           => false,
+        }
+      }
+
+      it_behaves_like "a good CLI command"
+    end
+
+    context "when asked to continue on error" do
+      let(:args) { [ config_file, "--continue-on-error" ] }
+      let(:cli_options) {
+        {
+          "dont-power-on"     => false,
+          "continue-on-error" => true,
+          "quiet"             => false,
+          "verbose"           => false,
+        }
+      }
+
+      it_behaves_like "a good CLI command"
+    end
+
+    context "when asked to be quiet" do
+      let(:args) { [ config_file, "--quiet" ] }
+      let(:cli_options) {
+        {
+          "dont-power-on"     => false,
+          "continue-on-error" => false,
+          "quiet"             => true,
+          "verbose"           => false,
+        }
+      }
+
+      it_behaves_like "a good CLI command"
+    end
+
+    context "when asked to be verbose" do
+      let(:args) { [ config_file, "--verbose" ] }
+      let(:cli_options) {
+        {
+          "dont-power-on"     => false,
+          "continue-on-error" => false,
+          "quiet"             => false,
+          "verbose"           => true,
+        }
+      }
+
+      it_behaves_like "a good CLI command"
+    end
+
+    context "when asked to be verbose and continue on errors" do
+      let(:args) { [ config_file, "--continue-on-error", "--verbose" ] }
+      let(:cli_options) {
+        {
+          "dont-power-on"     => false,
+          "continue-on-error" => true,
+          "quiet"             => false,
+          "verbose"           => true,
+        }
+      }
+
+      it_behaves_like "a good CLI command"
+    end
+
+    context "when asked to display version" do
+      let(:args) { %w{--version} }
+
+      it "does not call Launch" do
+        expect(Vcloud::Launcher::Launch).not_to receive(:new)
+      end
+
+      it "prints version and exits normally" do
+        expect(subject.stdout).to eq(Vcloud::Launcher::VERSION)
+        expect(subject.exitstatus).to eq(0)
+      end
+    end
+
+    context "when asked to display help" do
+      let(:args) { %w{--help} }
+
+      it "does not call Launch" do
+        expect(Vcloud::Launcher::Launch).not_to receive(:new)
+      end
+
+      it "prints usage and exits normally" do
+        expect(subject.stderr).to match(/\AUsage: \S+ \[options\] config_file\n/)
+        expect(subject.exitstatus).to eq(0)
+      end
+    end
+  end
+
+  describe "incorrect usage" do
+    shared_examples "print usage and exit abnormally" do |error|
+      it "does not call Launch" do
+        expect(Vcloud::Launcher::Launch).not_to receive(:new)
+      end
+
+      it "prints error message and usage" do
+        expect(subject.stderr).to match(/\A\S+: #{error}\nUsage: \S+/)
+      end
+
+      it "exits abnormally for incorrect usage" do
+        expect(subject.exitstatus).to eq(2)
+      end
+    end
+
+    context "when run without any arguments" do
+      let(:args) { %w{} }
+
+      it_behaves_like "print usage and exit abnormally", "must supply config_file"
+    end
+
+    context "when given multiple config files" do
+      let(:args) { %w{one.yaml two.yaml} }
+
+      it_behaves_like "print usage and exit abnormally", "must supply config_file"
+    end
+
+    context "when given an unrecognised argument" do
+      let(:args) { %w{--this-is-garbage} }
+
+      it_behaves_like "print usage and exit abnormally", "invalid option: --this-is-garbage"
+    end
+  end
+
+  describe "error handling" do
+    context "when underlying code raises an exception" do
+      let(:args) { %w{test.yaml} }
+
+      it "should print error without backtrace and exit abnormally" do
+        expect(Vcloud::Launcher::Launch).to receive(:new).
+          and_raise("something went horribly wrong")
+        expect(subject.stderr).to eq("something went horribly wrong")
+        expect(subject.exitstatus).to eq(1)
+      end
+    end
+
+    context "when passed an non-existent configuration file" do
+      let(:args) { %w{non-existent.yaml} }
+
+      it "raises a descriptive error" do
+        expect(subject.stderr).to match("No such file or directory(?: @ rb_sysopen)? - non-existent.yaml")
+        expect(subject.exitstatus).to eq(1)
+      end
+    end
+  end
+end