fog-xenserver 0.0.1.beta1 → 0.0.1.beta2

data/spec/fog/compute/xen_server/models/guests_metrics_spec.rb

@@ -0,0 +1,9 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::GuestsMetrics do
+  let(:guests_metrics_class) { Fog::Compute::XenServer::Models::GuestsMetrics }
+
+  it 'should be a collection of GuestsMetrics' do
+    guests_metrics_class.model.must_equal(Fog::Compute::XenServer::Models::GuestMetrics)
+  end
+end

data/spec/fog/compute/xen_server/models/host_cpu_spec.rb

@@ -0,0 +1,73 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::HostCpu do
+  let(:host_cpu_class) do
+    class Fog::Compute::XenServer::Models::HostCpu
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::HostCpu
+  end
+
+  it 'should associate to a provider class' do
+    host_cpu_class.provider_class.must_equal('host_cpu')
+  end
+
+  it 'should have a collection name' do
+    host_cpu_class.collection_name.must_equal(:host_cpus)
+  end
+
+  it 'should have an unique id' do
+    host_cpu_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 13 attributes' do
+    host_cpu_class.attributes.must_equal([ :reference,
+                                           :family,
+                                           :features,
+                                           :flags,
+                                           :model,
+                                           :model_name,
+                                           :number,
+                                           :other_config,
+                                           :speed,
+                                           :stepping,
+                                           :utilisation,
+                                           :uuid,
+                                           :vendor ])
+  end
+
+  it 'should have 1 association' do
+    host_cpu_class.associations.must_equal(:host => :hosts)
+  end
+
+  it 'should have 14 masks' do
+    host_cpu_class.masks.must_equal(:reference => :reference, 
+                                    :family => :family, 
+                                    :features => :features, 
+                                    :flags => :flags, 
+                                    :model => :model, 
+                                    :model_name => :modelname, 
+                                    :number => :number, 
+                                    :other_config => :other_config, 
+                                    :speed => :speed, 
+                                    :stepping => :stepping, 
+                                    :utilisation => :utilisation, 
+                                    :uuid => :uuid, 
+                                    :vendor => :vendor, 
+                                    :host => :host)
+  end
+
+  it 'should have 1 alias' do
+    host_cpu_class.aliases.must_equal(:modelname => :model_name)
+  end
+
+  it "shouldn't have default values" do
+    host_cpu_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    host_cpu_class.require_before_save.must_equal([])
+  end
+end

data/spec/fog/compute/xen_server/models/host_cpus_spec.rb

@@ -0,0 +1,9 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::HostCpus do
+  let(:host_cpus_class) { Fog::Compute::XenServer::Models::HostCpus }
+
+  it 'should be a collection of HostsCpus' do
+    host_cpus_class.model.must_equal(Fog::Compute::XenServer::Models::HostCpu)
+  end
+end

data/spec/fog/compute/xen_server/models/host_crash_dump_spec.rb

@@ -0,0 +1,57 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::HostCrashDump do
+  let(:host_crash_dump_class) do
+    class Fog::Compute::XenServer::Models::HostCrashDump
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::HostCrashDump
+  end
+
+  it 'should associate to a provider class' do
+    host_crash_dump_class.provider_class.must_equal('host_crashdump')
+  end
+
+  it 'should have a collection name' do
+    host_crash_dump_class.collection_name.must_equal(:host_crash_dumps)
+  end
+
+  it 'should have an unique id' do
+    host_crash_dump_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 5 attributes' do
+    host_crash_dump_class.attributes.must_equal([ :reference,
+                                                  :other_config,
+                                                  :size,
+                                                  :timestamp,
+                                                  :uuid ])
+  end
+
+  it 'should have 1 association' do
+    host_crash_dump_class.associations.must_equal(:host => :hosts)
+  end
+
+  it 'should have 6 masks' do
+    host_crash_dump_class.masks.must_equal(:reference => :reference, 
+                                           :other_config => :other_config, 
+                                           :size => :size, 
+                                           :timestamp => :timestamp, 
+                                           :uuid => :uuid, 
+                                           :host => :host)
+  end
+
+  it "shouldn't have aliases" do
+    host_crash_dump_class.aliases.must_equal({})
+  end
+
+  it "shouldn't have default values" do
+    host_crash_dump_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    host_crash_dump_class.require_before_save.must_equal([])
+  end
+end

