fog-xenserver 0.0.1.alpha2 → 0.0.1.beta1

data/test/fog/compute/xen_server/models/network_test.rb

@@ -0,0 +1,51 @@
+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
+
+      def self.read_provider_class
+        instance_variable_get('@provider_class')
+      end
+    end
+    Fog::Compute::XenServer::Models::Network
+  end
+
+  it 'should associate to a provider class' do
+    network_class.read_provider_class.must_equal('network')
+  end
+
+  it 'should have an unique id' do
+    network_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 14 attributes' do
+    network_class.attributes.must_equal([ :reference,
+                                          :allowed_operations,
+                                          :blobs,
+                                          :bridge,
+                                          :current_operations,
+                                          :default_locking_mode,
+                                          :description,
+                                          :mtu,
+                                          :name,
+                                          :other_config,
+                                          :tags,
+                                          :uuid,
+                                          :__pifs,
+                                          :__vifs ])
+  end
+
+  it 'should have 7 aliases' do
+    network_class.aliases.must_equal({ :VIFs => :__vifs,
+                                       :vifs => :__vifs,
+                                       :MTU => :mtu, 
+                                       :name_description => :description, 
+                                       :name_label => :name,
+                                       :PIFs => :__pifs,
+                                       :pifs => :__pifs })
+  end
+end

data/test/fog/compute/xen_server/models/pbd_test.rb

@@ -0,0 +1,40 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Pbd do
+  let(:pbd_class) do
+    class Fog::Compute::XenServer::Models::Pbd
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+
+      def self.read_provider_class
+        instance_variable_get('@provider_class')
+      end
+    end
+    Fog::Compute::XenServer::Models::Pbd
+  end
+
+  it 'should associate to a provider class' do
+    pbd_class.read_provider_class.must_equal('PBD')
+  end
+
+  it 'should have an unique id' do
+    pbd_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 7 attributes' do
+    pbd_class.attributes.must_equal([ :reference,
+                                      :currently_attached,
+                                      :device_config,
+                                      :other_config,
+                                      :uuid,
+                                      :__host,
+                                      :__sr ])
+  end
+
+  it 'should have 3 aliases' do
+    pbd_class.aliases.must_equal({ :host => :__host,
+                                   :SR => :__sr,
+                                   :sr => :__sr })
+  end
+end

data/test/fog/compute/xen_server/models/pci_test.rb

@@ -0,0 +1,40 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Pci do
+  let(:pci_class) do
+    class Fog::Compute::XenServer::Models::Pci
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+
+      def self.read_provider_class
+        instance_variable_get('@provider_class')
+      end
+    end
+    Fog::Compute::XenServer::Models::Pci
+  end
+
+  it 'should associate to a provider class' do
+    pci_class.read_provider_class.must_equal('PCI')
+  end
+
+  it 'should have an unique id' do
+    pci_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 8 attributes' do
+    pci_class.attributes.must_equal([ :reference,
+                                      :device_name,
+                                      :other_config,
+                                      :pci_id,
+                                      :uuid,
+                                      :vendor_name,
+                                      :__dependencies,
+                                      :__host ])
+  end
+
+  it 'should have 2 aliases' do
+    pci_class.aliases.must_equal({ :dependencies => :__dependencies,
+                                   :host => :__host })
+  end
+end

data/test/fog/compute/xen_server/models/pgpu_test.rb

@@ -0,0 +1,41 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Pgpu do
+  let(:pgpu_class) do
+    class Fog::Compute::XenServer::Models::Pgpu
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+
+      def self.read_provider_class
+        instance_variable_get('@provider_class')
+      end
+    end
+    Fog::Compute::XenServer::Models::Pgpu
+  end
+
+  it 'should associate to a provider class' do
+    pgpu_class.read_provider_class.must_equal('PGPU')
+  end
+
+  it 'should have an unique id' do
+    pgpu_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 6 attributes' do
+    pgpu_class.attributes.must_equal([ :reference,
+                                       :other_config,
+                                       :uuid,
+                                       :__gpu_group,
+                                       :__host,
+                                       :__pci ])
+  end
+
+  it 'should have 5 aliases' do
+    pgpu_class.aliases.must_equal({ :GPU_group => :__gpu_group,
+                                    :gpu_group => :__gpu_group,
+                                    :host => :__host,
+                                    :PCI => :__pci,
+                                    :pci => :__pci })
+  end
+end

