fog 1.34.0 → 1.35.0

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

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