data/spec/fog/compute/xen_server/models/host_crash_dumps_spec.rb

@@ -0,0 +1,9 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::HostCrashDumps do
+  let(:host_crash_dumps_class) { Fog::Compute::XenServer::Models::HostCrashDumps }
+
+  it 'should be a collection of HostCrashDumps' do
+    host_crash_dumps_class.model.must_equal(Fog::Compute::XenServer::Models::HostCrashDump)
+  end
+end

data/spec/fog/compute/xen_server/models/host_metrics_spec.rb

@@ -0,0 +1,72 @@
+require 'minitest_helper'
+require 'xmlrpc/datetime'
+
+describe Fog::Compute::XenServer::Models::HostMetrics do
+  let(:host_metrics_class) do
+    class Fog::Compute::XenServer::Models::HostMetrics
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::HostMetrics
+  end
+  let(:host_metrics) { Fog::Compute::XenServer::Models::HostMetrics.new }
+
+  it 'should associate to a provider class' do
+    host_metrics_class.provider_class.must_equal('host_metrics')
+  end
+
+  it 'should have a collection name' do
+    host_metrics_class.collection_name.must_equal(:hosts_metrics)
+  end
+
+  it 'should have an unique id' do
+    host_metrics_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 7 attributes' do
+    host_metrics_class.attributes.must_equal([ :reference,
+                                               :last_updated,
+                                               :live,
+                                               :memory_free,
+                                               :memory_total,
+                                               :other_config,
+                                               :uuid ])
+  end
+
+  it "shouldn't have associations" do
+    host_metrics_class.associations.must_equal({})
+  end
+
+  it 'should have 7 masks' do
+    host_metrics_class.masks.must_equal(:reference => :reference, 
+                                        :last_updated => :last_updated, 
+                                        :live => :live, 
+                                        :memory_free => :memory_free, 
+                                        :memory_total => :memory_total, 
+                                        :other_config => :other_config, 
+                                        :uuid => :uuid)
+  end
+
+  it "shouldn't have aliases" do
+    host_metrics_class.aliases.must_equal({})
+  end
+
+  it "shouldn't have default values" do
+    host_metrics_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    host_metrics_class.require_before_save.must_equal([])
+  end
+
+  describe '#last_updated' do
+    before :each do
+      host_metrics.last_updated = XMLRPC::DateTime.new(2000, 7, 8, 10, 20, 34)
+    end
+
+    it  'should be an instance of Time' do
+      host_metrics.last_updated.must_be_instance_of(Time)
+    end
+  end
+end

data/spec/fog/compute/xen_server/models/host_patch_spec.rb

@@ -0,0 +1,68 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::HostPatch do
+  let(:host_patch_class) do
+    class Fog::Compute::XenServer::Models::HostPatch
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::HostPatch
+  end
+
+  it 'should associate to a provider class' do
+    host_patch_class.provider_class.must_equal('host_patch')
+  end
+
+  it 'should have a collection name' do
+    host_patch_class.collection_name.must_equal(:host_patchs)
+  end
+
+  it 'should have an unique id' do
+    host_patch_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 9 attributes' do
+    host_patch_class.attributes.must_equal([ :reference,
+                                             :applied,
+                                             :description,
+                                             :name,
+                                             :other_config,
+                                             :size,
+                                             :timestamp_applied,
+                                             :uuid,
+                                             :version ])
+  end
+
+  it 'should have 2 associations' do
+    host_patch_class.associations.must_equal(:host => :hosts,
+                                             :pool_patch => :pool_patchs)
+  end
+
+  it 'should have 11 masks' do
+    host_patch_class.masks.must_equal(:reference => :reference, 
+                                      :applied => :applied, 
+                                      :description => :description, 
+                                      :name => :name, 
+                                      :other_config => :other_config, 
+                                      :size => :size, 
+                                      :timestamp_applied => :timestamp_applied, 
+                                      :uuid => :uuid, 
+                                      :version => :version, 
+                                      :host => :host, 
+                                      :pool_patch => :pool_patch)
+  end
+
+  it 'should have 2 aliases' do
+    host_patch_class.aliases.must_equal(:name_description => :description,
+                                        :name_label => :name)
+  end
+
+  it "shouldn't have default values" do
+    host_patch_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    host_patch_class.require_before_save.must_equal([])
+  end
+end

