fog-xenserver 0.3.0 → 1.0.0

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

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

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

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

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

@@ -1,75 +0,0 @@
-require 'minitest_helper'
-
-describe Fog::Compute::XenServer::Models::StorageManager do
-  let(:storage_manager_class) do
-    class Fog::Compute::XenServer::Models::StorageManager
-      def self.read_identity
-        instance_variable_get('@identity')
-      end
-    end
-    Fog::Compute::XenServer::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/compute/xen_server/models/storage_managers_spec.rb

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

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

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

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

@@ -1,92 +0,0 @@
-require 'minitest_helper'
-
-describe Fog::Compute::XenServer::Models::StorageRepository do
-  let(:storage_repository_class) do
-    class Fog::Compute::XenServer::Models::StorageRepository
-      def self.read_identity
-        instance_variable_get('@identity')
-      end
-    end
-    Fog::Compute::XenServer::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/compute/xen_server/models/tunnel_spec.rb

@@ -1,57 +0,0 @@
-require 'minitest_helper'
-
-describe Fog::Compute::XenServer::Models::Tunnel do
-  let(:tunnel_class) do
-    class Fog::Compute::XenServer::Models::Tunnel
-      def self.read_identity
-        instance_variable_get('@identity')
-      end
-    end
-    Fog::Compute::XenServer::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/compute/xen_server/models/tunnels_spec.rb

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

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

@@ -1,70 +0,0 @@
-require 'minitest_helper'
-require 'xmlrpc/datetime'
-
-describe Fog::Compute::XenServer::Models::VbdMetrics do
-  let(:vbd_metrics_class) do
-    class Fog::Compute::XenServer::Models::VbdMetrics
-      def self.read_identity
-        instance_variable_get('@identity')
-      end
-    end
-    Fog::Compute::XenServer::Models::VbdMetrics
-  end
-  let(:vbd_metrics) { Fog::Compute::XenServer::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/compute/xen_server/models/vbd_spec.rb

@@ -1,194 +0,0 @@
-require 'minitest_helper'
-
-describe Fog::Compute::XenServer::Models::Vbd do
-  let(:vbd_class) do
-    class Fog::Compute::XenServer::Models::Vbd
-      def self.read_identity
-        instance_variable_get('@identity')
-      end
-    end
-    Fog::Compute::XenServer::Models::Vbd
-  end
-  let(:vbd) { Fog::Compute::XenServer::Models::Vbd.new }
-  let(:service) { Object.new }
-  let(:vdi) { Fog::Compute::XenServer::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