fog-maestrodev 1.7.0.20121114190951 → 1.8.0.20130109172219

data/tests/vsphere/compute_tests.rb

@@ -21,10 +21,10 @@ Shindo.tests('Fog::Compute[:vsphere]', ['vsphere']) do
 
     tests("When converting an incomplete vm object") do
       test("it should return a Hash") do
-        compute.convert_vm_mob_ref_to_attr_hash(fake_vm_mob_ref).kind_of? Hash
+        compute.send(:convert_vm_mob_ref_to_attr_hash, fake_vm_mob_ref).kind_of? Hash
       end
       tests("The converted Hash should") do
-        attr_hash = compute.convert_vm_mob_ref_to_attr_hash(fake_vm_mob_ref)
+        attr_hash = compute.send(:convert_vm_mob_ref_to_attr_hash, fake_vm_mob_ref)
         test("have a name") { attr_hash['name'] == 'fakevm' }
         test("have a mo_ref") {attr_hash['mo_ref'] == 'vm-123' }
         test("have an id") { attr_hash['id'] == 'vm-123' }
@@ -33,7 +33,7 @@ Shindo.tests('Fog::Compute[:vsphere]', ['vsphere']) do
     end
 
     tests("When passed a nil object") do
-      attr_hash = compute.convert_vm_mob_ref_to_attr_hash(nil)
+      attr_hash = compute.send :convert_vm_mob_ref_to_attr_hash, nil
       test("it should return a nil object") do
         attr_hash.nil?
       end

data/tests/vsphere/models/compute/server_tests.rb

@@ -26,8 +26,7 @@ Shindo.tests('Fog::Compute[:vsphere] | server model', ['vsphere']) do
         :connection_state,
         :hypervisor,
         :name,
-        :ipaddress,
-        :is_a_template]
+        :ipaddress]
       tests("The server model should respond to") do
         attributes.each do |attribute|
           test("#{attribute}") { server.respond_to? attribute }

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

@@ -1,19 +1,11 @@
 Shindo.tests('Fog::Compute[:vsphere] | list_virtual_machines request', ['vsphere']) do
 
-  key = 'virtual_machines'
-
   tests("When listing all machines") do
 
     response = Fog::Compute[:vsphere].list_virtual_machines
 
     tests("The response data format ...") do
-      test("be a kind of Hash") { response.kind_of? Hash }
-      test("have a #{key} key") do
-        response.has_key? key
-      end
-      test("it should be a kind of Array") do
-        response[key].kind_of? Array
-      end
+      test("be a kind of Hash") { response.kind_of? Array }
     end
   end
 
