vcloud-core 1.0.0 → 1.0.1

data/spec/vcloud/core/vapp_template_spec.rb

@@ -1,92 +1,88 @@
 require 'spec_helper'
 
-module Vcloud
-  module Core
-    describe VappTemplate do
-
-      before(:each) do
-        @id = 'vappTemplate-12345678-1234-1234-1234-000000234121'
-        @mock_fog_interface = StubFogInterface.new
-        allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
-      end
-
-      context "Class public interface" do
-        it { expect(VappTemplate).to respond_to(:get) }
-      end
-
-      context "Instance public interface" do
-        subject { VappTemplate.new(@id) }
-        it { should respond_to(:id) }
-        it { should respond_to(:vcloud_attributes) }
-        it { should respond_to(:name) }
-        it { should respond_to(:href) }
-      end
-
-      context "#initialize" do
-
-        it "should be constructable from just an id reference" do
-          obj = VappTemplate.new(@id)
-          expect(obj.class).to be(Vcloud::Core::VappTemplate)
-        end
-
-        it "should store the id specified" do
-          obj = VappTemplate.new(@id)
-          expect(obj.id).to eq(@id)
-        end
-
-        it "should raise error if id is not in correct format" do
-          bogus_id = '12314124-ede5-4d07-bad5-000000111111'
-          expect{ VappTemplate.new(bogus_id) }.to raise_error("vappTemplate id : #{bogus_id} is not in correct format" )
-        end
-
-      end
-
-
-      context '#get' do
-
-        it 'should raise a RuntimeError if there is no template' do
-          q_results = [ ]
-          mock_query = double(:query_runner)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).
-            with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
-            and_return(q_results)
-          expect { VappTemplate.get('test_template', 'test_catalog') }.
-            to raise_error('Could not find template vApp')
-        end
-
-        it 'should raise an error if more than one template is returned' do
-          q_results = [
-            { :name => 'test_template',
-              :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890ab001" },
-            { :name => 'test_template',
-              :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890ab002" },
-          ]
-          mock_query = double(:query_runner)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).
-            with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
-            and_return(q_results)
-          expect { VappTemplate.get('test_template', 'test_catalog') }.
-            to raise_error('Template test_template is not unique in catalog test_catalog')
-        end
-
-        it 'should return a valid template object if it exists' do
-          q_results = [
-            { :name => 'test_template',
-              :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890abcde" }
-          ]
-          mock_query = double(:query)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).
-            with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
-            and_return(q_results)
-          test_template = VappTemplate.get('test_template', 'test_catalog')
-          expect(test_template.id).to eq('vappTemplate-12345678-90ab-cdef-0123-4567890abcde')
-        end
-
-      end
+describe Vcloud::Core::VappTemplate do
 
+  before(:each) do
+    @id = 'vappTemplate-12345678-1234-1234-1234-000000234121'
+    @mock_fog_interface = StubFogInterface.new
+    allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
+  end
+
+  context "Class public interface" do
+    it { expect(Vcloud::Core::VappTemplate).to respond_to(:get) }
+  end
+
+  context "Instance public interface" do
+    subject { Vcloud::Core::VappTemplate.new(@id) }
+    it { should respond_to(:id) }
+    it { should respond_to(:vcloud_attributes) }
+    it { should respond_to(:name) }
+    it { should respond_to(:href) }
+  end
+
+  context "#initialize" do
+
+    it "should be constructable from just an id reference" do
+      obj = Vcloud::Core::VappTemplate.new(@id)
+      expect(obj.class).to be(Vcloud::Core::VappTemplate)
+    end
+
+    it "should store the id specified" do
+      obj = Vcloud::Core::VappTemplate.new(@id)
+      expect(obj.id).to eq(@id)
     end
+
+    it "should raise error if id is not in correct format" do
+      bogus_id = '12314124-ede5-4d07-bad5-000000111111'
+      expect{ Vcloud::Core::VappTemplate.new(bogus_id) }.to raise_error("vappTemplate id : #{bogus_id} is not in correct format" )
+    end
+
   end
+
+
+  context '#get' do
+
+    it 'should raise a RuntimeError if there is no template' do
+      q_results = [ ]
+      mock_query = double(:query_runner)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).
+        with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
+        and_return(q_results)
+      expect { Vcloud::Core::VappTemplate.get('test_template', 'test_catalog') }.
+        to raise_error('Could not find template vApp')
+    end
+
+    it 'should raise an error if more than one template is returned' do
+      q_results = [
+        { :name => 'test_template',
+          :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890ab001" },
+          { :name => 'test_template',
+            :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890ab002" },
+      ]
+      mock_query = double(:query_runner)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).
+        with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
+        and_return(q_results)
+      expect { Vcloud::Core::VappTemplate.get('test_template', 'test_catalog') }.
+        to raise_error('Template test_template is not unique in catalog test_catalog')
+    end
+
+    it 'should return a valid template object if it exists' do
+      q_results = [
+        { :name => 'test_template',
+          :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890abcde" }
+      ]
+      mock_query = double(:query)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).
+        with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
+        and_return(q_results)
+      test_template = Vcloud::Core::VappTemplate.get('test_template', 'test_catalog')
+      expect(test_template.id).to eq('vappTemplate-12345678-90ab-cdef-0123-4567890abcde')
+    end
+
+  end
+
 end

data/spec/vcloud/core/vdc_spec.rb

@@ -1,68 +1,62 @@
 require 'spec_helper'
 
-module Vcloud
-  module Core
-    describe Vdc do
+describe Vcloud::Core::Vdc do
 
-      before(:each) do
-        @vdc_id = '12345678-1234-1234-1234-000000111232'
-        @mock_fog_interface = StubFogInterface.new
-        allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
-      end
-
-      context "Class public interface" do
-        it { expect(Vdc).to respond_to(:get_by_name) }
-      end
-
-      context "Instance public interface" do
-        subject { Vdc.new(@vdc_id) }
-        it { should respond_to(:id) }
-        it { should respond_to(:name) }
-        it { should respond_to(:href) }
-      end
-
-      context "#initialize" do
+  before(:each) do
+    @vdc_id = '12345678-1234-1234-1234-000000111232'
+    @mock_fog_interface = StubFogInterface.new
+    allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
+  end
 
-        it "should be constructable from just an id reference" do
-          obj = Vdc.new(@vdc_id)
-          expect(obj.class).to be(Vcloud::Core::Vdc)
-        end
+  context "Class public interface" do
+    it { expect(Vcloud::Core::Vdc).to respond_to(:get_by_name) }
+  end
 
-        it "should store the id specified" do
-          obj = Vdc.new(@vdc_id)
-          expect(obj.id).to eq(@vdc_id)
-        end
+  context "Instance public interface" do
+    subject { Vcloud::Core::Vdc.new(@vdc_id) }
+    it { should respond_to(:id) }
+    it { should respond_to(:name) }
+    it { should respond_to(:href) }
+  end
 
-        it "should raise error if id is not in correct format" do
-          bogus_id = '123123-bogus-id-123445'
-          expect{ Vdc.new(bogus_id) }.to raise_error("vdc id : #{bogus_id} is not in correct format" )
-        end
+  context "#initialize" do
 
-      end
+    it "should be constructable from just an id reference" do
+      obj = Vcloud::Core::Vdc.new(@vdc_id)
+      expect(obj.class).to be(Vcloud::Core::Vdc)
+    end
 
-      context "#get_by_name" do
+    it "should store the id specified" do
+      obj = Vcloud::Core::Vdc.new(@vdc_id)
+      expect(obj.id).to eq(@vdc_id)
+    end
 
-        it "should return a Vdc object if name exists" do
-          q_results = [
-            { :name => 'vdc-test-1', :href => @vdc_id }
-          ]
-          mock_query = double(:query_runner)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).with('orgVdc', :filter => "name==vdc-test-1").and_return(q_results)
-          obj = Vdc.get_by_name('vdc-test-1')
-          expect(obj.class).to be(Vcloud::Core::Vdc)
-        end
+    it "should raise error if id is not in correct format" do
+      bogus_id = '123123-bogus-id-123445'
+      expect{ Vcloud::Core::Vdc.new(bogus_id) }.to raise_error("vdc id : #{bogus_id} is not in correct format" )
+    end
 
