fog-xenserver 0.3.0 → 1.0.0

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

@@ -1,72 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,231 +0,0 @@
-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

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

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

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

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

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

@@ -1,79 +0,0 @@
-require 'minitest_helper'
-
-describe Fog::Compute::XenServer::Models::Network do
-  let(:network_class) do
-    class Fog::Compute::XenServer::Models::Network
-      def self.read_identity
-        instance_variable_get('@identity')
-      end
-    end
-    Fog::Compute::XenServer::Models::Network
-  end
-
-  it 'should associate to a provider class' do
-    network_class.provider_class.must_equal('network')
-  end
-
-  it 'should have a collection name' do
-    network_class.collection_name.must_equal(:networks)
-  end
-
-  it 'should have an unique id' do
-    network_class.read_identity.must_equal(:reference)
-  end
-
-  it 'should have 12 attributes' do
-    network_class.attributes.must_equal([ :reference,
-                                          :allowed_operations,
-                                          :blobs,
-                                          :bridge,
-                                          :current_operations,
-                                          :default_locking_mode,
-                                          :description,
-                                          :mtu,
-                                          :name,
-                                          :other_config,
-                                          :tags,
-                                          :uuid ])
-  end
-
-  it 'should have 2 associations' do
-    network_class.associations.must_equal(:pifs => :pifs,
-                                          :vifs => :vifs)
-  end
-
-  it 'should have 14 masks' do
-    network_class.masks.must_equal(:reference => :reference, 
-                                   :allowed_operations => :allowed_operations, 
-                                   :blobs => :blobs, 
-                                   :bridge => :bridge, 
-                                   :current_operations => :current_operations, 
-                                   :default_locking_mode => :default_locking_mode, 
-                                   :description => :name_description,
-                                   :mtu => :MTU, 
-                                   :name => :name_label,
-                                   :other_config => :other_config, 
-                                   :tags => :tags, 
-                                   :uuid => :uuid, 
-                                   :pifs => :PIFs, 
-                                   :vifs => :VIFs)
-  end
-
-  it 'should have 5 aliases' do
-    network_class.aliases.must_equal(:MTU => :mtu,
-                                     :name_description => :description,
-                                     :name_label => :name,
-                                     :PIFs => :pifs,
-                                     :VIFs => :vifs)
-  end
-
-  it 'should have 3 default values' do
-    network_class.default_values.must_equal(:description => '',
-                                            :name => '',
-                                            :other_config => {})
-  end
-
-  it 'should require 1 attribute before save' do
-    network_class.require_before_save.must_equal([ :name ])
-  end
-end