fog-vcloud-director 0.1.8 → 0.1.9

data/lib/fog/vcloud_director.rb

@@ -1 +1,2 @@
 require 'fog/vcloud_director/compute'
+require 'securerandom'

data/lib/fog/vcloud_director/generators/compute/compose_common.rb

@@ -10,10 +10,19 @@ module Fog
 
           private
 
+          def href(path)
+            @endpoint ||= @configuration[:endpoint].to_s.sub(/\/$/, '') # ensure not ending with '/'
+            "#{@endpoint}#{path}"
+          end
+
           def vapp_attrs
             attrs = {
-              :xmlns => 'http://www.vmware.com/vcloud/v1.5',
-              'xmlns:ovf' => 'http://schemas.dmtf.org/ovf/envelope/1'
+              :xmlns          => 'http://www.vmware.com/vcloud/v1.5',
+              'xmlns:vcloud'  => 'http://www.vmware.com/vcloud/v1.5',
+              'xmlns:ovf'     => 'http://schemas.dmtf.org/ovf/envelope/1',
+              'xmlns:vssd'    => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData',
+              'xmlns:rasd'    => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData',
+              'xmlns:vmw'     => 'http://www.vmware.com/schema/ovf'
             }
 
             [:deploy, :powerOn, :name].each do |a|
@@ -30,12 +39,19 @@ module Fog
 
           def build_vapp_instantiation_params(xml)
             xml.Description @configuration[:Description] if @configuration[:Description]
-            
-            vapp = @configuration[:InstantiationParams]
-            if vapp 
-              xml.InstantiationParams {
+            return unless @configuration[:vapp_networks] || @configuration[:InstantiationParams]
+
+            xml.InstantiationParams do
+              if (vapp_networks = @configuration[:vapp_networks])
+                xml.NetworkConfigSection do
+                  xml['ovf'].Info
+                  array_wrap(vapp_networks).each { |vapp_net| vapp_network_section(xml, **vapp_net) }
+                end
+              # Backwards compatibility
+              # TODO: disable inputing InstantiationParams directly as below because it offers bad UX
+              elsif (vapp = @configuration[:InstantiationParams])
                 xml.DefaultStorageProfileSection {
-                    xml.StorageProfile vapp[:DefaultStorageProfile]
+                  xml.StorageProfile vapp[:DefaultStorageProfile]
                 } if (vapp.key? :DefaultStorageProfile)
                 xml.NetworkConfigSection {
                   xml['ovf'].Info
@@ -48,7 +64,7 @@ module Fog
                     }
                   end if vapp[:NetworkConfig]
                 }
-              }
+              end
             end
           end
           
@@ -102,6 +118,9 @@ module Fog
                       xml.ComputerName customization[:ComputerName]
                     }
                   end
+                  if (hardware = vm[:hardware])
+                    build_virtual_hardware_section(xml, hardware)
+                  end
                 }
                 xml.StorageProfile(:href => vm[:StorageProfileHref]) if (vm.key? :StorageProfileHref)
               }
@@ -115,6 +134,123 @@ module Fog
             xml.AllEULAsAccepted (@configuration[:AllEULAsAccepted] || true)
           end
 
