fog-xenserver 0.0.1.beta1 → 0.0.1.beta2

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

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

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

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

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

@@ -0,0 +1,66 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::PoolPatch do
+  let(:pool_patch_class) do
+    class Fog::Compute::XenServer::Models::PoolPatch
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::PoolPatch
+  end
+
+  it 'should associate to a provider class' do
+    pool_patch_class.provider_class.must_equal('pool_patch')
+  end
+
+  it 'should have a collection name' do
+    pool_patch_class.collection_name.must_equal(:pool_patchs)
+  end
+
+  it 'should have an unique id' do
+    pool_patch_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 9 attributes' do
+    pool_patch_class.attributes.must_equal([ :reference,
+                                             :after_apply_guidance,
+                                             :description,
+                                             :name,
+                                             :other_config,
+                                             :pool_applied,
+                                             :size,
+                                             :uuid,
+                                             :version ])
+  end
+
+  it 'should have 1 association' do
+    pool_patch_class.associations.must_equal(:host_patches => :host_patchs)
+  end
+
+  it 'should have 10 masks' do
+    pool_patch_class.masks.must_equal(:reference => :reference, 
+                                      :after_apply_guidance => :after_apply_guidance, 
+                                      :description => :description, 
+                                      :name => :name, 
+                                      :other_config => :other_config, 
+                                      :pool_applied => :pool_applied, 
+                                      :size => :size, 
+                                      :uuid => :uuid, 
+                                      :version => :version, 
+                                      :host_patches => :host_patches)
+  end
+
+  it 'should have 2 aliases' do
+    pool_patch_class.aliases.must_equal(:name_description => :description,
+                                        :name_label => :name)
+  end
+
+  it "shouldn't have default values" do
+    pool_patch_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    pool_patch_class.require_before_save.must_equal([])
+  end
+end

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

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

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

@@ -0,0 +1,106 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Pool do
+  let(:pool_class) do
+    class Fog::Compute::XenServer::Models::Pool
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::Pool
+  end
+
+  it 'should associate to a provider class' do
+    pool_class.provider_class.must_equal('pool')
+  end
+
+  it 'should have a collection name' do
+    pool_class.collection_name.must_equal(:pools)
+  end
+
+  it 'should have an unique id' do
+    pool_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 23 attributes' do
+    pool_class.attributes.must_equal([ :reference,
+                                       :blobs,
+                                       :description,
+                                       :gui_config,
+                                       :ha_allow_overcommit,
+                                       :ha_configuration,
+                                       :ha_enabled,
+                                       :ha_host_failures_to_tolerate,
+                                       :ha_overcommitted,
+                                       :ha_plan_exists_for,
+                                       :ha_statefiles,
+                                       :name,
+                                       :other_config,
+                                       :redo_log_enabled,
+                                       :redo_log_vdi,
+                                       :restrictions,
+                                       :tags,
+                                       :uuid,
+                                       :vswitch_controller,
+                                       :wlb_enabled,
+                                       :wlb_url,
+                                       :wlb_username,
+                                       :wlb_verify_cert ])
+  end
+
+  it 'should have 5 associations' do
+    pool_class.associations.must_equal(:crash_dump_sr => :storage_repositories, 
+                                       :default_sr => :storage_repositories, 
+                                       :master => :hosts, 
+                                       :metadata_vdis => :vdis, 
+                                       :suspend_image_sr => :storage_repositories)
+  end
+
+  it 'should have 28 masks' do
+    pool_class.masks.must_equal(:reference => :reference, 
+                                :blobs => :blobs, 
+                                :description => :description, 
+                                :gui_config => :gui_config, 
+                                :ha_allow_overcommit => :ha_allow_overcommit, 
+                                :ha_configuration => :ha_configuration, 
+                                :ha_enabled => :ha_enabled, 
+                                :ha_host_failures_to_tolerate => :ha_host_failures_to_tolerate, 
+                                :ha_overcommitted => :ha_overcommitted, 
+                                :ha_plan_exists_for => :ha_plan_exists_for, 
+                                :ha_statefiles => :ha_statefiles, 
+                                :name => :name, 
+                                :other_config => :other_config, 
+                                :redo_log_enabled => :redo_log_enabled, 
+                                :redo_log_vdi => :redo_log_vdi, 
+                                :restrictions => :restrictions, 
+                                :tags => :tags, 
+                                :uuid => :uuid, 
+                                :vswitch_controller => :vswitch_controller, 
+                                :wlb_enabled => :wlb_enabled, 
+                                :wlb_url => :wlb_url, 
+                                :wlb_username => :wlb_username, 
+                                :wlb_verify_cert => :wlb_verify_cert, 
+                                :crash_dump_sr => :crash_dump_SR, 
+                                :default_sr => :default_SR, 
+                                :master => :master, 
+                                :metadata_vdis => :metadata_VDIs, 
+                                :suspend_image_sr => :suspend_image_SR)
+  end
+
+  it 'should have 6 aliases' do
+    pool_class.aliases.must_equal(:name_label => :name,
+                                  :name_description => :description,
+                                  :crash_dump_SR => :crash_dump_sr,
+                                  :default_SR => :default_sr,
+                                  :metadata_VDIs => :metadata_vdis,
+                                  :suspend_image_SR => :suspend_image_sr)
+  end
+
+  it "shouldn't have default values" do
+    pool_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    pool_class.require_before_save.must_equal([])
+  end
+end

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

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

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

