clc-chef-metal-vsphere 0.3.67 → 0.3.77

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34ad1c100d44092d3dd2eca5f1f39656da3a4980
-  data.tar.gz: 4f62daeff98060413fc99a3af19151d25b503be9
+  metadata.gz: 70b737e146fc06425bc7e06afb4b0e0da717adbb
+  data.tar.gz: ef0e6156688e989f3d3d26f0cbdf0fe5dd6c6442
 SHA512:
-  metadata.gz: 115c2b68dcb87a8f8b4aa19d221be1b07fc72df46a5f332db4b5f19890558c4de6c20b631b4c0e716684270969ede47557d9a32017a45e99b4fe87fbb41c5020
-  data.tar.gz: 5537d58010da22da92967c884294c1c191f94553450e8710bb118412e768dc139a5ccafdfd8d35c9fa3b6bfd123a3e9fde172db8d7656fe555d6c225d4fb67e7
+  metadata.gz: ad9b91f224f03b815e1360aab2eeac730cf1aa1a59a425f3799efe8617a08ce476c8837c7ebbb327d391ba0ee0c42098c6f279a3cf650f0edd7420d94363d1f2
+  data.tar.gz: bb6ea68e822464035932b3b7f464b5505d190e0724dfe3d42119ee93b66a2eec784c2acbb9c08700a16a4a2b9fbf9d68deff07a108f97383eed2536bde1785f1

data/Rakefile

@@ -1,30 +1,17 @@
-require 'bundler'
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-def gem_server
-  @gem_server ||= ENV['GEM_SERVER'] || 'rubygems.org'
-end
-
-module Bundler
-  class GemHelper
-    unless gem_server == 'rubygems.org'
-      unless method_defined?(:rubygem_push)
-        raise NoMethodError, "Monkey patching Bundler::GemHelper#rubygem_push failed: did the Bundler API change???"
-      end
-
-      def rubygem_push(path)
-        print "Username: "
-        username = STDIN.gets.chomp
-        print "Password: "
-        password = STDIN.gets.chomp
+$:.unshift(File.dirname(__FILE__) + '/lib')
+require 'chef_metal_vsphere/version'
 
