fog 1.1.0 → 1.2.0

data/tests/vcloud/models/compute/servers_tests.rb

@@ -1,95 +1,23 @@
-Shindo.tests("Vcloud::Compute | servers", ['vcloud']) do
-
-  tests("#server.new('#{Vcloud::Compute::TestSupport::template}')").returns(true) do
-    pending if Fog.mocking?
-    @svr = Vcloud.servers.create :catalog_item_uri => Vcloud::Compute::TestSupport::template, :name => 'fog_test_run', :password => 'password'
-    print "Waiting for server to be ready"
-    @svr.wait_for(1200) { print '.' ; ready? }
-    puts ""
-    @svr.ready?
-  end
-
-  tests("#svr.power_on()").returns(true) do
-    pending if Fog.mocking?
-    @svr.power_on
-    @svr.wait_for { on? }
-    @svr.wait_for { ready? }
-    @svr.on?
-  end
+require 'fog/vcloud/models/compute/servers'
 
-  tests("#svr.description(\"testing\")").returns("testing") do
-    pending if Fog.mocking?
-    @svr.wait_for { ready? }
-    @svr.description = "testing"
-    @svr.save
-    @svr.wait_for { ready? }
-    @svr.description
-  end
-
-  # Power off only stops the OS, doesn't free up resources. #undeploy is for this.
-  tests("#svr.undeploy()").returns(true) do
-    pending if Fog.mocking?
-    @svr.undeploy
-    @svr.wait_for { off? }
-    @svr.wait_for { ready? }
-    @svr.off?
-  end
-
-  tests("#svr.memory(384)").returns(384) do
-    pending if Fog.mocking?
-    raise 'Server template memory already 384m - change to something different' if @svr.memory[:amount] == 384
-    @svr.wait_for { ready? }
-    @svr.memory = 384
-    @svr.save
-    @svr.wait_for { ready? }
-    # Can take a little while for the VM to know it has different ram, and not tied to a task..
-    (1..20).each do |i|
-      break if @svr.reload.memory[:amount] == '384'
-      sleep 1
-    end
-    @svr.reload.memory[:amount]
-  end
-
-  tests("#svr.add_disk(4096)").returns([2, "4096"]) do
-    pending if Fog.mocking?
-    raise 'Server template already has two disks' if @svr.disks.size == 2
-    @svr.wait_for { ready? }
-    @svr.add_disk(4096)
-    @svr.save
-    @svr.wait_for { ready? }
-    # Can take a little while for the VM to know it has different ram, and not tied to a task..
-    (1..20).each do |i|
-      break if @svr.reload.disks.size == 2
-      sleep 1
-    end
-    [
-     @svr.disks.size,
-     @svr.disks[1][:resource][:vcloud_capacity]
-    ]
-  end
+Shindo.tests("Vcloud::Compute | servers", ['vcloud']) do
 
-  tests("#svr.delete_disk(1)").returns(1) do
-    pending if Fog.mocking?
-    raise "Server doesn't have two disks - did previous step fail? " if @svr.disks.size != 2
-    @svr.wait_for { ready? }
-    sleep 5 # otherwise complains about being busy
-    @svr.delete_disk 1
-    @svr.save
-    @svr.wait_for { ready? }
-    # Can take a little while for the VM to know it has different ram, and not tied to a task..
-    (1..20).each do |i|
-      break if @svr.reload.disks.size == 1
-      sleep 1
+  Fog::Vcloud::Compute::SUPPORTED_VERSIONS.each do |version|
+    tests("api version #{version}") do
+      pending if Fog.mocking?
+      instance = Fog::Vcloud::Compute::Servers.new(
+        :connection => Fog::Vcloud::Compute.new(
+          :vcloud_host => 'vcloud.example.com',
+          :vcloud_username => 'username',
+          :vcloud_password => 'password',
+          :vcloud_version => version),
+        :href       =>  "https://vcloud.example.com/api#{(version == '1.0') ? '/v1.0' : ''}/vApp/vapp-1"
+      )
+    
+      tests("collection") do
+        returns(2) { instance.size }
+        returns("https://vcloud.example.com/api#{(version == '1.0') ? '/v1.0' : ''}/vApp/vm-2") { instance.first.href }
+      end
     end
-    @svr.disks.size
   end
