fog-vcloud-director 0.1.0

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

@@ -0,0 +1,58 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+Shindo.tests('Compute::VcloudDirector | media', ['vclouddirector']) do
+  pending if Fog.mocking?
+
+  medias = vdc.medias
+  media_name = VcloudDirector::Compute::Helper.test_name
+
+  tests('Compute::VcloudDirector | media', ['create']) do
+    tests('#create').returns(Fog::Compute::VcloudDirector::Media) do
+      File.open(VcloudDirector::Compute::Helper.fixture('test.iso'), 'rb') do |iso|
+        medias.create(media_name, iso).class
+      end
+    end
+  end
+
+  media = medias.get_by_name(media_name)
+
+  tests('Compute::VcloudDirector | media') do
+    tests('#href').returns(String) { media.href.class }
+    tests('#type').returns('application/vnd.vmware.vcloud.media+xml') { media.type }
+    tests('#id').returns(String) { media.id.class }
+    tests('#name').returns(String) { media.name.class }
+  end
+
+  tests('Compute::VcloudDirector | media', ['lazy load attrs']) do
+    media.lazy_load_attrs.each do |lazy_attr|
+      tests("##{lazy_attr} is not loaded yet").returns(NonLoaded) { media.attributes[lazy_attr] }
+    end
+  end
+
+  tests('Compute::VcloudDirector | media', ['load on demand']) do
+    tests('#description is not loaded yet').returns(NonLoaded) { media.attributes[:description] }
+    tests('#description is loaded on demand').returns(String) { media.description.class }
+    tests('#description is now loaded').returns(true) { media.attributes[:description] != NonLoaded }
+  end
+
+  tests('Compute::VcloudDirector | media', ['lazy load attrs']) do
+    media.lazy_load_attrs.each do |lazy_attr|
+      tests("##{lazy_attr} is now loaded").returns(true) { media.attributes[lazy_attr] != NonLoaded }
+    end
+  end
+
+  tests('Compute::VcloudDirector | media' ['attributes']) do
+    tests('#status').returns(Fixnum) { media.status.class }
+    tests('#image_type').returns(String) { media.image_type.class }
+    tests('#size').returns(Fixnum) { media.size.class }
+  end
+
+  tests('Compute::VcloudDirector | media', ['get']) do
+    tests('#get_by_name').returns(media.name) { medias.get_by_name(media.name).name }
+    tests('#get').returns(media.id) { medias.get(media.id).id }
+  end
+
+  tests('Compute::VcloudDirector | media', ['destroy']) do
+    tests('#destroy').returns(true) { media.destroy }
+  end
+end

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

