fog 0.7.1 → 2.3.0

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

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

@@ -0,0 +1,101 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+Shindo.tests("Compute::VcloudDirector | vms", ['vclouddirector', 'all']) do
+  pending if Fog.mocking?
+  vapp = vapps.find {|v| v.vms.size >= 1}
+
+  # we can't run these tests if there is no vapps with a vm in them
+  pending unless vapp
+
+  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("#deployed").returns(String){ vm.deployed.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 }
+    tests("#network_adapters").returns(Array){ vm.network_adapters.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
+
+  # We should also be able to find this VM via Query API
+  #  :name is not unique for VMs though, so let us query by href
+  tests("Compute::VcloudDirector | vm", ['find_by_query']) do
+    tests('we can retrieve :name without lazy loading').returns(vm.name) do
+      query_vm = vms.find_by_query(:filter => "href==#{vm.href}").first
+      query_vm.attributes[:name]
+    end
+    tests('we can retrieve name via model object returned by query').returns(vm.name) do
+      query_vm = vms.find_by_query(:filter => "href==#{vm.href}").first
+      query_vm.name
+    end
+  end
+
+end

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

@@ -0,0 +1,16 @@
+Shindo.tests('Compute::VcloudDirector | admin requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+
+  tests('#get_vcloud').data_matches_schema(VcloudDirector::Compute::Schema::VCLOUD_TYPE) do
+     @service.get_vcloud.body
+  end
+
+  @org = VcloudDirector::Compute::Helper.current_org(@service)
+
+  tests('#get_org_settings').returns(Hash) do
+    pending if Fog.mocking?
+    @service.get_org_settings(@org[:href].split('/').last).body.class
+  end
+
+end

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

@@ -0,0 +1,42 @@
+Shindo.tests('Compute::VcloudDirector | catalog requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+  @org = VcloudDirector::Compute::Helper.current_org(@service)
+
+  tests('#get_catalog').data_matches_schema(VcloudDirector::Compute::Schema::CATALOG_TYPE) do
+    link = @org[:Link].find do |l|
+      l[:rel] == 'down' && l[:type] == 'application/vnd.vmware.vcloud.catalog+xml'
+    end
+    @catalog_id = link[:href].split('/').last
+    pending if Fog.mocking?
+    @catalog = @service.get_catalog(@catalog_id).body
+  end
+
+  tests('#get_catalog_metadata').data_matches_schema(VcloudDirector::Compute::Schema::METADATA_TYPE) do
+    pending if Fog.mocking?
+    @service.get_catalog_metadata(@catalog_id).body
+  end
+
+  tests('#get_control_access_params_catalog').data_matches_schema(VcloudDirector::Compute::Schema::CONTROL_ACCESS_PARAMS_TYPE) do
+    pending if Fog.mocking?
+    @service.get_control_access_params_catalog(@org[:href].split('/').last, @catalog_id).body
+  end
+
+  tests('#get_catalogs_from_query') do
+    pending if Fog.mocking?
+    %w[idrecords records references].each do |format|
+      tests(":format => #{format}") do
+        tests('#body').data_matches_schema(VcloudDirector::Compute::Schema::CONTAINER_TYPE) do
+          @body = @service.get_catalogs_from_query(:format => format).body
+        end
+        key = (format == 'references') ? 'CatalogReference' : 'CatalogRecord'
+        tests("#body.key?(:#{key})").returns(true) { @body.key?(key.to_sym) }
+      end
+    end
+  end
+
+  tests('Retrieve non-existent Catalog').raises(Fog::Compute::VcloudDirector::Forbidden) do
+    @service.get_catalog('00000000-0000-0000-0000-000000000000')
+  end
+
+end

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

@@ -0,0 +1,178 @@
+Shindo.tests('Compute::VcloudDirector | disk requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+  @disk_name = VcloudDirector::Compute::Helper.test_name
+
+  tests('error conditions') do
+    tests('#post_upload_disk') do
+      tests('Invalid size').raises(Fog::Compute::VcloudDirector::BadRequest) do
+        @service.post_upload_disk('00000000-0000-0000-0000-000000000000', @disk_name, -1)
+      end
+    end
+    tests('Upload to non-existent vDC').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.post_upload_disk('00000000-0000-0000-0000-000000000000', @disk_name, 0)
+    end
+    tests('Retrieve non-existent Disk').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_disk('00000000-0000-0000-0000-000000000000')
+    end
+    tests('Retrieve owner of non-existent Disk').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_disk_owner('00000000-0000-0000-0000-000000000000')
+    end
+    tests('Retrieve VM list for non-existent Disk').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_vms_disk_attached_to('00000000-0000-0000-0000-000000000000')
+    end
+    tests('Delete non-existent Disk').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.delete_disk('00000000-0000-0000-0000-000000000000')
+    end
+  end
+
+  @org = VcloudDirector::Compute::Helper.current_org(@service)
+  @size = 1024
+
+  tests('Upload and manipulate a disk') do
+    tests('#post_upload_disk').data_matches_schema(VcloudDirector::Compute::Schema::DISK_TYPE) do
+      @vdc_id = VcloudDirector::Compute::Helper.first_vdc_id(@org)
+      @disk = @service.post_upload_disk(@vdc_id, @disk_name, @size).body
+    end
+    @service.process_task(@disk[:Tasks][:Task])
+    @disk_id = @disk[:href].split('/').last
+
+    tests("#get_disk(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::DISK_TYPE) do
+      @disk = @service.get_disk(@disk_id).body
+    end
+    tests("disk[:name]").returns(@disk_name) { @disk[:name] }
+    tests("disk[:size]").returns(@size) { @disk[:size].to_i }
+
+    tests("#get_disk_owner(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::OWNER_TYPE) do
+      @owner = @service.get_disk_owner(@disk_id).body
+    end
+    tests("owner[:User][:name]").returns(@service.user_name) { @owner[:User][:name] }
+
+    #tests("#put_disk(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::TASK_TYPE) do
+    #  @disk_name += '-renamed'
+    #  @task = @service.put_disk(@disk_id, @disk_name).body
+    #end
+    #@service.process_task(@task)
+    #tests("#get_disk(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::DISK_TYPE) do
+    #  @disk = @service.get_disk(@disk_id).body
+    #end
+    #tests("disk[:name]").returns(@disk_name) { @disk[:name] }
+    #tests("disk[:size]").returns(@size) { @disk[:size].to_i } # shouldn't change
+
+    tests('disk metadata') do
+      pending if Fog.mocking?
+
+      tests("#put_disk_metadata_item_metadata(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::TASK_TYPE) do
+        @task = @service.put_disk_metadata_item_metadata(@disk_id, 'fog-test-key', 'fog-test-value').body
+      end
+      @service.process_task(@task)
+
+      tests("#put_disk_metadata_item_metadata(#{@disk_id})") do
+        tests("#put_disk_metadata_item_metadata(Boolean)").returns(true) do
+          task = @service.put_disk_metadata_item_metadata(@disk_id, 'fog-test-boolean', true).body
+          @service.process_task(task)
+        end
+        tests("#put_disk_metadata_item_metadata(DateTime)").returns(true) do
+          task = @service.put_disk_metadata_item_metadata(@disk_id, 'fog-test-datetime', DateTime.now).body
+          @service.process_task(task)
+        end
+        tests("#put_disk_metadata_item_metadata(Number)").returns(true) do
+          task = @service.put_disk_metadata_item_metadata(@disk_id, 'fog-test-number', 111).body
+          @service.process_task(task)
+        end
+      end
+
+      tests("#post_update_disk_metadata(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::TASK_TYPE) do
+        metadata = {
+          'fog-test-key-update' => 'fog-test-value-update',
+          'fog-test-boolean-update' => false,
+          'fog-test-datetime-update' => DateTime.now,
+          'fog-test-number-update' => 222
+        }
+        @task = @service.post_update_disk_metadata(@disk_id, metadata).body
+      end
+      @service.process_task(@task)
+
+      tests("#get_disk_metadata(#{@disk_id})") do
+        tests('response format').data_matches_schema(VcloudDirector::Compute::Schema::METADATA_TYPE) do
+          @metadata = @service.get_disk_metadata(@disk_id).body
+        end
+        tests('TypedValue') do
+          pending if @service.api_version.to_f < 5.1
+          tests('key').returns('MetadataStringValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-key'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('boolean').returns('MetadataBooleanValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-boolean'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('datetime').returns('MetadataDateTimeValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-datetime'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('number').returns('MetadataNumberValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-number'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('key-update').returns('MetadataStringValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-key-update'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('boolean-update').returns('MetadataBooleanValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-boolean-update'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('datetime-update').returns('MetadataDateTimeValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-datetime-update'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('number-update').returns('MetadataNumberValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-number-update'}
+            entry[:TypedValue][:xsi_type]
+          end
+        end
+      end
+    end
+
+    tests("#get_vms_disk_attached_to(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::VMS_TYPE) do
+      pending if Fog.mocking?
+      @service.get_vms_disk_attached_to(@disk_id).body
+    end
+
+    tests("#delete_disk(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::TASK_TYPE) do
+      @task = @service.delete_disk(@disk_id).body
+    end
+    @service.process_task(@task)
+  end
+
+  tests('Disk no longer exists') do
+    tests("#get_disk(#{@disk_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_disk(@disk_id)
+    end
+    tests("#get_disk_owner(#{@disk_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_disk_owner(@disk_id)
+    end
+    tests("#get_disk_metadata(#{@disk_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      pending if Fog.mocking?
+      @service.get_disk_metadata(@disk_id)
+    end
+    tests("#delete_disk(#{@disk_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.delete_disk(@disk_id)
+    end
+  end
+
+  tests('#get_disks_from_query') do
+    pending if Fog.mocking?
+    %w[idrecords records references].each do |format|
+      tests(":format => #{format}") do
+        tests('#body').data_matches_schema(VcloudDirector::Compute::Schema::CONTAINER_TYPE) do
+          @body = @service.get_disks_from_query(:format => format).body
+        end
+        key = (format == 'references') ? 'DiskReference' : 'DiskRecord'
+        tests("#body.key?(:#{key})").returns(true) { @body.key?(key.to_sym) }
+      end
+    end
+  end
+
+end