data/test/fog/compute/xen_server/models/pif_metrics_test.rb

@@ -0,0 +1,45 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::PifMetrics do
+  let(:pif_metrics_class) do
+    class Fog::Compute::XenServer::Models::PifMetrics
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+
+      def self.read_provider_class
+        instance_variable_get('@provider_class')
+      end
+    end
+    Fog::Compute::XenServer::Models::PifMetrics
+  end
+
+  it 'should associate to a provider class' do
+    pif_metrics_class.read_provider_class.must_equal('PIF_metrics')
+  end
+
+  it 'should have an unique id' do
+    pif_metrics_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 14 attributes' do
+    pif_metrics_class.attributes.must_equal([ :reference,
+                                              :carrier,
+                                              :device_id,
+                                              :device_name,
+                                              :duplex,
+                                              :io_read_kbs,
+                                              :io_write_kbs,
+                                              :last_updated,
+                                              :other_config,
+                                              :pci_bus_path,
+                                              :speed,
+                                              :uuid,
+                                              :vendor_id,
+                                              :vendor_name ])
+  end
+
+  it "shouldn't have aliases" do
+    pif_metrics_class.aliases.must_equal({})
+  end
+end

data/test/fog/compute/xen_server/models/pif_test.rb

@@ -0,0 +1,81 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Pif do
+  let(:pif_class) do
+    class Fog::Compute::XenServer::Models::Pif
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+
+      def self.read_provider_class
+        instance_variable_get('@provider_class')
+      end
+    end
+    Fog::Compute::XenServer::Models::Pif
+  end
+
+  it 'should associate to a provider class' do
+    pif_class.read_provider_class.must_equal('PIF')
+  end
+
+  it 'should have an unique id' do
+    pif_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 32 attributes' do
+    pif_class.attributes.must_equal([ :reference,
+                                      :disallow_unplug,
+                                      :currently_attached,
+                                      :device,
+                                      :device_name,
+                                      :dns,
+                                      :gateway,
+                                      :ip,
+                                      :ip_configuration_mode,
+                                      :ipv6,
+                                      :ipv6_configuration_mode,
+                                      :ipv6_gateway,
+                                      :mac,
+                                      :management,
+                                      :mtu,
+                                      :netmask,
+                                      :other_config,
+                                      :physical,
+                                      :primary_address_type,
+                                      :status_code,
+                                      :status_detail,
+                                      :vlan,
+                                      :uuid,
+                                      :__bond_master_of,
+                                      :__bond_slave_of,
+                                      :__host,
+                                      :__metrics,
+                                      :__network,
+                                      :__tunnel_access_pif_of,
+                                      :__tunnel_transport_pif_of,
+                                      :__vlan_master_of,
+                                      :__vlan_slave_of ])
+  end
+
+  it 'should have 19 aliases' do
+    pif_class.aliases.must_equal({ :bond_master_of => :__bond_master_of,
+                                   :bond_slave_of => :__bond_slave_of, 
+                                   :MAC => :mac,
+                                   :DNS => :dns, 
+                                   :IP => :ip, 
+                                   :IPv6 => :ipv6, 
+                                   :MTU => :mtu, 
+                                   :network => :__network,
+                                   :metrics => :__metrics,
+                                   :tunnel_access_PIF_of => :__tunnel_access_pif_of,
+                                   :tunnel_access_pif_of => :__tunnel_access_pif_of,
+                                   :tunnel_transport_PIF_of => :__tunnel_transport_pif_of,
+                                   :tunnel_transport_pif_of => :__tunnel_transport_pif_of,
+                                   :VLAN => :vlan,
+                                   :VLAN_master_of => :__vlan_master_of,
+                                   :vlan_master_of => :__vlan_master_of,
+                                   :VLAN_slave_of => :__vlan_slave_of,
+                                   :vlan_slave_of => :__vlan_slave_of,
+                                   :host => :__host })
+  end
+end

data/test/fog/compute/xen_server/models/pool_patch_test.rb

