fog-xenserver 0.0.1.beta1 → 0.0.1.beta2

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

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

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

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

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

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

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

@@ -0,0 +1,67 @@
+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
+    end
+    Fog::Compute::XenServer::Models::Pbd
+  end
+
+  it 'should associate to a provider class' do
+    pbd_class.provider_class.must_equal('PBD')
+  end
+
+  it 'should have a collection name' do
+    pbd_class.collection_name.must_equal(:pbds)
+  end
+
+  it 'should have an unique id' do
+    pbd_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 5 attributes' do
+    pbd_class.attributes.must_equal([ :reference,
+                                      :currently_attached,
+                                      :device_config,
+                                      :other_config,
+                                      :uuid ])
+  end
+
+  it 'should have 2 associations' do
+    pbd_class.associations.must_equal(:host => :hosts,
+                                      :sr => :storage_repositories)
+  end
+
+  it 'should have 7 masks' do
+    pbd_class.masks.must_equal(:reference => :reference, 
+                               :currently_attached => :currently_attached, 
+                               :device_config => :device_config, 
+                               :other_config => :other_config, 
+                               :uuid => :uuid, 
+                               :host => :host, 
+                               :sr => :SR)
+  end
+
+  it 'should have 1 alias' do
+    pbd_class.attributes.must_equal([ :reference,
+                                      :currently_attached,
+                                      :device_config,
+                                      :other_config,
+                                      :uuid ])
+  end
+
+  it "shouldn't have aliases" do
+    pbd_class.aliases.must_equal(:SR => :sr)
+  end
+
+  it "shouldn't have default values" do
+    pbd_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    pbd_class.require_before_save.must_equal([])
+  end
+end

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

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

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

@@ -0,0 +1,61 @@
+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
+    end
+    Fog::Compute::XenServer::Models::Pci
+  end
+
+  it 'should associate to a provider class' do
+    pci_class.provider_class.must_equal('PCI')
+  end
+
+  it 'should have a collection name' do
+    pci_class.collection_name.must_equal(:pcis)
+  end
+
+  it 'should have an unique id' do
+    pci_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 6 attributes' do
+    pci_class.attributes.must_equal([ :reference,
+                                      :device_name,
+                                      :other_config,
+                                      :pci_id,
+                                      :uuid,
+                                      :vendor_name ])
+  end
+
+  it 'should have 2 associations' do
+    pci_class.associations.must_equal(:dependencies => :pcis,
+                                      :host => :hosts)
+  end
+
+  it 'should have 8 masks' do
+    pci_class.masks.must_equal(:reference => :reference, 
+                               :device_name => :device_name, 
+                               :other_config => :other_config, 
+                               :pci_id => :pci_id, 
+                               :uuid => :uuid, 
+                               :vendor_name => :vendor_name, 
+                               :dependencies => :dependencies, 
+                               :host => :host)
+  end
+
+  it "shouldn't have aliases" do
+    pci_class.aliases.must_equal({})
+  end
+
+  it "shouldn't have default values" do
+    pci_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    pci_class.require_before_save.must_equal([])
+  end
+end

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

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

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

@@ -0,0 +1,58 @@
+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
+    end
+    Fog::Compute::XenServer::Models::Pgpu
+  end
+
+  it 'should associate to a provider class' do
+    pgpu_class.provider_class.must_equal('PGPU')
+  end
+
+  it 'should have a collection name' do
+    pgpu_class.collection_name.must_equal(:pgpus)
+  end
+
+  it 'should have an unique id' do
+    pgpu_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 3 attributes' do
+    pgpu_class.attributes.must_equal([ :reference,
+                                       :other_config,
+                                       :uuid ])
+  end
+
+  it 'should have 3 associations' do
+    pgpu_class.associations.must_equal(:gpu_group => :gpu_groups,
+                                       :host => :hosts,
+                                       :pci => :pcis)
+  end
+
+  it 'should have 6 masks' do
+    pgpu_class.masks.must_equal(:reference => :reference,
+                                :other_config => :other_config,
+                                :uuid => :uuid,
+                                :gpu_group => :GPU_group,
+                                :host => :host,
+                                :pci => :PCI)
+  end
+
+  it 'should have 2 aliases' do
+    pgpu_class.aliases.must_equal(:GPU_group => :gpu_group,
+                                  :PCI => :pci)
+  end
+
+  it "shouldn't have default values" do
+    pgpu_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    pgpu_class.require_before_save.must_equal([])
+  end
+end

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

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

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