data/spec/fog/compute/xen_server/models/host_patchs_spec.rb

@@ -0,0 +1,9 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::HostPatchs do
+  let(:host_patchs_class) { Fog::Compute::XenServer::Models::HostPatchs }
+
+  it 'should be a collection of HostPatchs' do
+    host_patchs_class.model.must_equal(Fog::Compute::XenServer::Models::HostPatch)
+  end
+end

data/spec/fog/compute/xen_server/models/host_spec.rb

@@ -0,0 +1,231 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Host do
+  let(:host_class) do
+    class Fog::Compute::XenServer::Models::Host
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::Host
+  end
+  let(:host) { Fog::Compute::XenServer::Models::Host.new }
+  let(:service) { Object.new }
+
+  it 'should associate to a provider class' do
+    host_class.provider_class.must_equal('host')
+  end
+
+  it 'should have a collection name' do
+    host_class.collection_name.must_equal(:hosts)
+  end
+
+  it 'should have an unique id' do
+    host_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 39 attributes' do
+    host_class.attributes.must_equal([ :reference,
+                                       :address,
+                                       :allowed_operations,
+                                       :api_version_major,
+                                       :api_version_minor,
+                                       :api_version_vendor,
+                                       :api_version_vendor_implementation,
+                                       :bios_strings,
+                                       :blobs,
+                                       :capabilities,
+                                       :chipset_info,
+                                       :cpu_configuration,
+                                       :cpu_info,
+                                       :current_operations,
+                                       :description,
+                                       :edition,
+                                       :enabled,
+                                       :external_auth_configuration,
+                                       :external_auth_service_name,
+                                       :external_auth_type,
+                                       :guest_vcpus_params,
+                                       :ha_network_peers,
+                                       :ha_statefiles,
+                                       :hostname,
+                                       :license_params,
+                                       :license_server,
+                                       :logging,
+                                       :memory_overhead,
+                                       :name,
+                                       :other_config,
+                                       :patches,
+                                       :power_on_config,
+                                       :power_on_mode,
+                                       :sched_policy,
+                                       :software_version,
+                                       :supported_bootloaders,
+                                       :suspend_image_sr,
+                                       :tags,
+                                       :uuid ])
+  end
+
+  it 'should have 10 associations' do
+    host_class.associations.must_equal(:crashdumps => :crash_dumps, 
+                                       :crash_dump_sr => :storage_repositories, 
+                                       :host_cpus => :host_cpus, 
+                                       :local_cache_sr => :storage_repositories, 
+                                       :metrics => :hosts_metrics, 
+                                       :pbds => :pbds, 
+                                       :pcis => :pcis, 
+                                       :pgpus => :pgpus, 
+                                       :pifs => :pifs, 
+                                       :resident_vms => :servers)
+  end
+
+  it 'should have 49 masks' do
+    host_class.masks.must_equal(:reference => :reference,
+                                :address => :address,
+                                :allowed_operations => :allowed_operations,
+                                :api_version_major => :API_version_major,
+                                :api_version_minor => :API_version_minor,
+                                :api_version_vendor => :API_version_vendor,
+                                :api_version_vendor_implementation => :API_version_vendor_implementation,
+                                :bios_strings => :bios_strings,
+                                :blobs => :blobs,
+                                :capabilities => :capabilities,
+                                :chipset_info => :chipset_info,
+                                :cpu_configuration => :cpu_configuration,
+                                :cpu_info => :cpu_info,
+                                :current_operations => :current_operations,
+                                :description => :description,
+                                :edition => :edition,
+                                :enabled => :enabled,
+                                :external_auth_configuration => :external_auth_configuration,
+                                :external_auth_service_name => :external_auth_service_name,
+                                :external_auth_type => :external_auth_type,
+                                :guest_vcpus_params => :guest_VCPUs_params,
+                                :ha_network_peers => :ha_network_peers,
+                                :ha_statefiles => :ha_statefiles,
+                                :hostname => :hostname,
+                                :license_params => :license_params,
+                                :license_server => :license_server,
+                                :logging => :logging,
+                                :memory_overhead => :memory_overhead,
+                                :name => :name,
+                                :other_config => :other_config,
+                                :patches => :patches,
+                                :power_on_config => :power_on_config,
+                                :power_on_mode => :power_on_mode,
+                                :sched_policy => :sched_policy,
+                                :software_version => :software_version,
+                                :supported_bootloaders => :supported_bootloaders,
+                                :suspend_image_sr => :suspend_image_sr,
+                                :tags => :tags,
+                                :uuid => :uuid,
+                                :crashdumps => :crashdumps,
+                                :crash_dump_sr => :crash_dump_sr,
+                                :host_cpus => :host_CPUs,
+                                :local_cache_sr => :local_cache_sr,
+                                :metrics => :metrics,
+                                :pbds => :PBDs,
+                                :pcis => :PCIs,
+                                :pgpus => :PGPUs,
+                                :pifs => :PIFs,
+                                :resident_vms => :resident_VMs)
+  end
+
+  it 'should have 13 aliases' do
+    host_class.aliases.must_equal(:name_label => :name,
+                                  :API_version_major => :api_version_major,
+                                  :API_version_minor => :api_version_minor,
+                                  :API_version_vendor => :api_version_vendor,
+                                  :API_version_vendor_implementation => :api_version_vendor_implementation,
+                                  :guest_VCPUs_params => :guest_vcpus_params,
+                                  :name_description => :description,
+                                  :host_CPUs => :host_cpus,
+                                  :PBDs => :pbds,
+                                  :PCIs => :pcis,
+                                  :PGPUs => :pgpus,
+                                  :PIFs => :pifs,
+                                  :resident_VMs => :resident_vms)
+  end
+
+  it "shouldn't have default values" do
+    host_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    host_class.require_before_save.must_equal([])
+  end
+
+  describe '#shutdown' do
+    describe 'with auto_disable equal true' do
+      before :each do
+        def service.disable_host(reference); @disabled = true end
+        def service.shutdown_host(reference); @halted = true end
+        host.stub(:service, service) do
+          host.shutdown
+        end
+      end
+
+      it 'should disable the host' do
+        service.instance_variable_get(:@disabled).must_equal(true)
+      end
+
+      it 'should shutdown the host' do
+        service.instance_variable_get(:@halted).must_equal(true)
+      end
+    end
+
+    describe 'with auto_disable equal false' do
+      before :each do
+        def service.shutdown_host(reference); @halted = true end
+        host.stub(:service, service) do
+          host.shutdown(false)
+        end
+      end
+
+      it 'should not disable the host' do
+        service.instance_variable_get(:@disabled).must_equal(nil)
+      end
+
+      it 'should shutdown the host' do
+        service.instance_variable_get(:@halted).must_equal(true)
+      end
+    end
+  end
+
+  describe '#reboot' do
+    describe 'with auto_disable equal true' do
+      before :each do
+        def service.disable_host(reference); @disabled = true end
+        def service.reboot_host(reference); @rebooted = true end
+        host.stub(:service, service) do
+          host.reboot
+        end
+      end
+
+      it 'should disable the host' do
+        service.instance_variable_get(:@disabled).must_equal(true)
+      end
+
+      it 'should shutdown the host' do
+        service.instance_variable_get(:@rebooted).must_equal(true)
+      end
+    end
+
+    describe 'with auto_disable equal false' do
+      before :each do
+        def service.reboot_host(reference); @rebooted = true end
+        host.stub(:service, service) do
+          host.reboot(false)
+        end
+      end
+
+      it 'should not disable the host' do
+        service.instance_variable_get(:@disabled).must_equal(nil)
+      end
+
+      it 'should shutdown the host' do
+        service.instance_variable_get(:@rebooted).must_equal(true)
+      end
+    end
+  end
+end