fog 1.34.0 → 1.35.0

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

@@ -1,32 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | clone_server request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-  servers = compute.servers
-  (servers.all :name_matches => test_ephemeral_vm_name).each do |s|
-    s.destroy
-  end
-
-  tests('clone_server should') do
-    raises(ArgumentError, 'raise exception when template nil') do
-      compute.clone_server 'fooserver', nil
-    end
-    raises(ArgumentError, 'raise exception when name nil') do
-      compute.clone_server nil, 'fooref'
-    end
-
-    compute.default_template = test_template_name
-    tmpl = compute.default_template
-    test('accept a string template ref') do
-      ref = compute.clone_server test_ephemeral_vm_name, tmpl.reference
-      (ref =~ /OpaqueRef:/) == 0 and !(servers.custom_templates.find { |s| s.reference == ref }).nil?
-    end
-    test('accept a Server object') do
-      ref = compute.clone_server test_ephemeral_vm_name, tmpl
-      (ref =~ /OpaqueRef:/) == 0 and !(servers.custom_templates.find { |s| s.reference == ref }).nil?
-    end
-  end
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when ref,class missing') { compute.clone_server }
-  end
-end

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

@@ -1,20 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | create_network request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-
-  tests('success') do
-    test('#create_network') do
-      @ref = compute.create_network 'test-net'
-      !(compute.networks.find { |n| n.reference == @ref }).nil?
-    end
-    test('#create_network with description') do
-      # Destroy previously created network
-      compute.networks.get(@ref).destroy
-      @ref = compute.create_network 'test-net', :description => 'foo'
-      !(compute.networks.find { |n| n.description == 'foo' }).nil?
-    end
-  end
-
-  compute.destroy_network @ref
-
-end

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

@@ -1,129 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | create_server request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-  servers = compute.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
-
-  tests('create_server should') do
-    raises(StandardError, 'raise exception when template nil') do
-      compute.create_server 'fooserver', nil
-    end
-
-    ref = compute.create_server test_ephemeral_vm_name, test_template_name
-    test('return a valid reference') do
-      if (ref != "OpaqueRef:NULL") and (ref.split("1") != "NULL")
-        true
-      else
-        false
-      end
-    end
-  end
-
-  tests('get_vm_by_name should') do
-    test('return a valid OpaqueRef') do
-      (compute.get_vm_by_name(test_template_name) =~ /OpaqueRef:/) and \
-        (compute.get_vm_by_name(test_template_name) != "OpaqueRef:NULL" )
-    end
-    returns(nil, 'return nil if VM does not exist') { compute.get_vm_by_name('sdfsdf') }
-  end
-
-  tests('create_server_raw should') do
-    raises(ArgumentError, 'raise exception when name_label nil') do
-      compute.create_server_raw
-    end
-    test('create a server') do
-      ref = compute.create_server_raw(
-        {
-          :name_label => test_ephemeral_vm_name,
-          :affinity => compute.hosts.first
-        }
-      )
-      valid_ref? ref
-    end
-    test('create a server with name foobar') do
-      ref = compute.create_server_raw(
-        {
-          :name_label => test_ephemeral_vm_name,
-          :affinity => compute.hosts.first
-        }
-      )
-      (compute.servers.get ref).name == test_ephemeral_vm_name
-    end
-    test('set the PV_bootloader attribute to eliloader') do
-      ref = compute.create_server_raw(
-        {
-          :name_label => test_ephemeral_vm_name,
-          :affinity => compute.hosts.first,
-          :PV_bootloader => 'eliloader',
-        }
-      )
-      (compute.servers.get ref).pv_bootloader == 'eliloader'
-    end
-    test('set the :pv_bootloader attribute to eliloader') do
-      ref = compute.create_server_raw(
-        {
-          :name_label => test_ephemeral_vm_name,
-          :affinity => compute.hosts.first,
-          :pv_bootloader => 'eliloader',
-        }
-      )
-      (compute.servers.get ref).pv_bootloader == 'eliloader'
-    end
-    test('set the "vcpus_attribute" to 1') do
-      ref = compute.create_server_raw(
-        {
-          :name_label => test_ephemeral_vm_name,
-          :affinity => compute.hosts.first,
-          'vcpus_max' => '1',
-        }
-      )
-      (compute.servers.get ref).vcpus_max == '1'
-    end
-    tests('set lowercase hash attributes') do
-      %w{
-        VCPUs_params
-        HVM_boot_params
-      }.each do |a|
-        test("set the :#{a} to { :foo => 'bar' }") do
-          ref = compute.create_server_raw(
-            {
-              :name_label => test_ephemeral_vm_name,
-              :affinity => compute.hosts.first,
-              a.downcase.to_sym => {:foo => :bar},
-            }
-          )
-          eval "(compute.servers.get ref).#{a.to_s.downcase}['foo'] == 'bar'"
-        end
-      end
-      %w{ VCPUs_at_startup
-          VCPUs_max
-          PV_bootloader_args
-          PV_bootloader
-          PV_kernel
-          PV_ramdisk
-          PV_legacy_args
-      }.each do |a|
-        test("set the :#{a} to 1") do
-          ref = compute.create_server_raw(
-            {
-              :name_label => test_ephemeral_vm_name,
-              :affinity => compute.hosts.first,
-              a.downcase.to_sym => '1',
-            }
-          )
-          eval "(compute.servers.get ref).#{a.to_s.downcase} == '1'"
-        end
-      end
-    end
-  end
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when ref,class missing') { compute.create_server }
-  end
-end

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

