fog 1.34.0 → 1.35.0

data/tests/xenserver/helper.rb

@@ -1,36 +0,0 @@
-def test_template_name
-  ENV['FOG_XENSERVER_TEMPLATE'] || 'squeeze-test'
-end
-
-def test_ephemeral_vm_name
-  'fog-test-server-shindo'
-end
-
-def valid_ref?(ref)
-  (ref =~ /OpaqueRef:/) and \
-    (ref != "OpaqueRef:NULL" )
-end
-
-def create_ephemeral_vm
-  Fog::Compute[:xenserver].servers.create(:name => test_ephemeral_vm_name,
-                                          :template_name => test_template_name)
-end
-
-def create_ephemeral_server
-  create_ephemeral_vm
-end
-
-def destroy_ephemeral_servers
-  servers = Fog::Compute[:xenserver].servers
-  # Teardown 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
-end
-
-def destroy_ephemeral_vms
-  destroy_ephemeral_servers
-end

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

@@ -1,35 +0,0 @@
-
-Shindo.tests('Fog::Compute[:xenserver] | console model', ['xenserver']) do
-  consoles = Fog::Compute[:xenserver].consoles
-  console = consoles.first
-
-  tests('The console model should') do
-    tests('have attributes') do
-      model_attribute_hash = console.attributes
-      attributes = [
-        :reference,
-        :location,
-        :protocol,
-        :uuid,
-        :__vm
-      ]
-      tests("The console model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { console.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::Console') { console.kind_of? Fog::Compute::XenServer::Console }
-  end
-  tests('A real console should') do
-    tests('return valid vm') do
-      test('object') { console.vm.kind_of? Fog::Compute::XenServer::Server }
-    end
-  end
-end

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

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

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

@@ -1,58 +0,0 @@
-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.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

@@ -1,48 +0,0 @@
-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.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

@@ -1,98 +0,0 @@
-
-Shindo.tests('Fog::Compute[:xenserver] | host model', ['xenserver']) do
-
-  hosts = Fog::Compute[:xenserver].hosts
-  host = hosts.first
-
-  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
-      model_attribute_hash = host.attributes
-      attributes = [
-        :reference,
-        :uuid,
-        :name,
-        :address,
-        :allowed_operations,
-        :enabled,
-        :hostname,
-        :__metrics,
-        :name_description,
-        :other_config,
-        :__pbds,
-        :__pifs,
-        :__resident_vms,
-        :__host_cpus,
-        :edition,
-        :software_version
-      ]
-      tests("The host model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { host.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::Host') { host.kind_of? Fog::Compute::XenServer::Host }
-
-  end
-
-  tests("A real host should") do
-    tests("return valid PIFs") do
-      test("as an array") { host.pifs.kind_of? Array }
-      host.pifs.each { |i|
-          test("and each PIF should be a Fog::Compute::XenServer::PIF") { i.kind_of? Fog::Compute::XenServer::PIF}
-      }
-    end
-    tests("return valid PBDs") do
-      test("as an array") { host.pbds.kind_of? Array }
-      host.pbds.each { |i|
-          test("and each PBD should be a Fog::Compute::XenServer::PBD") { i.kind_of? Fog::Compute::XenServer::PBD}
-      }
-    end
-    tests("return valid resident servers") do
-      test("as an array") { host.resident_servers.kind_of? Array }
-      host.resident_servers.each { |i|
-          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
-
-end

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

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

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

@@ -1,79 +0,0 @@
-Shindo.tests('Fog::Compute[:network] | network model', ['xenserver']) do
-
-  networks = Fog::Compute[:xenserver].networks
-  network = networks.first
-
-  tests('The network model should') do
-    tests('have the action') do
-      %w{ reload refresh destroy save vifs pifs  }.each do |action|
-        test(action) { network.respond_to? action }
-        #test("#{action} returns successfully") { server.send(action.to_sym) ? true : false }
-      end
-    end
-    tests('have attributes') do
-      model_attribute_hash = network.attributes
-      attributes = [
-        :reference,
-        :uuid,
-        :__vifs,
-        :tags,
-        :mtu,
-        :bridge,
-        :name,
-        :other_config,
-        :__pifs,
-        :allowed_operations,
-        :current_operations,
-        :blobs
-      ]
-      tests("The network model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { network.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::Network') { network.kind_of? Fog::Compute::XenServer::Network }
-
-  end
-
-  tests("A real network should") do
-    tests("return valid vifs") do
-      test("as an array") { network.vifs.kind_of? Array }
-      network.vifs.each { |i|
-          test("and each VIF should be a Fog::Compute::XenServer::VIF") { i.kind_of? Fog::Compute::XenServer::VIF }
-      }
-    end
-    tests("return valid PIFs") do
-      networks.each do |network|
-          test("as an array") { network.pifs.kind_of? Array }
-          network.pifs.each { |i|
-              test("and each PIF should be a Fog::Compute::XenServer::PIF") { i.kind_of? Fog::Compute::XenServer::PIF}
-          }
-      end
-    end
-
-    test("be able to refresh itself") { network.refresh }
-
-  end
-
-  tests("#save") do
-    test 'should create a network' do
-      @net = networks.create :name => 'foo-net'
-      @net.is_a? Fog::Compute::XenServer::Network
-    end
-  end
-
-  tests("#destroy") do
-    test 'should destroy the network' do
-      @net.destroy
-      (networks.find { |n| n.reference == @net.reference }).nil?
-    end
-  end
-
-end

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

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

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

@@ -1,76 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | PBD model', ['xenserver']) do
-
-  pbds = Fog::Compute[:xenserver].pbds
-  pbd = pbds.first
-
-  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
-      attributes = [
-        :reference,
-        :uuid,
-        :__host,
-        :__sr,
-        :currently_attached
-      ]
-      tests("The PBD model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { pbd.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::PBD') { pbd.kind_of? Fog::Compute::XenServer::PBD}
-
-  end
-
-  tests("A real PBD should") do
-    tests("return valid host") do
-      test("should be a Fog::Compute::XenServer::Host") { pbd.host.kind_of? Fog::Compute::XenServer::Host }
-    end
-    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
-
-end