-        gem_server_url = "https://#{username}:#{password}@#{gem_server}/"
-        sh %{gem push #{path} --host #{gem_server_url}}
+RSpec::Core::RakeTask.new(:unit) do |task|
+  task.pattern = 'spec/unit_tests/*_spec.rb'
+  task.rspec_opts = ['--color', '-f documentation']
+end
 
-        Bundler.ui.confirm "Pushed #{name} #{version} to #{gem_server}"
-      end
+RSpec::Core::RakeTask.new(:integration) do |task|
+  task.pattern = 'spec/integration_tests/*_spec.rb'
+  task.rspec_opts = ['--color', '-f documentation']
+end
 
-      puts "Monkey patched Bundler::GemHelper#rubygem_push to push to #{gem_server}."
-    end
-  end
-end
+task :default => [:unit]

data/lib/chef_metal_vsphere/version.rb

@@ -1,3 +1,3 @@
 module ChefMetalVsphere
-  VERSION = '0.3.67'
+  VERSION = '0.3.77'
 end

data/lib/chef_metal_vsphere/vsphere_driver.rb

@@ -286,9 +286,14 @@ module ChefMetalVsphere
       vm = vm_for(machine_spec)
       if vm
         action_handler.perform_action "Delete VM [#{vm.parent.name}/#{vm.name}]" do
-          vm.PowerOffVM_Task.wait_for_completion unless vm.runtime.powerState == 'poweredOff'
-          vm.Destroy_Task.wait_for_completion
-          machine_spec.location = nil
+          begin
+            vm.PowerOffVM_Task.wait_for_completion unless vm.runtime.powerState == 'poweredOff'
+            vm.Destroy_Task.wait_for_completion
+          rescue RbVmomi::Fault => fault
+            raise fault unless fault.fault.class.wsdl_name == "ManagedObjectNotFound"
+          ensure
+            machine_spec.location = nil
+          end
         end
       end
       strategy = convergence_strategy_for(machine_spec, machine_options)
@@ -339,7 +344,7 @@ module ChefMetalVsphere
               Chef::Log.info "Ubuntu version 12.04 or greater. Need to patch DNS."
               interfaces_file = "/etc/network/interfaces"
               nameservers = bootstrap_options[:customization_spec][:ipsettings][:dnsServerList].join(' ')
-              machine.execute_always("if ! cat #{interfaces_file} | grep -q dns-search ; then echo 'dns-search #{machine_spec.name}' >> #{interfaces_file} ; fi")
+              machine.execute_always("if ! cat #{interfaces_file} | grep -q dns-search ; then echo 'dns-search #{bootstrap_options[:customization_spec][:domain]}' >> #{interfaces_file} ; fi")
               machine.execute_always("if ! cat #{interfaces_file} | grep -q dns-nameservers ; then echo 'dns-nameservers #{nameservers}' >> #{interfaces_file} ; fi")
               machine.execute_always('/etc/init.d/networking restart')
               machine.execute_always('apt-get -qq update')
@@ -489,7 +494,13 @@ module ChefMetalVsphere
       bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
       ssh_options = bootstrap_options[:ssh]
       remote_host = machine_spec.location['ipaddress'] || ip_for(bootstrap_options, vm)
-      winrm_options = {:user => "#{ssh_options[:user]}", :pass => ssh_options[:password], :basic_auth_only => true}
+
+      winrm_options = {:user => "#{ssh_options[:user]}", :pass => ssh_options[:password]}
+      if ssh_options[:user].include?("\\")
+        winrm_options[:disable_sspi] = true
+      else
+        winrm_options[:basic_auth_only] = true
+      end
 
       ChefMetal::Transport::WinRM.new("http://#{remote_host}:5985/wsman", :plaintext, winrm_options, config)
     end

data/lib/chef_metal_vsphere/vsphere_helpers.rb

@@ -106,23 +106,22 @@ module ChefMetalVsphere
     end
 
     def dc(dc_name)
-      vim.serviceInstance.find_datacenter(dc_name) or raise("vSphere Datacenter not found [#{datacenter}]")
+      vim.serviceInstance.find_datacenter(dc_name) or raise("vSphere Datacenter not found [#{dc_name}]")
     end
 
-    def network_adapter_for(operation, network_name, network_label, device_key)
-        nic_backing_info = RbVmomi::VIM::VirtualEthernetCardNetworkBackingInfo(:deviceName => network_name)
-        connectable = RbVmomi::VIM::VirtualDeviceConnectInfo(
-          :allowGuestControl => true,
-          :connected => true,
-          :startConnected => true)
-        device = RbVmomi::VIM::VirtualVmxnet3(
-          :backing => nic_backing_info,
-          :deviceInfo => RbVmomi::VIM::Description(:label => network_label, :summary => network_name),
-          :key => device_key,
-          :connectable => connectable)
-        RbVmomi::VIM::VirtualDeviceConfigSpec(
-          :operation => operation,
-          :device => device)
+    def network_adapter_for(operation, network_name, network_label, device_key, backing_info)
+      connectable = RbVmomi::VIM::VirtualDeviceConnectInfo(
+        :allowGuestControl => true,
+        :connected => true,
+        :startConnected => true)
+      device = RbVmomi::VIM::VirtualVmxnet3(
+        :backing => backing_info,
+        :deviceInfo => RbVmomi::VIM::Description(:label => network_label, :summary => network_name),
+        :key => device_key,
+        :connectable => connectable)
+      RbVmomi::VIM::VirtualDeviceConfigSpec(
+        :operation => operation,
+        :device => device)
     end
 
     def find_ethernet_cards_for(vm)
@@ -182,8 +181,8 @@ module ChefMetalVsphere
       deviceAdditions, changes = network_device_changes(action_handler, vm_template, options)
 
       if deviceAdditions.count > 0
-        current_networks = find_ethernet_cards_for(vm).map{|card| card.backing.deviceName}
-        new_devices = deviceAdditions.select { |device| !current_networks.include?(device.device.backing.deviceName)}
+        current_networks = find_ethernet_cards_for(vm).map{|card| network_id_for(card.backing)}
+        new_devices = deviceAdditions.select { |device| !current_networks.include?(network_id_for(device.device.backing))}
         
         if new_devices.count > 0
           action_handler.report_progress "Adding extra NICs"
@@ -194,6 +193,14 @@ module ChefMetalVsphere
       end
     end
 
+    def network_id_for(backing_info)
+      if backing_info.is_a?(RbVmomi::VIM::VirtualEthernetCardDistributedVirtualPortBackingInfo)
+        backing_info.port.portgroupKey
+      else
+        backing_info.network
+      end
+    end
+
     def relocate_spec_for(dc_name, vm_template, options)
       datacenter = dc(dc_name)
       if options.has_key?(:host)
@@ -276,23 +283,42 @@ module ChefMetalVsphere
       key = 4000
       networks.each_index do | i |
         label = "Ethernet #{i+1}"
+        backing_info = backing_info_for(action_handler, dc(options[:datacenter]), networks[i])
         if card = cards.shift
           key = card.key
           operation = RbVmomi::VIM::VirtualDeviceConfigSpecOperation('edit')
           action_handler.report_progress "changing template nic for #{networks[i]}"
           changes.push(
-            network_adapter_for(operation, networks[i], label, key))
+            network_adapter_for(operation, networks[i], label, key, backing_info))
         else
           key = key + 1
           operation = RbVmomi::VIM::VirtualDeviceConfigSpecOperation('add')
           action_handler.report_progress "will be adding nic for #{networks[i]}"
           additions.push(
-            network_adapter_for(operation, networks[i], label, key))
+            network_adapter_for(operation, networks[i], label, key, backing_info))
         end
       end
       [additions, changes]
     end
 
