fog 1.34.0 → 1.35.0

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

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

@@ -1,76 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | VLAN model', ['xenserver']) do
-
-  service = Fog::Compute[:xenserver]
-  vlans = service.vlans
-  vlan = vlans.first
-
-  tests('The VLAN model should') do
-    tests('have the action') do
-      %w{ reload destroy save untagged_pif tagged_pif }.each do |action|
-        test(action) { vlan.respond_to? action }
-      end
-    end
-    tests('have attributes') do
-      model_attribute_hash = vlan.attributes
-      attributes = [
-        :reference,
-        :uuid,
-        :__untagged_pif,
-        :__tagged_pif,
-        :tag
-      ]
-      tests("The VLAN model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { vlan.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::VLAN') { vlan.kind_of? Fog::Compute::XenServer::VLAN}
-
-  end
-
-  tests("#save") do
-    test 'should create a VLAN' do
-      @net = service.networks.create :name => 'test-net'
-      # try to use a bonded interface first
-      pif = service.pifs.find { |p| p.device == 'bond0' and p.vlan == "-1" }
-      unless pif
-        pif = compute.pifs.find { |p| p.device == 'eth0' and p.vlan == "-1" }
-      end
-      @vlan = vlans.create :tag => 1499,
-                           :pif => pif,
-                           :network => @net
-      @vlan.is_a? Fog::Compute::XenServer::VLAN
-    end
-    test 'VLAN ID should be 1449' do
-      @vlan.tag == 1499
-    end
-  end
-
-  tests("#destroy") do
-    test 'should destroy the network' do
-      @vlan.destroy
-      @net.destroy
-      (vlans.reload.find { |v| v.reference == @vlan.reference }).nil?
-    end
-  end
-
-  tests("#tagged_pif") do
-    test 'should return a PIF' do
-      vlans.find.first.tagged_pif.is_a? Fog::Compute::XenServer::PIF
-    end
-  end
-
-  tests("#untagged_pif") do
-    test 'should return a PIF' do
-      vlans.find.first.untagged_pif.is_a? Fog::Compute::XenServer::PIF
-    end
-  end
-
-end

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

@@ -1,36 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | Vlans collection', ['xenserver']) do
-
-  service = Fog::Compute[:xenserver]
-
-  tests('The Vlans collection') do
-
-    test('should not be empty') { !service.vlans.empty? }
-
-    test('should be a kind of Fog::Compute::XenServer::Vlans') do
-      service.vlans.kind_of? Fog::Compute::XenServer::Vlans
-    end
-
-    tests('should be able to reload itself').succeeds { service.vlans.reload }
-
-    tests('should be able to get a model') do
-      tests('by reference').succeeds {
-        service.vlans.get(service.vlans.first.reference).is_a? \
-          Fog::Compute::XenServer::VLAN
-      }
-    end
-
-  end
-
-  tests('failures') do
-    test 'with an invalid reference' do
-      raises = false
-      begin
-        service.vlans.get('OpaqueRef:foo')
-      rescue Fog::XenServer::RequestFailed => e
-        raises = true if e.message =~ /HANDLE_INVALID/
-      end
-      raises
-    end
-  end
-
-end