+          def build_virtual_hardware_section(xml, hardware)
+            xml[:ovf].VirtualHardwareSection do
+              xml[:ovf].Info('Virtual hardware requirements')
+              virtual_hardware_section_item_mem(xml, **hardware[:memory]) if hardware[:memory]
+              virtual_hardware_section_item_cpu(xml, **hardware[:cpu]) if hardware[:cpu]
+              array_wrap(hardware[:disk]).each { |disk| virtual_hardware_section_item_hdd(xml, **disk) }
+            end
+          end
+
+          def virtual_hardware_section_item_base(xml, type:, name: nil, id: nil)
+            id ||= SecureRandom.uuid
+            name ||= id
+            xml[:ovf].Item do
+              xml[:rasd].ResourceType(type)
+              xml[:rasd].ElementName(name)
+              xml[:rasd].InstanceID(id)
+
+              yield
+
+              # RASD elements must be alphabetically sorted
+              sort_nodes_by_name(xml)
+            end
+          end
+
+          def virtual_hardware_section_item_mem(xml, quantity_mb:, reservation: nil, limit: nil, weight: nil)
+            virtual_hardware_section_item_base(xml, :type => 4) do
+              xml[:rasd].AllocationUnits('byte * 2^20')
+              xml[:rasd].VirtualQuantity(quantity_mb)
+              xml[:rasd].Reservation(reservation) if reservation
+              xml[:rasd].Limit(limit) if limit
+              xml[:rasd].Weight(weight) if weight
+            end
+          end
+
+          def virtual_hardware_section_item_cpu(xml, num_cores:, cores_per_socket: nil, reservation: nil, limit: nil, weight: nil)
+            virtual_hardware_section_item_base(xml, :type => 3) do
+              xml[:rasd].AllocationUnits('hertz * 10^6')
+              xml[:rasd].VirtualQuantity(num_cores)
+              xml[:rasd].Reservation(reservation) if reservation
+              xml[:rasd].Limit(limit) if limit
+              xml[:rasd].Weight(weight) if weight
+              xml[:vmw].CoresPerSocket(cores_per_socket) if cores_per_socket
+            end
+          end
+
+          def virtual_hardware_section_item_hdd(xml, capacity_mb:, id:, address: nil, type: nil, subtype: nil)
+            virtual_hardware_section_item_base(xml, :type => 17, :id => id) do
+              xml[:rasd].AddressOnParent(address) if address
+              attrs = {}
+              attrs['vcloud:capacity'] = capacity_mb if capacity_mb
+              attrs['vcloud:busType'] = type if type
+              attrs['vcloud:busSubType'] = subtype if subtype
+              xml[:rasd].HostResource(attrs)
+            end
+          end
+
+          def sort_nodes_by_name(xml)
+            nodes = xml.parent.children.remove
+            nodes.sort_by { |n| "#{n.namespace.prefix}:#{n.name}" }.each { |n| xml.parent.add_child(n) }
+          end
+
+          def array_wrap(val)
+            return val if val.kind_of?(Array)
+            [val].compact
+          end
+
+          def vapp_network_section(xml, name:, subnet:, description: nil, deployed: nil, parent: nil, parent_name: nil,
+                                   fence_mode: nil, retain: false, external_ip: nil)
+            description ||= name
+            parent = href("/network/#{parent}") if parent
+            fence_mode = calculate_fence_mode(fence_mode, parent, parent_name)
+            xml.NetworkConfig(:networkName => name) do
+              xml.Description(description)
+              xml.IsDeployed(deployed) unless deployed.nil?
+              xml.Configuration do
+                xml.IpScopes do
+                  array_wrap(subnet).each { |s| ip_scope_section(xml, **s) }
+                end
+                attr = {
+                  :href => parent.to_s
+                }
+                attr[:name] = parent_name if parent_name
+                xml.ParentNetwork(attr) if parent || parent_name
+                xml.FenceMode(fence_mode)
+                xml.RetainNetInfoAcrossDeployments(retain)
+                xml.RouterInfo do
+                  xml.ExternalIp(external_ip)
+                end if external_ip
+              end
+            end
+          end
+
+          def ip_scope_section(xml, gateway:, netmask:, enabled: true, inherited: false, dns1: nil, dns2: nil, dns_suffix: nil, ip_range: nil)
+            xml.IpScope do
+              xml.IsInherited(inherited)
+              xml.Gateway(gateway)
+              xml.Netmask(netmask)
+              xml.Dns1(dns1) if dns1
+              xml.Dns2(dns2) if dns2
+              xml.DnsSuffix(dns_suffix) if dns_suffix
+              xml.IsEnabled(enabled)
+              xml.IpRanges do
+                array_wrap(ip_range).each do |range|
+                  xml.IpRange do
+                    xml.StartAddress(range[:start])
+                    xml.EndAddress(range[:end])
+                  end
+                end
+              end if ip_range
+            end
+          end
+
+          def calculate_fence_mode(mode, parent, parent_name)
+            return 'isolated' unless parent || parent_name
+            return 'bridged' unless mode && mode != 'isolated'
+            mode
+          end
         end
       end
     end

data/lib/fog/vcloud_director/requests/compute/instantiate_vapp_template.rb

@@ -41,20 +41,25 @@ module Fog
           options[:vdc_uri] =  vdc_end_point(options[:vdc_id])
           options[:network_uri] = network_end_point(options[:network_id]) if options[:network_id]
           options[:template_uri] = vapp_template_end_point(options[:template_id]) || raise("template_id option is required")
+          options[:endpoint] = end_point
           options
         end
 
         def generate_instantiate_vapp_template_request(options ={})
-          #overriding some params so they work with new standardised generator
-          options[:InstantiationParams] =
-          {
-            :NetworkConfig =>
-              [{
-                :networkName => options[:network_name],
-                :networkHref => options[:network_uri],
-                # :fenceMode => "bridged"
-              }]
-          } unless options[:InstantiationParams]
+          # TODO: this is old format for customizing vapp networks, please use :vapp_networks instead to let
+          #       us do the XML building magic for you
+          if options.key?(:network_name) || options.key?(:network_uri)
+            options[:InstantiationParams] = {
+              :NetworkConfig =>
+                [{
+                  :networkName => options[:network_name],
+                  :networkHref => options[:network_uri],
+                  # :fenceMode => "bridged"
+                }]
+            } unless options[:InstantiationParams]
+            network_config = options[:InstantiationParams][:NetworkConfig]
+            network_config.each_with_index { |_, i| network_config[i][:networkHref] = network_end_point(network_config[i].delete(:networkId)) if network_config[i].key?(:networkId) }
+          end
           options[:name] = options.delete(:vapp_name) if options[:vapp_name]
           options[:Description] = options.delete(:description) unless options[:Description]
           if options[:vms_config] then
