fog 1.34.0 → 1.35.0

data/tests/xenserver/requests/compute/destroy_sr_tests.rb

@@ -1,46 +0,0 @@
-#
-# @rubiojr
-#
-# Testing this requires a very specific setup:
-#
-# I use VirtualBox to virtualize XenServer/XCP and create the XenServer VM using
-# two virtual disks under the same SATA controller. One of the virtual disks
-# will be /dev/sdb, used to perform the tests.
-#
-
-Shindo.tests('Fog::Compute[:xenserver] | destroy_sr request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-  # We need the SR available for this to work, so create it first
-  ref = compute.create_sr compute.hosts.first.reference,
-                         'FOG TEST SR',
-                         'ext',
-                         '',
-                         { :device => '/dev/sdb' },
-                         '0',
-                         'user',
-                         false,
-                         {}
-
-  tests('#destroy_sr') do
-    test('destroyed "FOG TEST SR"') do
-      compute.storage_repositories.each do |sr|
-        next unless sr.name == 'FOG TEST SR'
-        sr.pbds.each { |pbd| pbd.unplug }
-      end
-      compute.destroy_sr ref
-      (compute.storage_repositories.find { |sr| sr.name == 'FOG TEST SR' }).nil?
-    end
-
-    raises(Fog::XenServer::RequestFailed,
-           'raises HandleInvalid trying to destroy it twice') do
-      compute.destroy_sr ref
-    end
-  end
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when arguments missing') \
-      { compute.destroy_sr }
-  end
-
-end

data/tests/xenserver/requests/compute/destroy_vdi_tests.rb

@@ -1,25 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | destroy_vdi request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-  sr = compute.storage_repositories.find { |sr| sr.name == 'Local storage' }
-
-  tests('destroy_vdi should') do
-    ref = compute.create_vdi( {
-      :storage_repository => sr,
-      :name => 'foovdi',
-      :virtual_size => '8589934592',
-      :type => 'system',
-      :read_only => false,
-      :sharable => false,
-      :other_config => {}
-    } )
-    raises(Fog::XenServer::RequestFailed, 'destroy it') do
-      compute.destroy_vdi ref
-      compute.vdis.get ref
-    end
-  end
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when vm_ref,net_ref missing') { compute.destroy_vdi }
-  end
-end

data/tests/xenserver/requests/compute/destroy_vlan_tests.rb

@@ -1,36 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | destroy_vlan request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-
-  tests('success') do
-    test('#destroy_vlan') do
-      @net = compute.networks.create :name => 'test-net'
-
-      # try to use a bonded interface first
-      @pif = compute.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
-
-      @ref = compute.create_vlan @pif.reference, 1499, @net.reference
-      compute.destroy_vlan @ref
-      (compute.vlans.reload.find { |v| v.reference == @ref }).nil?
-    end
-  end
-
-  tests('failure') do
-    test('#destroy_vlan invalid') do
-      raises = false
-      # Try to create a VLAN with a duplicated tag
-      begin
-        compute.destroy_vlan @ref
-      rescue Fog::XenServer::RequestFailed => e
-        raises = true if (e.message =~ /HANDLE_INVALID/)
-      end
-      raises
-    end
-  end
-
-  @net.destroy
-
-end

data/tests/xenserver/requests/compute/disable_host_tests.rb

@@ -1,16 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | disable_host request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-  host = compute.hosts.first
-
-  tests('#disable_host') do
-    test('disables the host') do
-      compute.disable_host host.reference
-      host.reload
-      !host.enabled
-    end
-  end
-
-  # Cleanup
-  host.enable
-end

data/tests/xenserver/requests/compute/enable_host_tests.rb

@@ -1,16 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | enable_host request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-  host = compute.hosts.first
-
-  tests('#enable_host') do
-    test('enables the host') do
-      compute.enable_host host.reference
-      host.reload
-      host.enabled
-    end
-  end
-
-  # Cleanup
-  host.enable
-end

data/tests/xenserver/requests/compute/get_record_tests.rb

@@ -1,15 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | get_record request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-  vm_ref = 'alksjdfoiuoiwueroiwe'
-
-  tests('The response should') do
-    raises(Fog::XenServer::RequestFailed, 'when ref invalid') do
-      response = compute.get_record(vm_ref, 'VM')
-    end
-  end
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when ref,class missing') { compute.get_record }
-  end
-end

data/tests/xenserver/requests/compute/set_attribute_tests.rb

@@ -1,66 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | set_attribute request', ['xenserver']) do
-
-  # Setup cleanup
-  destroy_ephemeral_servers
-
-  connection = Fog::Compute[:xenserver]
-  servers = connection.servers
-  server = create_ephemeral_server
-
-  tests('Setting an attribute with set_attribute should') do
-    test('set the PV_bootloader attr to foobar') do
-      response = connection.set_attribute('VM', server.reference, 'PV_bootloader', 'foobar')
-      server.reload
-      server.pv_bootloader == 'foobar'
-    end
-    test('set the PV-bootloader attr to stuff') do
-      response = connection.set_attribute('VM', server.reference, 'PV-bootloader', 'stuff')
-      server.reload
-      server.pv_bootloader == 'stuff'
-    end
-    test('set the other_config attr { "foo" => "bar", :stuff => "crap" }') do
-      response = connection.set_attribute('VM', server.reference, 'other_config', { "foo" => "bar", :stuff => 'crap' })
-      server.reload
-      (server.other_config['foo'] == 'bar') and \
-        (server.other_config['stuff'] == 'crap')
-    end
-    test('set the multiple valued attribute memory_limits }') do
-      server = create_ephemeral_server
-      server.stop 'hard'
-      server.wait_for { not running? }
-      response = connection.set_attribute('VM',
-                                          server.reference,
-                                          'memory_limits',
-                                          '1073741824',
-                                          '1073741824',
-                                          '1073741824',
-                                          '1073741824'
-                                         )
-      server.reload
-      (server.memory_dynamic_max == "1073741824") and \
-        (server.memory_dynamic_min == "1073741824") and \
-        (server.memory_static_max == "1073741824") and \
-        (server.memory_static_min == "1073741824")
-
-      server.start
-    end
-    test('set an array valued attribute') do
-      server = create_ephemeral_server
-      response = connection.set_attribute('VM',
-                                          server.reference,
-                                          'tags',
-                                          ['foo','bar']
-                                         )
-      server.reload
-      server.tags.include?('foo') and server.tags.include?('bar')
-    end
-  end
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when ref,attr,value missing') { connection.get_record }
-  end
-
-  # Teardown cleanup
-  destroy_ephemeral_servers
-
-end

data/tests/xenserver/requests/compute/unplug_pbd_tests.rb

@@ -1,48 +0,0 @@
-#
-# @rubiojr
-#
-# Testing this requires a very specific setup:
-#
-# I use VirtualBox to virtualize XenServer/XCP and create the XenServer VM using
-# two virtual disks under the same SATA controller. One of the virtual disks
-# will be /dev/sdb, used to perform the tests.
-#
-
-Shindo.tests('Fog::Compute[:xenserver] | unplug_pbd request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-  # Creating a new SR automatically plugs the PBD
-  # We need the SR available for this to work, so create it first
-  ref = compute.create_sr compute.hosts.first.reference,
-                         'FOG TEST SR',
-                         'ext',
-                         '',
-                         { :device => '/dev/sdb' },
-                         '0',
-                         'user',
-                         false,
-                         {}
-
-  tests('#unplug_pbd') do
-    test('unplugged') do
-      sr = compute.storage_repositories.find { |sr| sr.name == 'FOG TEST SR' }
-      pbd = sr.pbds.first
-      compute.unplug_pbd pbd.reference
-      pbd.reload
-      pbd.currently_attached == false
-    end
-  end
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when arguments missing') \
-      { compute.unplug_pbd }
-  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

data/tests/xenserver/xenserver_tests.rb

@@ -1,33 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver]', ['xenserver']) do
-
-  tests("Login") do
-    raises(Fog::XenServer::InvalidLogin, 'raises error when invalid password') do
-      conn = Fog::Compute.new({
-        :provider => 'XenServer',
-        :xenserver_url => 'xenserver-test',
-        :xenserver_username => 'root',
-        :xenserver_password => 'asdfsadf'
-
-      })
-    end
-    raises(Fog::XenServer::InvalidLogin, 'raises error when invalid user') do
-      conn = Fog::Compute.new({
-        :provider => 'XenServer',
-        :xenserver_url => 'xenserver-test',
-        :xenserver_username => 'rootffff',
-        :xenserver_password => 'changeme'
-
-      })
-    end
-    raises(SocketError, 'raises error when invalid host') do
-      conn = Fog::Compute.new({
-        :provider => 'XenServer',
-        :xenserver_url => 'xenserver-testlakjsdflkj',
-        :xenserver_username => 'root',
-        :xenserver_password => 'changeme'
-
-      })
-    end
-  end
-
-end