fog-xenserver 0.3.0 → 1.0.0

data/spec/fog/xenserver/compute/models/servers_metrics_spec.rb

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

data/spec/fog/xenserver/compute/models/servers_spec.rb

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

data/spec/fog/xenserver/compute/models/storage_manager_spec.rb

@@ -0,0 +1,75 @@
+require 'minitest_helper'
+
+describe Fog::XenServer::Compute::Models::StorageManager do
+  let(:storage_manager_class) do
+    class Fog::XenServer::Compute::Models::StorageManager
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::XenServer::Compute::Models::StorageManager
+  end
+
+  it 'should associate to a provider class' do
+    storage_manager_class.provider_class.must_equal('SM')
+  end
+
+  it 'should have a collection name' do
+    storage_manager_class.collection_name.must_equal(:storage_managers)
+  end
+
+  it 'should have an unique id' do
+    storage_manager_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 14 attributes' do
+    storage_manager_class.attributes.must_equal([ :reference,
+                                                  :capabilities,
+                                                  :configuration,
+                                                  :copyright,
+                                                  :description,
+                                                  :driver_filename,
+                                                  :features,
+                                                  :name,
+                                                  :other_config,
+                                                  :required_api_version,
+                                                  :type,
+                                                  :uuid,
+                                                  :vendor,
+                                                  :version ])
+  end
+
+  it "shouldn't have associations" do
+    storage_manager_class.associations.must_equal({})
+  end
+
+  it 'should have 14 masks' do
+    storage_manager_class.masks.must_equal(:reference => :reference, 
+                                           :capabilities => :capabilities, 
+                                           :configuration => :configuration, 
+                                           :copyright => :copyright, 
+                                           :description => :description, 
+                                           :driver_filename => :driver_filename, 
+                                           :features => :features, 
+                                           :name => :name, 
+                                           :other_config => :other_config, 
+                                           :required_api_version => :required_api_version, 
+                                           :type => :type, 
+                                           :uuid => :uuid, 
+                                           :vendor => :vendor, 
+                                           :version => :version)
+  end
+
+  it 'should have 2 aliases' do
+    storage_manager_class.aliases.must_equal({ :name_description => :description,
+                                               :name_label => :name })
+  end
+
+  it "shouldn't have default values" do
+    storage_manager_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    storage_manager_class.require_before_save.must_equal([])
+  end
+end

data/spec/fog/xenserver/compute/models/storage_managers_spec.rb

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

data/spec/fog/xenserver/compute/models/storage_repositories_spec.rb

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

data/spec/fog/xenserver/compute/models/storage_repository_spec.rb

@@ -0,0 +1,92 @@
+require 'minitest_helper'
+
+describe Fog::XenServer::Compute::Models::StorageRepository do
+  let(:storage_repository_class) do
+    class Fog::XenServer::Compute::Models::StorageRepository
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::XenServer::Compute::Models::StorageRepository
+  end
+
+  it 'should associate to a provider class' do
+    storage_repository_class.provider_class.must_equal('SR')
+  end
+
+  it 'should have a collection name' do
+    storage_repository_class.collection_name.must_equal(:storage_repositories)
+  end
+
+  it 'should have an unique id' do
+    storage_repository_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 18 attributes' do
+    storage_repository_class.attributes.must_equal([ :reference,
+                                                     :allowed_operations,
+                                                     :blobs,
+                                                     :content_type,
+                                                     :current_operations,
+                                                     :description,
+                                                     :introduced_by,
+                                                     :local_cache_enabled,
+                                                     :name,
+                                                     :other_config,
+                                                     :physical_size,
+                                                     :physical_utilisation,
+                                                     :shared,
+                                                     :sm_config,
+                                                     :tags,
+                                                     :type,
+                                                     :uuid,
+                                                     :virtual_allocation ])
+  end
+
+  it 'should have 2 associations' do
+    storage_repository_class.associations.must_equal(:pbds => :pbds,
+                                                     :vdis => :vdis)
+  end
+
+  it 'should have 20 masks' do
+    storage_repository_class.masks.must_equal(:reference => :reference, 
+                                              :allowed_operations => :allowed_operations, 
+                                              :blobs => :blobs, 
+                                              :content_type => :content_type, 
+                                              :current_operations => :current_operations, 
+                                              :description => :description, 
+                                              :introduced_by => :introduced_by, 
+                                              :local_cache_enabled => :local_cache_enabled, 
+                                              :name => :name, 
+                                              :other_config => :other_config, 
+                                              :physical_size => :physical_size, 
+                                              :physical_utilisation => :physical_utilisation, 
+                                              :shared => :shared, 
+                                              :sm_config => :sm_config, 
+                                              :tags => :tags, 
+                                              :type => :type, 
+                                              :uuid => :uuid, 
+                                              :virtual_allocation => :virtual_allocation, 
+                                              :pbds => :PBDs, 
+                                              :vdis => :VDIs)
+  end
+
+  it 'should have 4 aliases' do
+    storage_repository_class.aliases.must_equal(:name_label => :name,
+                                                :name_description => :description,
+                                                :PBDs => :pbds,
+                                                :VDIs => :vdis)
+  end
+
+  it 'should have 5 default values' do
+    storage_repository_class.default_values.must_equal(:content_type => 'user',
+                                                       :shared => false,
+                                                       :description => '',
+                                                       :physical_size => '0',
+                                                       :sm_config => {})
+  end
+
+  it 'should require 2 attributes before save' do
+    storage_repository_class.require_before_save.must_equal([ :name, :type ])
+  end
+end

