fog-maestrodev 1.15.0.20130829165835 → 1.15.0.20130927082724

data/tests/vcloud_director/models/compute/organizations_tests.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+VCR.use_cassette(File.basename(__FILE__)) do
+
+  Shindo.tests("Compute::VcloudDirector | organizations", ['vclouddirector', 'all']) do
+    organizations = vcloud_director.organizations
+    tests("#There is at least one organization").returns(true) { organizations.size >= 1 }
+
+    org = organizations.first
+
+    tests("Compute::VcloudDirector | organization") do
+      tests("#name").returns(String) { org.name.class }
+      tests("#type").returns("application/vnd.vmware.vcloud.org+xml") { org.type }
+    end
+
+    tests("Compute::VcloudDirector | organization", ['get']) do
+      tests("#get_by_name").returns(org.name) { organizations.get_by_name(org.name).name }
+      tests("#get").returns(org.id) { organizations.get(org.id).id }
+    end
+  end
+
+end

data/tests/vcloud_director/models/compute/vapp_life_cycle_tests.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+
+VAPP_NAME = "shindo07"
+NETWORK_NAME = "DevOps - Dev Network Connection"
+NETWORK_MODE = "POOL"
+CATALOG_NAME = "Public VM Templates"
+CATALOG_ITEM_NAME = "DEVWEB"
+TAGS = { :company => "acme", :environment => "testing" }
+
+
+VCR.use_cassette(File.basename(__FILE__)) do
+
+  Shindo.tests("Compute::VcloudDirector | vapp", ['vclouddirector', 'creation']) do
+    pending if Fog.mocking?
+    pending # FIXME: vCloud environment needs to be set up in advance
+    tests("#it creates a vApp from a catalog item").returns(true){ the_catalog_item.instantiate(VAPP_NAME, { :network_id => the_network.id, :network_name => NETWORK_NAME}) }
+    vapp = vapps.get_by_name(VAPP_NAME)
+    tests("#Finds the just created vApp").returns(VAPP_NAME) { vapp.name }
+    tests("#it has one vm").returns(1) { vapp.vms.size}
+    tests("Compute::VcloudDirector | vm", ['configuration']) do
+      vm = vapp.vms.first
+      tests("Compute::VcloudDirector | vm", ['network']) do
+        network = vm.network
+        network.network = NETWORK_NAME
+        network.is_connected = true
+        network.ip_address_allocation_mode = NETWORK_MODE
+        tests("save network changes").returns(true){ network.save }
+        network.reload
+        tests("#network").returns(NETWORK_NAME) { network.network }
+        tests("#is_connected").returns(true) { network.is_connected }
+        tests("#ip_address_allocation_mode").returns(NETWORK_MODE) { network.ip_address_allocation_mode }
+      end
+
+      tests("Compute::VcloudDirector | vm", ['customization']) do
+        customization = vm.customization
+        customization.script = 'this is the user data'
+        customization.enabled = true
+        tests("save customization changes").returns(true){ customization.save }
+        tests("#script").returns('this is the user data') { customization.script }
+        tests("#enabled").returns(true) { customization.enabled  }
+      end
+
+      tests("Compute::VcloudDirector | vm", ['doble the disk size']) do
+        disk = vm.disks.get_by_name('Hard disk 1')
+        tests("#disk_size").returns(Fixnum) { disk.capacity.class}
+        new_size = disk.capacity * 2
+        disk.capacity = new_size
+        disk.reload
+        tests("#disk_size is now doubled").returns(new_size) { disk.capacity }
+      end
+
+      tests("Compute::VcloudDirector | vm", ['add a new disk']) do
+        tests("hard disk 2 doesn't exist").returns(nil) { vm.disks.get_by_name('Hard disk 2') }
+        tests("#create").returns(true) { vm.disks.create(1024) }
+        tests("hard disk 2 exists").returns(1024) { vm.disks.get_by_name('Hard disk 2').capacity }
+        tests("delete disk 2").returns(true) { vm.disks.get_by_name('Hard disk 2').destroy }
+        tests("hard disk 2 doesn't exist anymore").returns(nil) { vm.disks.get_by_name('Hard disk 2') }
+      end
+
+      tests("Compute::VcloudDirector | vm", ['doble the memory size']) do
+        tests("#memory").returns(Fixnum) { vm.memory.class}
+        new_size = vm.memory * 2
+        vm.memory = new_size
+        vm.reload
+        tests("#memory is now doubled").returns(new_size) { vm.memory }
+      end
+
+      tests("Compute::VcloudDirector | vm", ['doble the cpu size']) do
+        tests("#cpu").returns(Fixnum) { vm.cpu.class}
+        new_size = vm.cpu * 2
+        vm.cpu = new_size
+        vm.reload
+        tests("#memory is now doubled").returns(new_size) { vm.cpu }
+      end
+
+      tests("Compute::VcloudDirector | vm", ['tags']) do
+        TAGS.each_pair do |k,v|
+          tests('create tag').returns(true) {vm.tags.create(k, v)}
+        end
+        tests('there are two tags').returns(2){ vm.tags.size }
+        tests('#get_by_name').returns("acme"){ vm.tags.get_by_name('company').value }
+        tests('#get_by_name').returns("testing"){ vm.tags.get_by_name('environment').value }
+        tests('delete company').returns(true){ vm.tags.get_by_name('company').destroy }
+        tests("company doesn't exists anymore").returns(nil){ vm.tags.get_by_name('company') }
+        tests('there is only one tag').returns(1){ vm.tags.size }
+      end
+
+      tests("Compute::VcloudDirector | vm", ['power on']) do
+        tests('#vm is off').returns("off"){ vm.status }
+        tests('#power_on').returns(true){ vm.power_on }
+        vm.reload
+        tests('#vm is on').returns("on"){ vm.status }
+      end
+
+    end
+  end
+end