-        it "should raise an error if no vDC with that name exists" do
-          q_results = [ ]
-          mock_query = double(:query_runner)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).with('orgVdc', :filter => "name==vdc-test-1").and_return(q_results)
-          expect{ Vdc.get_by_name('vdc-test-1') }.to raise_exception(RuntimeError, "vDc vdc-test-1 not found")
-        end
+  end
 
-      end
+  context "#get_by_name" do
+
+    it "should return a Vcloud::Core::Vdc object if name exists" do
+      q_results = [
+        { :name => 'vdc-test-1', :href => @vdc_id }
+      ]
+      mock_query = double(:query_runner)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with('orgVdc', :filter => "name==vdc-test-1").and_return(q_results)
+      obj = Vcloud::Core::Vdc.get_by_name('vdc-test-1')
+      expect(obj.class).to be(Vcloud::Core::Vdc)
+    end
 
+    it "should raise an error if no vDC with that name exists" do
+      q_results = [ ]
+      mock_query = double(:query_runner)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with('orgVdc', :filter => "name==vdc-test-1").and_return(q_results)
+      expect{ Vcloud::Core::Vdc.get_by_name('vdc-test-1') }.to raise_exception(RuntimeError, "vDc vdc-test-1 not found")
     end
 
   end

data/spec/vcloud/core/vm_spec.rb

