fog-xenserver 0.0.1.beta1 → 0.0.1.beta2

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

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

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

@@ -0,0 +1,89 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Vmpp do
+  let(:vmpp_class) do
+    class Fog::Compute::XenServer::Models::Vmpp
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::Vmpp
+  end
+
+  it 'should associate to a provider class' do
+    vmpp_class.provider_class.must_equal('VMPP')
+  end
+
+  it 'should have a collection name' do
+    vmpp_class.collection_name.must_equal(:vmpps)
+  end
+
+  it 'should have an unique id' do
+    vmpp_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 20 attributes' do
+    vmpp_class.attributes.must_equal([ :reference,
+                                       :alarm_config,
+                                       :archive_frequency,
+                                       :archive_last_run_time,
+                                       :archive_schedule,
+                                       :archive_target_config,
+                                       :archive_target_type,
+                                       :backup_frequency,
+                                       :backup_last_run_time,
+                                       :backup_retention_value,
+                                       :backup_schedule,
+                                       :backup_type,
+                                       :description,
+                                       :is_alarm_enabled,
+                                       :is_archive_running,
+                                       :is_backup_running,
+                                       :is_policy_enabled,
+                                       :name,
+                                       :recent_alerts,
+                                       :uuid ])
+  end
+
+  it 'should have 1 association' do
+    vmpp_class.associations.must_equal(:vms => :servers)
+  end
+
+  it 'should have 21 masks' do
+    vmpp_class.masks.must_equal(:reference => :reference, 
+                                :alarm_config => :alarm_config, 
+                                :archive_frequency => :archive_frequency, 
+                                :archive_last_run_time => :archive_last_run_time, 
+                                :archive_schedule => :archive_schedule, 
+                                :archive_target_config => :archive_target_config, 
+                                :archive_target_type => :archive_target_type, 
+                                :backup_frequency => :backup_frequency, 
+                                :backup_last_run_time => :backup_last_run_time, 
+                                :backup_retention_value => :backup_retention_value, 
+                                :backup_schedule => :backup_schedule, 
+                                :backup_type => :backup_type, 
+                                :description => :description, 
+                                :is_alarm_enabled => :is_alarm_enabled, 
+                                :is_archive_running => :is_archive_running, 
+                                :is_backup_running => :is_backup_running, 
+                                :is_policy_enabled => :is_policy_enabled, 
+                                :name => :name, 
+                                :recent_alerts => :recent_alerts, 
+                                :uuid => :uuid, 
+                                :vms => :VMs)
+  end
+
+  it 'should have 2 aliases' do
+    vmpp_class.aliases.must_equal(:name_description => :description,
+                                  :name_label => :name,
+                                  :VMs => :vms)
+  end
+
+  it "shouldn't have default values" do
+    vmpp_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    vmpp_class.require_before_save.must_equal([])
+  end
+end

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

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

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

@@ -0,0 +1,53 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer::Models::Vtpm do
+  let(:vtpm_class) do
+    class Fog::Compute::XenServer::Models::Vtpm
+      def self.read_identity
+        instance_variable_get('@identity')
+      end
+    end
+    Fog::Compute::XenServer::Models::Vtpm
+  end
+
+  it 'should associate to a provider class' do
+    vtpm_class.provider_class.must_equal('VTPM')
+  end
+
+  it 'should have a collection name' do
+    vtpm_class.collection_name.must_equal(:vtpms)
+  end
+
+  it 'should have an unique id' do
+    vtpm_class.read_identity.must_equal(:reference)
+  end
+
+  it 'should have 2 attributes' do
+    vtpm_class.attributes.must_equal([ :reference,
+                                       :uuid ])
+  end
+
+  it 'should have 2 associations' do
+    vtpm_class.associations.must_equal(:backend => :servers,
+                                       :vm => :servers)
+  end
+
+  it 'should have 4 masks' do
+    vtpm_class.masks.must_equal(:reference => :reference,
+                                :uuid => :uuid,
+                                :backend => :backend,
+                                :vm => :vm)
+  end
+
+  it "shouldn't have aliases" do
+    vtpm_class.aliases.must_equal({})
+  end
+
+  it "shouldn't have default values" do
+    vtpm_class.default_values.must_equal({})
+  end
+
+  it "shouldn't require attributes before save" do
+    vtpm_class.require_before_save.must_equal([])
+  end
+end

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

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