@@ -1,54 +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] | create_sr request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-
-  tests('#create_sr "FOG TEST SR" with device /dev/sdb') do
-    test('create an EXT SR') do
-      ref = compute.create_sr compute.hosts.first.reference,
-                             'FOG TEST SR',
-                             'ext',
-                             '',
-                             { :device => '/dev/sdb' },
-                             '0',
-                             'user',
-                             false,
-                             {}
-      valid_ref? ref
-    end
-
-    raises(Fog::XenServer::RequestFailed, 'raise when device in use') do
-      ref = compute.create_sr compute.hosts.first.reference,
-                             'FOG TEST SR',
-                             'ext',
-                             '',
-                             { :device => '/dev/sdb' },
-                             '0',
-                             'user',
-                             false,
-                             {}
-      valid_ref? ref
-    end
-  end
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when arguments missing') { compute.create_sr }
-  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/requests/compute/create_vdi_tests.rb

@@ -1,80 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | create_vdi request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-  sr = compute.storage_repositories.find { |sr| sr.name == 'Local storage' }
-
-  tests('create_vdi should') do
-    raises(ArgumentError, 'raise ArgumentError if virtual_size is no specified') do
-      ref = compute.create_vdi( {
-        :storage_repository => sr,
-        :name => 'foovdi',
-        :type => 'system',
-        :read_only => false,
-        :sharable => false,
-        :other_config => {}
-      } )
-    end
-    raises(ArgumentError, 'raise ArgumentError if type is no specified') do
-      ref = compute.create_vdi( {
-        :storage_repository => sr,
-        :name => 'foovdi',
-        :virtual_size => '8589934592',
-        :read_only => false,
-        :sharable => false,
-        :other_config => {}
-      } )
-      valid_ref? ref
-    end
-    raises(ArgumentError, 'raise ArgumentError if read_only is no specified') do
-      ref = compute.create_vdi( {
-        :storage_repository => sr,
-        :name => 'foovdi',
-        :virtual_size => '8589934592',
-        :type => 'system',
-        :sharable => false,
-        :other_config => {}
-      } )
-      valid_ref? ref
-    end
-    raises(ArgumentError, 'raise ArgumentError if sharable is no specified') do
-      ref = compute.create_vdi( {
-        :storage_repository => sr,
-        :name => 'foovdi',
-        :virtual_size => '8589934592',
-        :type => 'system',
-        :read_only => false,
-        :other_config => {}
-      } )
-      valid_ref? ref
-    end
-    raises(ArgumentError, 'raise ArgumentError if other_config is no specified') do
-      ref = compute.create_vdi( {
-        :storage_repository => sr,
-        :name => 'foovdi',
-        :virtual_size => '8589934592',
-        :type => 'system',
-        :read_only => false,
-        :sharable => false,
-      } )
-      valid_ref? ref
-    end
-    test('create a VDI') do
-      ref = compute.create_vdi( {
-        :storage_repository => sr,
-        :name => 'foovdi',
-        :virtual_size => '8589934592',
-        :type => 'system',
-        :read_only => false,
-        :sharable => false,
-        :other_config => {}
-      } )
-      valid_ref? ref
-    end
-  end
-
-  compute.vdis.each { |vdi| vdi.destroy if vdi.name == 'foovdi' }
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when vm_ref,net_ref missing') { compute.create_vdi }
-  end
-end

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