@@ -26,9 +18,9 @@ Shindo.tests('Fog::Compute[:vsphere] | list_virtual_machines request', ['vsphere
       response = Fog::Compute[:vsphere].list_virtual_machines({'instance_uuid' => uuid})
 
       tests("The response should") do
-        test("contain one vm") { response[key].length == 1 }
-        test("contain that is an attribute hash") { response[key][0].kind_of? Hash }
-        test("find jefftest") { response[key].first['name'] == 'jefftest' }
+        test("contain one vm") { response.length == 1 }
+        test("contain that is an attribute hash") { response[0].kind_of? Hash }
+        test("find jefftest") { response.first[:name] == 'jefftest' }
       end
     end
 
@@ -37,7 +29,7 @@ Shindo.tests('Fog::Compute[:vsphere] | list_virtual_machines request', ['vsphere
         response = Fog::Compute[:vsphere].list_virtual_machines({'instance_uuid' => uuid})
 
         tests("The response should") do
-          test("be empty") { response[key].empty? }
+          test("be empty") { response.empty? }
         end
       end
     end

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

@@ -4,18 +4,20 @@ Shindo.tests("Fog::Compute[:vsphere] | vm_clone request", 'vsphere') do
   response = nil
   response_linked = nil
 
-  template = "/Datacenters/Solutions/vm/Jeff/Templates/centos56gm2"
+  template = "folder/rhel64"
+  datacenter = "Solutions"
   tests("Standard Clone | The return value should") do
-    response = compute.vm_clone('path' => template, 'name' => 'cloning_vm', 'wait' => 1)
+    response = compute.vm_clone('datacenter' => datacenter, 'template_path' => template, 'name' => 'cloning_vm', 'wait' => 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
 
-  template = "/Datacenters/Solutions/vm/Jeff/Templates/centos56gm2"
+  template = "folder/rhel64"
+  datacenter = "Solutions"
   tests("Linked Clone | The return value should") do
-    response = compute.vm_clone('path' => template, 'name' => 'cloning_vm_linked', 'wait' => 1, 'linked_clone' => true)
+    response = compute.vm_clone('datacenter' => datacenter, 'template_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 }

data/tests/xenserver/models/compute/host_metrics_tests.rb

@@ -0,0 +1,48 @@
+Shindo.tests('Fog::Compute[:xenserver] | PBD model', ['xenserver']) do
+
+  host = Fog::Compute[:xenserver].hosts.first
+
+  tests('The HostMetrics model should') do
+    tests('have attributes') do
+      model_attribute_hash = host.metrics.attributes
+      attributes = [ 
+        :reference,
+        :uuid,
+        :memory_free,
+        :memory_total,
+        :other_config,
+        :last_updated
+      ]
+      tests("The HostMetrics model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { host.metrics.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+
+    test('be a kind of Fog::Compute::XenServer::HostMetrics') do
+      host.metrics.kind_of? Fog::Compute::XenServer::HostMetrics
+    end
+
+    test("have a last_updated Time property") { host.metrics.last_updated.kind_of? Time }
+    
+    test("return a valid memory_free ammount") do 
+      (host.metrics.memory_free =~ /^\d+$/) == 0 
+    end
+
+    test("have memory_free > 0") { host.metrics.memory_free.to_i > 0 }
+    
+    test("return a valid memory_total ammount") do
+      (host.metrics.memory_total =~ /^\d+$/) == 0 
+    end
+    
+    test("have memory_total > 0") { host.metrics.memory_total.to_i > 0 }
+
+  end
+
+end

data/tests/xenserver/models/compute/host_tests.rb

@@ -7,6 +7,9 @@ Shindo.tests('Fog::Compute[:xenserver] | host model', ['xenserver']) do
   tests('The host model should') do
     tests('have the action') do
       test('reload') { host.respond_to? 'reload' }
+      test('shutdown') { host.respond_to? 'shutdown' }
+      test('disable') { host.respond_to? 'disable' }
+      test('reboot') { host.respond_to? 'reboot' }
     end
 
     tests('have attributes') do
@@ -19,7 +22,7 @@ Shindo.tests('Fog::Compute[:xenserver] | host model', ['xenserver']) do
         :allowed_operations,
         :enabled,
         :hostname,
-        :metrics,
+        :__metrics,
         :name_description,
         :other_config,
         :__pbds,
@@ -61,6 +64,22 @@ Shindo.tests('Fog::Compute[:xenserver] | host model', ['xenserver']) do
           test("and each Server should be a Fog::Compute::XenServer::Server") { i.kind_of? Fog::Compute::XenServer::Server}
       } 
     end
+    tests("return valid HostMetrics") do
+      test("object") { host.metrics.kind_of? Fog::Compute::XenServer::HostMetrics }
+    end
+
+    tests('be able to be') do
+      test('disable') do
+        host.disable
+        host.reload
+        host.enabled == false
+      end
+      test('enabled') do
+        host.enable
+        host.reload
+        host.enabled
+      end
+    end
 
   end
 

data/tests/xenserver/models/compute/pbd_tests.rb

@@ -6,6 +6,7 @@ Shindo.tests('Fog::Compute[:xenserver] | PBD model', ['xenserver']) do
   tests('The PBD model should') do
     tests('have the action') do
       test('reload') { pbd.respond_to? 'reload' }
+      test('unplug') { pbd.respond_to? 'reload' }
     end
     tests('have attributes') do
       model_attribute_hash = pbd.attributes
@@ -13,7 +14,8 @@ Shindo.tests('Fog::Compute[:xenserver] | PBD model', ['xenserver']) do
         :reference,
         :uuid,
         :__host,
-        :__sr
+        :__sr,
+        :currently_attached
       ]
       tests("The PBD model should respond to") do
         attributes.each do |attribute|
@@ -38,6 +40,36 @@ Shindo.tests('Fog::Compute[:xenserver] | PBD model', ['xenserver']) do
     tests("return valid storage repository") do
       test("should be a Fog::Compute::XenServer::StorageRepository") { pbd.storage_repository.kind_of? Fog::Compute::XenServer::StorageRepository }
     end
+    # FIXME: find a better way (faster, lighter) to tests this
+    tests("be plugged or unplugged") do
+      compute = Fog::Compute[:xenserver]
+      # Create a storage repository only to tests PBD.unplug
+      ref = compute.create_sr compute.hosts.first.reference,
+                              'FOG TEST SR',
+                              'ext',
+                              '',
+                              { :device => '/dev/sdb' },
+                              '0',
+                              'user',
+                              false,
+                              {}
+      sr = compute.storage_repositories.find { |sr| sr.name == 'FOG TEST SR' }
+      pbd = sr.pbds.first
+      test('plugged') do
+        pbd.currently_attached == true
+      end
+      pbd.unplug
+      pbd.reload
+      test('unplugged') do
+        pbd.currently_attached == false
+      end
+      # Clean-up
+      compute.storage_repositories.each do |sr|
+        next unless sr.name == 'FOG TEST SR'
+        sr.pbds.each { |pbd| pbd.unplug }
+        sr.destroy
+      end
+    end
 
   end
 

data/tests/xenserver/models/compute/pool_tests.rb

@@ -19,7 +19,8 @@ Shindo.tests('Fog::Compute[:xenserver] | Pool model', ['xenserver']) do
         :tags,
         :restrictions,
         :ha_enabled,
-        :vswitch_controller
+        :vswitch_controller,
+        :__suspend_image_sr
       ]
       tests("The Pool model should respond to") do
         attributes.each do |attribute|
@@ -44,6 +45,11 @@ Shindo.tests('Fog::Compute[:xenserver] | Pool model', ['xenserver']) do
     tests("return valid Host as the master") do
       test("should be a Fog::Compute::XenServer::Host") { pool.master.kind_of? Fog::Compute::XenServer::Host }
     end
+    test("be able to be configured as a valid suspend_image_sr") do
+      pool.suspend_image_sr = pool.default_storage_repository
+      pool.reload
+      pool.suspend_image_sr.reference == pool.default_storage_repository.reference
+    end
 
   end
 

data/tests/xenserver/models/compute/storage_repository_tests.rb

@@ -2,10 +2,14 @@ Shindo.tests('Fog::Compute[:xenserver] | StorageRepository model', ['xenserver']
 
   storage_repositories = Fog::Compute[:xenserver].storage_repositories
   storage_repository = storage_repositories.first
+  conn = Fog::Compute[:xenserver]
 
   tests('The StorageRepository model should') do
     tests('have the action') do
       test('reload') { storage_repository.respond_to? 'reload' }
+      test('destroy') { storage_repository.respond_to? 'destroy' }
+      test('scan') { storage_repository.respond_to? 'scan' }
+      test('save') { storage_repository.respond_to? 'save' }
     end
     tests('have attributes') do
       model_attribute_hash = storage_repository.attributes
@@ -25,7 +29,9 @@ Shindo.tests('Fog::Compute[:xenserver] | StorageRepository model', ['xenserver']
         :tags,
         :__vdis,
         :physical_size,
-        :physical_utilisation
+        :physical_utilisation,
+        :virtual_allocation,
+        :sm_config
       ]
       tests("The StorageRepository model should respond to") do
         attributes.each do |attribute|
@@ -60,4 +66,49 @@ Shindo.tests('Fog::Compute[:xenserver] | StorageRepository model', ['xenserver']
     end
   end
 
+  tests('#save should') do
+    sr = nil
+    test('save with required attributes') do
+      sr = conn.storage_repositories.create :name => 'FOG TEST SR',
+                                            :host => conn.hosts.first,
+                                            :type => 'ext',
+                                            :device_config => { :device => '/dev/sdb' }
+      !(conn.storage_repositories.find { |sr| sr.name == 'FOG TEST SR' }).nil?
+    end
+    # Cleanup
+    sr.pbds.each { |pbd| pbd.unplug }
+    sr.destroy
+    test('save with additional attributes') do
+      sr = conn.storage_repositories.create :name => 'FOG TEST SR',
+                                            :host => conn.hosts.first,
+                                            :type => 'ext',
+                                            :content_type => 'user',
+                                            :device_config => { :device => '/dev/sdb' },
+                                            :shared => false
+      !(conn.storage_repositories.find { |sr| sr.name == 'FOG TEST SR' }).nil?
+    end
+    # Cleanup
+    sr.pbds.each { |pbd| pbd.unplug }
+    sr.destroy
+    test('return sane defaults') do
+      sr = conn.storage_repositories.create :name => 'FOG TEST SR',
+                                            :host => conn.hosts.first,
+                                            :type => 'ext',
+                                            :device_config => { :device => '/dev/sdb' }
+      sr.reload
+      (sr.content_type == 'user') and \
+        (sr.shared == false) and (sr.sm_config.is_a? Hash) and \
+        (sr.description == '')
+    end
+  end
+
+  tests('#destroy should') do
+    test('destroy existing FOG TEST SR') do 
+      sr = (conn.storage_repositories.find { |sr| sr.name == 'FOG TEST SR' })
+      sr.pbds.each { |pbd| pbd.unplug }
+      sr.destroy
+      (conn.storage_repositories.find { |sr| sr.name == 'FOG TEST SR' }).nil?
+    end
+  end
+
 end

data/tests/xenserver/requests/compute/create_sr_tests.rb

@@ -0,0 +1,54 @@
+#
+# @rubiojr
+#
+# Testing this requires a very specific setup:
+#
+# I use VirtualBox to virtualize XenServer/XCP and create the XenServer VM using
+# two virtual disks under the same SATA controller. One of the virtual disks
+# will be /dev/sdb, used to perform the tests.
+#
+
+Shindo.tests('Fog::Compute[:xenserver] | create_sr request', ['xenserver']) do
+
+  compute = Fog::Compute[:xenserver]
+  
+  tests('#create_sr "FOG TEST SR" with device /dev/sdb') do
+    test('create an EXT SR') do
+      ref = compute.create_sr compute.hosts.first.reference,
+                             'FOG TEST SR',
+                             'ext',
+                             '',
+                             { :device => '/dev/sdb' },
+                             '0',
+                             'user',
+                             false,
+                             {}
+      valid_ref? ref
+    end
+
+    raises(Fog::XenServer::RequestFailed, 'raise when device in use') do
+      ref = compute.create_sr compute.hosts.first.reference,
+                             'FOG TEST SR',
+                             'ext',
+                             '',
+                             { :device => '/dev/sdb' },
+                             '0',
+                             'user',
+                             false,
+                             {}
+      valid_ref? ref
+    end
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when arguments missing') { compute.create_sr }
+  end
+
+  # Clean-up
+  compute.storage_repositories.each do |sr|
+    next unless sr.name == 'FOG TEST SR'
+    sr.pbds.each { |pbd| pbd.unplug }
+    sr.destroy
+  end
+
+end

data/tests/xenserver/requests/compute/destroy_sr_tests.rb

@@ -0,0 +1,46 @@
+#
+# @rubiojr
+#
+# Testing this requires a very specific setup:
+#
+# I use VirtualBox to virtualize XenServer/XCP and create the XenServer VM using
+# two virtual disks under the same SATA controller. One of the virtual disks
+# will be /dev/sdb, used to perform the tests.
+#
+
+Shindo.tests('Fog::Compute[:xenserver] | destroy_sr request', ['xenserver']) do
+
+  compute = Fog::Compute[:xenserver]
+  # We need the SR available for this to work, so create it first
+  ref = compute.create_sr compute.hosts.first.reference,
+                         'FOG TEST SR',
+                         'ext',
+                         '',
+                         { :device => '/dev/sdb' },
+                         '0',
+                         'user',
+                         false,
+                         {}
+  
+  tests('#destroy_sr') do
+    test('destroyed "FOG TEST SR"') do
+      compute.storage_repositories.each do |sr|
+        next unless sr.name == 'FOG TEST SR'
+        sr.pbds.each { |pbd| pbd.unplug }
+      end
+      compute.destroy_sr ref
+      (compute.storage_repositories.find { |sr| sr.name == 'FOG TEST SR' }).nil?
+    end
+
+    raises(Fog::XenServer::RequestFailed, 
+           'raises HandleInvalid trying to destroy it twice') do
+      compute.destroy_sr ref
+    end
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when arguments missing') \
+      { compute.destroy_sr }
+  end
+
+end