data/tests/vcloud_director/models/compute/vapp_tests.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+VCR.use_cassette(File.basename(__FILE__)) do
+
+  Shindo.tests("Compute::VcloudDirector | vapps", ['vclouddirector', 'all']) do
+    pending if Fog.mocking?
+    tests("#There is more than one vapp").returns(true){ vdc.vapps.size >= 1 }
+
+    vapps = vdc.vapps
+    vapp = vapps.first
+
+    tests("Compute::VcloudDirector | vapp") do
+      tests("#id").returns(String){ vapp.id.class }
+      tests("#name").returns(String){ vapp.name.class }
+      tests("#href").returns(String){ vapp.href.class }
+      tests("#type").returns("application/vnd.vmware.vcloud.vApp+xml"){ vapp.type }
+    end
+
+    tests("Compute::VcloudDirector | vapp", ['lazy load attrs']) do
+      vapp.lazy_load_attrs.each do |lazy_attr|
+        tests("##{lazy_attr} is not loaded yet").returns(NonLoaded) { vapp.attributes[lazy_attr] }
+      end
+    end
+
+    tests("Compute::VcloudDirector | vapp", ['load on demand']) do
+      tests("#description is not loaded yet").returns(NonLoaded) { vapp.attributes[:description] }
+      tests("#description is loaded on demand").returns(String) { vapp.description.class }
+      tests("#description is now loaded").returns(true) { vapp.attributes[:description] != NonLoaded }
+    end
+
+    tests("Compute::VcloudDirector | vapp", ['lazy load attrs']) do
+      vapp.lazy_load_attrs.each do |lazy_attr|
+        tests("##{lazy_attr} is now loaded").returns(true) { vapp.attributes[lazy_attr] != NonLoaded }
+      end
+    end
+
+    tests("Compute::VcloudDirector | vapp", ['get']) do
+      tests("#get_by_name").returns(vapp.name) { vapps.get_by_name(vapp.name).name }
+      tests("#get").returns(vapp.id) { vapps.get(vapp.id).id }
+    end
+  end
+end

data/tests/vcloud_director/models/compute/vdcs_tests.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+VCR.use_cassette(File.basename(__FILE__)) do
+
+  Shindo.tests("Compute::VcloudDirector | vdcs", ['vclouddirector', 'all']) do
+    pending if Fog.mocking?
+    tests("#There is one or more vdc").returns(true){ organization.vdcs.size >= 1 }
+
+    vdcs = organization.vdcs
+    vdc = vdcs.first
+
+    tests("Compute::VcloudDirector | vdc") do
+      tests("#id").returns(String) { vdc.id.class }
+      tests("#name").returns(String) { vdc.name.class }
+      tests("#href").returns(String) { vdc.href.class }
+      tests("#type").returns("application/vnd.vmware.vcloud.vdc+xml") { vdc.type }
+    end
+
+    tests("Compute::VcloudDirector | vdc", ['lazy load attrs']) do
+      vdc.lazy_load_attrs.each do |lazy_attr|
+        tests("##{lazy_attr} is not loaded yet").returns(NonLoaded) { vdc.attributes[lazy_attr] }
+      end
+    end
+
+    tests("Compute::VcloudDirector | vdc", ['load on demand']) do
+      tests("#description is not loaded yet").returns(NonLoaded) { vdc.attributes[:description] }
+      tests("#description is loaded on demand").returns(String) { vdc.description.class }
+      tests("#description is now loaded").returns(true) { vdc.attributes[:description] != NonLoaded }
+    end
+
+    tests("Compute::VcloudDirector | vdc", ['lazy load attrs']) do
+      lazy_attrs = vdc.lazy_load_attrs
+      lazy_attrs.delete(:storage_capacity) if vcloud_director.api_version.to_f >= 5.1
+      lazy_attrs.each do |lazy_attr|
+        tests("##{lazy_attr} is now loaded").returns(true) { vdc.attributes[lazy_attr] != NonLoaded }
+      end
+    end
+
+    tests("Compute::VcloudDirector | vdc", ['get']) do
+      tests("#get_by_name").returns(vdc.name) { vdcs.get_by_name(vdc.name).name }
+      tests("#get").returns(vdc.id) { vdcs.get(vdc.id).id }
+    end
+  end
+
+end