@@ -64,9 +69,6 @@ module Fog
           options[:Source] = options.delete(:template_uri) if options[:template_uri]
           options[:source_vms].each_with_index { |_, i| options[:source_vms][i][:href] = vapp_template_vm_end_point(options[:source_vms][i].delete(:vm_id)) if options[:source_vms][i].has_key?(:vm_id) }
 
-          network_config = options[:InstantiationParams][:NetworkConfig]
-          network_config.each_with_index { |_, i| network_config[i][:networkHref] = network_end_point(network_config[i].delete(:networkId)) if network_config[i].key?(:networkId) }
-
           Fog::Generators::Compute::VcloudDirector::InstantiateVappTemplateParams.new(options).generate_xml
         end
 

data/lib/fog/vcloud_director/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module VcloudDirector
-    VERSION = "0.1.8".freeze
+    VERSION = "0.1.9".freeze
   end
 end

data/spec/vcloud_director/generators/compute/compose_common_spec.rb

@@ -0,0 +1,72 @@
+require './spec/vcloud_director/spec_helper.rb'
+require 'minitest/autorun'
+require 'nokogiri'
+require './lib/fog/vcloud_director/generators/compute/compose_common.rb'
+
+include Fog::Generators::Compute::VcloudDirector::ComposeCommon
+
+describe Fog::Generators::Compute::VcloudDirector::ComposeCommon do
+  describe '.calculate_fence_mode' do
+    [
+      {
+        :case        => 'default',
+        :mode        => nil,
+        :parent      => nil,
+        :parent_name => nil,
+        :expected    => 'isolated'
+      },
+      {
+        :case        => 'prevent isolated when parent',
+        :mode        => 'isolated',
+        :parent      => 'parent-id',
+        :parent_name => nil,
+        :expected    => 'bridged'
+      },
+      {
+        :case        => 'keep natRouted when parent',
+        :mode        => 'natRouted',
+        :parent      => 'parent-id',
+        :parent_name => nil,
+        :expected    => 'natRouted'
+      },
+      {
+        :case        => 'keep bridged when parent',
+        :mode        => 'bridged',
+        :parent      => 'parent-id',
+        :parent_name => nil,
+        :expected    => 'bridged'
+      },
+      {
+        :case        => 'prevent bridged when no parent',
+        :mode        => 'bridged',
+        :parent      => nil,
+        :parent_name => nil,
+        :expected    => 'isolated'
+      },
+      {
+        :case        => 'prevent natRouted when no parent',
+        :mode        => 'natRouted',
+        :parent      => nil,
+        :parent_name => nil,
+        :expected    => 'isolated'
+      },
+      {
+        :case        => 'prevent isolated when parent_name',
+        :mode        => 'isolated',
+        :parent      => nil,
+        :parent_name => 'parent-name',
+        :expected    => 'bridged'
+      },
+    ].each do |args|
+      it args[:case].to_s do
+        mode = Fog::Generators::Compute::VcloudDirector::ComposeCommon.send(
+          :calculate_fence_mode,
+          args[:mode],
+          args[:parent],
+          args[:parent_name]
+        )
+        mode.must_equal(args[:expected])
+      end
+    end
+  end
+end

data/spec/vcloud_director/generators/compute/instantiate_vapp_template_params_spec.rb

@@ -4,65 +4,543 @@ require 'nokogiri'
 require './lib/fog/vcloud_director/generators/compute/instantiate_vapp_template_params.rb'
 
 describe Fog::Generators::Compute::VcloudDirector::InstantiateVappTemplateParams do
