fog 1.31.0 → 1.37.0

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

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

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

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

@@ -1,58 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | PIF model', ['xenserver']) do
-
-  pifs = Fog::Compute[:xenserver].pifs
-  pif = pifs.first
-
-  tests('The PIF model should') do
-    tests('have the action') do
-      test('reload') { pif.respond_to? 'reload' }
-    end
-    tests('have attributes') do
-      model_attribute_hash = pif.attributes
-      attributes = [
-        :reference,
-        :uuid,
-        :physical,
-        :mac,
-        :currently_attached,
-        :device,
-        :metrics,
-        :dns,
-        :gateway,
-        :ip,
-        :ip_configuration_mode,
-        :mtu,
-        :__network,
-        :netmask,
-        :management,
-        :vlan,
-        :other_config,
-        :__host
-      ]
-      tests("The PIF model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { pif.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::PIF') { pif.kind_of? Fog::Compute::XenServer::PIF}
-
-  end
-
-  tests("A real PIF should") do
-    tests("return a valid network") do
-      test("should be a Fog::Compute::XenServer::Network") { pif.network.kind_of? Fog::Compute::XenServer::Network }
-    end
-    tests("return valid host") do
-      test("should be a Fog::Compute::XenServer::Host") { pif.host.kind_of? Fog::Compute::XenServer::Host }
-    end
-
-  end
-
-end

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

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

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

@@ -1,56 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | Pool model', ['xenserver']) do
-
-  pools = Fog::Compute[:xenserver].pools
-  pool = pools.first
-
-  tests('The Pool model should') do
-    tests('have the action') do
-      test('reload') { pool.respond_to? 'reload' }
-    end
-    tests('have attributes') do
-      model_attribute_hash = pool.attributes
-      attributes = [
-        :reference,
-        :uuid,
-        :name,
-        :description,
-        :__default_sr,
-        :__master,
-        :tags,
-        :restrictions,
-        :ha_enabled,
-        :vswitch_controller,
-        :__suspend_image_sr
-      ]
-      tests("The Pool model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { pool.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::Pool') { pool.kind_of? Fog::Compute::XenServer::Pool}
-
-  end
-
-  tests("A real Pool should") do
-    tests("return a valid default_storage_repository") do
-      test("should be a Fog::Compute::XenServer::StorageRepository") { pool.default_storage_repository.kind_of? Fog::Compute::XenServer::StorageRepository }
-    end
-    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
-
-end

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

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