-
-  tests("#svr.destroy").raises(Excon::Errors::Forbidden) do
-    pending if Fog.mocking?
-    @svr.destroy
-    sleep 5 # allow cleanup..
-    Vcloud.servers.get(@svr.href) == nil
-  end
-
-
 end

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

@@ -0,0 +1,32 @@
+require 'fog/vcloud/models/compute/vapps'
+require 'fog/vcloud/models/compute/vapp'
+
+Shindo.tests("Vcloud::Compute | vapp", ['vcloud']) do
+
+  Fog::Vcloud::Compute::SUPPORTED_VERSIONS.each do |version|
+    tests("api version #{version}") do
+      pending if Fog.mocking?
+      instance = Fog::Vcloud::Compute.new(
+        :vcloud_host => 'vcloud.example.com',
+        :vcloud_username => 'username',
+        :vcloud_password => 'password',
+        :vcloud_version => version
+      ).get_vapp("https://vcloud.example.com/api#{(version == '1.0') ? '/v1.0' : ''}/vApp/vapp-1")
+      instance.reload
+    
+      tests("#href").returns("https://vcloud.example.com/api#{(version == '1.0') ? '/v1.0' : ''}/vApp/vapp-1") { instance.href }
+      tests("#name").returns("vApp1") { instance.name }
+      tests("#vdc").returns("vDC1"){ instance.vdc.name }
+      tests("#description").returns("Some Description of a vApp") { instance.description }
+      tests("#status").returns('8') { instance.status }
+      tests("#deployed").returns(true) { instance.deployed }
+    
+      tests("#children").returns(2) { instance.children.size }
+      tests("#servers").returns(2) { instance.servers.size }
+    
+      tests("#friendly_status").returns('off') { instance.friendly_status }
+      tests("#on?").returns(false) { instance.on? }
+      tests("#off?").returns(true) { instance.off? }
+    end
+  end
+end

data/tests/vcloud/models/compute/vapps_tests.rb

@@ -0,0 +1,19 @@
+require 'fog/vcloud/models/compute/vapps'
+
+Shindo.tests("Vcloud::Compute | vapps", ['vcloud']) do
+
+  Fog::Vcloud::Compute::SUPPORTED_VERSIONS.each do |version|
+    tests("api version #{version}") do
+      pending if Fog.mocking?
+      instance = Fog::Vcloud::Compute::Vapps.new(
+        :connection => Fog::Vcloud::Compute.new(:vcloud_host => 'vcloud.example.com', :vcloud_username => 'username', :vcloud_password => 'password'),
+        :href       =>  "https://vcloud.example.com/api#{(version == '1.0') ? '/v1.0' : ''}/vdc/1"
+      )
+    
+      tests("collection") do
+        returns(2) { instance.size }
+        returns("https://vcloud.example.com/api#{(version == '1.0') ? '/v1.0' : ''}/vApp/vapp-1") { instance.first.href }
+      end
+    end
+  end
+end

data/tests/vcloud/models/compute/vdc_tests.rb