data/spec/fog/compute/xen_server/requests/builtin_templates_spec.rb

@@ -0,0 +1,18 @@
+require 'minitest_helper'
+
+describe "#builtin_templates" do
+  let(:connection) do
+    VCR.use_cassette('open_connection') do
+      Fog::Compute.new(:provider => 'XenServer',
+                       :xenserver_url => '192.168.10.2',
+                       :xenserver_username => 'root',
+                       :xenserver_password => '123456')
+    end
+  end
+
+  it "should return all builtin templates" do
+    VCR.use_cassette('builtin_templates') do
+      connection.builtin_templates.size.must_equal 63
+    end
+  end
+end

data/spec/fog/compute/xen_server/requests/clone_server_spec.rb

@@ -0,0 +1,36 @@
+require 'minitest_helper'
+
+describe "#clone_vm" do
+  let(:connection) do
+    VCR.use_cassette('open_connection') do
+      Fog::Compute.new(:provider => 'XenServer',
+                       :xenserver_url => '192.168.10.2',
+                       :xenserver_username => 'root',
+                       :xenserver_password => '123456')
+    end
+  end
+  let(:server) do
+    host = VCR.use_cassette('create_server_get_all_hosts') do
+      connection.hosts.first
+    end
+    @server = connection.servers.new(:name => 'CrazyName')
+    @server.affinity = host
+    VCR.use_cassette('create_server_create_vm') do
+      @server.save
+    end
+    @server
+  end
+
+  before :each do
+    @template_uuid = server.uuid
+    VCR.use_cassette('clone_server') do
+      server.clone('Awesome Server')
+    end
+  end
+
+  it 'should create a new template' do
+    server.persisted?.must_equal(true)
+    server.uuid.wont_equal(@template_uuid)
+    server.name.must_equal('Awesome Server')
+  end
+end

data/spec/fog/compute/xen_server/requests/create_network_spec.rb

@@ -0,0 +1,24 @@
+require 'minitest_helper'
+
+describe "#create_network" do
+  let(:connection) do
+    VCR.use_cassette('open_connection') do
+      Fog::Compute.new(:provider => 'XenServer',
+                       :xenserver_url => '192.168.10.2',
+                       :xenserver_username => 'root',
+                       :xenserver_password => '123456')
+    end
+  end
+
+  before :each do
+    @network = connection.networks.new(:name => 'CrazyName')
+    VCR.use_cassette('create_network') do
+      @network.save
+    end
+  end
+
+  it 'should create a new network' do
+    @network.persisted?.must_equal(true)
+    @network.name.must_equal('CrazyName')
+  end
+end

data/spec/fog/compute/xen_server/requests/create_server_spec.rb

@@ -0,0 +1,30 @@
+require 'minitest_helper'
+
+describe "#create_vm" do
+  let(:connection) do
+    VCR.use_cassette('create_server_open_connection') do
+      Fog::Compute.new(:provider => 'XenServer',
+                       :xenserver_url => '192.168.10.2',
+                       :xenserver_username => 'root',
+                       :xenserver_password => '123456')
+    end
+  end
+  let(:host) do
+    VCR.use_cassette('create_server_get_all_hosts') do
+      connection.hosts.first
+    end
+  end
+
+  before :each do
+    @server = connection.servers.new(:name => 'CrazyName')
+    @server.affinity = host
+    VCR.use_cassette('create_server_create_vm') do
+      @server.save
+    end
+  end
+
+  it 'should create a new server' do
+    @server.persisted?.must_equal(true)
+    @server.name.must_equal('CrazyName')
+  end
+end

data/spec/fog/compute/xen_server/requests/create_vbd_spec.rb