data/tests/vcloud_director/models/compute/vms_tests.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+VCR.use_cassette(File.basename(__FILE__)) do
+
+  Shindo.tests("Compute::VcloudDirector | vms", ['vclouddirector', 'all']) do
+    pending if Fog.mocking?
+    vapp = vapps.detect {|v| v.vms.size >= 1}
+
+    tests("#There is more than one vm").returns(true){ vapp.vms.size >= 1 }
+
+    vms = vapp.vms
+    vm = vms.first
+
+    tests("Compute::VcloudDirector | vm") do
+      tests("#model").returns(Fog::Compute::VcloudDirector::Vm){vm.class}
+      tests("#id").returns(String){ vm.id.class }
+      tests("#name").returns(String){ vm.name.class }
+      tests("#href").returns(String){ vm.href.class }
+      tests("#type").returns("application/vnd.vmware.vcloud.vm+xml"){ vm.type }
+      tests("#vapp_id").returns(String){ vm.vapp_id.class }
+      tests("#status").returns(String){ vm.status.class }
+      tests("#operating_system").returns(String){ vm.operating_system.class }
+      tests("#ip_address").returns(String){ vm.ip_address.class }
+      tests("#cpu").returns(Fixnum){ vm.cpu.class }
+      tests("#memory").returns(Fixnum){ vm.memory.class }
+      tests("#hard_disks").returns(Array){ vm.hard_disks.class }
+    end
+
+    tests("Compute::VcloudDirector | vm", ['get']) do
+      tests("#get_by_name").returns(vm.name) { vms.get_by_name(vm.name).name }
+      tests("#get").returns(vm.id) { vms.get(vm.id).id }
+    end
+
+    tests("Compute::VcloudDirector | vm | disks") do
+      tests("#collection").returns(Fog::Compute::VcloudDirector::Disks){ vm.disks.class }
+      tests("#get_by_name").returns(Fog::Compute::VcloudDirector::Disk) { vm.disks.get_by_name("Hard disk 1").class }
+
+      hard_disk = vm.disks.get_by_name("Hard disk 1")
+      tests("#id").returns(2000){ hard_disk.id }
+      tests("#name").returns("Hard disk 1"){ hard_disk.name }
+      tests("#description").returns("Hard disk"){ hard_disk.description }
+      tests("#resource_type").returns(17){ hard_disk.resource_type }
+      tests("#address_on_parent").returns(0){ hard_disk.address_on_parent }
+      tests("#parent").returns(2){ hard_disk.parent }
+      tests("#capacity").returns(Fixnum){ hard_disk.capacity.class }
+      tests("#bus_sub_type").returns(String){ hard_disk.bus_sub_type.class }
+      tests("#bus_type").returns(6){ hard_disk.bus_type }
+    end
+
+    tests("Compute::VcloudDirector | vm | customization") do
+      customization = vm.customization
+      tests("#model").returns(Fog::Compute::VcloudDirector::VmCustomization){customization.class}
+      tests("#id").returns(String){ customization.id.class }
+      tests("#href").returns(String){ customization.href.class }
+      tests("#type").returns("application/vnd.vmware.vcloud.guestCustomizationSection+xml"){ customization.type }
+      tests("#virtual_machine_id").returns(String){ customization.virtual_machine_id.class }
+      tests("#computer_name").returns(String){ customization.computer_name.class }
+      tests("#enabled").returns(true){ boolean? customization.enabled }
+      tests("#change_sid").returns(true){ boolean? customization.change_sid }
+      tests("#join_domain_enabled").returns(true){ boolean? customization.join_domain_enabled }
+      tests("#use_org_settings").returns(true){ boolean? customization.use_org_settings }
+      tests("#admin_password_enabled").returns(true){ boolean? customization.admin_password_enabled }
+      tests("#reset_password_required").returns(true){ boolean? customization.reset_password_required }
+    end
+
+    tests("Compute::VcloudDirector | vm | network") do
+      network = vm.network
+      tests("#model").returns(Fog::Compute::VcloudDirector::VmNetwork){network.class}
+      tests("#id").returns(String){ network.id.class }
+      tests("#href").returns(String){ network.href.class }
+      tests("#type").returns("application/vnd.vmware.vcloud.networkConnectionSection+xml"){ network.type }
+      tests("#info").returns(String){ network.info.class }
+      tests("#primary_network_connection_index").returns(Fixnum){ network.primary_network_connection_index.class }
+      tests("#network").returns(String){ network.network.class }
+      tests("#network_connection_index").returns(Fixnum){ network.network_connection_index.class }
+      tests("#mac_address").returns(String){ network.mac_address.class }
+      tests("#ip_address_allocation_mode").returns(String){ network.ip_address_allocation_mode.class }
+      tests("#needs_customization").returns(true){ boolean? network.needs_customization }
+      tests("#is_connected").returns(true){ boolean? network.is_connected }
+    end
+
+    tests("Compute::VcloudDirector | vm | tags") do
+      tags = vm.tags
+      tests("#collection").returns(Fog::Compute::VcloudDirector::Tags){ tags.class }
+    end
+
+
+  end
+end