@@ -0,0 +1,48 @@
+require 'fog/vcloud/models/compute/vdcs'
+require 'fog/vcloud/models/compute/vdc'
+
+Shindo.tests("Vcloud::Compute | vdc", ['vcloud']) do
+
+  Fog::Vcloud::Compute::SUPPORTED_VERSIONS.each do |version|
+    tests("api version #{version}") do
+      pending if Fog.mocking?
+      instance = Fog::Vcloud::Compute.new(
+        :vcloud_host => 'vcloud.example.com',
+        :vcloud_username => 'username',
+        :vcloud_password => 'password',
+        :vcloud_version => version
+      ).get_vdc("https://vcloud.example.com/api#{(version == '1.0') ? '/v1.0' : ''}/vdc/1")
+    
+      instance.reload
+    
+      tests("#href").returns("https://vcloud.example.com/api#{(version == '1.0') ? '/v1.0' : ''}/vdc/1") { instance.href }
+      tests("#name").returns("vDC1") { instance.name }
+      tests('#organization').returns("Org1") { instance.organization.name }
+      tests("#description").returns("Some Description") { instance.description }
+      tests("#network_quota").returns(10) { instance.network_quota }
+      tests("#nic_quota").returns(10) { instance.nic_quota }
+      tests("#vm_quota").returns(10) { instance.vm_quota }
+      tests("#is_enabled").returns(true) { instance.is_enabled }
+    
+      tests("#available_networks") do
+        tests("#size").returns(2) { instance.available_networks.size }
+      end
+    
+      tests("#storage_capacity") do
+        tests("units").returns("MB") { instance.storage_capacity[:Units] }
+        tests("allocated").returns("10240") { instance.storage_capacity[:Allocated] }
+      end
+    
+      tests("#compute_capacity") do
+        tests("cpu") do
+          tests("allocated").returns("20000") { instance.compute_capacity[:Cpu][:Allocated] }
+          tests("units").returns("MHz") { instance.compute_capacity[:Cpu][:Units] }
+        end
+        tests("memory") do
+          tests("allocated").returns("1024") { instance.compute_capacity[:Memory][:Allocated] }
+          tests("units").returns("MB") { instance.compute_capacity[:Memory][:Units] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'fog/vcloud/models/compute/vdcs'
+
+Shindo.tests("Vcloud::Compute | vdcs", ['vcloud']) do
+
+  Fog::Vcloud::Compute::SUPPORTED_VERSIONS.each do |version|
+    tests("api version #{version}") do
+      pending if Fog.mocking?
+
+       instance = Fog::Vcloud::Compute::Vdcs.new(
+        :connection => Fog::Vcloud::Compute.new(
+                          :vcloud_host => 'vcloud.example.com',
+                          :vcloud_username => 'username',
+                          :vcloud_password => 'password',
+                          :vcloud_version => version),
+        :href       =>  "https://vcloud.example.com/api#{(version == '1.0') ? '/v1.0' : ''}/org/1"
+       )
+    
+      tests("collection") do
+        returns(1) { instance.size }
+        returns("https://vcloud.example.com/api#{(version == '1.0') ? '/v1.0' : ''}/vdc/1") { instance.first.href }
+      end
+    end
+  end
+end

data/tests/vsphere/requests/compute/vm_clone_tests.rb

@@ -1,21 +1,29 @@
 Shindo.tests("Fog::Compute[:vsphere] | vm_clone request", 'vsphere') do
-  #require 'guid'
-  template = "50323f93-6835-1178-8b8f-9e2109890e1a"
+  # require 'guid'
   compute = Fog::Compute[:vsphere]
+  response = nil
+  response_linked = nil
 
-  tests("The return value should") do
-    response = compute.vm_clone('instance_uuid' => template, 'name' => 'cloning_vm')
+  template = "/Datacenters/Solutions/vm/Jeff/Templates/centos56gm2"
+  tests("Standard Clone | The return value should") do
+    response = compute.vm_clone('path' => template, 'name' => 'cloning_vm', 'wait' => 1)
     test("be a kind of Hash") { response.kind_of? Hash }
     %w{ vm_ref task_ref }.each do |key|
       test("have a #{key} key") { response.has_key? key }
     end
   end
+
+  template = "/Datacenters/Solutions/vm/Jeff/Templates/centos56gm2"
+  tests("Linked Clone | The return value should") do
+    response = compute.vm_clone('path' => template, 'name' => 'cloning_vm_linked', 'wait' => 1, 'linked_clone' => true)
+    test("be a kind of Hash") { response.kind_of? Hash }
+    %w{ vm_ref task_ref }.each do |key|
+      test("have a #{key} key") { response.has_key? key }
+    end
+  end
+
   tests("When invalid input is presented") do
     raises(ArgumentError, 'it should raise ArgumentError') { compute.vm_clone(:foo => 1) }
-    raises(Fog::Vsphere::Errors::ServiceError,
-           'it should raise ServiceError if a VM already exists with the provided name') do
-      compute.vm_clone('instance_uuid' => '123', 'name' => 'jefftest')
-    end
     raises(Fog::Compute::Vsphere::NotFound, 'it should raise Fog::Compute::Vsphere::NotFound when the UUID is not a string') do
       pending # require 'guid'
       compute.vm_clone('instance_uuid' => Guid.from_s(template), 'name' => 'jefftestfoo')

data/tests/vsphere/requests/compute/vm_create_tests.rb

@@ -0,0 +1,20 @@
+Shindo.tests("Fog::Compute[:vsphere] | vm_create request", 'vsphere') do
+  #require 'guid'
+  path = "/Datacenters/Solutions"
+  compute = Fog::Compute[:vsphere]
+
+  tests("The return value should") do
+    response = compute.vm_create('path' => path, 'name' => 'fog_test_vm', 'cluster' => 'cluster01')
+    test("be a kind of Hash") { response.kind_of? Hash }
+    %w{ vm_ref task_ref }.each do |key|
+      test("have a #{key} key") { response.has_key? key }
+    end
+  end
+  tests("When invalid input is presented") do
+    raises(ArgumentError, 'it should raise ArgumentError') { compute.vm_create(:foo => 1) }
+    raises(Fog::Compute::Vsphere::NotFound, 'it should raise Fog::Compute::Vsphere::NotFound when the UUID is not a string') do
+      pending # require 'guid'
+      compute.vm_create('instance_uuid' => Guid.from_s(template), 'name' => 'jefftestfoo')
+    end
+  end
+end

data/tests/vsphere/requests/compute/vm_migrate_tests.rb

@@ -0,0 +1,16 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_migrate request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  powered_on_vm = '50137835-88a1-436e-768e-9b2677076e67'
+
+  tests('The response should') do
+    response = compute.vm_migrate('instance_uuid' => powered_on_vm)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.has_key? 'task_state' }
+  end
+  
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when instance_uuid option is missing') { compute.vm_migrate }
+  end
+end