-  
-  let(:xml) do 
-    params = {
-      :name => 'VAPP_NAME',
-      :Description => 'MY VAPP',
-      :InstantiationParams => {
-        :NetworkConfig => [
+  describe 'Complete xml' do
+    let(:xml) do
+      params = {
+        :name => 'VAPP_NAME',
+        :Description => 'MY VAPP',
+        :InstantiationParams => {
+          :NetworkConfig => [
+            {
+              :networkName => 'NETWORK',
+              :networkHref => 'http://vcloud/api/network/123456789',
+              :fenceMode => 'bridged'
+            }
+          ]
+        },
+        :Source => 'http://vcloud/vapp_template/1234',
+        :source_vms => [
+          {
+            :name => 'VM1',
+            :href => 'http://vcloud/api/vm/12345',
+            :StorageProfileHref => 'http://vcloud/storage/123456789',
+            :hardware => {
+              :memory => { :quantity_mb => 1024, :reservation => 0, :limit => 1, :weight => 2 },
+              :cpu => { :num_cores => 4, :cores_per_socket => 2, :reservation => 0, :limit => 1, :weight => 2 },
+              :disks => [
+                { :id => 'ID1', :size => 1000 },
+                { :id => 'ID2', :size => 2000 }
+              ]
+            }
+          },
           {
-            :networkName => 'NETWORK',
-            :networkHref => 'http://vcloud/api/network/123456789',
-            :fenceMode => 'bridged'
+            :name => 'VM2',
+            :href => 'http://vcloud/api/vm/56789',
+            :StorageProfileHref => 'http://vcloud/storage/123456789'
           }
         ]
+
+      }
+
+      output = Fog::Generators::Compute::VcloudDirector::InstantiateVappTemplateParams.new(params).generate_xml
+      Nokogiri::XML(output)
+    end
+
+    it 'Generates InstantiateVAppTemplateParams' do
+      xml.xpath('//InstantiateVAppTemplateParams').must_be_instance_of Nokogiri::XML::NodeSet
+    end
+
+    it 'Has a valid Network' do
+      xml.xpath('//xmlns:NetworkConfig')[0].attr('networkName').must_equal 'NETWORK'
+      xml.xpath('//xmlns:ParentNetwork')[0].attr('href').must_equal 'http://vcloud/api/network/123456789'
+    end
+
+    it 'Has valid source VAPP info' do
+      node = xml.xpath('//xmlns:Source[@href="http://vcloud/vapp_template/1234"]')
+      node.length.must_equal 1
+    end
+
+    it 'Has valid source VM info' do
+      xml.xpath('//xmlns:StorageProfile[@href="http://vcloud/storage/123456789"]').length.must_equal 2
+    end
+
+    it 'Allows New VM Parameters' do
+      nodes = xml.xpath('//xmlns:VmGeneralParams')
+      nodes.length.must_equal 2
+    end
+  end
+
+  describe 'Hardware customization' do
+    [
+      {
+        case: 'nil hardware section',
+        hardware: nil,
+        :expect => ->(out) {}
       },
-      :Source => 'http://vcloud/vapp_template/1234',
-      :source_vms => [
-        {
-          :name => 'VM1',
-          :href => 'http://vcloud/api/vm/12345',
-          :StorageProfileHref => 'http://vcloud/storage/123456789'
+      {
+        case: 'nil memory section',
+        hardware: {
+          :memory => nil
         },
-        {
-          :name => 'VM2',
-          :href => 'http://vcloud/api/vm/12345',
-          :StorageProfileHref => 'http://vcloud/storage/123456789'
+        :expect => ->(out) {}
+      },
+      {
+        case: 'minimal memory section',
+        hardware: {
+          :memory => { :quantity_mb => 1024 }
+        },
+        :expect => lambda do |out|
+          mems = hw_items_by_type(out, 4)
+          mems.count.must_equal 1
+          mem = mems.first
+          common_mem_assertions(mem)
+          mem.xpath('./rasd:VirtualQuantity').text.must_equal('1024')
+          mem.xpath('./rasd:Reservation').must_be_empty
+          mem.xpath('./rasd:Limit').must_be_empty
+          mem.xpath('./rasd:Weight').must_be_empty
+        end
+      },
+      {
+        case: 'full memory section',
+        hardware: {
+          :memory => { :quantity_mb => 1024, :reservation => 0, :limit => 1, :weight => 2 }
+        },
+        :expect => lambda do |out|
+          mems = hw_items_by_type(out, 4)
+          mems.count.must_equal 1
+          mem = mems.first
+          common_mem_assertions(mem)
+          mem.xpath('./rasd:VirtualQuantity').text.must_equal('1024')
+          mem.xpath('./rasd:Reservation').text.must_equal('0')
+          mem.xpath('./rasd:Limit').text.must_equal('1')
+          mem.xpath('./rasd:Weight').text.must_equal('2')
+        end
+      },
+      {
+        case: 'nil cpu section',
+        hardware: {
+          :cpu => nil
+        },
+        :expect => ->(out) {}
+      },
+      {
+        case: 'minimal cpu section',
+        hardware: {
+          :cpu => { :num_cores => 4 }
+        },
+        :expect => lambda do |out|
+          cpus = hw_items_by_type(out, 3)
+          cpus.count.must_equal 1
+          cpu = cpus.first
+          common_cpu_assertions(cpu)
+          cpu.xpath('./rasd:VirtualQuantity').text.must_equal('4')
+          cpu.xpath('./rasd:Reservation').must_be_empty
+          cpu.xpath('./rasd:Limit').must_be_empty
+          cpu.xpath('./rasd:Weight').must_be_empty
+          cpu.xpath('./vmw:CoresPerSocket').must_be_empty
+        end
+      },
+      {
+        case: 'full cpu section',
+        hardware: {
+          :cpu => { :num_cores => 4, :cores_per_socket => 2, :reservation => 0, :limit => 1, :weight => 2 }
+        },
+        :expect => lambda do |out|
+          cpus = hw_items_by_type(out, 3)
+          cpus.count.must_equal 1
+          cpu = cpus.first
+          common_cpu_assertions(cpu)
+          cpu.xpath('./rasd:VirtualQuantity').text.must_equal('4')
+          cpu.xpath('./rasd:Reservation').text.must_equal('0')
+          cpu.xpath('./rasd:Limit').text.must_equal('1')
+          cpu.xpath('./rasd:Weight').text.must_equal('2')
+          cpu.xpath('./vmw:CoresPerSocket').text.must_equal('2')
+        end
+      },
+      {
+        case: 'nil disk section',
+        hardware: {
+          :disk => nil
+        },
+        :expect => ->(out) {}
+      },
+      {
+        case: 'minimal disk section',
+        hardware: {
+          :disk => { :id => 2000, :capacity_mb => 1024 }
+        },
+        :expect => lambda do |out|
+          hdds = hw_items_by_type(out, 17)
+          hdds.count.must_equal 1
+          hdd = hdds.first
+          common_hw_assertions(hdd)
+          hdd.xpath('./rasd:InstanceID').text.must_equal('2000')
+          hdd.xpath('./rasd:HostResource').text.must_be_empty
+          hdd.xpath('./rasd:HostResource/@vcloud:capacity').text.must_equal('1024')
+          hdd.xpath('./rasd:HostResource/@vcloud:busType').must_be_empty
+          hdd.xpath('./rasd:HostResource/@vcloud:busSubType').must_be_empty
+          hdd.xpath('./rasd:AddressOnParent').must_be_empty
+        end
+      },
+      {
+        case: 'full disk section',
+        hardware: {
+          :disk => { :id => 2000, :capacity_mb => 1024, :address => 0, :type => 6, :subtype => 'VirtualSCSI' }
+        },
+        :expect => lambda do |out|
+          hdds = hw_items_by_type(out, 17)
+          hdds.count.must_equal 1
+          hdd = hdds.first
+          common_hw_assertions(hdd)
+          hdd.xpath('./rasd:InstanceID').text.must_equal('2000')
+          hdd.xpath('./rasd:HostResource').text.must_be_empty
+          hdd.xpath('./rasd:HostResource/@vcloud:capacity').text.must_equal('1024')
+          hdd.xpath('./rasd:HostResource/@vcloud:busType').text.must_equal('6')
+          hdd.xpath('./rasd:HostResource/@vcloud:busSubType').text.must_equal('VirtualSCSI')
+          hdd.xpath('./rasd:AddressOnParent').text.must_equal('0')
+        end
+      },
+      {
+        case: 'two disks',
+        hardware: {
+          :disk => [
+            { :id => 2000, :capacity_mb => 1024 },
+            { :id => 3000, :capacity_mb => 2048 }
+          ]
+        },
+        :expect => lambda do |out|
+          hdds = hw_items_by_type(out, 17)
+          hdds.count.must_equal 2
+          hdds.each { |hdd| common_hw_assertions(hdd) }
+        end
+      }
+    ].each do |args|
+      it args[:case].to_s do
+        input = {
+          :name => 'VAPP_NAME',
+          :source_vms => [
+            {
+              :name => 'VM1',
+              :hardware => args[:hardware]
+            }
+          ]
         }
-      ]
-      
-    }
+        output = Fog::Generators::Compute::VcloudDirector::InstantiateVappTemplateParams.new(input).generate_xml
+        args[:expect].call(Nokogiri::XML(output))
+      end
+    end
 
-    output = Fog::Generators::Compute::VcloudDirector::InstantiateVappTemplateParams.new(params).generate_xml
-    Nokogiri::XML(output)
-  end
-  
-  it "Generates InstantiateVAppTemplateParams" do
-    xml.xpath('//InstantiateVAppTemplateParams').must_be_instance_of Nokogiri::XML::NodeSet 
-  end
-  
-  it "Has a valid Network" do
-    node = xml.xpath('//xmlns:NetworkConfigSection')
-    
-    xml.xpath("//xmlns:NetworkConfig")[0].attr('networkName').must_equal "NETWORK"    
-    xml.xpath('//xmlns:ParentNetwork')[0].attr('href').must_equal 'http://vcloud/api/network/123456789'
-    
+    def self.hw_items_by_type(xml, type)
+      xml.xpath("//xmlns:SourcedItem/xmlns:InstantiationParams/ovf:VirtualHardwareSection/ovf:Item[./rasd:ResourceType = '#{type}']")
+    end
+
+    def self.common_hw_assertions(xml)
+      # RASD elements must be alphabetically sorted
+      children = xml.children.select { |n| n.type == 1 }.map { |n| "#{n.namespace.prefix}:#{n.name}" }
+      sorted = children.sort
+      children.must_equal(sorted)
+
+      xml.xpath('./rasd:ElementName').text.length.must_be :>, 0
+      xml.xpath('./rasd:InstanceID').text.length.must_be :>, 0
+    end
+
+    def self.common_mem_assertions(xml)
+      common_hw_assertions(xml)
+      xml.xpath('./rasd:VirtualQuantity').text.length.must_be :>, 0
+      xml.xpath('./rasd:AllocationUnits').text.must_equal('byte * 2^20')
+    end
+
+    def self.common_cpu_assertions(xml)
+      common_hw_assertions(xml)
+      xml.xpath('./rasd:VirtualQuantity').text.length.must_be :>, 0
+      xml.xpath('./rasd:AllocationUnits').text.must_equal('hertz * 10^6')
+    end
   end
-  
-  it "Has valid source VAPP info" do
-    node = xml.xpath('//xmlns:Source[@href="http://vcloud/vapp_template/1234"]')
-    node.length.must_equal 1
+
+  describe 'vApp Network customization' do
+    [
+      {
+        :case          => 'minimal vapp networking',
+        :vapp_networks => [
+          {
+            :name   => 'network',
+            :subnet => [
+              {
+                :gateway => '1.2.3.4',
+                :netmask => '255.255.255.0'
+              }
+            ]
+          }
+        ],
+        :expect        => lambda do |vapp_net_conf|
+          common_vapp_network_config_assertions(vapp_net_conf)
+          vapp_net_conf.xpath('./vcloud:NetworkConfig/@networkName').text.must_equal 'network'
+          conf = vapp_net_conf.xpath('./vcloud:NetworkConfig/vcloud:Configuration')
+          conf.xpath('./vcloud:FenceMode').text.must_equal 'isolated'
+          conf.xpath('./vcloud:ParentNetwork').text.must_be_empty
+          subnet = conf.xpath('./vcloud:IpScopes/vcloud:IpScope')
+          subnet.xpath('./vcloud:Gateway').text.must_equal '1.2.3.4'
+          subnet.xpath('./vcloud:Netmask').text.must_equal '255.255.255.0'
+        end
+      },
+      {
+        :case          => 'full networking',
+        :vapp_networks => [
+          {
+            :name        => 'network',
+            :description => 'VM Network Description',
+            :deployed    => true,
+            :parent      => 'parent-network-id',
+            :fence_mode  => 'bridged',
+            :retain      => false,
+            :external_ip => '17.17.17.17',
+            :subnet      => [
+              {
+                :enabled    => true,
+                :inherited  => false,
+                :gateway    => '1.2.3.4',
+                :netmask    => '255.255.255.0',
+                :dns1       => '5.6.7.8',
+                :dns2       => '9.10.11.12',
+                :dns_suffix => 'dns-suffix',
+                :ip_range   => [{ :start => '192.168.254.100', :end => '192.168.254.199' }]
+              }
+            ]
+          }
+        ],
+        :expect        => lambda do |vapp_net_conf|
+          common_vapp_network_config_assertions(vapp_net_conf)
+          vapp_net_conf.xpath('./vcloud:NetworkConfig/@networkName').text.must_equal 'network'
+          vapp_net_conf.xpath('./vcloud:NetworkConfig/vcloud:Description').text.must_equal 'VM Network Description'
+          vapp_net_conf.xpath('./vcloud:NetworkConfig/vcloud:IsDeployed').text.must_equal 'true'
+          conf = vapp_net_conf.xpath('./vcloud:NetworkConfig/vcloud:Configuration')
+          conf.xpath('./vcloud:FenceMode').text.must_equal 'bridged'
+          conf.xpath('./vcloud:ParentNetwork/@href').text.must_equal 'ENDPOINT/network/parent-network-id'
+          conf.xpath('./vcloud:RetainNetInfoAcrossDeployments').text.must_equal 'false'
+          conf.xpath('./vcloud:RouterInfo/vcloud:ExternalIp').text.must_equal '17.17.17.17'
+          subnet = conf.xpath('./vcloud:IpScopes/vcloud:IpScope')
+          subnet.xpath('./vcloud:IsEnabled').text.must_equal 'true'
+          subnet.xpath('./vcloud:IsInherited').text.must_equal 'false'
+          subnet.xpath('./vcloud:Gateway').text.must_equal '1.2.3.4'
+          subnet.xpath('./vcloud:Netmask').text.must_equal '255.255.255.0'
+          subnet.xpath('./vcloud:Dns1').text.must_equal '5.6.7.8'
+          subnet.xpath('./vcloud:Dns2').text.must_equal '9.10.11.12'
+          ip_range = subnet.xpath('./vcloud:IpRanges/vcloud:IpRange')
+          ip_range.xpath('./vcloud:StartAddress').text.must_equal '192.168.254.100'
+          ip_range.xpath('./vcloud:EndAddress').text.must_equal '192.168.254.199'
+        end
+      },
+      {
+        :case          => 'two vapp networks',
+        :vapp_networks => [
+          {
+            :name   => 'network1',
+            :subnet => [
+              {
+                :gateway => '1.1.1.1',
+                :netmask => '255.255.255.1'
+              }
+            ]
+          },
+          {
+            :name   => 'network2',
+            :subnet => [
+              {
+                :gateway => '2.2.2.2',
+                :netmask => '255.255.255.2'
+              }
+            ]
+          }
+        ],
+        :expect        => lambda do |vapp_net_conf|
+          common_vapp_network_config_assertions(vapp_net_conf)
+          vapp_net_conf.xpath('./vcloud:NetworkConfig').count.must_equal 2
+          vapp_net_conf.xpath('./vcloud:NetworkConfig[1]/@networkName').text.must_equal 'network1'
+          vapp_net_conf.xpath('./vcloud:NetworkConfig[2]/@networkName').text.must_equal 'network2'
+          conf1 = vapp_net_conf.xpath('./vcloud:NetworkConfig[1]/vcloud:Configuration')
+          subnet1 = conf1.xpath('./vcloud:IpScopes/vcloud:IpScope')
+          subnet1.xpath('./vcloud:Gateway').text.must_equal '1.1.1.1'
+          subnet1.xpath('./vcloud:Netmask').text.must_equal '255.255.255.1'
+          conf2 = vapp_net_conf.xpath('./vcloud:NetworkConfig[2]/vcloud:Configuration')
+          subnet2 = conf2.xpath('./vcloud:IpScopes/vcloud:IpScope')
+          subnet2.xpath('./vcloud:Gateway').text.must_equal '2.2.2.2'
+          subnet2.xpath('./vcloud:Netmask').text.must_equal '255.255.255.2'
+        end
+      }
+    ].each do |args|
+      it args[:case].to_s do
+        input = {
+          :name          => 'VAPP_NAME',
+          :vapp_networks => args[:vapp_networks],
+          :endpoint      => 'ENDPOINT'
+        }
+        output = Fog::Generators::Compute::VcloudDirector::InstantiateVappTemplateParams.new(input).generate_xml
+        args[:expect].call(vapp_network_config(Nokogiri::XML(output)))
+      end
+    end
+
+    def vapp_network_config(xml)
+      xml.xpath('//xmlns:NetworkConfigSection')
+    end
+
+    def self.common_vapp_network_config_assertions(vapp_net_conf)
+      vapp_net_conf.count.must_equal 1
+    end
   end
-  
-  it "Has valid source VM info" do
-    
-    xml.xpath('//xmlns:StorageProfile[@href="http://vcloud/storage/123456789"]').length.must_equal 2
+
+  describe 'Guest customization' do
+    [
+      {
+        :case                => 'hostname',
+        :guest_customization => {
+          :ComputerName => 'hostname'
+        },
+        :expect              => lambda do |guest_customization|
+          common_guest_customization_assertions(guest_customization)
+          hostnames = guest_customization.xpath('./xmlns:ComputerName')
+          hostnames.count.must_equal 1
+          hostname = hostnames.first
+          hostname.text.must_equal 'hostname'
+        end
+      }
+    ].each do |args|
+      it args[:case].to_s do
+        input = {
+          :name       => 'VAPP_NAME',
+          :source_vms => [
+            {
+              :name                => 'VM1',
+              :guest_customization => args[:guest_customization]
+            }
+          ]
+        }
+        output = Fog::Generators::Compute::VcloudDirector::InstantiateVappTemplateParams.new(input).generate_xml
+        args[:expect].call(guest_customization(Nokogiri::XML(output)))
+      end
+    end
+
+    def guest_customization(xml)
+      xml.xpath('//xmlns:SourcedItem/xmlns:InstantiationParams/xmlns:GuestCustomizationSection')
+    end
+
+    def self.common_guest_customization_assertions(guest_customization)
+      guest_customization.count.must_equal 1
+    end
   end
-  
-  it "Allows New VM Parameters" do
-    nodes = xml.xpath('//xmlns:VmGeneralParams')
-    nodes.length.must_equal 2   
+
+  describe 'NIC connection customization' do
+    [
+      {
+        :case     => 'connect NIC#0 in DHCP mode',
+        :networks => [
+          {
+            :networkName             => 'network',
+            :IpAddressAllocationMode => 'DHCP',
+            :IsConnected             => true
+          }
+        ],
+        :expect   => lambda do |networks|
+          common_networks_assertions(networks)
+          network = networks.first
+          network.xpath('./@network').text.must_equal 'network'
+          network.xpath('./xmlns:NetworkConnectionIndex').text.must_equal '0'
+          network.xpath('./xmlns:IpAddressAllocationMode').text.must_equal 'DHCP'
+          network.xpath('./xmlns:IpAddress').text.must_be_empty
+          network.xpath('./xmlns:IsConnected').text.must_equal 'true'
+        end
+      },
+      {
+        :case     => 'connect NIC#0 in MANUAL mode',
+        :networks => [
+          {
+            :networkName             => 'network',
+            :IpAddressAllocationMode => 'MANUAL',
+            :IpAddress               => '1.2.3.4',
+            :IsConnected             => true
+          }
+        ],
+        :expect   => lambda do |networks|
+          common_networks_assertions(networks)
+          network = networks.first
+          network.xpath('./@network').text.must_equal 'network'
+          network.xpath('./xmlns:NetworkConnectionIndex').text.must_equal '0'
+          network.xpath('./xmlns:IpAddressAllocationMode').text.must_equal 'MANUAL'
+          network.xpath('./xmlns:IpAddress').text.must_equal '1.2.3.4'
+          network.xpath('./xmlns:IsConnected').text.must_equal 'true'
+        end
+      },
+      {
+        :case     => 'connect NIC#0 in POOL mode',
+        :networks => [
+          {
+            :networkName             => 'network',
+            :IpAddressAllocationMode => 'POOL',
+            :IsConnected             => true
+          }
+        ],
+        :expect   => lambda do |networks|
+          common_networks_assertions(networks)
+          network = networks.first
+          network.xpath('./@network').text.must_equal 'network'
+          network.xpath('./xmlns:NetworkConnectionIndex').text.must_equal '0'
+          network.xpath('./xmlns:IpAddressAllocationMode').text.must_equal 'POOL'
+          network.xpath('./xmlns:IpAddress').text.must_be_empty
+          network.xpath('./xmlns:IsConnected').text.must_equal 'true'
+        end
+      },
+      {
+        :case     => 'connect NIC#0 and NIC#1',
+        :networks => [
+          {
+            :networkName             => 'network0',
+            :IpAddressAllocationMode => 'DHCP',
+            :IsConnected             => true
+          },
+          {
+            :networkName             => 'network1',
+            :IpAddressAllocationMode => 'MANUAL',
+            :IpAddress               => '1.2.3.4',
+            :IsConnected             => true
+          }
+        ],
+        :expect   => lambda do |networks|
+          networks.count.must_equal 2
+          nic0_network = networks[0]
+          nic0_network.xpath('./@network').text.must_equal 'network0'
+          nic0_network.xpath('./xmlns:NetworkConnectionIndex').text.must_equal '0'
+          nic0_network.xpath('./xmlns:IpAddressAllocationMode').text.must_equal 'DHCP'
+          nic0_network.xpath('./xmlns:IpAddress').text.must_be_empty
+          nic0_network.xpath('./xmlns:IsConnected').text.must_equal 'true'
+          nic1_network = networks[1]
+          nic1_network.xpath('./@network').text.must_equal 'network1'
+          nic1_network.xpath('./xmlns:NetworkConnectionIndex').text.must_equal '1'
+          nic1_network.xpath('./xmlns:IpAddressAllocationMode').text.must_equal 'MANUAL'
+          nic1_network.xpath('./xmlns:IpAddress').text.must_equal '1.2.3.4'
+          nic1_network.xpath('./xmlns:IsConnected').text.must_equal 'true'
+        end
+      }
+    ].each do |args|
+      it args[:case].to_s do
+        input = {
+          :name       => 'VAPP_NAME',
+          :source_vms => [
+            {
+              :name     => 'VM1',
+              :networks => args[:networks]
+            }
+          ]
+        }
+        output = Fog::Generators::Compute::VcloudDirector::InstantiateVappTemplateParams.new(input).generate_xml
+        args[:expect].call(networks(Nokogiri::XML(output)))
+      end
+    end
+
+    def networks(xml)
+      xml.xpath('//xmlns:SourcedItem/xmlns:InstantiationParams/xmlns:NetworkConnectionSection/xmlns:NetworkConnection')
+    end
+
+    def self.common_networks_assertions(networks)
+      networks.count.must_equal 1
+    end
   end
-  
-end
+end