fog 1.31.0 → 1.37.0

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

@@ -1,184 +0,0 @@
-
-Shindo.tests('Fog::Compute[:xenserver] | server model', ['xenserver']) do
-
-  connection = Fog::Compute[:xenserver]
-  servers = connection.servers
-  # pre-flight cleanup
-  (servers.all :name_matches => test_ephemeral_vm_name).each do |s|
-    s.destroy
-  end
-  (servers.templates.select { |t| t.name == test_ephemeral_vm_name}).each do |s|
-    s.destroy
-  end
-
-  server = Fog::Compute[:xenserver].servers.create(:name => test_ephemeral_vm_name,
-                                                   :template_name => test_template_name)
-  server.reload
-
-  tests('The server model should') do
-    tests('have the action') do
-      test('reload') { server.respond_to? 'reload' }
-      %w{ affinity set_attribute refresh stop clean_shutdown hard_shutdown start destroy reboot hard_reboot clean_reboot }.each do |action|
-        test(action) { server.respond_to? action }
-        #test("#{action} returns successfully") { server.send(action.to_sym) ? true : false }
-      end
-    end
-    tests('have attributes') do
-      model_attribute_hash = server.attributes
-      attributes = [
-        :reference,
-        :uuid,
-        :is_a_template,
-        :__affinity,
-        :allowed_operations,
-        :__consoles,
-        :domarch,
-        :domid,
-        :__guest_metrics,
-        :is_a_snapshot,
-        :is_a_template,
-        :is_control_domain,
-        :memory_dynamic_max,
-        :memory_dynamic_min,
-        :memory_static_max,
-        :memory_static_min,
-        :memory_target,
-        :metrics,
-        :name_description,
-        :other_config,
-        :power_state,
-        :pv_args,
-        :__resident_on,
-        :__vbds,
-        :__vifs,
-        :vcpus_params,
-        :vcpus_at_startup,
-        :vcpus_max,
-        :hvm_boot_policy,
-        :hvm_boot_params,
-        :pci_bus,
-        :pv_kernel,
-        :pv_ramdisk,
-        :pv_legacy_args,
-        :pv_bootloader_args,
-        :snapshots
-      ]
-      tests("The server model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { server.respond_to? attribute }
-        end
-      end
-      tests("The attributes hash should have key") do
-        attributes.each do |attribute|
-          test("#{attribute}") { model_attribute_hash.key? attribute }
-        end
-      end
-    end
-
-    test('be a kind of Fog::Compute::XenServer::Server') { server.kind_of? Fog::Compute::XenServer::Server }
-    #test('return a Fog::Compute::XenServer::Host affinity') { server.affinity.kind_of? Fog::Compute::XenServer::Host }
-
-  end
-
-  tests("Creating a server") do
-    tests("it should create a server") do
-      s = nil
-      test("named #{test_ephemeral_vm_name}") do
-        s = servers.create(:name => test_ephemeral_vm_name,
-                           :template_name => test_template_name)
-        servers.get(s.reference).name == test_ephemeral_vm_name
-      end
-      test("and destroy it afterwards") { s.destroy }
-    end
-    tests("it should create a server") do
-      s = nil
-      # The template has 2 VIFs already, we add 2 more
-      test("with 4 NICs") do
-        s = servers.create(:name => test_ephemeral_vm_name,
-                           :template_name => test_template_name,
-                           :networks => [connection.default_network, connection.default_network])
-        s.reload
-        s.networks.size == 4
-      end
-      test("and destroy it afterwards") { s.destroy }
-    end
-  end
-
-  tests("A real server should") do
-    tests("return valid vbds") do
-      test("as an array") { server.vbds.kind_of? Array }
-      server.vbds.each { |i|
-        test("and each VBD should be a Fog::Compute::XenServer::VBD") { i.kind_of? Fog::Compute::XenServer::VBD }
-      }
-    end
-
-    tests('return valid consoles') do
-      test('as an array') { server.consoles.kind_of? Array }
-      server.consoles.each { |i|
-        test('and each Console should be a Fog::Compute::XenServer::Console') { i.kind_of? Fog::Compute::XenServer::Console }
-      }
-    end
-
-    test("have 0 or more networks") { server.networks.kind_of? Array }
-
-    tests("have networks if networks > 0") do
-      if server.networks.size > 0
-        server.networks.each do |n|
-          test("and network is of type Fog::Compute::XenServer::Network") do
-            n.kind_of? Fog::Compute::XenServer::Network
-          end
-        end
-      end
-    end
-
-    test("reside on a Fog::Compute::XenServer::Host") { server.resident_on.kind_of? Fog::Compute::XenServer::Host }
-    #test("have Fog::Compute::XenServer::GuestMetrics") { server.guest_metrics.kind_of? Fog::Compute::XenServer::GuestMetrics }
-    test("be able to refresh itself") { server.refresh }
-
-    test("always stop when I say stop('hard')") do
-      server.stop 'hard'
-    end
-
-    # shutdown is async apparently, we wait
-    test("not be running when it's stopped") do
-      server.wait_for { !server.running? }
-      true
-    end
-
-    test("do nothing when I say stop('hard') but it's not running") do
-      server.stop('hard') == false
-    end
-
-    test("always start when I say start") do
-      server.start
-    end
-
-    # start is async apparently, we wait
-    test("be running if I started the server") do
-      server.wait_for { server.running? }
-      true
-    end
-
-    test("set attribute PV_bootloader to supergrub") do
-      server.set_attribute 'PV_bootloader', 'supergrub'
-      server.reload
-      server.pv_bootloader == 'supergrub'
-    end
-
-    tests("Creating a snapshot") do
-      snap_ref = server.snapshot('newsnapshot')
-      tests("it should create a snapshot") do
-        snap_ref = server.snapshot('newsnapshot')
-        servers.get(snap_ref).reference == snap_ref
-      end
-      test("and destroy it afterwards") { servers.get(snap_ref).destroy }
-    end
-
-    test("be able to be destroyed!") do
-      server.destroy
-      servers.get_by_name('fog-test-server-shindo') == nil
-    end
-
-  end
-
-end

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

@@ -1,89 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | servers collection', ['xenserver']) do
-
-  conn = Fog::Compute[:xenserver]
-  destroy_ephemeral_servers
-  servers = conn.servers
-  templates = conn.servers.templates
-
-  tests('The servers collection') do
-    servers = conn.servers.all
-
-    test('should be empty') do
-      servers.empty?
-    end
-
-    server = conn.servers.create(:name => test_ephemeral_vm_name,
-                                 :template_name => test_template_name)
-    test('should NOT be empty') do
-      servers.reload
-      !servers.empty?
-    end
-    server.destroy
-
-    test('should be a kind of Fog::Compute::XenServer::Servers') { servers.kind_of? Fog::Compute::XenServer::Servers }
-
-    test('should be a kind of Fog::Compute::XenServer::Servers') { servers.kind_of? Fog::Compute::XenServer::Servers }
-
-    tests('should have Fog::Compute::XenServer::Servers inside') do
-      conn.servers.each do |s|
-        test { s.kind_of? Fog::Compute::XenServer::Server }
-      end
-    end
-
-    test("should return a list of templates") do
-      templates.kind_of? Array
-    end
-
-    tests("The servers template list should") do
-      test("should include only templates in servers.templates") do
-        ok = true
-        templates.each { |t| ok = false if !t.is_a_template }
-        ok
-      end
-      test("include a #{test_template_name} template in custom_templates") do
-        found = false
-        servers.custom_templates.each do |s|
-          found = (s.name == test_template_name)
-        end
-        found
-      end
-      test("NOT include a #{test_template_name} template in built-in templates") do
-        found = false
-        servers.builtin_templates.each do |s|
-          found = (s.name != test_template_name)
-        end
-        found
-      end
-      # This may fail in other test scenarios with more than one built-in template
-      # present
-      test("include only one custom template") { servers.custom_templates.size == 1 }
-      tests("not include built-in templates in custom_templates") do
-        servers.custom_templates.each do |s|
-          test("#{s.name} is NOT a built-in template") {s.allowed_operations.include?('destroy') }
-        end
-      end
-      test("include more than one built-in templates") { servers.builtin_templates.size >= 1 }
-      tests("not include real servers") do
-        servers.builtin_templates.each do |s|
-          test("#{s.name} is not a real server") { s.is_a_template }
-        end
-      end
-    end
-
-    tests('should be able to reload itself').succeeds { servers.reload }
-
-    tests('should be able to get a model') do
-      server = conn.servers.create(:name => test_ephemeral_vm_name,
-                                   :template_name => test_template_name)
-      test('by name') { servers.get_by_name(test_ephemeral_vm_name).kind_of? Fog::Compute::XenServer::Server }
-      test('by instance uuid') { servers.get_by_uuid(server.uuid).kind_of? Fog::Compute::XenServer::Server }
-      test('by instance reference') { servers.get(server.reference).kind_of? Fog::Compute::XenServer::Server }
-      server.destroy
-    end
-
-  end
-
-  # Teardown cleaup
-  destroy_ephemeral_servers
-
-end

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

@@ -1,30 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | StorageRepositories collection', ['xenserver']) do
-
-  conn = Fog::Compute[:xenserver]
-
-  tests('The storage_repositories collection') do
-    storage_repositories = conn.storage_repositories.all
-
-    test('should not be empty') { !storage_repositories.empty? }
-
-    test('should be a kind of Fog::Compute::XenServer::StorageRepositories') { storage_repositories.kind_of? Fog::Compute::XenServer::StorageRepositories }
-
-    tests('should be an array of Fog::Compute::XenServer::StorageRepository') do
-      storage_repositories.each do |p|
-        test("#{p.uuid} is a Fog::Compute::XenServer::StorageRepository") {
-          p.is_a? Fog::Compute::XenServer::StorageRepository
-        }
-      end
-    end
-
-    tests('should be able to reload itself').succeeds { storage_repositories.reload }
-
-    tests('should be able to get a model') do
-      tests('by reference').succeeds {
-        storage_repositories.get(storage_repositories.first.reference).is_a? Fog::Compute::XenServer::StorageRepository
-      }
-    end
-
-  end
-
-end

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

@@ -1,114 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | StorageRepository model', ['xenserver']) do
-
-  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
-      attributes = [
-        :reference,
-        :name,
-        :uuid,
-        :description,
-        :uuid,
-        :allowed_operations,
-        :current_operations,
-        :content_type,
-        :other_config,
-        :__pbds,
-        :shared,
-        :type,
-        :tags,
-        :__vdis,
-        :physical_size,
-        :physical_utilisation,
-        :virtual_allocation,
-        :sm_config
-      ]
-      tests("The StorageRepository model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { storage_repository.respond_to? attribute }
-        end
-      end
-      tests("The attributes hash should have key") do
-        attributes.each do |attribute|
-          test("#{attribute}") { model_attribute_hash.key? attribute }
-        end
-      end
-    end
-
-    test('be a kind of Fog::Compute::XenServer::StorageRepository') { storage_repository.kind_of? Fog::Compute::XenServer::StorageRepository }
-
-  end
-
-  tests("A real StorageRepository should") do
-    tests("return a valid list of VDIs") do
-      storage_repository.vdis.each do |vdi|
-        test("where #{vdi.uuid} is a Fog::Compute::XenServer::VDI") {
-          vdi.is_a? Fog::Compute::XenServer::VDI
-        }
-      end
-    end
-    tests("return a valid list of PBDs") do
-      storage_repository.pbds.each do |pbd|
-        test("where #{pbd.uuid} is a Fog::Compute::XenServer::PBD") {
-          pbd.is_a? Fog::Compute::XenServer::PBD
-        }
-      end
-    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/models/compute/vbd_tests.rb

@@ -1,115 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | VBD model', ['xenserver']) do
-
-  vbds = Fog::Compute[:xenserver].vbds
-  vbd = vbds.first
-  servers = Fog::Compute[:xenserver].servers
-  server = create_ephemeral_vm
-
-  tests('The VBD model should') do
-    tests('have the action') do
-      test('reload') { vbd.respond_to? 'reload' }
-      test('eject') { vbd.respond_to? 'eject' }
-      test('insert') { vbd.respond_to? 'insert' }
-      test('unplug') { vbd.respond_to? 'unplug' }
-      test('unplug_force') { vbd.respond_to? 'unplug_force' }
-    end
-    tests('have attributes') do
-      model_attribute_hash = vbd.attributes
-      attributes = [
-        :reference,
-        :uuid,
-        :currently_attached,
-        :__vdi,
-        :__vm,
-        :device,
-        :status_detail,
-        :type,
-        :allowed_operations,
-        :current_operations,
-        :status_code,
-        :storage_lock,
-        :mode,
-        :runtime_properties,
-        :unpluggable,
-        :userdevice,
-        :bootable,
-        :empty,
-        :__metrics
-      ]
-      tests("The VBD model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { vbd.respond_to? attribute }
-        end
-      end
-      tests("The attributes hash should have key") do
-        attributes.each do |attribute|
-          test("#{attribute}") { model_attribute_hash.key? attribute }
-        end
-      end
-    end
-
-    test('be a kind of Fog::Compute::XenServer::VBD') { vbd.kind_of? Fog::Compute::XenServer::VBD}
-
-  end
-
-  tests("A real VBD should") do
-    test("have a valid OpaqueRef") do
-      puts vbd.reference
-      (vbd.reference =~ /OpaqueRef:/).eql?(0) and \
-        vbd.reference != "OpaqueRef:NULL"
-    end
-    tests("belong to a VM when attached") do
-      vbds.each do |vbd|
-        test("#{vbd.uuid}") do
-          if vbd.currently_attached
-            (vbd.__vm =~ /OpaqueRef/).eql?(0) and \
-              vbd.__vm != "OpaqueRef:NULL"
-          else
-            true
-          end
-        end
-      end
-    end
-    vbds.each do |vbd|
-      test("return a Fog::Compute::XenServer::VDI when type Disk") do
-        if vbd.type == 'Disk'
-          vbd.vdi.kind_of? Fog::Compute::XenServer::VDI
-        else
-          true
-        end
-      end
-      test("return a nil VDI when type CD") do
-        if vbd.type == 'CD'
-          vbd.vdi.nil?
-        else
-          true
-        end
-      end
-      test("return a VbdMetrics object when attached") do
-        if vbd.currently_attached
-          vbd.metrics.kind_of? Fog::Compute::XenServer::VbdMetrics
-        else
-          vbd.metrics.nil?
-        end
-      end
-    end
-    tests("return valid Server") do
-      test("should be a Fog::Compute::XenServer::Server") { vbd.server.kind_of? Fog::Compute::XenServer::Server }
-    end
-    test("be able to be unplugged when type is CD") do
-       if vbd.type == "CD"
-         vbd.unpluggable == true
-       else
-         vbd.unpluggable == false
-       end
-    end
-
-  end
-
-  tests("VBD Metrics should") do
-    test("have a last_updated Time property") { server.vbds.first.metrics.last_updated.kind_of? Time }
-  end
-
-  destroy_ephemeral_servers
-
-end

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

@@ -1,22 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | VBDs collection', ['xenserver']) do
-
-  conn = Fog::Compute[:xenserver]
-
-  tests('The vbds collection') do
-    vbds = conn.vbds.all
-
-    test('should not be empty') { !vbds.empty? }
-
-    test('should be a kind of Fog::Compute::XenServer::Vbds') { vbds.kind_of? Fog::Compute::XenServer::Vbds }
-
-    tests('should be able to reload itself').succeeds { vbds.reload }
-
-    tests('should be able to get a model') do
-      tests('by reference').succeeds {
-        vbds.get(vbds.first.reference).is_a? Fog::Compute::XenServer::VBD
-      }
-    end
-
-  end
-
-end

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

@@ -1,53 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | VIF model', ['xenserver']) do
-
-  vifs = Fog::Compute[:xenserver].vifs
-  vif = vifs.first
-
-  tests('The VIF model should') do
-    tests('have the action') do
-      test('reload save destroy network server') { vif.respond_to? 'reload' }
-    end
-    tests('have attributes') do
-      model_attribute_hash = vif.attributes
-      attributes = [
-        :reference,
-        :mac,
-        :uuid,
-        :allowed_operations,
-        :currently_attached,
-        :device,
-        :mac_autogenerated,
-        :metrics,
-        :mtu,
-        :__network,
-        :status_code,
-        :status_detail,
-        :__vm
-      ]
-      tests("The VIF model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { vif.respond_to? attribute }
-        end
-      end
-      tests("The attributes hash should have key") do
-        attributes.each do |attribute|
-          test("#{attribute}") { model_attribute_hash.key? attribute }
-        end
-      end
-    end
-
-    test('be a kind of Fog::Compute::XenServer::VIF') { vif.kind_of? Fog::Compute::XenServer::VIF}
-
-  end
-
-  tests("A real VIF should") do
-    tests("return a valid network") do
-      test("should be a Fog::Compute::XenServer::Network") { vif.network.kind_of? Fog::Compute::XenServer::Network }
-    end
-    tests("return valid VIF") do
-      test("should be a Fog::Compute::XenServer::Server") { vif.server.kind_of? Fog::Compute::XenServer::Server }
-    end
-
-  end
-
-end

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

@@ -1,22 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | VIFs collection', ['xenserver']) do
-
-  conn = Fog::Compute[:xenserver]
-
-  tests('The vifs collection') do
-    vifs = conn.vifs.all
-
-    test('should not be empty') { !vifs.empty? }
-
-    test('should be a kind of Fog::Compute::XenServer::Vifs') { vifs.kind_of? Fog::Compute::XenServer::Vifs }
-
-    tests('should be able to reload itself').succeeds { vifs.reload }
-
-    tests('should be able to get a model') do
-      tests('by reference').succeeds {
-        vifs.get(vifs.first.reference).is_a? Fog::Compute::XenServer::VIF
-      }
-    end
-
-  end
-
-end