data/tests/vcloud_director/models/tools/reduced_vcr_requests.rb

@@ -0,0 +1,27 @@
+#!/usr/local/bin/ruby
+
+# TO FIX: it reduces the number of requests but it make the tests to faile
+require 'yaml'
+PATH = ARGV.shift
+vcr_cassete = YAML.load_file(PATH)
+
+@num_request = 0
+@pending_requests = {}
+
+reduced_requests = vcr_cassete["http_interactions"].reject do |i| 
+  @num_request += 1
+  if i["response"]["body"]["string"] =~ /running/ && i["response"]["headers"]["Content-Type"].to_s == 'application/vnd.vmware.vcloud.task+xml;version=1.5'
+    @pending_requests[@num_request]=true  
+    @pending_requests[@num_request] && @pending_requests[@num_request-1] && @pending_requests[@num_request-2]
+  else
+    @pending_requests[@num_request]=false
+  end
+end
+
+cleaned = vcr_cassete["http_interactions"].size - reduced_requests.size
+puts "cleaned: #{cleaned} requests"
+
+vcr_cassete["http_interactions"] = reduced_requests
+
+File.open(PATH, 'w') {|f| f.write(vcr_cassete.to_yaml) }
+

data/tests/vcloud_director/requests/compute/organization_tests.rb

@@ -0,0 +1,48 @@
+Shindo.tests('Compute::VcloudDirector | organization requests', ['vclouddirector']) do
+
+  ORG_LIST_FORMAT = {
+    :xmlns => 'http://www.vmware.com/vcloud/v1.5',
+    :xmlns_xsi => 'http://www.w3.org/2001/XMLSchema-instance',
+    :type => 'application/vnd.vmware.vcloud.orgList+xml',
+    :href => String,
+    :xsi_schemaLocation => String,
+    :Org => [{
+      :type => 'application/vnd.vmware.vcloud.org+xml',
+      :name => String,
+      :href => String
+    }]
+  }
+
+  ORG_FORMAT = {
+    :xmlns => 'http://www.vmware.com/vcloud/v1.5',
+    :xmlns_xsi => 'http://www.w3.org/2001/XMLSchema-instance',
+    :name => String,
+    :id => String,
+    :type => 'application/vnd.vmware.vcloud.org+xml',
+    :href => String,
+    :xsi_schemaLocation => String,
+    :Link => [{
+      :rel => String,
+      :type => String,
+    # :name => String, -- not always true
+      :href => String,
+    }],
+    :Description => String,
+    :FullName => String
+  }
+
+  @service = Fog::Compute::VcloudDirector.new
+
+  tests('#get_organizations').formats(ORG_LIST_FORMAT) do
+    @org_list = @service.get_organizations.body
+    @org_list[:Org] = [@org_list[:Org]] if @org_list[:Org].is_a?(Hash)
+    @org_list
+  end
+
+  tests('#get_organization').formats(ORG_FORMAT) do
+    org = @org_list[:Org].detect {|o| o[:name] == @service.org_name}
+    org_uuid = org[:href].split('/').last
+    @service.get_organization(org_uuid).body
+  end
+
+end