+    def backing_info_for(action_handler, datacenter, network_name)
+      networks = datacenter.network.select {|net| net.name == network_name}
+      if networks.count > 0
+        dpg = networks.select { |net| net.is_a?(RbVmomi::VIM::DistributedVirtualPortgroup) }
+        networks = dpg unless dpg.empty?
+      end
+      action_handler.report_progress "network: #{network_name} is a #{networks[0].class}}"
+      if networks[0].is_a?(RbVmomi::VIM::DistributedVirtualPortgroup)
+        port = RbVmomi::VIM::DistributedVirtualSwitchPortConnection(
+          :switchUuid => networks[0].config.distributedVirtualSwitch.uuid,
+          :portgroupKey => networks[0].key
+        )
+        RbVmomi::VIM::VirtualEthernetCardDistributedVirtualPortBackingInfo(:port => port)
+      else
+        RbVmomi::VIM::VirtualEthernetCardNetworkBackingInfo(:deviceName => network_name)
+      end
+    end
+
     def find_datastore(dc, datastore_name)
         baseEntity = dc.datastore
         baseEntity.find { |f| f.info.name == datastore_name } or raise "no such datastore #{datastore_name}"    

data/lib/kitchen/driver/vsphere.rb

@@ -37,7 +37,7 @@ module Kitchen
           state[:vsphere_name] = config[:server_name]
         end
 