data/spec/fog/xenserver/compute/models/tunnel_spec.rb

@@ -0,0 +1,57 @@
+require 'minitest_helper'
+
+describe Fog::XenServer::Compute::Models::Tunnel do
+  let(:tunnel_class) do
+    class Fog::XenServer::Compute::Models::Tunnel
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::XenServer::Compute::Models::Tunnel
+  end
+
+  it 'should associate to a provider class' do
+    tunnel_class.provider_class.must_equal('tunnel')
+  end
+
+  it 'should have a collection name' do
+    tunnel_class.collection_name.must_equal(:tunnels)
+  end
+
+  it 'should have an unique id' do
+    tunnel_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 4 attributes' do
+    tunnel_class.attributes.must_equal([ :reference,
+                                         :other_config,
+                                         :status,
+                                         :uuid ])
+  end
+
+  it 'should have 1 association' do
+    tunnel_class.associations.must_equal(:access_pif => :pifs,
+                                         :transport_pif => :pifs)
+  end
+
+  it 'should have 5 masks' do
+    tunnel_class.masks.must_equal(:reference => :reference, 
+                                  :other_config => :other_config, 
+                                  :status => :status, :uuid => :uuid, 
+                                  :access_pif => :access_PIF, 
+                                  :transport_pif => :transport_PIF)
+  end
+
+  it 'should have 2 aliases' do
+    tunnel_class.aliases.must_equal(:access_PIF => :access_pif,
+                                    :transport_PIF => :transport_pif)
+  end
+
+  it "shouldn't have default values" do
+    tunnel_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    tunnel_class.require_before_save.must_equal([])
+  end
+end

data/spec/fog/xenserver/compute/models/tunnels_spec.rb

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

data/spec/fog/xenserver/compute/models/vbd_metrics_spec.rb

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

data/spec/fog/xenserver/compute/models/vbd_spec.rb