@@ -0,0 +1,108 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+Shindo.tests("Compute::VcloudDirector | networks", ['vclouddirector', 'all']) do
+
+  # unless there is at least one network we cannot run these tests
+  pending if organization.networks.empty?
+
+  service = Fog::Compute::VcloudDirector.new
+
+  networks = organization.networks
+  network_raw = nil
+
+  # Run initial tests against a natRouted network, since these
+  # are more likely to be created, and must be populated with
+  # Gateway and EdgeGateway sections
+  network = networks.find do |net|
+    network_raw = service.get_network_complete(net.id).body
+    network_raw[:Configuration][:FenceMode] == 'natRouted'
+  end
+
+  # We don't have a sufficiently populated natRouted network to test against
+  pending if network_raw.nil?
+
+  UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+  IP_REGEX = /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/
+
+  tests("Compute::VcloudDirector | network") do
+    tests("#id").returns(0) { network.id =~ UUID_REGEX }
+    tests("#name").returns(String) { network.name.class }
+    tests("#href").returns(String) { network.href.class }
+    tests("#type").returns("application/vnd.vmware.vcloud.orgNetwork+xml"){ network.type }
+  end
+
+  tests("Compute::VcloudDirector | network", ['lazy load attrs']) do
+    network.lazy_load_attrs.each do |lazy_attr|
+      tests("##{lazy_attr} is not loaded yet").returns(NonLoaded) { network.attributes[lazy_attr] }
+    end
+  end
+
+  tests("Compute::VcloudDirector | network", ['load on demand']) do
+    network_raw_gateway = network_raw[:Configuration][:IpScopes][:IpScope][:Gateway]
+    tests("#gateway is not loaded yet").returns(NonLoaded) { network.attributes[:gateway] }
+    tests("#gateway is loaded on demand").returns(network_raw_gateway) { network.gateway }
+    tests("#gateway is now loaded").returns(true) { network.attributes[:gateway] != NonLoaded }
+  end
+
+  tests("Compute::VcloudDirector | network", ['all lazy load attrs should now be loaded with data']) do
+    network.lazy_load_attrs.each do |field|
+      tests("##{field.to_s} is now loaded").returns(true) { network.attributes[field] != NonLoaded }
+    end
+  end
+
+  tests("Compute::VcloudDirector | network", ['ip_ranges is an array of start-end pairs']) do
+    tests("#ip_ranges is an Array").returns(Array) { network.ip_ranges.class }
+    network.ip_ranges.each do |range|
+      tests("each ip_range has a :start_address").returns(0) { range[:start_address] =~ IP_REGEX }
+      tests("each ip_range has an :end_address").returns(0) { range[:end_address] =~ IP_REGEX }
+    end
+  end
+
+  tests("Compute::VcloudDirector | network", ['is_shared is a string boolean']) do
+    tests("#is_shared is either 'true' or 'false'").returns(true) {
+      [ 'false', 'true' ].include?(network.is_shared)
+    }
+  end
+
+  # NB: get_by_name is buggy with orgVdcNetworks - network names are only
+  # unique per-vDC, not per organization.
+  # As a result, it returns the *first* network matching that name.
+  tests("Compute::VcloudDirector | networks", ['get']) do
+    tests("#get_by_name").returns(network.name) { networks.get_by_name(network.name).name }
+    tests("#get").returns(network.id) { networks.get(network.id).id }
+  end
+
+
+  # Now let's also check against an isolated network, since these have some
+  # additional features like DHCP ServiceConfigurations.
+  isolated_network_raw = nil
+  isolated_network = networks.find do |net|
+    isolated_network_raw = service.get_network_complete(net.id).body
+    isolated_network_raw[:Configuration][:FenceMode] == 'isolated'
+  end
+
+  pending if isolated_network_raw.nil?
+
+  tests("Compute::VcloudDirector | isolated network", ['load on demand']) do
+    tests("#fence_mode is not loaded yet").returns(NonLoaded) { isolated_network.attributes[:fence_mode] }
+    tests("#fence_mode is loaded on demand").returns('isolated') { isolated_network.fence_mode }
+    tests("#fence_mode is now loaded").returns(true) { isolated_network.attributes[:fence_mode] != NonLoaded }
+  end
+
+  # We should also be able to find these same networks via Query API
+  tests("Compute::VcloudDirector | networks", ['find_by_query']) do
+    tests('we can retrieve :name without lazy loading').returns(network.name) do
+      query_network = networks.find_by_query(:filter => "name==#{network.name}").first
+      query_network.attributes[:name]
+    end
+    tests('by name: natRouted').returns(network.name) do
+      query_network = networks.find_by_query(:filter => "name==#{network.name}").first
+      query_network.name
+    end
+    tests('by name: isolated').returns(isolated_network.name) do
+      query_network = networks.find_by_query(:filter => "name==#{isolated_network.name}").first
+      query_network.name
+    end
+  end
+
+end

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

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+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.get_by_name(vcloud_director.org_name)
+
+  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

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

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+Shindo.tests('Compute::VcloudDirector | tasks', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new()
+
+  if Fog.mocking?
+    # add a bunch of tasks
+    50.times do
+      task_id = @service.enqueue_task(
+        "Bogus Task",
+        'BogusTaskName',
+        {
+          :href => 'https://example.com/api/bogus/12345678-1234-1234-1234-123456789012',
+          :name => 'Bogus object',
+          :type => 'application/vnd.vmware.vcloud.bogus+xml'
+        }
+      )
+    end
+  end
+
+  tasks = organization.tasks
+  pending if tasks.empty?
+  task = tasks.first
+
+  tests('Compute::VcloudDirector | task') do
+    tests('#href').returns(String) { task.href.class }
+    tests('#type').returns('application/vnd.vmware.vcloud.task+xml') { task.type }
+    tests('#id').returns(String) { task.id.class }
+    tests('#name').returns(String) { task.name.class }
+    tests('#status').returns(String) { task.status.class }
+    tests('#end_time').returns(Time) { task.end_time.class }
+    tests('#expiry_time').returns(Time) { task.expiry_time.class }
+    tests('#operation').returns(String) { task.operation.class }
+    tests('#operation_name').returns(String) { task.operation_name.class }
+  end
+
+  tests('Compute::VcloudDirector | task', ['get']) do
+    tests('#get_by_name').returns(task.name) { tasks.get_by_name(task.name).name }
+    tests('#get').returns(task.id) { tasks.get(task.id).id }
+  end
+
+  # We should also be able to find tasks via the Query API
+  # NB:  Query name == task.operation_name
+  tests("Compute::VcloudDirector | tasks", ['find_by_query']) do
+    tests('we can retrieve :name without lazy loading').returns(task.operation_name) do
+      query_task = tasks.find_by_query(:filter => "name==#{task.operation_name}").first
+      query_task.attributes[:name]
+    end
+    tests('by name').returns(task.operation_name) do
+      query_task = tasks.find_by_query(:filter => "name==#{task.operation_name}").first
+      query_task.name
+    end
+  end
+
+end

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

@@ -0,0 +1,93 @@
+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" }
+
+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

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

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+Shindo.tests("Compute::VcloudDirector | vapp_templates", ['vclouddirector', 'all']) do
+
+  # unless there is atleast one vapp we cannot run these tests
+  pending if vdc.vapp_templates.empty?
+
+  vapp_templates = vdc.vapp_templates
+  vapp = vapp_templates.first
+
+  tests("Compute::VcloudDirector | vapp_template") 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.vAppTemplate+xml"){ vapp.type }
+  end
+  
+  tests("Compute::VcloudDirector | vapp_template vms") do
+    tests("#vms").returns(Fog::Compute::VcloudDirector::TemplateVms) { vapp.vms.class }
+    pending if Fog.mock?
+    vm = vapp.vms[0]
+    tests("#name").returns(String){ vm.name.class }
+    tests("#type").returns("application/vnd.vmware.vcloud.vm+xml"){ vm.type }
+    
+  end
+
+
+
+end

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

@@ -0,0 +1,61 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+Shindo.tests("Compute::VcloudDirector | vapps", ['vclouddirector', 'all']) do
+
+  # unless there is atleast one vapp we cannot run these tests
+  pending if vdc.vapps.empty?
+
+  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
+
+  tests("Compute::VcloudDirector | vapp", ['custom_fields']) do
+    pending if Fog.mocking?
+    tests("#set_custom_field").returns('2'){ vapp.custom_fields[:custom_field] = '2' }
+
+    tests("#get_custom_field_by_name").returns('2') { vapp.custom_fields[:custom_field].value }
+    tests("#delete_custom_field").returns([]){ vapp.custom_fields.delete(:custom_field); vapp.custom_fields }
+  end
+
+  # We should also be able to find this vApp via Query API
+  tests("Compute::VcloudDirector | vapps", ['find_by_query']) do
+    tests('we can retrieve :name without lazy loading').returns(vapp.name) do
+      query_vapp = vapps.find_by_query(:filter => "name==#{vapp.name}").first
+      query_vapp.attributes[:name]
+    end
+    tests('we can retrieve name via model object returned by query').returns(vapp.name) do
+      query_vapp = vapps.find_by_query(:filter => "name==#{vapp.name}").first
+      query_vapp.name
+    end
+  end
+
+end

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

@@ -0,0 +1,54 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+Shindo.tests("Compute::VcloudDirector | vdcs", ['vclouddirector', 'all']) do
+  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
+
+  pending if Fog.mocking?
+
+  # We should also be able to find this same vdc via Query API
+  tests("Compute::VcloudDirector | vdcs", ['find_by_query']) do
+    tests('we can retrieve :name without lazy loading').returns(vdc.name) do
+      query_vdc = vdcs.find_by_query(:filter => "name==#{vdc.name}").first
+      query_vdc.attributes[:name]
+    end
+    tests('by name').returns(vdc.name) do
+      query_vdc = vdcs.find_by_query(:filter => "name==#{vdc.name}").first
+      query_vdc.name
+    end
+  end
+end