fog-xenserver 0.3.0 → 1.0.0

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

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

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

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

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

@@ -1,162 +0,0 @@
-require 'minitest_helper'
-
-describe Fog::Compute::XenServer::Models::Vdi do
-  let(:vdi_class) do
-    class Fog::Compute::XenServer::Models::Vdi
-      def self.read_identity
-        instance_variable_get('@identity')
-      end
-    end
-    Fog::Compute::XenServer::Models::Vdi
-  end
-  let(:vdi) { Fog::Compute::XenServer::Models::Vdi.new }
-  let(:service) { Object.new }
-
-  it 'should associate to a provider class' do
-    vdi_class.provider_class.must_equal('VDI')
-  end
-
-  it 'should have a collection name' do
-    vdi_class.collection_name.must_equal(:vdis)
-  end
-
-  it 'should have an unique id' do
-    vdi_class.read_identity.must_equal(:reference)
-  end
-
-  it 'should have 25 attributes' do
-    vdi_class.attributes.must_equal([ :reference,
-                                      :allowed_operations,
-                                      :allow_caching,
-                                      :current_operations,
-                                      :description,
-                                      :is_a_snapshot,
-                                      :location,
-                                      :managed,
-                                      :metadata_latest,
-                                      :metadata_of_pool,
-                                      :missing,
-                                      :name,
-                                      :on_boot,
-                                      :other_config,
-                                      :physical_utilisation,
-                                      :read_only,
-                                      :sharable,
-                                      :sm_config,
-                                      :snapshot_time,
-                                      :storage_lock,
-                                      :tags,
-                                      :type,
-                                      :uuid,
-                                      :virtual_size,
-                                      :xenstore_data ])
-  end
-
-  it 'should have 6 associations' do
-    vdi_class.associations.must_equal(:crash_dumps => :crash_dumps, 
-                                      :parent => :vdis, 
-                                      :snapshots => :vdis, 
-                                      :snapshot_of => :vdis, 
-                                      :sr => :storage_repositories, 
-                                      :vbds => :vbds)
-  end
-
-  it 'should have 31 masks' do
-    vdi_class.masks.must_equal(:reference => :reference, 
-                               :allowed_operations => :allowed_operations, 
-                               :allow_caching => :allow_caching, 
-                               :current_operations => :current_operations, 
-                               :description => :name_description,
-                               :is_a_snapshot => :is_a_snapshot, 
-                               :location => :location, 
-                               :managed => :managed, 
-                               :metadata_latest => :metadata_latest, 
-                               :metadata_of_pool => :metadata_of_pool, 
-                               :missing => :missing, 
-                               :name => :name_label,
-                               :on_boot => :on_boot, 
-                               :other_config => :other_config, 
-                               :physical_utilisation => :physical_utilisation, 
-                               :read_only => :read_only, 
-                               :sharable => :sharable, 
-                               :sm_config => :sm_config, 
-                               :snapshot_time => :snapshot_time, 
-                               :storage_lock => :storage_lock, 
-                               :tags => :tags, 
-                               :type => :type, 
-                               :uuid => :uuid, 
-                               :virtual_size => :virtual_size, 
-                               :xenstore_data => :xenstore_data, 
-                               :crash_dumps => :crash_dumps, 
-                               :parent => :parent, 
-                               :snapshots => :snapshots, 
-                               :snapshot_of => :snapshot_of, 
-                               :sr => :SR, 
-                               :vbds => :VBDs)
-  end
-
-  it 'should have 4 aliases' do
-    vdi_class.aliases.must_equal(:name_label => :name,
-                                 :name_description => :description,
-                                 :SR => :sr,
-                                 :VBDs => :vbds)
-  end
-
-  it 'should have 5 default values' do
-    vdi_class.default_values.must_equal(:other_config => {},
-                                        :read_only => false,
-                                        :sharable => false,
-                                        :type => 'system',
-                                        :virtual_size => '8589934592')
-  end
-
-  it 'should require 3 attributes before save' do
-    vdi_class.require_before_save.must_equal([ :name, :storage_repository, :type ])
-  end
-
-  describe '#can_be_destroyed?' do
-    describe "when allowed_operation contain 'destroy'" do
-      before :each do
-        vdi.allowed_operations = %w(destroy)
-      end
-
-      it 'should return true' do
-        vdi.can_be_destroyed?.must_equal(true)
-      end
-    end
-
-    describe "when allowed_operation does not contain 'destroy'" do
-      before :each do
-        vdi.allowed_operations = []
-      end
-
-      it 'should return false' do
-        vdi.can_be_destroyed?.must_equal(false)
-      end
-    end
-  end
-
-  describe '#destroy' do
-    describe 'when it can be destroyed' do
-      before :each do
-        def vdi.can_be_destroyed?; true end
-        def service.destroy_record(reference, provider_class); @destroyed = true end
-        vdi.stub(:service, service) do
-          vdi.destroy.must_equal(true)
-        end
-      end
-
-      it 'should destroy it' do
-        service.instance_variable_get(:@destroyed).must_equal(true)
-      end
-    end
-
-    describe 'when can not be destroyed' do
-      it 'should return false' do
-        vdi.stub(:can_be_destroyed?, false) do
-          vdi.destroy.must_equal(false)
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,58 +0,0 @@
-require 'minitest_helper'
-
-describe Fog::Compute::XenServer::Models::VifMetrics do
-  let(:vif_metrics_class) do
-    class Fog::Compute::XenServer::Models::VifMetrics
-      def self.read_identity
-        instance_variable_get('@identity')
-      end
-    end
-    Fog::Compute::XenServer::Models::VifMetrics
-  end
-
-  it 'should associate to a provider class' do
-    vif_metrics_class.provider_class.must_equal('VIF_metrics')
-  end
-
-  it 'should have a collection name' do
-    vif_metrics_class.collection_name.must_equal(:vifs_metrics)
-  end
-
-  it 'should have an unique id' do
-    vif_metrics_class.read_identity.must_equal(:reference)
-  end
-
-  it 'should have 6 attributes' do
-    vif_metrics_class.attributes.must_equal([ :reference,
-                                              :io_read_kbs,
-                                              :io_write_kbs,
-                                              :last_updated,
-                                              :other_config,
-                                              :uuid ])
-  end
-
-  it "shouldn't have associations" do
-    vif_metrics_class.associations.must_equal({})
-  end
-
-  it 'should have 6 masks' do
-    vif_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
-    vif_metrics_class.aliases.must_equal({})
-  end
-
-  it "shouldn't have default values" do
-    vif_metrics_class.default_values.must_equal({})
-  end
-
-  it "shouldn't require attributes before save" do
-    vif_metrics_class.require_before_save.must_equal([])
-  end
-end

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