@@ -1,88 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | create_vif request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-  servers = compute.servers
-  # pre-flight cleanup
-  (servers.all :name_matches => test_ephemeral_vm_name).each do |s|
-    s.destroy
-  end
-
-  tests('create_vif should') do
-    vm_ref = compute.create_server test_ephemeral_vm_name, test_template_name
-    ref = compute.create_vif vm_ref, compute.networks.first.reference
-    s = servers.get vm_ref
-    test('return a valid reference') do
-      if (ref != "OpaqueRef:NULL") and (ref.split("1") != "NULL")
-        true
-      else
-        false
-      end
-    end
-    test('add the VIF to the server') do
-      !(s.vifs.find { |vif| vif.reference == ref }).nil?
-    end
-    raises(ArgumentError, 'raise ArgumentError when vm_ref nil') do
-      ref = compute.create_vif nil, compute.networks.first.reference
-    end
-    raises(ArgumentError, 'raise ArgumentError when network_ref nil') do
-      ref = compute.create_vif vm_ref, nil
-    end
-    test('create a VIF with device number 9') do
-      ref = compute.create_vif vm_ref, compute.networks.first.reference, 9
-      s.reload
-      (compute.vifs.get(ref).device == 9.to_s) and \
-        !(s.vifs.find { |vif| vif.reference == ref }).nil?
-    end
-  end
-
-  tests('create_vif_custom should') do
-    vm_ref = compute.create_server test_ephemeral_vm_name, test_template_name
-    network_ref = compute.networks.first.reference
-    conf = {
-      'MAC_autogenerated' => 'True',
-      'VM' => vm_ref,
-      'network' => network_ref,
-      'MAC' => '',
-      'device' => '4',
-      'MTU' => '0',
-      'other_config' => {},
-      'qos_algorithm_type' => 'ratelimit',
-      'qos_algorithm_params' => {}
-    }
-    ref = compute.create_vif_custom conf
-    s = servers.get vm_ref
-    test('return a valid reference') do
-      if (ref != "OpaqueRef:NULL") and (ref.split("1") != "NULL")
-        true
-      else
-        false
-      end
-    end
-    test('add the VIF to the server') do
-      !(s.vifs.find { |vif| vif.reference == ref }).nil?
-    end
-    raises(ArgumentError, 'raise ArgumentError when conf is not a Hash') do
-      conf['device'] = '5'
-      ref = compute.create_vif_custom 'foobar'
-    end
-    test('create a VIF with device number 9') do
-      conf['device'] = '9'
-      ref = compute.create_vif_custom conf
-      s.reload
-      (compute.vifs.get(ref).device == 9.to_s) and \
-        !(s.vifs.find { |vif| vif.reference == ref }).nil?
-    end
-    test('create a VIF with MAC 11:22:33:44:55:66') do
-      conf['MAC_autogenerated'] = 'False'
-      conf['MAC'] = '11:22:33:44:55:66'
-      conf['device'] = '6'
-      ref = compute.create_vif_custom conf
-      vif = compute.vifs.get ref
-      vif.mac == '11:22:33:44:55:66'
-    end
-  end
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when vm_ref,net_ref missing') { compute.create_vif }
-  end
-end

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

@@ -1,36 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | create_vlan request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-
-  tests('success') do
-    test('#create_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
-      @ref.start_with? "OpaqueRef"
-    end
-  end
-
-  tests('failure') do
-    test('#create_vlan duplicated') do
-      raises = false
-      # Try to create a VLAN with a duplicated tag
-      begin
-        @ref = compute.create_vlan @pif.reference, 1499, @net.reference
-      rescue Fog::XenServer::RequestFailed => e
-        raises = true if (e.message =~ /NETWORK_ALREADY_CONNECTED/)
-      end
-      raises
-    end
-  end
-
-  compute.destroy_vlan @ref
-  @net.destroy
-
-end

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

@@ -1,13 +0,0 @@
-Shindo.tests('Fog::Compute[:xenserver] | destroy_network request', ['xenserver']) do
-
-  compute = Fog::Compute[:xenserver]
-
-  tests('success') do
-    test('#destroy_network') do
-      @ref = compute.create_network 'test-net'
-      compute.destroy_network @ref
-      (compute.networks.find { |n| n.reference == @ref }).nil?
-    end
-  end
-
-end