fog 1.8.0 → 1.9.0

data/tests/rackspace/requests/dns/records_tests.rb

@@ -12,8 +12,8 @@ Shindo.tests('Fog::DNS[:rackspace] | dns records requests', ['rackspace', 'dns']
         Fog::DNS[:rackspace].list_records(@domain_id).body
       end
 
-      tests("add_records(#{@domain_id}, [{ :name => 'test1.#{domain_name}', :type => 'A', :data => '192.168.2.1'}])").formats(RECORD_LIST_FORMAT) do
-        response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].add_records(@domain_id, [{ :name => 'test1.' + domain_name, :type => 'A', :data => '192.168.2.1'}])
+      tests("add_records(#{@domain_id}, [{ :name => 'test1.#{domain_name}', :type => 'A', :data => '192.168.2.1', :ttl => 550}])").formats(RECORD_LIST_FORMAT) do
+        response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].add_records(@domain_id, [{ :name => 'test1.' + domain_name, :type => 'A', :data => '192.168.2.1', :ttl => 550}])
         @record_id = response.body['response']['records'].first['id']
         response.body['response']
       end

data/tests/rackspace/requests/load_balancers/content_caching_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Rackspace::LoadBalancers | content_caching', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  given_a_load_balancer_service do
+    given_a_load_balancer do
+      tests('success') do
+        tests("#get_content_caching(#{@lb.id})").formats(CONTENT_CACHING_FORMAT) do
+          @service.get_content_caching(@lb.id).body
+        end
+
+        @lb.wait_for { ready? }
+        tests("#set_content_caching(#{@lb.id}, true)").succeeds do
+          @service.set_content_caching(@lb.id, true)
+        end
+      end
+
+      tests('failure') do
+        tests("#set_content_caching(#{@lb.id}, 'aaa')").raises(Fog::Rackspace::LoadBalancers::InternalServerError) do
+          @service.set_content_caching(@lb.id, 'aaa')
+        end
+      end
+    end
+  end
+end

data/tests/rackspace/requests/load_balancers/helper.rb

@@ -78,7 +78,11 @@ SESSION_PERSISTENCE_FORMAT = {
     'persistenceType' => Fog::Nullable::String
   }
 }
-
+CONTENT_CACHING_FORMAT = {
+  'contentCaching' => {
+    'enabled' => Fog::Boolean
+  }
+}
 ACCESS_LIST_FORMAT = {
   'accessList' => [
     {

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/rhel64"
+  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/rhel64"
+  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_cpu_tests.rb

@@ -0,0 +1,58 @@
+Shindo.tests('Fog::Compute[:xenserver] | HostCpu model', ['xenserver']) do
+
+  host = Fog::Compute[:xenserver].hosts.first
+  host_cpu = host.host_cpus.first
+
+  tests('The HostCpu model should') do
+    tests('have attributes') do
+      model_attribute_hash = host_cpu.attributes
+      attributes = [ 
+        :reference,
+        :uuid,
+        :family,
+        :flags,
+        :__host,
+        :model_name,
+        :model,
+        :number,
+        :other_config,
+        :speed,
+        :stepping,
+        :utilisation,
+        :vendor
+      ]
+      tests("The HostCpu model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { host_cpu.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::HostCpu') do
+      host_cpu.kind_of? Fog::Compute::XenServer::HostCpu
+    end
+
+    test("return a valid host") do
+      host_cpu.host.kind_of? Fog::Compute::XenServer::Host
+    end
+    
+    test("have a valid vendor string") do
+      host_cpu.vendor.kind_of? String
+    end
+    
+    test("have a valid other_config") do
+      host_cpu.other_config.kind_of? Hash
+    end
+    
+    test("have a valid utilisation attribute") do
+      host_cpu.utilisation.kind_of? Float
+    end
+
+  end
+
+end

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

@@ -0,0 +1,48 @@
+Shindo.tests('Fog::Compute[:xenserver] | HostMetrics 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,12 +22,15 @@ Shindo.tests('Fog::Compute[:xenserver] | host model', ['xenserver']) do
         :allowed_operations,
         :enabled,
         :hostname,
-        :metrics,
+        :__metrics,
         :name_description,
         :other_config,
         :__pbds,
         :__pifs,
-        :__resident_vms
+        :__resident_vms,
+        :__host_cpus,
+        :edition,
+        :software_version
       ]
       tests("The host model should respond to") do
         attributes.each do |attribute|
@@ -61,7 +67,32 @@ 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
 
+    tests('return a list of HostCpu') do
+      test('as an Array') do
+        host.host_cpus.kind_of? Array 
+      end
+      test('with one element at least') do
+        host.host_cpus.first.kind_of? Fog::Compute::XenServer::HostCpu
+      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