@@ -1,377 +1,373 @@
 require 'spec_helper'
 
-module Vcloud
-  module Core
-    describe Vm do
-
-      before(:each) do
-        @vm_id = 'vm-1234'
-        @vapp_id = 'vapp-4321'
-        @vapp_name = 'test-vapp-1'
-        @vm_name = 'test-vm-1'
-        @data_dir = File.join(File.dirname(__FILE__), "/data")
-        @mock_vm_memory_size = 1024
-        @mock_metadata = {
-            :foo => "bar",
-            :false_thing => false,
-            :true_thing => true,
-            :number => 53,
-            :zero => 0,
-        }
-        @mock_vm_cpu_count = 1
-        @fog_interface = StubFogInterface.new
-        @mock_vapp = double(:vappm, :name => @vapp_name, :id => @vapp_id)
-        allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@fog_interface)
-        allow(@fog_interface).to receive(:get_vapp).with(@vm_id).and_return({
-            :name => "#{@vm_name}",
-            :href => "vm-href/#{@vm_id}",
-            :'ovf:VirtualHardwareSection' => {
-                :'ovf:Item' => [
-                    {
-                        :'rasd:ResourceType' => '4',
-                        :'rasd:VirtualQuantity' => "#{@mock_vm_memory_size}",
-                    },
-                    {
-                        :'rasd:ResourceType' => '3',
-                        :'rasd:VirtualQuantity' => "#{@mock_vm_cpu_count}",
-                    }
-                ]
-            }
-        })
-        @vm =  Vm.new(@vm_id, @mock_vapp)
-      end
-
-      context "Class public interface" do
-      end
-
-      context "Instance public interface" do
-        subject { Vm.new(@vm_id, @mock_vapp) }
-        it { should respond_to(:id) }
-        it { should respond_to(:vcloud_attributes) }
-        it { should respond_to(:name) }
-        it { should respond_to(:href) }
-        it { should respond_to(:vapp_name) }
-        it { should respond_to(:update_name) }
-        it { should respond_to(:update_cpu_count) }
-        it { should respond_to(:update_metadata) }
-        it { should respond_to(:update_storage_profile) }
-        it { should respond_to(:add_extra_disks) }
-        it { should respond_to(:attach_independent_disks) }
-        it { should respond_to(:detach_independent_disks) }
-        it { should respond_to(:configure_network_interfaces) }
-        it { should respond_to(:configure_guest_customization_section) }
-      end
-
-      context "#initialize" do
-
-        it "should be constructable from just an id reference & Vapp object" do
-          obj = Vm.new(@vm_id, @mock_vapp)
-          expect(obj.class).to be(Vcloud::Core::Vm)
-        end
-
-        it "should store the id specified" do
-          obj = Vm.new(@vm_id, @mock_vapp)
-          expect(obj.id).to eq(@vm_id)
-        end
-
-        it "should raise error if id is not in correct format" do
-          bogus_id = '12314124-ede5-4d07-bad5-000000111111'
-          expect{ Vm.new(bogus_id, @mock_vapp) }.to raise_error("vm id : #{bogus_id} is not in correct format" )
-        end
-
-      end
-
-      context "update memory in VM" do
-        it "should not allow memory size < 64MB" do
-          expect(@fog_interface).not_to receive(:put_memory)
-          @vm.update_memory_size_in_mb(63)
-        end
-        it "should not update memory if is size has not changed" do
-          expect(@fog_interface).not_to receive(:put_memory)
-          @vm.update_memory_size_in_mb(@mock_vm_memory_size)
-        end
-        it "should gracefully handle a nil memory size" do
-          expect(@fog_interface).not_to receive(:put_memory)
-          @vm.update_memory_size_in_mb(nil)
-        end
-        it "should set memory size 64MB" do
-          expect(@fog_interface).to receive(:put_memory).with(@vm_id, 64)
-          @vm.update_memory_size_in_mb(64)
-        end
-        it "should set memory size 4096MB" do
-          expect(@fog_interface).to receive(:put_memory).with(@vm_id, 4096)
-          @vm.update_memory_size_in_mb(4096)
-        end
-      end
-
-      context "update the number of cpus in vm" do
-        it "should gracefully handle nil cpu count" do
-          expect(@fog_interface).not_to receive(:put_cpu)
-          @vm.update_cpu_count(nil)
-        end
-        it "should not update cpu if is count has not changed" do
-          expect(@fog_interface).not_to receive(:put_cpu)
-          @vm.update_cpu_count(@mock_vm_cpu_count)
-        end
-        it "should not allow a zero cpu count" do
-          expect(@fog_interface).not_to receive(:put_cpu)
-          @vm.update_cpu_count(0)
-        end
-        it "should update cpu count in input is ok" do
-          expect(@fog_interface).to receive(:put_cpu).with(@vm_id, 2)
-          @vm.update_cpu_count(2)
-        end
-      end
-
-      context '#configure_guest_customization_section' do
-        let(:preamble) do
-          <<-'EOF'
+describe Vcloud::Core::Vm do
+
+  before(:each) do
+    @vm_id = 'vm-1234'
+    @vapp_id = 'vapp-4321'
+    @vapp_name = 'test-vapp-1'
+    @vm_name = 'test-vm-1'
+    @data_dir = File.join(File.dirname(__FILE__), "/data")
+    @mock_vm_memory_size = 1024
+    @mock_metadata = {
+      :foo => "bar",
+      :false_thing => false,
+      :true_thing => true,
+      :number => 53,
+      :zero => 0,
+    }
+    @mock_vm_cpu_count = 1
+    @fog_interface = StubFogInterface.new
+    @mock_vapp = double(:vappm, :name => @vapp_name, :id => @vapp_id)
+    allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@fog_interface)
+    allow(@fog_interface).to receive(:get_vapp).with(@vm_id).and_return({
+      :name => "#{@vm_name}",
+      :href => "vm-href/#{@vm_id}",
+      :'ovf:VirtualHardwareSection' => {
+        :'ovf:Item' => [
+          {
+        :'rasd:ResourceType' => '4',
+        :'rasd:VirtualQuantity' => "#{@mock_vm_memory_size}",
+      },
+      {
+        :'rasd:ResourceType' => '3',
+        :'rasd:VirtualQuantity' => "#{@mock_vm_cpu_count}",
+      }
+      ]
+      }
+    })
+    @vm =  Vcloud::Core::Vm.new(@vm_id, @mock_vapp)
+  end
+
+  context "Class public interface" do
+  end
+
+  context "Instance public interface" do
+    subject { Vcloud::Core::Vm.new(@vm_id, @mock_vapp) }
+    it { should respond_to(:id) }
+    it { should respond_to(:vcloud_attributes) }
+    it { should respond_to(:name) }
+    it { should respond_to(:href) }
+    it { should respond_to(:vapp_name) }
+    it { should respond_to(:update_name) }
+    it { should respond_to(:update_cpu_count) }
+    it { should respond_to(:update_metadata) }
+    it { should respond_to(:update_storage_profile) }
+    it { should respond_to(:add_extra_disks) }
+    it { should respond_to(:attach_independent_disks) }
+    it { should respond_to(:detach_independent_disks) }
+    it { should respond_to(:configure_network_interfaces) }
+    it { should respond_to(:configure_guest_customization_section) }
+  end
+
+  context "#initialize" do
+
+    it "should be constructable from just an id reference & Vapp object" do
+      obj = Vcloud::Core::Vm.new(@vm_id, @mock_vapp)
+      expect(obj.class).to be(Vcloud::Core::Vm)
+    end
+
+    it "should store the id specified" do
+      obj = Vcloud::Core::Vm.new(@vm_id, @mock_vapp)
+      expect(obj.id).to eq(@vm_id)
+    end
+
+    it "should raise error if id is not in correct format" do
+      bogus_id = '12314124-ede5-4d07-bad5-000000111111'
+      expect{ Vcloud::Core::Vm.new(bogus_id, @mock_vapp) }.to raise_error("vm id : #{bogus_id} is not in correct format" )
+    end
+
+  end
+
+  context "update memory in VM" do
+    it "should not allow memory size < 64MB" do
+      expect(@fog_interface).not_to receive(:put_memory)
+      @vm.update_memory_size_in_mb(63)
+    end
+    it "should not update memory if is size has not changed" do
+      expect(@fog_interface).not_to receive(:put_memory)
+      @vm.update_memory_size_in_mb(@mock_vm_memory_size)
+    end
+    it "should gracefully handle a nil memory size" do
+      expect(@fog_interface).not_to receive(:put_memory)
+      @vm.update_memory_size_in_mb(nil)
+    end
+    it "should set memory size 64MB" do
+      expect(@fog_interface).to receive(:put_memory).with(@vm_id, 64)
+      @vm.update_memory_size_in_mb(64)
+    end
+    it "should set memory size 4096MB" do
+      expect(@fog_interface).to receive(:put_memory).with(@vm_id, 4096)
+      @vm.update_memory_size_in_mb(4096)
+    end
+  end
+
+  context "update the number of cpus in vm" do
+    it "should gracefully handle nil cpu count" do
+      expect(@fog_interface).not_to receive(:put_cpu)
+      @vm.update_cpu_count(nil)
+    end
+    it "should not update cpu if is count has not changed" do
+      expect(@fog_interface).not_to receive(:put_cpu)
+      @vm.update_cpu_count(@mock_vm_cpu_count)
+    end
+    it "should not allow a zero cpu count" do
+      expect(@fog_interface).not_to receive(:put_cpu)
+      @vm.update_cpu_count(0)
+    end
+    it "should update cpu count in input is ok" do
+      expect(@fog_interface).to receive(:put_cpu).with(@vm_id, 2)
+      @vm.update_cpu_count(2)
+    end
+  end
+
+  context '#configure_guest_customization_section' do
+    let(:preamble) do
+      <<-'EOF'
           #!/usr/bin/env bash
           echo "Hello World"