@@ -0,0 +1,56 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Role do
+  let(:role_class) do
+    class Fog::Compute::XenServer::Models::Role
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::Role
+  end
+
+  it 'should associate to a provider class' do
+    role_class.provider_class.must_equal('role')
+  end
+
+  it 'should have a collection name' do
+    role_class.collection_name.must_equal(:roles)
+  end
+
+  it 'should have an unique id' do
+    role_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 4 attributes' do
+    role_class.attributes.must_equal([ :reference,
+                                       :description,
+                                       :name,
+                                       :uuid ])
+  end
+
+  it 'should have 1 association' do
+    role_class.associations.must_equal(:subroles => :roles)
+  end
+
+  it 'should have 5 masks' do
+    role_class.masks.must_equal(:reference => :reference, 
+                                :description => :description, 
+                                :name => :name, 
+                                :uuid => :uuid, 
+                                :subroles => :subroles)
+  end
+
+  it 'should have 2 aliases' do
+    role_class.aliases.must_equal({ :name_description => :description,
+                                    :name_label => :name })
+  end
+
+  it "shouldn't have default values" do
+    role_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    role_class.require_before_save.must_equal([])
+  end
+end

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

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

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

@@ -0,0 +1,61 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::ServerAppliance do
+  let(:server_appliance_class) do
+    class Fog::Compute::XenServer::Models::ServerAppliance
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::ServerAppliance
+  end
+
+  it 'should associate to a provider class' do
+    server_appliance_class.provider_class.must_equal('VM_appliance')
+  end
+
+  it 'should have a collection name' do
+    server_appliance_class.collection_name.must_equal(:server_appliances)
+  end
+
+  it 'should have an unique id' do
+    server_appliance_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 6 attributes' do
+    server_appliance_class.attributes.must_equal([ :reference,
+                                                   :allowed_operations,
+                                                   :current_operations,
+                                                   :description,
+                                                   :name,
+                                                   :uuid ])
+  end
+
+  it 'should have 1 association' do
+    server_appliance_class.associations.must_equal(:vms => :servers)
+  end
+
+  it 'should have 7 masks' do
+    server_appliance_class.masks.must_equal(:reference => :reference, 
+                                            :allowed_operations => :allowed_operations, 
+                                            :current_operations => :current_operations, 
+                                            :description => :description, 
+                                            :name => :name, 
+                                            :uuid => :uuid, 
+                                            :vms => :VMs)
+  end
+
+  it 'should have 3 aliases' do
+    server_appliance_class.aliases.must_equal(:name_description => :description,
+                                              :name_label => :name,
+                                              :VMs => :vms)
+  end
+
+  it "shouldn't have default values" do
+    server_appliance_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    server_appliance_class.require_before_save.must_equal([])
+  end
+end

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

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

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