@@ -1,141 +0,0 @@
-require 'minitest_helper'
-
-describe Fog::Compute::XenServer::Models::Vif do
-  let(:vif_class) do
-    class Fog::Compute::XenServer::Models::Vif
-      def self.read_identity
-        instance_variable_get('@identity')
-      end
-    end
-    Fog::Compute::XenServer::Models::Vif
-  end
-  let(:vif) { Fog::Compute::XenServer::Models::Vif.new }
-  let(:vm) { Fog::Compute::XenServer::Models::Server.new }
-  let(:service) { Object.new }
-
-  it 'should associate to a provider class' do
-    vif_class.provider_class.must_equal('VIF')
-  end
-
-  it 'should have a collection name' do
-    vif_class.collection_name.must_equal(:vifs)
-  end
-
-  it 'should have an unique id' do
-    vif_class.read_identity.must_equal(:reference)
-  end
-
-  it 'should have 19 attributes' do
-    vif_class.attributes.must_equal([ :reference,
-                                      :allowed_operations,
-                                      :current_operations,
-                                      :currently_attached,
-                                      :device,
-                                      :ipv4_allowed,
-                                      :ipv6_allowed,
-                                      :locking_mode,
-                                      :mac,
-                                      :mac_autogenerated,
-                                      :mtu,
-                                      :other_config,
-                                      :qos_algorithm_params,
-                                      :qos_algorithm_type,
-                                      :qos_supported_algorithms,
-                                      :runtime_properties,
-                                      :status_code,
-                                      :status_detail,
-                                      :uuid ])
-  end
-
-  it 'should have 3 associations' do
-    vif_class.associations.must_equal(:metrics => :vifs_metrics,
-                                      :network => :networks,
-                                      :vm => :servers)
-  end
-
-  it 'should have 22 masks' do
-    vif_class.masks.must_equal(:reference => :reference,
-                               :allowed_operations => :allowed_operations,
-                               :current_operations => :current_operations,
-                               :currently_attached => :currently_attached,
-                               :device => :device,
-                               :ipv4_allowed => :ipv4_allowed,
-                               :ipv6_allowed => :ipv6_allowed,
-                               :locking_mode => :locking_mode,
-                               :mac => :MAC,
-                               :mac_autogenerated => :MAC_autogenerated,
-                               :mtu => :MTU,
-                               :other_config => :other_config,
-                               :qos_algorithm_params => :qos_algorithm_params,
-                               :qos_algorithm_type => :qos_algorithm_type,
-                               :qos_supported_algorithms => :qos_supported_algorithms,
-                               :runtime_properties => :runtime_properties,
-                               :status_code => :status_code,
-                               :status_detail => :status_detail,
-                               :uuid => :uuid,
-                               :metrics => :metrics,
-                               :network => :network,
-                               :vm => :VM)
-  end
-
-  it 'should have 4 aliases' do
-    vif_class.aliases.must_equal(:MAC => :mac,
-                                 :MAC_autogenerated => :mac_autogenerated,
-                                 :MTU => :mtu,
-                                 :VM => :vm)
-  end
-
-  it 'should have 6 default values' do
-    vif_class.default_values.must_equal(:mac => '',
-                                        :mac_autogenerated => 'True',
-                                        :mtu => '0',
-                                        :other_config => {},
-                                        :qos_algorithm_params => {},
-                                        :qos_algorithm_type => 'ratelimit')
-  end
-
-  it 'should require 3 attributes before save' do
-    vif_class.require_before_save.must_equal([ :vm, :network, :device ])
-  end
-
-  describe '#set_device_number' do
-    describe 'when vm is nil' do
-      it 'should set the device as 0' do
-        lambda { vif.set_device_number }.must_raise(ArgumentError, 'vm is required for this operation')
-      end
-    end
-
-    describe 'when vm is not nil' do
-      describe 'and no vif exists' do
-        before :each do
-          vif.vm = vm
-          vif.stub(:vm, vm) do
-            vm.stub(:vifs, []) do
-              vif.set_device_number
-            end
-          end
-        end
-
-        it 'should set the device as 0' do
-          vif.device.must_equal('0')
-        end
-      end
-
-      describe 'and exists vifs' do
-        before :each do
-          @vif2 = Fog::Compute::XenServer::Models::Vif.new(:device => 2)
-          @vif4 = Fog::Compute::XenServer::Models::Vif.new(:device => 4)
-          vif.stub(:vm, vm) do
-            vm.stub(:vifs, [@vif2, @vif4]) do
-              vif.set_device_number
-            end
-          end
-        end
-
-        it 'should set the device value based on the existent vifs' do
-          vif.device.must_equal('5')
-        end
-      end
-    end
-  end
-end

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

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

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

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

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