@@ -0,0 +1,45 @@
+require 'minitest_helper'
+
+describe "#create_vbd" do
+  let(:connection) do
+    VCR.use_cassette('create_vbd_open_connection') do
+      Fog::Compute.new(:provider => 'XenServer',
+                       :xenserver_url => '192.168.10.2',
+                       :xenserver_username => 'root',
+                       :xenserver_password => '123456')
+    end
+  end
+  let(:sr) do
+    VCR.use_cassette('create_vbd_get_storage_repository') do
+      connection.storage_repositories.get_by_name('Local storage')
+    end
+  end
+  let(:vdi) do
+    VCR.use_cassette('create_vbd_create_vdi') do
+      connection.vdis.create(:name => 'Craziest Vdi Ever', :storage_repository => sr)
+    end
+  end
+  let(:host) do
+    VCR.use_cassette('create_vbd_get_all_hosts') do
+      connection.hosts.first
+    end
+  end
+  let(:vm) do
+    VCR.use_cassette('create_vbd_create_vm') do
+      connection.servers.create(:name => "CrazyName", :affinity => host)
+    end
+  end
+
+  before :each do
+    @vbd = connection.vbds.new
+    @vbd.vdi = vdi
+    @vbd.vm = vm
+    VCR.use_cassette('create_vbd_create_vbd') do
+      @vbd.save
+    end
+  end
+
+  it 'should create a new vbd' do
+    @vbd.persisted?.must_equal(true)
+  end
+end

data/spec/fog/compute/xen_server/requests/create_vdi_spec.rb

@@ -0,0 +1,27 @@
+require 'minitest_helper'
+
+describe "#create_vdi" do
+  let(:connection) do
+    VCR.use_cassette('open_connection') do
+      Fog::Compute.new(:provider => 'XenServer',
+                       :xenserver_url => '192.168.10.2',
+                       :xenserver_username => 'root',
+                       :xenserver_password => '123456')
+    end
+  end
+  let(:sr) do
+    VCR.use_cassette('get_storage_repository') do
+      connection.storage_repositories.get_by_name('Local storage')
+    end
+  end
+
+  before :each do
+    VCR.use_cassette('create_vdi') do
+      @vdi = connection.vdis.create(:name => 'Craziest Vdi Ever', :storage_repository => sr)
+    end
+  end
+
+  it 'should create a new vdi' do
+    @vdi.persisted?.must_equal(true)
+  end
+end

data/spec/fog/compute/xen_server/requests/create_vif_spec.rb

@@ -0,0 +1,46 @@
+require 'minitest_helper'
+
+describe "#create_vif" do
+  let(:connection) do
+    VCR.use_cassette('create_vif_open_connection') do
+      Fog::Compute.new(:provider => 'XenServer',
+                       :xenserver_url => '192.168.10.2',
+                       :xenserver_username => 'root',
+                       :xenserver_password => '123456')
+    end
+  end
+  let(:network) do
+    VCR.use_cassette('create_vif_get_network_by_name') do
+      connection.networks.get_by_name('Pool-wide network associated with eth0')
+    end
+  end
+  let(:host) do
+    VCR.use_cassette('create_server_get_all_hosts') do
+      connection.hosts.first
+    end
+  end
+  let(:vm) do
+    @server = connection.servers.new(:name => 'CrazyName')
+    @server.affinity = host
+    VCR.use_cassette('create_server_create_vm') do
+      @server.save
+    end
+    @server
+  end
+
+  before :each do
+    @vif = connection.vifs.new
+    @vif.network = network
+    @vif.vm = vm
+    VCR.use_cassette('create_vif_vif_set_device_number') do
+      @vif.set_device_number
+    end
+    VCR.use_cassette('create_vif_create_vif') do
+      @vif.save
+    end
+  end
+
+  it 'should create a new vif' do
+    @vif.persisted?.must_equal(true)
+  end
+end

data/spec/fog/compute/xen_server/requests/sync_database_pool_spec.rb

@@ -0,0 +1,16 @@
+require 'minitest_helper'
+
+describe "#sync_database_pool" do
+  let(:connection) do
+    Fog::Compute.new(:provider => 'XenServer',
+                     :xenserver_url => '192.168.10.2',
+                     :xenserver_username => 'root',
+                     :xenserver_password => '123456')
+  end
+
+  it "should return success" do
+    VCR.use_cassette('sync_database_pool') do
+      connection.pools.first.sync_database.size.must_equal 0
+    end
+  end
+end

data/spec/fog/compute/xen_server_spec.rb

@@ -0,0 +1,13 @@
+require 'minitest_helper'
+
+describe Fog::Compute::XenServer do
+  describe '.const_missing' do
+    before :each do
+      Fog::Compute::XenServer::Models::Abc = Class.new
+    end
+
+    it 'should look for missing constants in the Models namespace' do
+      Fog::Compute::XenServer::Abc.must_equal Fog::Compute::XenServer::Models::Abc
+    end
+  end
+end