data/tests/vcloud_director/requests/compute/session_tests.rb

@@ -0,0 +1,29 @@
+Shindo.tests('Compute::VcloudDirector | session requests', ['vclouddirector']) do
+
+  SESSION_FORMAT = {
+    :xmlns => 'http://www.vmware.com/vcloud/v1.5',
+    :xmlns_xsi => 'http://www.w3.org/2001/XMLSchema-instance',
+    :user => String,
+    :org => String,
+    :type => 'application/vnd.vmware.vcloud.session+xml',
+    :href => String,
+    :xsi_schemaLocation => String,
+    :Link => [{
+      :rel => String,
+      :type => String,
+      :href => String
+    }]
+  }
+
+  @service = Fog::Compute::VcloudDirector.new
+
+  tests('#post_login_sessions').formats(SESSION_FORMAT) do
+    pending
+    @service.login.body # calls post_login_sessions
+  end
+
+  tests('#get_current_session').formats(SESSION_FORMAT) do
+    @service.get_current_session.body
+  end
+
+end

data/tests/vcloud_director/requests/compute/vdc_tests.rb

@@ -0,0 +1,90 @@
+Shindo.tests('Compute::VcloudDirector | vdc requests', ['vclouddirector']) do
+
+  VDC_FORMAT = {
+    :xmlns => 'http://www.vmware.com/vcloud/v1.5',
+    :xmlns_xsi => 'http://www.w3.org/2001/XMLSchema-instance',
+    :status => String,
+    :name => String,
+    :id => String,
+    :type => 'application/vnd.vmware.vcloud.vdc+xml',
+    :href => String,
+    :xsi_schemaLocation => String,
+    :Link => [{
+      :rel => String,
+      :type => String,
+      :href => String
+    }],
+    :Description => String,
+    :AllocationModel => String,
+    :ComputeCapacity => {
+      :Cpu => {
+        :Units => String,
+        :Allocated => String,
+        :Limit => String,
+        :Reserved => String,
+        :Used => String,
+        :Overhead => String,
+      },
+      :Memory => {
+        :Units => String,
+        :Allocated => String,
+        :Limit => String,
+        :Reserved => String,
+        :Used => String,
+        :Overhead => String
+      }
+    },
+    :ResourceEntities => {
+      :ResourceEntity => [{
+        :type => String,
+        :name => String,
+        :href => String
+      }]
+    },
+    :AvailableNetworks => {
+      :Network => [{
+        :type => String,
+        :name => String,
+        :href => String
+      }]
+    },
+    :Capabilities => {
+      :SupportedHardwareVersions => {
+        :SupportedHardwareVersion => String,
+      }
+    },
+    :NicQuota => String,
+    :NetworkQuota => String,
+    :UsedNetworkCount => String,
+    :VmQuota => String,
+    :IsEnabled => String,
+    # TODO
+    #:VdcStorageProfiles => { # >= 5.1
+    #  :VdcStorageProfile => [{
+    #    :type => String,
+    #    :name => String,
+    #    :href => String
+    #  }]
+    #}
+  }
+
+  @service = Fog::Compute::VcloudDirector.new
+
+  tests('#Get current organization') do
+    session = @service.get_current_session.body
+    org_href = session[:Link].detect {|l| l[:type] == 'application/vnd.vmware.vcloud.org+xml'}[:href]
+    @org = @service.get_organization(org_uuid = org_href.split('/')[-1]).body
+  end
+
+  tests('#get_vdc').formats(VDC_FORMAT) do
+    vdc_href = @org[:Link].detect {|l| l[:type] == 'application/vnd.vmware.vcloud.vdc+xml'}[:href]
+    vdc = @service.get_vdc(vdc_href.split('/')[-1]).body
+    vdc[:AvailableNetworks][:Network] = [vdc[:AvailableNetworks][:Network]] if vdc[:AvailableNetworks][:Network].is_a?(Hash)
+    vdc[:ResourceEntities][:ResourceEntity] = [vdc[:ResourceEntities][:ResourceEntity]] if vdc[:ResourceEntities][:ResourceEntity].is_a?(Hash)
+    if vdc.has_key?(:VdcStorageProfiles)
+      vdc[:VdcStorageProfiles][:VdcStorageProfile] = [vdc[:VdcStorageProfiles][:VdcStorageProfile]] if vdc[:VdcStorageProfiles][:VdcStorageProfile].is_a?(Hash)
+    end
+    vdc
+  end
+
+end