@@ -1,58 +0,0 @@
-require 'minitest_helper'
-
-describe Fog::Compute::XenServer::Models::Vlan do
-  let(:vlan_class) do
-    class Fog::Compute::XenServer::Models::Vlan
-      def self.read_identity
-        instance_variable_get('@identity')
-      end
-    end
-    Fog::Compute::XenServer::Models::Vlan
-  end
-
-  it 'should associate to a provider class' do
-    vlan_class.provider_class.must_equal('VLAN')
-  end
-
-  it 'should have a collection name' do
-    vlan_class.collection_name.must_equal(:vlans)
-  end
-
-  it 'should have an unique id' do
-    vlan_class.read_identity.must_equal(:reference)
-  end
-
-  it 'should have 4 attributes' do
-    vlan_class.attributes.must_equal([ :reference,
-                                       :other_config,
-                                       :tag,
-                                       :uuid ])
-  end
-
-  it 'should have 2 associations' do
-    vlan_class.associations.must_equal(:tagged_pif => :pifs,
-                                       :untagged_pif => :pifs)
-  end
-
-  it 'should have 6 masks' do
-    vlan_class.masks.must_equal(:reference => :reference, 
-                                :other_config => :other_config, 
-                                :tag => :tag, 
-                                :uuid => :uuid, 
-                                :tagged_pif => :tagged_PIF, 
-                                :untagged_pif => :untagged_PIF)
-  end
-
-  it 'should have 2 aliases' do
-    vlan_class.aliases.must_equal(:tagged_PIF => :tagged_pif,
-                                  :untagged_PIF => :untagged_pif)
-  end
-
-  it "shouldn't have default values" do
-    vlan_class.default_values.must_equal({})
-  end
-
-  it 'should require 1 attribute before save' do
-    vlan_class.require_before_save.must_equal([ :tag ])
-  end
-end