@@ -0,0 +1,76 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::ServerMetrics do
+  let(:server_metrics_class) do
+    class Fog::Compute::XenServer::Models::ServerMetrics
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::ServerMetrics
+  end
+
+  it 'should associate to a provider class' do
+    server_metrics_class.provider_class.must_equal('VM_metrics')
+  end
+
+  it 'should have a collection name' do
+    server_metrics_class.collection_name.must_equal(:servers_metrics)
+  end
+
+  it 'should have an unique id' do
+    server_metrics_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 13 attributes' do
+    server_metrics_class.attributes.must_equal([ :reference,
+                                                 :install_time,
+                                                 :last_updated,
+                                                 :memory_actual,
+                                                 :other_config,
+                                                 :start_time,
+                                                 :state,
+                                                 :uuid,
+                                                 :vcpus_cpu,
+                                                 :vcpus_flags,
+                                                 :vcpus_number,
+                                                 :vcpus_params,
+                                                 :vcpus_utilisation ])
+  end
+
+  it "shouldn't have associations" do
+    server_metrics_class.associations.must_equal({})
+  end
+
+  it 'should have 13 masks' do
+    server_metrics_class.masks.must_equal(:reference => :reference,
+                                          :install_time => :install_time,
+                                          :last_updated => :last_updated,
+                                          :memory_actual => :memory_actual,
+                                          :other_config => :other_config,
+                                          :start_time => :start_time,
+                                          :state => :state,
+                                          :uuid => :uuid,
+                                          :vcpus_cpu => :VCPUs_CPU,
+                                          :vcpus_flags => :VCPUs_flags,
+                                          :vcpus_number => :VCPUs_number,
+                                          :vcpus_params => :VCPUs_params,
+                                          :vcpus_utilisation => :VCPUs_utilisation)
+  end
+
+  it 'should have 6 aliases' do
+    server_metrics_class.aliases.must_equal(:VCPUs_CPU => :vcpus_cpu,
+                                            :VCPUs_flags => :vcpus_flags,
+                                            :VCPUs_number => :vcpus_number,
+                                            :VCPUs_params => :vcpus_params,
+                                            :VCPUs_utilisation => :vcpus_utilisation)
+  end
+
+  it "shouldn't have default values" do
+    server_metrics_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    server_metrics_class.require_before_save.must_equal([])
+  end
+end

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