-          EOF
-        end
-
-        it 'passes a pre-generated preamble to fog' do
-          expect(@fog_interface).to receive(:put_guest_customization_section).with(@vm_id, @vapp_name, preamble)
-
-          @vm.configure_guest_customization_section(preamble)
-        end
-      end
-
-      context "update metadata" do
-        it "should handle empty metadata hash" do
-          expect(@fog_interface).not_to receive(:put_vapp_metadata_value)
-          @vm.update_metadata(nil)
-        end
-        it "should handle metadata of multiple types" do
-          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :foo, 'bar')
-          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :false_thing, false)
-          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :true_thing, true)
-          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :number, 53)
-          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :zero, 0)
-          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :foo, 'bar')
-          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :false_thing, false)
-          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :true_thing, true)
-          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :number, 53)
-          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :zero, 0)
-          @vm.update_metadata(@mock_metadata)
-        end
-      end
-
-      context "configure vm network interfaces" do
-        it "should configure single nic without an IP" do
-          network_config = [{:name => 'Default'}]
-          expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
-              :PrimaryNetworkConnectionIndex => 0,
-              :NetworkConnection => [
-                  {
-                      :network => 'Default',
-                      :needsCustomization => true,
-                      :NetworkConnectionIndex => 0,
-                      :IsConnected => true,
-                      :IpAddressAllocationMode => "DHCP"
-                  }
-              ]})
-          @vm.configure_network_interfaces(network_config)
-        end
-
-        it "should configure nic from pool" do
-          network_config = [{:name => 'Default', :allocation_mode => 'pool'}]
-          expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
-              :PrimaryNetworkConnectionIndex => 0,
-              :NetworkConnection => [
-                  {
-                      :network => 'Default',
-                      :needsCustomization => true,
-                      :NetworkConnectionIndex => 0,
-                      :IsConnected => true,
-                      :IpAddressAllocationMode => "POOL"
-                  }
-              ]})
-          @vm.configure_network_interfaces(network_config)
-        end
-
-        it "should prefer configuring nic with static address" do
-          network_config = [{:name => 'Default', :allocation_mode => 'dhcp', :ip_address => '192.168.1.1'}]
-          expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
-              :PrimaryNetworkConnectionIndex => 0,
-              :NetworkConnection => [
-                  {
-                      :network => 'Default',
-                      :needsCustomization => true,
-                      :NetworkConnectionIndex => 0,
-                      :IsConnected => true,
-                      :IpAddress => "192.168.1.1",
-                      :IpAddressAllocationMode => "MANUAL"
-                  }
-              ]})
-          @vm.configure_network_interfaces(network_config)
-        end
-
-        it "should configure single nic" do
-          network_config = [{:name => 'Default', :ip_address => '192.168.1.1'}]
-          expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
-              :PrimaryNetworkConnectionIndex => 0,
-              :NetworkConnection => [
-                  {
-                      :network => 'Default',
-                      :needsCustomization => true,
-                      :NetworkConnectionIndex => 0,
-                      :IsConnected => true,
-                      :IpAddress => "192.168.1.1",
-                      :IpAddressAllocationMode => "MANUAL"
-                  }
-              ]})
-          @vm.configure_network_interfaces(network_config)
-        end
-
-        it "should configure multiple nics" do
-          network_config = [
-              {:name => 'Default', :ip_address => '192.168.1.1'},
-              {:name => 'Monitoring', :ip_address => '192.168.2.1'}
-          ]
-
-          expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
-              :PrimaryNetworkConnectionIndex => 0,
-              :NetworkConnection => [
-                  {
-                      :network => 'Default',
-                      :needsCustomization => true,
-                      :NetworkConnectionIndex => 0,
-                      :IsConnected => true,
-                      :IpAddress => "192.168.1.1",
-                      :IpAddressAllocationMode => "MANUAL"
-                  },
-                  {
-                      :network => 'Monitoring',
-                      :needsCustomization => true,
-                      :NetworkConnectionIndex => 1,
-                      :IsConnected => true,
-                      :IpAddress => "192.168.2.1",
-                      :IpAddressAllocationMode => "MANUAL"
-                  },
-              ]})
-          @vm.configure_network_interfaces(network_config)
-        end
-
-        it "should configure no nics" do
-          network_config = nil
-          expect(@fog_interface).not_to receive(:put_network_connection_system_section_vapp)
-          @vm.configure_network_interfaces(network_config)
-        end
-
-      end
-
-      context "update storage profiles" do
-        it "should update the storage profile" do
-          storage_profile = 'storage_profile_name'
-          vdc_results = [
-            { :vdcName => 'vdc-test-1' }
-          ]
-          mock_vdc_query = double(:query_runner)
-
-          storage_profile_results = [
-            { :href => 'test-href' }
-          ]
-          mock_sp_query = double(:query_runner)
-
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_vdc_query)
-          expect(mock_vdc_query).to receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_sp_query)
-          expect(mock_sp_query).to receive(:run).
-            with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
-            and_return(storage_profile_results)
-
-          generated_storage_profile = { name: 'storage_profile_name', href: 'test-href' }
-          expect(@fog_interface).to receive(:put_vm).with(@vm_id, @vm_name, { :StorageProfile => generated_storage_profile} ).and_return(true)
-          expect(@vm.update_storage_profile(storage_profile)).to eq(true)
-        end
-
-        it "should raise an error if storage profile is not found" do
-          storage_profile = 'storage_profile_name'
-          vdc_results = [
-            { :vdcName => 'vdc-test-1' }
-          ]
-          mock_vdc_query = double(:query_runner)
-
-          storage_profile_results = []
-          mock_sp_query = double(:query_runner)
-
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_vdc_query)
-          expect(mock_vdc_query).to receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_sp_query)
-          expect(mock_sp_query).to receive(:run).
-            with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
-            and_return(storage_profile_results)
-
-          expect{ @vm.update_storage_profile(storage_profile) }.to raise_error("storage profile not found" )
-        end
-
-        it "should raise an error if storage profile id is in unexpected format" do
-          storage_profile = 'storage_profile_name'
-          vdc_results = [
-            { :vdcName => 'vdc-test-1' }
-          ]
-          mock_vdc_query = double(:query_runner)
-
-          storage_profile_results = [ { :id => 'test-href'  }]
-          mock_sp_query = double(:query_runner)
-
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_vdc_query)
-          expect(mock_vdc_query).to receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_sp_query)
-          expect(mock_sp_query).to receive(:run).
-            with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
-            and_return(storage_profile_results)
-
-          expect{ @vm.update_storage_profile(storage_profile) }.to raise_error("storage profile not found" )
-        end
-
-      end
-
-      context "#attach_independent_disks" do
-
-        let(:disk1) { double(:disk, :name => 'test-disk-1',
+      EOF
+    end
+
+    it 'passes a pre-generated preamble to fog' do
+      expect(@fog_interface).to receive(:put_guest_customization_section).with(@vm_id, @vapp_name, preamble)
+
+      @vm.configure_guest_customization_section(preamble)
+    end
+  end
+
+  context "update metadata" do
+    it "should handle empty metadata hash" do
+      expect(@fog_interface).not_to receive(:put_vapp_metadata_value)
+      @vm.update_metadata(nil)
+    end
+    it "should handle metadata of multiple types" do
+      expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :foo, 'bar')
+      expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :false_thing, false)
+      expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :true_thing, true)
+      expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :number, 53)
+      expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :zero, 0)
+      expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :foo, 'bar')
+      expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :false_thing, false)
+      expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :true_thing, true)
+      expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :number, 53)
+      expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :zero, 0)
+      @vm.update_metadata(@mock_metadata)
+    end
+  end
+
+  context "configure vm network interfaces" do
+    it "should configure single nic without an IP" do
+      network_config = [{:name => 'Default'}]
+      expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+        :PrimaryNetworkConnectionIndex => 0,
+        :NetworkConnection => [
+          {
+        :network => 'Default',
+        :needsCustomization => true,
+        :NetworkConnectionIndex => 0,
+        :IsConnected => true,
+        :IpAddressAllocationMode => "DHCP"
+      }
+      ]})
+      @vm.configure_network_interfaces(network_config)
+    end
+
+    it "should configure nic from pool" do
+      network_config = [{:name => 'Default', :allocation_mode => 'pool'}]
+      expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+        :PrimaryNetworkConnectionIndex => 0,
+        :NetworkConnection => [
+          {
+        :network => 'Default',
+        :needsCustomization => true,
+        :NetworkConnectionIndex => 0,
+        :IsConnected => true,
+        :IpAddressAllocationMode => "POOL"
+      }
+      ]})
+      @vm.configure_network_interfaces(network_config)
+    end
+
+    it "should prefer configuring nic with static address" do
+      network_config = [{:name => 'Default', :allocation_mode => 'dhcp', :ip_address => '192.168.1.1'}]
+      expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+        :PrimaryNetworkConnectionIndex => 0,
+        :NetworkConnection => [
+          {
+        :network => 'Default',
+        :needsCustomization => true,
+        :NetworkConnectionIndex => 0,
+        :IsConnected => true,
+        :IpAddress => "192.168.1.1",
+        :IpAddressAllocationMode => "MANUAL"
+      }
+      ]})
+      @vm.configure_network_interfaces(network_config)
+    end
+
+    it "should configure single nic" do
+      network_config = [{:name => 'Default', :ip_address => '192.168.1.1'}]
+      expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+        :PrimaryNetworkConnectionIndex => 0,
+        :NetworkConnection => [
+          {
+        :network => 'Default',
+        :needsCustomization => true,
+        :NetworkConnectionIndex => 0,
+        :IsConnected => true,
+        :IpAddress => "192.168.1.1",
+        :IpAddressAllocationMode => "MANUAL"
+      }
+      ]})
+      @vm.configure_network_interfaces(network_config)
+    end
+
+    it "should configure multiple nics" do
+      network_config = [
+        {:name => 'Default', :ip_address => '192.168.1.1'},
+        {:name => 'Monitoring', :ip_address => '192.168.2.1'}
+      ]
+
+      expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+        :PrimaryNetworkConnectionIndex => 0,
+        :NetworkConnection => [
+          {
+        :network => 'Default',
+        :needsCustomization => true,
+        :NetworkConnectionIndex => 0,
+        :IsConnected => true,
+        :IpAddress => "192.168.1.1",
+        :IpAddressAllocationMode => "MANUAL"
+      },
+        {
+        :network => 'Monitoring',
+        :needsCustomization => true,
+        :NetworkConnectionIndex => 1,
+        :IsConnected => true,
+        :IpAddress => "192.168.2.1",
+        :IpAddressAllocationMode => "MANUAL"
+      },
+      ]})
+      @vm.configure_network_interfaces(network_config)
+    end
+
+    it "should configure no nics" do
+      network_config = nil
+      expect(@fog_interface).not_to receive(:put_network_connection_system_section_vapp)
+      @vm.configure_network_interfaces(network_config)
+    end
+
+  end
+
+  context "update storage profiles" do
+    it "should update the storage profile" do
+      storage_profile = 'storage_profile_name'
+      vdc_results = [
+        { :vdcName => 'vdc-test-1' }
+      ]
+      mock_vdc_query = double(:query_runner)
+
+      storage_profile_results = [
+        { :href => 'test-href' }
+      ]
+      mock_sp_query = double(:query_runner)
+
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_vdc_query)
+      expect(mock_vdc_query).to receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_sp_query)
+      expect(mock_sp_query).to receive(:run).
+        with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
+        and_return(storage_profile_results)
+
+      generated_storage_profile = { name: 'storage_profile_name', href: 'test-href' }
+      expect(@fog_interface).to receive(:put_vm).with(@vm_id, @vm_name, { :StorageProfile => generated_storage_profile} ).and_return(true)
+      expect(@vm.update_storage_profile(storage_profile)).to eq(true)
+    end
+
+    it "should raise an error if storage profile is not found" do
+      storage_profile = 'storage_profile_name'
+      vdc_results = [
+        { :vdcName => 'vdc-test-1' }
+      ]
+      mock_vdc_query = double(:query_runner)
+
+      storage_profile_results = []
+      mock_sp_query = double(:query_runner)
+
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_vdc_query)
+      expect(mock_vdc_query).to receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_sp_query)
+      expect(mock_sp_query).to receive(:run).
+        with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
+        and_return(storage_profile_results)
+
+      expect{ @vm.update_storage_profile(storage_profile) }.to raise_error("storage profile not found" )
+    end
+
+    it "should raise an error if storage profile id is in unexpected format" do
+      storage_profile = 'storage_profile_name'
+      vdc_results = [
+        { :vdcName => 'vdc-test-1' }
+      ]
+      mock_vdc_query = double(:query_runner)
+
+      storage_profile_results = [ { :id => 'test-href'  }]
+      mock_sp_query = double(:query_runner)
+
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_vdc_query)
+      expect(mock_vdc_query).to receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_sp_query)
+      expect(mock_sp_query).to receive(:run).
+        with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
+        and_return(storage_profile_results)
+
+      expect{ @vm.update_storage_profile(storage_profile) }.to raise_error("storage profile not found" )
+    end
+
+  end
+
+  context "#attach_independent_disks" do
+
+    let(:disk1) { double(:disk, :name => 'test-disk-1',
                          :id => '12341234-1234-1234-1234-12345678900')
-        }
-        let(:disk2) { double(:disk, :name => 'test-disk-2',
+    }
+    let(:disk2) { double(:disk, :name => 'test-disk-2',
                          :id => '12341234-1234-1234-1234-12345678901')
-        }
-        let(:disk3) { double(:disk, :name => 'test-disk-3',
+    }
+    let(:disk3) { double(:disk, :name => 'test-disk-3',
                          :id => '12341234-1234-1234-1234-12345678902')
-        }
+    }
 
-        it "handles attaching an array of Independent Disk objects" do
-          vm = Vm.new(@vm_id, @mock_vapp)
-          disk_array = [disk1, disk2, disk3]
-          expect(@fog_interface).to receive(:post_attach_disk).exactly(disk_array.size).times
-          vm.attach_independent_disks(disk_array)
-        end
+    it "handles attaching an array of Independent Disk objects" do
+      vm = Vcloud::Core::Vm.new(@vm_id, @mock_vapp)
+      disk_array = [disk1, disk2, disk3]
+      expect(@fog_interface).to receive(:post_attach_disk).exactly(disk_array.size).times
+      vm.attach_independent_disks(disk_array)
+    end
 
-      end
+  end
 
-      context "#detach_independent_disks" do
+  context "#detach_independent_disks" do
 
-        let(:disk1) { double(:disk, :name => 'test-disk-1',
+    let(:disk1) { double(:disk, :name => 'test-disk-1',
                          :id => '12341234-1234-1234-1234-12345678900')
-        }
-        let(:disk2) { double(:disk, :name => 'test-disk-2',
+    }
+    let(:disk2) { double(:disk, :name => 'test-disk-2',
                          :id => '12341234-1234-1234-1234-12345678901')
-        }
-        let(:disk3) { double(:disk, :name => 'test-disk-3',
+    }
+    let(:disk3) { double(:disk, :name => 'test-disk-3',
                          :id => '12341234-1234-1234-1234-12345678902')
-        }
-
-        it "handles detaching an array of Independent Disk objects" do
-          vm = Vm.new(@vm_id, @mock_vapp)
-          disk_array = [disk1, disk2, disk3]
-          expect(@fog_interface).to receive(:post_detach_disk).exactly(disk_array.size).times
-          vm.detach_independent_disks(disk_array)
-        end
-
-      end
+    }
 
+    it "handles detaching an array of Independent Disk objects" do
+      vm = Vcloud::Core::Vm.new(@vm_id, @mock_vapp)
+      disk_array = [disk1, disk2, disk3]
+      expect(@fog_interface).to receive(:post_detach_disk).exactly(disk_array.size).times
+      vm.detach_independent_disks(disk_array)
     end
+
   end
+
 end