-        node_dir = File.join(instance.busser[:test_base_path], "nodes")
+        node_dir = File.join(instance.verifier[:test_base_path], "nodes")
         Dir.mkdir(node_dir) unless Dir.exist?(node_dir)
         node_file = File.join(node_dir, "#{instance.suite.name}.json")
         node = {
@@ -65,7 +65,7 @@ module Kitchen
         state.delete(:hostname)
         state.delete(:vsphere_name)
 
-        node_file = File.join(instance.busser[:test_base_path], "nodes/#{instance.suite.name}.json")
+        node_file = File.join(instance.verifier[:test_base_path], "nodes/#{instance.suite.name}.json")
         File.delete(node_file) if File.exist?(node_file)
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clc-chef-metal-vsphere
 version: !ruby/object:Gem::Version
-  version: 0.3.67
+  version: 0.3.77
 platform: ruby
 authors:
 - CenturyLink Cloud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-14 00:00:00.000000000 Z
+date: 2015-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbvmomi
@@ -36,28 +36,34 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.14.alpha.8
+        version: 0.14.alpha.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.14.alpha.8
+        version: 0.14.alpha.10
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.6
+        version: 1.1.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.6
+        version: 1.1.7
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -102,11 +108,6 @@ files:
 - lib/chef_metal_vsphere/vsphere_helpers.rb
 - lib/chef_metal_vsphere/vsphere_url.rb
 - lib/kitchen/driver/vsphere.rb
-- spec/integration_tests/.gitignore
-- spec/integration_tests/config.rb
-- spec/integration_tests/vsphere_driver_spec.rb
-- spec/unit_tests/VsphereDriver_spec.rb
-- spec/unit_tests/VsphereUrl_spec.rb
 homepage: https://github.com/RallySoftware-cookbooks/chef-metal-vsphere
 licenses:
 - MIT

data/spec/integration_tests/.gitignore

@@ -1 +0,0 @@
-config.rb

data/spec/integration_tests/vsphere_driver_spec.rb

@@ -1,148 +0,0 @@
-require 'chef_metal_vsphere/vsphere_driver'
-require 'chef_metal/chef_machine_spec'
-
-	# A file named config.rb in the same directory as this spec file 
-	# must exist containing the driver options to use for the test.
-	# Here is an example:
-	# {
-	#   :driver_options => { 
-	#   	:host => '213.45.67.88',
-	#   	:user => 'vmapi',
-	#   	:password => 'SuperSecureP@ssw0rd',
-	#   	:insecure => true
-	#   },
-	#   :machine_options => { 
-	# 		:start_timeout => 600, 
- #            :create_timeout => 600, 	  	
- #            :bootstrap_options => {
-	#   		:datacenter => 'QA1',
-	#   		:template_name => 'UBUNTU-12-64-TEMPLATE',
-	#   		:vm_folder => 'DLAB',
-	#   		:num_cpus => 2,
-	#   		:network_name => 'vlan152_172.21.152',
-	#   		:memory_mb => 4096,
-	#   		:resource_pool => 'CLSTR02/DLAB',
-	# 	  	:ssh => {
-	# 	  		:user => 'root',
-	# 	  		:password => 'SuperSecureP@ssw0rd',
-	# 	  		:paranoid => false,
-	# 	  		:port => 22
-	# 	  	},
-	# 	  	:convergence_options => {}
-	#   	}
-	#   }
-	# }
-
-describe "vsphere_driver" do
-    include ChefMetalVsphere::Helpers
-
-	before :all do
-		@vm_name = "cmvd-test-#{SecureRandom.hex}"
-		@metal_config = eval File.read(File.expand_path('../config.rb', __FILE__))
-		Cheffish.honor_local_mode do
-			chef_server = Cheffish.default_chef_server(Cheffish.profiled_config)
-			puts "chef server:#{chef_server}"
-			@machine_spec = ChefMetal::ChefMachineSpec.new({'name' => @vm_name}, chef_server)
-			@driver = ChefMetal.driver_for_url("vsphere://#{@metal_config[:driver_options][:host]}", @metal_config)
-			action_handler = ChefMetal::ActionHandler.new
-			@driver.allocate_machine(action_handler, @machine_spec, @metal_config[:machine_options])
-			@metal_config[:machine_options][:convergence_options] = {:chef_server => chef_server}
-			machine = @driver.ready_machine(action_handler, @machine_spec, @metal_config[:machine_options])
-			@server_id = @machine_spec.location['server_id']
-			@connection = vim(@metal_config[:driver_options])
-			@vm = find_vm_by_id(@server_id, @connection)
-		end
-	end
-
-
-    context 'when allocating a machine' do
-
-		it "adds machine to the correct folder" do
-			expect(@vm.parent.name).to eq(@metal_config[:machine_options][:bootstrap_options][:vm_folder])
-		end
-		it "has a matching id with the machine_spec" do
-			expect(@vm.config.instanceUuid).to eq(@machine_spec.location['server_id'])
-		end
-		it "has the correct name" do
-	      	now = Time.now.utc
-	      	trimmed_name = @vm.config.guestId.start_with?('win') ? @vm_name.byteslice(0,15) : @vm_name
-	      	expected_name="#{trimmed_name}.#{@metal_config[:machine_options][:bootstrap_options][:customization_spec][:domain]}"
-	        until (Time.now.utc - now) > 30 || (@vm.guest.hostName == expected_name) do
-	          print "."
-	          sleep 5
-	        end
-			expect(@vm.guest.hostName).to eq(expected_name)
-		end
-		it "has the correct number of CPUs" do
-			expect(@vm.config.hardware.numCPU).to eq(@metal_config[:machine_options][:bootstrap_options][:num_cpus])
-		end
-		it "has the correct amount of memory" do
-			expect(@vm.config.hardware.memoryMB).to eq(@metal_config[:machine_options][:bootstrap_options][:memory_mb])
-		end
-		it "is on the correct networks" do
-			expect(@vm.network.map {|n| n.name}).to include(@metal_config[:machine_options][:bootstrap_options][:network_name][0])
-			expect(@vm.network.map {|n| n.name}).to include(@metal_config[:machine_options][:bootstrap_options][:network_name][1])
-		end
-		it "is on the correct datastore" do
-			expect(@vm.datastore[0].name).to eq(@metal_config[:machine_options][:bootstrap_options][:datastore])
-		end
-		it "is in the correct resource pool" do
-			if @metal_config[:machine_options][:bootstrap_options].has_key?(:resource_pool)
-				expect(@vm.resourcePool.name).to eq(@metal_config[:machine_options][:bootstrap_options][:resource_pool].split('/')[1])
-			end
-		end
-		it "is in the correct host" do
-			if @metal_config[:machine_options][:bootstrap_options].has_key?(:host)
-				expect(@vm.runtime.host.name).to eq(@metal_config[:machine_options][:bootstrap_options][:host].split('/')[1])
-			end
-		end
-		it "is in the correct cluster" do
-			if @metal_config[:machine_options][:bootstrap_options].has_key?(:resource_pool)
-				expect(@vm.resourcePool.owner.name).to eq(@metal_config[:machine_options][:bootstrap_options][:resource_pool].split('/')[0])
-			end
-		end
-		it "is in the correct datacenter" do
-			expect(@connection.serviceInstance.find_datacenter(@metal_config[:machine_options][:bootstrap_options][:datacenter]).find_vm("#{@vm.parent.name}/#{@vm_name}")).not_to eq(nil)
-		end
-		it "has an added disk of the correct size" do
-			disk_count = @vm.disks.count
-			expect(@vm.disks[disk_count-1].capacityInKB).to eq(@metal_config[:machine_options][:bootstrap_options][:additional_disk_size_gb] * 1024 * 1024)
-		end
-		it "has hot add cpu enabled" do
-			expect(@vm.config.cpuHotAddEnabled).to eq(true)
-		end
-		it "has hot remove cpu enabled" do
-			expect(@vm.config.cpuHotRemoveEnabled).to eq(true)
-		end
-		it "has hot add memory enabled" do
-			expect(@vm.config.memoryHotAddEnabled).to eq(true)
-		end		
-		it "has the correct IP address" do
-	      if @vm.guest.toolsRunningStatus != "guestToolsRunning"
-	      	now = Time.now.utc
-	        until (Time.now.utc - now) > 30 || (@vm.guest.toolsRunningStatus == "guestToolsRunning" && @vm.guest.net.count == 2 && @vm.guest.net[1].ipAddress[1] == @metal_config[:machine_options][:bootstrap_options][:customization_spec][:ipsettings][:ip]) do
-	          print "."
-	          sleep 5
-	        end
-	      end
-			expect(@vm.guest.net.map { |net| net.ipAddress}.flatten).to include(@metal_config[:machine_options][:bootstrap_options][:customization_spec][:ipsettings][:ip])
-		end
-    end
-
-	context "destroy_machine" do
-
-		it "removes the machine" do
-			Cheffish.honor_local_mode do
-				chef_server = Cheffish.default_chef_server(Cheffish.profiled_config)
-				driver = ChefMetal.driver_for_url("vsphere://#{@metal_config[:driver_options][:host]}", @metal_config)
-				action_handler = ChefMetal::ActionHandler.new
-				machine_spec = ChefMetal::ChefMachineSpec.new({'name' => @vm_name}, chef_server)
-				machine_spec.location = { 'driver_url' => driver.driver_url,
-										  'server_id' => @server_id}
-				driver.destroy_machine(action_handler, machine_spec, @metal_config[:machine_options])
-			end
-			vm = find_vm_by_id(@server_id, @connection)
-			expect(vm).to eq(nil)
-		end
-	end
-end

data/spec/unit_tests/VsphereDriver_spec.rb

@@ -1,206 +0,0 @@
-require 'chef_metal_vsphere/vsphere_driver'
-
-describe "canonicalize_url" do
-
-	context "when config does not include the properties included in the url" do
-		metal_config = {
-		  :driver_options => { 
-		  	:user => 'vmapi',
-		  	:password => '<password>'
-		  },
-		  :machine_options => { 
-		  	:ssh => {
-		  		:password => '<password>',
-		  		:paranoid => false
-		  	},
-		  	:bootstrap_options => {
-		  		:datacenter => 'QA1',
-		  		:template_name => 'UBUNTU-12-64-TEMPLATE',
-		  		:vm_folder => 'DLAB',
-		  		:num_cpus => 2,
-		  		:memory_mb => 4096,
-		  		:resource_pool => 'CLSTR02/DLAB'
-		  	}
-		  },
-		  :log_level => :debug
-		}
-
-		let(:results) {
-			ChefMetalVsphere::VsphereDriver.canonicalize_url('vsphere://3.3.3.3:999/crazyapi?use_ssl=false&insecure=true', metal_config)
-		}
-
-		it "populates the config with correct host from the driver url" do
-			expect(results[1][:driver_options][:connect_options][:host]).to eq('3.3.3.3')
-		end
-		it "populates the config with correct port from the driver url" do
-			expect(results[1][:driver_options][:connect_options][:port]).to eq(999)
-		end
-		it "populates the config with correct path from the driver url" do
-			expect(results[1][:driver_options][:connect_options][:path]).to eq('/crazyapi')
-		end
-		it "populates the config with correct use_ssl setting from the driver url" do
-			expect(results[1][:driver_options][:connect_options][:use_ssl]).to eq(false)
-		end
-		it "populates the config with correct insecure setting from the driver url" do
-			expect(results[1][:driver_options][:connect_options][:insecure]).to eq(true)
-		end
-	end
-
-	context "when config keys are stringified" do
-		metal_config = {
-		  'driver_options' => { 
-		  	'user' => 'vmapi',
-		  	'password' => '<password>'
-		  },
-		  'machine_options' => { 
-		  	'ssh' => {
-		  		'password' => '<password>'
-		  	},
-		  	'bootstrap_options' => {
-		  		'datacenter' => 'QA1'
-		  	}
-		  }
-		 }
-
-		let(:results) {
-			ChefMetalVsphere::VsphereDriver.canonicalize_url('vsphere://3.3.3.3:999/crazyapi?use_ssl=false&insecure=true', metal_config)
-		}
-
-		it "will symbolize user" do
-			expect(results[1][:driver_options][:connect_options][:user]).to eq('vmapi')
-		end
-		it "will symbolize password" do
-			expect(results[1][:driver_options][:connect_options][:password]).to eq('<password>')
-		end
-		it "will symbolize ssh password" do
-			expect(results[1][:machine_options][:ssh][:password]).to eq('<password>')
-		end
-		it "will symbolize ssh bootstrap options" do
-			expect(results[1][:machine_options][:bootstrap_options][:datacenter]).to eq('QA1')
-		end
-	end
-
-	context "when no url is in the config" do
-		metal_config = {
-		  :driver_options => { 
-		  	:user => 'vmapi',
-		  	:password => '<password>',
-		  	:host => '4.4.4.4',
-		  	:port => 888,
-		  	:path => '/yoda',
-		  	:use_ssl => 'false',
-		  	:insecure => 'true'
-		  },
-		  :machine_options => { 
-		  	:ssh => {
-		  		:password => '<password>',
-		  		:paranoid => false
-		  	},
-		  	:bootstrap_options => {
-		  		:datacenter => 'QA1',
-		  		:template_name => 'UBUNTU-12-64-TEMPLATE',
-		  		:vm_folder => 'DLAB',
-		  		:num_cpus => 2,
-		  		:memory_mb => 4096,
-		  		:resource_pool => 'CLSTR02/DLAB'
-		  	}
-		  },
-		  :log_level => :debug
-		}
-
-		let(:results) {
-			ChefMetalVsphere::VsphereDriver.canonicalize_url(nil, metal_config)
-		}
-
-		it "creates the correct driver url from config settings" do
-			expect(results[0]).to eq('vsphere://4.4.4.4:888/yoda?use_ssl=false&insecure=true')
-		end
-	end
-
-	context "when no url is in the config and config is missing defaulted values" do
-		metal_config = {
-		  :driver_options => { 
-		  	:user => 'vmapi',
-		  	:password => '<password>',
-		  	:host => '4.4.4.4'
-		  },
-		  :machine_options => { 
-		  	:bootstrap_options => {
-		  		:datacenter => 'QA1',
-		  		:template_name => 'UBUNTU-12-64-TEMPLATE',
-		  		:vm_folder => 'DLAB',
-		  		:num_cpus => 2,
-		  		:memory_mb => 4096,
-		  		:resource_pool => 'CLSTR02/DLAB',
-			  	:ssh => {
-			  		:password => '<password>',
-			  		:paranoid => false
-			  	}
-		  	}
-		  },
-		  :log_level => :debug
-		}
-
-		let(:results) {
-			ChefMetalVsphere::VsphereDriver.canonicalize_url(nil, metal_config)
-		}
-
-		it "creates the correct driver url from default settings" do
-			expect(results[0]).to eq('vsphere://4.4.4.4/sdk?use_ssl=true&insecure=false')
-		end
-		it "populates the config with correct port from default settings" do
-			expect(results[1][:driver_options][:connect_options][:port]).to eq(443)
-		end
-		it "populates the config with correct path from default settings" do
-			expect(results[1][:driver_options][:connect_options][:path]).to eq('/sdk')
-		end
-		it "populates the config with correct use_ssl setting from default settings" do
-			expect(results[1][:driver_options][:connect_options][:use_ssl]).to eq(true)
-		end
-		it "populates the config with correct insecure setting from default settings" do
-			expect(results[1][:driver_options][:connect_options][:insecure]).to eq(false)
-		end
-		it "populates the config with correct ssh port from default settings" do
-			expect(results[1][:machine_options][:bootstrap_options][:ssh][:port]).to eq(22)
-		end
-	end
-
-	context "when missing host" do
-		metal_config = {
-		  :driver_options => { 
-		  	:user => 'vmapi',
-		  	:password => '<password>',
-		  }
-		}
-
-		it "should raise an error" do
-			expect{ChefMetalVsphere::VsphereDriver.canonicalize_url(nil,metal_config)}.to raise_error(RuntimeError)
-		end
-	end
-
-	context "when missing user" do
-		metal_config = {
-		  :driver_options => { 
-		  	:host => 'host',
-		  	:password => '<password>',
-		  }
-		}
-
-		it "should raise an error" do
-			expect{ChefMetalVsphere::VsphereDriver.canonicalize_url(nil,metal_config)}.to raise_error(RuntimeError)
-		end
-	end
-
-	context "when missing password" do
-		metal_config = {
-		  :driver_options => { 
-		  	:host => 'host',
-		  	:user => 'user',
-		  }
-		}
-
-		it "should raise an error" do
-			expect{ChefMetalVsphere::VsphereDriver.canonicalize_url(nil,metal_config)}.to raise_error(RuntimeError)
-		end
-	end	
-end

data/spec/unit_tests/VsphereUrl_spec.rb

@@ -1,60 +0,0 @@
-require_relative '../../lib/chef_metal_vsphere/vsphere_url.rb'
-
-describe 'VsphereUrl' do
-	expected_host='1.1.1.1'
-	expected_port=1818
-	expected_path='/path'
-
-	let(:url) {URI("vsphere://#{expected_host}:#{expected_port}#{expected_path}")}
-
-	it "has the vsphere scheme" do
-		expect(url.scheme).to eq('vsphere')
-	end
-	it "has the expected host" do
-		expect(url.host).to eq(expected_host)
-	end
-	it "has the expected port" do
-		expect(url.port).to eq(expected_port)
-	end
-	it "has the expected path" do
-		expect(url.path).to eq(expected_path)
-	end
-	it "has the the default ssl setting" do
-		expect(url.use_ssl).to eq(true)
-	end
-	it "has the the default insecure setting" do
-		expect(url.insecure).to eq(false)
-	end
-
-	context "when setting from a hash" do
-		let(:url) {URI::VsphereUrl.from_config({:host => '2.2.2.2', :port => 2345, :path => "/hoooo", :use_ssl => false, :insecure => true})}
-
-		it "asigns the correct url" do
-			expect(url.to_s).to eq('vsphere://2.2.2.2:2345/hoooo?use_ssl=false&insecure=true')
-		end
-	end
-	context "when ssl is enabled" do
-		it "retuns an ssl value of true" do
-			url = URI("vsphere://#{expected_host}:#{expected_port}#{expected_path}?use_ssl=true")
-			expect(url.use_ssl).to eq(true)
-		end
-	end
-	context "when ssl is disabled" do
-		it "retuns an ssl value of true" do
-			url = URI("vsphere://#{expected_host}:#{expected_port}#{expected_path}?use_ssl=false")
-			expect(url.use_ssl).to eq(false)
-		end
-	end
-	context "when insecure is enabled" do
-		it "retuns an insecure value of true" do
-			url = URI("vsphere://#{expected_host}:#{expected_port}#{expected_path}?insecure=true")
-			expect(url.insecure).to eq(true)
-		end
-	end
-	context "when insecure is disabled" do
-		it "retuns an insecure value of true" do
-			url = URI("vsphere://#{expected_host}:#{expected_port}#{expected_path}?insecure=false")
-			expect(url.insecure).to eq(false)
-		end
-	end
-end