@@ -0,0 +1,554 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Server do
+  let(:server_class) do
+    class Fog::Compute::XenServer::Models::Server
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::Server
+  end
+
+  let(:server) { Fog::Compute::XenServer::Models::Server.new }
+  let(:service) { Object.new }
+  let(:collection) { Object.new }
+  let(:vif) { Fog::Compute::XenServer::Models::Vif.new }
+  let(:vbd) { Fog::Compute::XenServer::Models::Vbd.new }
+
+  it 'should associate to a provider class' do
+    server_class.provider_class.must_equal('VM')
+  end
+
+  it 'should have a collection name' do
+    server_class.collection_name.must_equal(:servers)
+  end
+
+  it 'should have an unique id' do
+    server_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 57 attributes' do
+    server_class.attributes.must_equal([ :reference,
+                                         :actions_after_crash,
+                                         :actions_after_reboot,
+                                         :actions_after_shutdown,
+                                         :allowed_operations,
+                                         :blobs,
+                                         :blocked_operations,
+                                         :bios_strings,
+                                         :current_operations,
+                                         :domarch,
+                                         :domid,
+                                         :description,
+                                         :generation_id,
+                                         :ha_always_run,
+                                         :ha_restart_priority,
+                                         :hvm_boot_params,
+                                         :hvm_boot_policy,
+                                         :hvm_shadow_multiplier,
+                                         :is_a_snapshot,
+                                         :is_a_template,
+                                         :is_control_domain,
+                                         :is_snapshot_from_vmpp,
+                                         :last_booted_record,
+                                         :last_boot_cpu_flags,
+                                         :memory_dynamic_max,
+                                         :memory_dynamic_min,
+                                         :memory_overhead,
+                                         :memory_static_max,
+                                         :memory_static_min,
+                                         :memory_target,
+                                         :name,
+                                         :order,
+                                         :other_config,
+                                         :pci_bus,
+                                         :platform,
+                                         :power_state,
+                                         :pv_args,
+                                         :pv_bootloader,
+                                         :pv_bootloader_args,
+                                         :pv_kernel,
+                                         :pv_legacy_args,
+                                         :pv_ramdisk,
+                                         :recommendations,
+                                         :shutdown_delay,
+                                         :snapshot_info,
+                                         :snapshot_metadata,
+                                         :snapshot_time,
+                                         :start_delay,
+                                         :tags,
+                                         :transportable_snapshot_id,
+                                         :user_version,
+                                         :uuid,
+                                         :vcpus_at_startup,
+                                         :vcpus_max,
+                                         :vcpus_params,
+                                         :version,
+                                         :xenstore_data ])
+  end
+
+  it 'should have 19 associations' do
+    server_class.associations.must_equal(:affinity => :hosts,
+                                         :appliance => :server_appliances,
+                                         :attached_pcis => :pcis,
+                                         :children => :servers,
+                                         :consoles => :consoles,
+                                         :crash_dumps => :crash_dumps,
+                                         :guest_metrics => :guests_metrics,
+                                         :metrics => :servers_metrics,
+                                         :parent => :servers,
+                                         :protection_policy => :vmpps,
+                                         :resident_on => :hosts,
+                                         :snapshots => :servers,
+                                         :snapshot_of => :servers,
+                                         :suspend_sr => :storage_repositories,
+                                         :suspend_vdi => :vdis,
+                                         :vbds => :vbds,
+                                         :vgpus => :vgpus,
+                                         :vifs => :vifs,
+                                         :vtpms => :vtpms)
+  end
+
+  it 'should have 76 masks' do
+    server_class.masks.must_equal(:reference => :reference,
+                                  :actions_after_crash => :actions_after_crash,
+                                  :actions_after_reboot => :actions_after_reboot,
+                                  :actions_after_shutdown => :actions_after_shutdown,
+                                  :allowed_operations => :allowed_operations,
+                                  :blobs => :blobs,
+                                  :blocked_operations => :blocked_operations,
+                                  :bios_strings => :bios_strings,
+                                  :current_operations => :current_operations,
+                                  :domarch => :domarch,
+                                  :domid => :domid,
+                                  :description => :name_description,
+                                  :generation_id => :generation_id,
+                                  :ha_always_run => :ha_always_run,
+                                  :ha_restart_priority => :ha_restart_priority,
+                                  :hvm_boot_params => :HVM_boot_params,
+                                  :hvm_boot_policy => :HVM_boot_policy,
+                                  :hvm_shadow_multiplier => :HVM_shadow_multiplier,
+                                  :is_a_snapshot => :is_a_snapshot,
+                                  :is_a_template => :is_a_template,
+                                  :is_control_domain => :is_control_domain,
+                                  :is_snapshot_from_vmpp => :is_snapshot_from_vmpp,
+                                  :last_booted_record => :last_booted_record,
+                                  :last_boot_cpu_flags => :last_boot_CPU_flags,
+                                  :memory_dynamic_max => :memory_dynamic_max,
+                                  :memory_dynamic_min => :memory_dynamic_min,
+                                  :memory_overhead => :memory_overhead,
+                                  :memory_static_max => :memory_static_max,
+                                  :memory_static_min => :memory_static_min,
+                                  :memory_target => :memory_target,
+                                  :name => :name_label,
+                                  :order => :order,
+                                  :other_config => :other_config,
+                                  :pci_bus => :PCI_bus,
+                                  :platform => :platform,
+                                  :power_state => :power_state,
+                                  :pv_args => :PV_args,
+                                  :pv_bootloader => :PV_bootloader,
+                                  :pv_bootloader_args => :PV_bootloader_args,
+                                  :pv_kernel => :PV_kernel,
+                                  :pv_legacy_args => :PV_legacy_args,
+                                  :pv_ramdisk => :PV_ramdisk,
+                                  :recommendations => :recommendations,
+                                  :shutdown_delay => :shutdown_delay,
+                                  :snapshot_info => :snapshot_info,
+                                  :snapshot_metadata => :snapshot_metadata,
+                                  :snapshot_time => :snapshot_time,
+                                  :start_delay => :start_delay,
+                                  :tags => :tags,
+                                  :transportable_snapshot_id => :transportable_snapshot_id,
+                                  :user_version => :user_version,
+                                  :uuid => :uuid,
+                                  :vcpus_at_startup => :VCPUs_at_startup,
+                                  :vcpus_max => :VCPUs_max,
+                                  :vcpus_params => :VCPUs_params,
+                                  :version => :version,
+                                  :xenstore_data => :xenstore_data,
+                                  :affinity => :affinity,
+                                  :appliance => :appliance,
+                                  :attached_pcis => :attached_PCIs,
+                                  :children => :children,
+                                  :consoles => :consoles,
+                                  :crash_dumps => :crash_dumps,
+                                  :guest_metrics => :guest_metrics,
+                                  :metrics => :metrics,
+                                  :parent => :parent,
+                                  :protection_policy => :protection_policy,
+                                  :resident_on => :resident_on,
+                                  :snapshots => :snapshots,
+                                  :snapshot_of => :snapshot_of,
+                                  :suspend_sr => :suspend_SR,
+                                  :suspend_vdi => :suspend_VDI,
+                                  :vbds => :VBDs,
+                                  :vgpus => :VGPUs,
+                                  :vifs => :VIFs,
+                                  :vtpms => :VTPMs)
+  end
+
+  it 'should have 23 aliases' do
+    server_class.aliases.must_equal(:attached_PCIs => :attached_pcis,
+                                    :name_label => :name,
+                                    :name_description => :description,
+                                    :last_boot_CPU_flags => :last_boot_cpu_flags,
+                                    :PV_args => :pv_args,
+                                    :PV_bootloader => :pv_bootloader,
+                                    :PV_bootloader_args => :pv_bootloader_args,
+                                    :PV_kernel => :pv_kernel,
+                                    :PV_ramdisk => :pv_ramdisk,
+                                    :PV_legacy_args => :pv_legacy_args,
+                                    :suspend_SR => :suspend_sr,
+                                    :suspend_VDI => :suspend_vdi,
+                                    :VBDs => :vbds,
+                                    :VCPUs_at_startup => :vcpus_at_startup,
+                                    :VCPUs_max => :vcpus_max,
+                                    :VCPUs_params => :vcpus_params,
+                                    :VGPUs => :vgpus,
+                                    :VIFs => :vifs,
+                                    :VTPMs => :vtpms,
+                                    :HVM_boot_policy => :hvm_boot_policy,
+                                    :HVM_boot_params => :hvm_boot_params,
+                                    :HVM_shadow_multiplier => :hvm_shadow_multiplier,
+                                    :PCI_bus => :pci_bus)
+  end
+
+  it 'should have 26 default values' do
+    server_class.default_values.must_equal(:actions_after_crash => 'Restart',
+                                           :actions_after_reboot => 'Restart',
+                                           :actions_after_shutdown => 'Destroy',
+                                           :description => '',
+                                           :hvm_boot_params => {},
+                                           :hvm_boot_policy => '',
+                                           :is_a_template => true,
+                                           :memory_dynamic_max => '536870912',
+                                           :memory_dynamic_min => '536870912',
+                                           :memory_static_max => '536870912',
+                                           :memory_static_min => '536870912',
+                                           :name => '',
+                                           :other_config => {},
+                                           :pci_bus => '',
+                                           :platform => { 'nx' => 'true',
+                                                          'acpi' => 'true',
+                                                          'apic' => 'true',
+                                                          'pae' => 'true',
+                                                          'viridian' => 'true' },
+                                           :pv_args => '-- quiet console=hvc0',
+                                           :pv_bootloader => 'pygrub',
+                                           :pv_bootloader_args => '',
+                                           :pv_kernel => '',
+                                           :pv_legacy_args => '',
+                                           :pv_ramdisk => '',
+                                           :recommendations => '',
+                                           :user_version => '0',
+                                           :vcpus_at_startup => '1',
+                                           :vcpus_max => '1',
+                                           :vcpus_params => {})
+  end
+
+  it 'should require 2 attributes before save' do
+    server_class.require_before_save.must_equal([ :name, :affinity ])
+  end
+
+  describe '#tools_installed?' do
+    describe 'when guest_metrics is nil' do
+      it 'should return false' do
+        server.stub(:guest_metrics, nil) do
+          server.tools_installed?.must_equal false
+        end
+      end
+    end
+
+    describe 'when guest_metrics is not nil' do
+      it 'should return true' do
+        server.stub(:guest_metrics, Object.new) do
+          server.tools_installed?.must_equal true
+        end
+      end
+    end
+  end
+
+  describe '#home_hypervisor' do
+    before :each do
+      def service.hosts
+        [ 1, 2 ]
+      end
+    end
+
+    it 'should return the first host' do
+      server.stub(:service, service) do
+        server.home_hypervisor.must_equal 1
+      end
+    end
+  end
+
+  describe '#mac_address' do
+    it 'should return the mac address of the first virtual interface' do
+      server.stub(:vifs, [ vif ]) do
+        vif.stub(:mac, 'mac') do
+          server.mac_address.must_equal 'mac'
+        end
+      end
+    end
+  end
+
+  describe '#running?' do
+    describe 'when it is running' do
+      before :each do
+        server.power_state = 'Running'
+      end
+
+      it 'should return true' do
+        server.stub(:reload, true) do
+          server.running?.must_equal true
+        end
+      end
+    end
+
+    describe 'when it is not running' do
+      before :each do
+        server.power_state = 'Anything'
+      end
+
+      it 'should return false' do
+        server.stub(:reload, true) do
+          server.running?.must_equal false
+        end
+      end
+    end
+  end
+
+  describe '#halted?' do
+    describe 'when it is halted' do
+      before :each do
+        server.power_state = 'Halted'
+      end
+
+      it 'should return true' do
+        server.stub(:reload, true) do
+          server.halted?.must_equal true
+        end
+      end
+    end
+
+    describe 'when it is not halted' do
+      before :each do
+        server.power_state = 'Anything'
+      end
+
+      it 'should return false' do
+        server.stub(:reload, true) do
+          server.halted?.must_equal false
+        end
+      end
+    end
+  end
+
+  describe '#destroy' do
+    before :each do
+      def server.hard_shutdown; @shutdown = true; end
+      def vbd.destroy; @destroyed = true; end
+      def service.destroy_record(_reference, _provider_class); @destroyed = true; end
+      server.stub(:service, service) do
+        server.stub(:vbds, [vbd]) do
+          server.destroy
+        end
+      end
+    end
+
+    it 'should shutdown the vm' do
+      server.instance_variable_get(:@shutdown).must_equal(true)
+    end
+
+    it 'should destroy the vbds' do
+      vbd.instance_variable_get(:@destroyed).must_equal(true)
+    end
+
+    it 'should destroy the vm' do
+      service.instance_variable_get(:@destroyed).must_equal(true)
+    end
+  end
+
+  describe '#start' do
+    describe 'on a running server' do
+      before :each do
+        def server.running?; true end
+      end
+
+      it 'should return false' do
+        server.start.must_equal(false)
+      end
+    end
+
+    describe 'on a halted server' do
+      before :each do
+        def server.running?; false end
+        def service.start_vm(reference); @started = true end
+        def server.wait_for(&block); instance_eval(&block); @started = true end
+        server.stub(:service, service) do
+          server.start
+        end
+      end
+
+      it 'should start the server' do
+        service.instance_variable_get(:@started).must_equal(true)
+      end
+
+      it 'should wait the server start' do
+        server.instance_variable_get(:@started).must_equal(true)
+      end
+
+      it 'should return true' do
+        server.stub(:service, service) do
+          server.start.must_equal(true)
+        end
+      end
+    end
+  end
+
+  describe '#hard_shutdown' do
+    describe 'on a halted server' do
+      before :each do
+        def server.halted?; true end
+      end
+
+      it 'should return false' do
+        server.hard_shutdown.must_equal(false)
+      end
+    end
+
+    describe 'on a running server' do
+      before :each do
+        def server.halted?; false end
+        def service.hard_shutdown_vm(reference); @halted = true end
+        def server.wait_for(&block); instance_eval(&block); @halted = true end
+        server.stub(:service, service) do
+          server.hard_shutdown
+        end
+      end
+
+      it 'should shutdown the server' do
+        service.instance_variable_get(:@halted).must_equal(true)
+      end
+
+      it 'should wait the server shutdown' do
+        server.instance_variable_get(:@halted).must_equal(true)
+      end
+
+      it 'should return true' do
+        server.stub(:service, service) do
+          server.hard_shutdown.must_equal(true)
+        end
+      end
+    end
+  end
+
+  describe '#clean_shutdown' do
+    describe 'on a halted server' do
+      before :each do
+        def server.halted?; true end
+      end
+
+      it 'should return false' do
+        server.clean_shutdown.must_equal(false)
+      end
+    end
+
+    describe 'on a running server' do
+      before :each do
+        def server.halted?; false end
+        def service.clean_shutdown_vm(reference); @halted = true end
+        def server.wait_for(&block); instance_eval(&block); @halted = true end
+        server.stub(:service, service) do
+          server.clean_shutdown
+        end
+      end
+
+      it 'should shutdown the server' do
+        service.instance_variable_get(:@halted).must_equal(true)
+      end
+
+      it 'should wait the server shutdown' do
+        server.instance_variable_get(:@halted).must_equal(true)
+      end
+
+      it 'should return true' do
+        server.stub(:service, service) do
+          server.clean_shutdown.must_equal(true)
+        end
+      end
+    end
+  end
+
+  describe '#can_be_cloned?' do
+    describe "when it can be cloned" do
+      before :each do
+        server.allowed_operations = %w(clone)
+      end
+
+      it 'should return true' do
+        server.can_be_cloned?.must_equal(true)
+      end
+    end
+
+    describe 'when can not be cloned' do
+      before :each do
+        server.allowed_operations = []
+      end
+
+      it 'should return false' do
+        server.can_be_cloned?.must_equal(false)
+      end
+    end
+  end
+
+  describe '#clone' do
+    describe "when it can be cloned" do
+      before :each do
+        def server.can_be_cloned?; true end
+        def service.clone_vm(name, reference); @cloned = true end
+        def server.reload; @reloaded = true end
+        server.stub(:service, service) do
+          server.clone('')
+        end
+      end
+
+      it 'should clone the vm' do
+        service.instance_variable_get(:@cloned).must_equal(true)
+      end
+
+      it 'should reload the vm' do
+        server.instance_variable_get(:@reloaded).must_equal(true)
+      end
+    end
+
+    describe 'when can not be cloned' do
+      before :each do
+        def server.can_be_cloned?; false end
+      end
+
+      it 'should raise an exception' do
+        lambda { server.clone('') }.must_raise RuntimeError, 'Clone Operation not Allowed'
+      end
+    end
+  end
+
+  describe '#revert_to' do
+    before :each do
+      collection.instance_variable_set(:@server, server)
+      def collection.get_by_reference_or_name_or_uuid(name); @server end
+      def service.revert_to_vm(reference); @reverted = true end
+      server.stub(:service, service) do
+        server.stub(:collection, collection) do
+          server.revert_to('snapshot')
+        end
+      end
+    end
+
+    it 'should revert the snapshot' do
+      service.instance_variable_get(:@reverted).must_equal(true)
+    end
+  end
+end