@@ -0,0 +1,74 @@
+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
+    end
+    Fog::Compute::XenServer::Models::PifMetrics
+  end
+
+  it 'should associate to a provider class' do
+    pif_metrics_class.provider_class.must_equal('PIF_metrics')
+  end
+
+  it 'should have a collection name' do
+    pif_metrics_class.collection_name.must_equal(:pifs_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 associations" do
+    pif_metrics_class.associations.must_equal({})
+  end
+
+  it 'should have 14 masks' do
+    pif_metrics_class.masks.must_equal(:reference => :reference, 
+                                       :carrier => :carrier, 
+                                       :device_id => :device_id, 
+                                       :device_name => :device_name, 
+                                       :duplex => :duplex, 
+                                       :io_read_kbs => :io_read_kbs, 
+                                       :io_write_kbs => :io_write_kbs, 
+                                       :last_updated => :last_updated, 
+                                       :other_config => :other_config, 
+                                       :pci_bus_path => :pci_bus_path, 
+                                       :speed => :speed, 
+                                       :uuid => :uuid, 
+                                       :vendor_id => :vendor_id, 
+                                       :vendor_name => :vendor_name)
+  end
+
+  it "shouldn't have aliases" do
+    pif_metrics_class.aliases.must_equal({})
+  end
+
+  it "shouldn't have default values" do
+    pif_metrics_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    pif_metrics_class.require_before_save.must_equal([])
+  end
+end

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

@@ -0,0 +1,118 @@
+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
+    end
+    Fog::Compute::XenServer::Models::Pif
+  end
+
+  it 'should associate to a provider class' do
+    pif_class.provider_class.must_equal('PIF')
+  end
+
+  it 'should have a collection name' do
+    pif_class.collection_name.must_equal(:pifs)
+  end
+
+  it 'should have an unique id' do
+    pif_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 23 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 ])
+  end
+
+  it 'should have 9 associations' do
+    pif_class.associations.must_equal(:bond_master_of => :bonds, 
+                                      :bond_slave_of => :bonds, 
+                                      :host => :hosts, 
+                                      :metrics => :pif_metrics, 
+                                      :network => :networks, 
+                                      :tunnel_access_pif_of => :tunnels, 
+                                      :tunnel_transport_pif_of => :tunnels, 
+                                      :vlan_master_of => :vlans, 
+                                      :vlan_slave_of => :vlans)
+  end
+
+  it 'should have 32 masks' do
+    pif_class.masks.must_equal(:reference => :reference, 
+                               :disallow_unplug => :disallow_unplug, 
+                               :currently_attached => :currently_attached, 
+                               :device => :device, 
+                               :device_name => :device_name, 
+                               :dns => :DNS, 
+                               :gateway => :gateway, 
+                               :ip => :IP, 
+                               :ip_configuration_mode => :ip_configuration_mode, 
+                               :ipv6 => :IPv6, 
+                               :ipv6_configuration_mode => :ipv6_configuration_mode, 
+                               :ipv6_gateway => :ipv6_gateway, 
+                               :mac => :MAC, 
+                               :management => :management, 
+                               :mtu => :MTU, 
+                               :netmask => :netmask, 
+                               :other_config => :other_config, 
+                               :physical => :physical, 
+                               :primary_address_type => :primary_address_type, 
+                               :status_code => :status_code, 
+                               :status_detail => :status_detail, 
+                               :vlan => :VLAN, 
+                               :uuid => :uuid, 
+                               :bond_master_of => :bond_master_of, 
+                               :bond_slave_of => :bond_slave_of, 
+                               :host => :host, 
+                               :metrics => :metrics, 
+                               :network => :network, 
+                               :tunnel_access_pif_of => :tunnel_access_PIF_of, 
+                               :tunnel_transport_pif_of => :tunnel_transport_PIF_of, 
+                               :vlan_master_of => :VLAN_master_of, 
+                               :vlan_slave_of => :VLAN_slave_of)
+  end
+
+  it 'should have 6 aliases' do
+    pif_class.aliases.must_equal(:MAC => :mac,
+                                 :DNS => :dns,
+                                 :IP => :ip,
+                                 :IPv6 => :ipv6,
+                                 :MTU => :mtu,
+                                 :VLAN => :vlan,
+                                 :tunnel_access_PIF_of => :tunnel_access_pif_of,
+                                 :tunnel_transport_PIF_of => :tunnel_transport_pif_of,
+                                 :VLAN_master_of => :vlan_master_of,
+                                 :VLAN_slave_of => :vlan_slave_of)
+  end
+
+  it "shouldn't have default values" do
+    pif_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    pif_class.require_before_save.must_equal([])
+  end
+end