@@ -0,0 +1,194 @@
+require 'minitest_helper'
+
+describe Fog::XenServer::Compute::Models::Vbd do
+  let(:vbd_class) do
+    class Fog::XenServer::Compute::Models::Vbd
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::XenServer::Compute::Models::Vbd
+  end
+  let(:vbd) { Fog::XenServer::Compute::Models::Vbd.new }
+  let(:service) { Object.new }
+  let(:vdi) { Fog::XenServer::Compute::Models::Vdi.new }
+
+  it 'should associate to a provider class' do
+    vbd_class.provider_class.must_equal('VBD')
+  end
+
+  it 'should have a collection name' do
+    vbd_class.collection_name.must_equal(:vbds)
+  end
+
+  it 'should have an unique id' do
+    vbd_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 20 attributes' do
+    vbd_class.attributes.must_equal([ :reference,
+                                      :allowed_operations,
+                                      :bootable,
+                                      :currently_attached,
+                                      :current_operations,
+                                      :device,
+                                      :empty,
+                                      :mode,
+                                      :other_config,
+                                      :qos_supported_algorithms,
+                                      :qos_algorithm_params,
+                                      :qos_algorithm_type,
+                                      :runtime_properties,
+                                      :status_code,
+                                      :status_detail,
+                                      :storage_lock,
+                                      :type,
+                                      :unpluggable,
+                                      :userdevice,
+                                      :uuid ])
+  end
+
+  it 'should have 3 associations' do
+    vbd_class.associations.must_equal(:metrics => :vbds_metrics,
+                                      :vdi => :vdis,
+                                      :vm => :servers)
+  end
+
+  it 'should have 23 masks' do
+    vbd_class.masks.must_equal(:reference => :reference,
+                               :allowed_operations => :allowed_operations,
+                               :bootable => :bootable,
+                               :currently_attached => :currently_attached,
+                               :current_operations => :current_operations,
+                               :device => :device,
+                               :empty => :empty,
+                               :mode => :mode,
+                               :other_config => :other_config,
+                               :qos_supported_algorithms => :qos_supported_algorithms,
+                               :qos_algorithm_params => :qos_algorithm_params,
+                               :qos_algorithm_type => :qos_algorithm_type,
+                               :runtime_properties => :runtime_properties,
+                               :status_code => :status_code,
+                               :status_detail => :status_detail,
+                               :storage_lock => :storage_lock,
+                               :type => :type,
+                               :unpluggable => :unpluggable,
+                               :userdevice => :userdevice,
+                               :uuid => :uuid,
+                               :metrics => :metrics,
+                               :vdi => :VDI,
+                               :vm => :VM)
+  end
+
+  it 'should have 2 aliases' do
+    vbd_class.aliases.must_equal(:VDI => :vdi,
+                                 :VM => :vm)
+  end
+
+  it 'should have 9 default values' do
+    vbd_class.default_values.must_equal(:bootable => true,
+                                        :mode => 'RW',
+                                        :empty => false,
+                                        :other_config => { 'owner' => '' },
+                                        :qos_supported_algorithms => [],
+                                        :qos_algorithm_params => {},
+                                        :qos_algorithm_type => '',
+                                        :type => 'Disk',
+                                        :userdevice => '0')
+  end
+
+  it 'should require 2 attributes before save' do
+    vbd_class.require_before_save.must_equal([ :vdi, :vm ])
+  end
+
+  describe '#can_be_unplugged?' do
+    describe "when allowed_operation contain 'unplug'" do
+      before :each do
+        vbd.allowed_operations = %w(unplug)
+      end
+
+      it 'should return true' do
+        vbd.can_be_unplugged?.must_equal(true)
+      end
+    end
+
+    describe "when allowed_operation does not contain 'unplug'" do
+      before :each do
+        vbd.allowed_operations = []
+      end
+
+      it 'should return false' do
+        vbd.can_be_unplugged?.must_equal(false)
+      end
+    end
+  end
+
+  describe '#unplug' do
+    describe "when it can be unplugged" do
+      before :each do
+        def vbd.can_be_unplugged?; true end
+        def service.unplug_vbd(reference); true end
+      end
+
+      it 'should return true' do
+        vbd.stub(:service, service) do
+          vbd.unplug.must_equal(true)
+        end
+      end
+    end
+
+    describe 'when can not be unplugged' do
+      it 'should return false' do
+        vbd.stub(:can_be_unplugged?, false) do
+          vbd.unplug.must_equal(false)
+        end
+      end
+    end
+  end
+
+  describe '#disk?' do
+    describe 'on a disk' do
+      before :each do
+        vbd.type = 'Disk'
+      end
+
+      it 'should return true' do
+        vbd.disk?.must_equal(true)
+      end
+    end
+
+    describe 'on a cd' do
+      before :each do
+        vbd.type = 'CD'
+      end
+
+      it 'should return false' do
+        vbd.disk?.must_equal(false)
+      end
+    end
+  end
+
+  describe '#destroy' do
+    describe 'on a disk' do
+      before :each do
+        vbd.type = 'Disk'
+        def vbd.unplug; @plugged = false; end
+        def vdi.destroy; @destroyed = true; end
+        def service.destroy_record(reference, provider_class); @destroyed = true end
+        vbd.stub(:vdi, vdi) do
+          vbd.stub(:service, service) do
+            vbd.destroy
+          end
+        end
+      end
+
+      it 'should unplug the vbd' do
+        vbd.instance_variable_get(:@plugged).must_equal(false)
+      end
+
+      it 'should destroy the vdi' do
+        vdi.instance_variable_get(:@destroyed).must_equal(true)
+      end
+    end
+  end
+end