@@ -0,0 +1,43 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::PoolPatch do
+  let(:pool_patch_class) do
+    class Fog::Compute::XenServer::Models::PoolPatch
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+
+      def self.read_provider_class
+        instance_variable_get('@provider_class')
+      end
+    end
+    Fog::Compute::XenServer::Models::PoolPatch
+  end
+
+  it 'should associate to a provider class' do
+    pool_patch_class.read_provider_class.must_equal('pool_patch')
+  end
+
+  it 'should have an unique id' do
+    pool_patch_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 10 attributes' do
+    pool_patch_class.attributes.must_equal([ :reference,
+                                             :after_apply_guidance,
+                                             :description,
+                                             :name,
+                                             :other_config,
+                                             :pool_applied,
+                                             :size,
+                                             :uuid,
+                                             :version,
+                                             :__host_patches ])
+  end
+
+  it 'should have 3 aliases' do
+    pool_patch_class.aliases.must_equal({ :host_patches => :__host_patches,
+                                          :name_description => :description,
+                                          :name_label => :name })
+  end
+end

data/test/fog/compute/xen_server/models/pool_test.rb

@@ -0,0 +1,69 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Pool do
+  let(:pool_class) do
+    class Fog::Compute::XenServer::Models::Pool
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+
+      def self.read_provider_class
+        instance_variable_get('@provider_class')
+      end
+    end
+    Fog::Compute::XenServer::Models::Pool
+  end
+
+  it 'should associate to a provider class' do
+    pool_class.read_provider_class.must_equal('pool')
+  end
+
+  it 'should have an unique id' do
+    pool_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 28 attributes' do
+    pool_class.attributes.must_equal([ :reference,
+                                       :blobs,
+                                       :description,
+                                       :gui_config,
+                                       :ha_allow_overcommit,
+                                       :ha_configuration,
+                                       :ha_enabled,
+                                       :ha_host_failures_to_tolerate,
+                                       :ha_overcommitted,
+                                       :ha_plan_exists_for,
+                                       :ha_statefiles,
+                                       :name,
+                                       :other_config,
+                                       :redo_log_enabled,
+                                       :redo_log_vdi,
+                                       :restrictions,
+                                       :tags,
+                                       :uuid,
+                                       :vswitch_controller,
+                                       :wlb_enabled,
+                                       :wlb_url,
+                                       :wlb_username,
+                                       :wlb_verify_cert,
+                                       :__crash_dump_sr,
+                                       :__default_sr,
+                                       :__master,
+                                       :__metadata_vdis,
+                                       :__suspend_image_sr ])
+  end
+
+  it 'should have 11 aliases' do
+    pool_class.aliases.must_equal({ :crash_dump_SR => :__crash_dump_sr,
+                                    :crash_dump_sr => :__crash_dump_sr,
+                                    :name_label => :name,
+                                    :name_description => :description,
+                                    :default_SR => :__default_sr,
+                                    :default_sr => :__default_sr,
+                                    :master => :__master,
+                                    :metadata_VDIs => :__metadata_vdis,
+                                    :metadata_vdis => :__metadata_vdis,
+                                    :suspend_image_SR => :__suspend_image_sr,
+                                    :suspend_image_sr => :__suspend_image_sr })
+  end
+end

data/test/fog/compute/xen_server/models/role_test.rb

@@ -0,0 +1,38 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Role do
+  let(:role_class) do
+    class Fog::Compute::XenServer::Models::Role
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+
+      def self.read_provider_class
+        instance_variable_get('@provider_class')
+      end
+    end
+    Fog::Compute::XenServer::Models::Role
+  end
+
+  it 'should associate to a provider class' do
+    role_class.read_provider_class.must_equal('role')
+  end
+
+  it 'should have an unique id' do
+    role_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 5 attributes' do
+    role_class.attributes.must_equal([ :reference,
+                                       :description,
+                                       :name,
+                                       :uuid,
+                                       :__subroles ])
+  end
+
+  it 'should have 3 aliases' do
+    role_class.aliases.must_equal({ :name_description => :description,
+                                    :name_label => :name, 
+                                    :subroles => :__subroles })
+  end
+end