fog-xenserver 0.0.1.beta1 → 0.0.1.beta2

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

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

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

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

@@ -0,0 +1,9 @@
+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/{test/fog/compute/xen_server/models/vif_metrics_test.rb → spec/fog/compute/xen_server/models/vif_metrics_spec.rb}

@@ -6,16 +6,16 @@ describe Fog::Compute::XenServer::Models::VifMetrics do
       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::VifMetrics
   end
 
   it 'should associate to a provider class' do
-    vif_metrics_class.read_provider_class.must_equal('VIF_metrics')
+    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
@@ -31,7 +31,28 @@ describe Fog::Compute::XenServer::Models::VifMetrics do
                                               :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

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

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

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

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