data/tests/vsphere/requests/compute/vm_power_on_tests.rb

@@ -5,7 +5,7 @@ Shindo.tests('Fog::Compute[:vsphere] | vm_power_on request', ['vsphere']) do
   powered_off_vm = nil
 
   tests('The response should') do
-    response = compute.vm_power_off('instance_uuid' => powered_off_vm)
+    response = compute.vm_power_on('instance_uuid' => powered_off_vm)
     test('be a kind of Hash') { response.kind_of? Hash }
     test('should have a task_state key') { response.has_key? 'task_state' }
   end

data/tests/vsphere/requests/compute/vm_reconfig_cpus_tests.rb

@@ -0,0 +1,19 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_reconfig_cpus request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  reconfig_target = '50137835-88a1-436e-768e-9b2677076e67'
+  reconfig_spec = 2
+
+  tests('The response should') do
+    response = compute.vm_reconfig_cpus('instance_uuid' => reconfig_target, 'cpus' => reconfig_spec)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.has_key? 'task_state' }
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when instance_uuid option is missing') { compute.vm_reconfig_cpus('cpus' => reconfig_spec) }
+    raises(ArgumentError, 'raises ArgumentError when cpus option is missing') { compute.vm_reconfig_cpus('instance_uuid' => reconfig_target) }
+  end
+
+end

data/tests/vsphere/requests/compute/vm_reconfig_hardware_tests.rb

@@ -0,0 +1,19 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_reconfig_hardware request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  reconfig_target = '50137835-88a1-436e-768e-9b2677076e67'
+  reconfig_spec = {'guestId' => 'rhel5_64Guest'}
+
+  tests('The response should') do
+    response = compute.vm_reconfig_hardware('instance_uuid' => reconfig_target, 'hardware_spec' => reconfig_spec)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.has_key? 'task_state' }
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when instance_uuid option is missing') { compute.vm_reconfig_hardware('hardware_spec' => reconfig_spec) }
+    raises(ArgumentError, 'raises ArgumentError when hardware_spec option is missing') { compute.vm_reconfig_hardware('instance_uuid' => reconfig_target) }
+  end
+
+end

data/tests/vsphere/requests/compute/vm_reconfig_memory_tests.rb

@@ -0,0 +1,19 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_reconfig_memory request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  reconfig_target = '50137835-88a1-436e-768e-9b2677076e67'
+  reconfig_spec = 4096
+
+  tests('The response should') do
+    response = compute.vm_reconfig_memory('instance_uuid' => reconfig_target, 'memory' => reconfig_spec)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.has_key? 'task_state' }
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when instance_uuid option is missing') { compute.vm_reconfig_memory('memory' => reconfig_spec) }
+    raises(ArgumentError, 'raises ArgumentError when memory option is missing') { compute.vm_reconfig_memory('instance_uuid' => reconfig_target) }
+  end
+
+end