vcloud-core 0.0.1

data/spec/vcloud/core/vapp_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+module Vcloud
+  module Core
+    describe Vapp do
+      before(:each) do
+        @vapp_id = 'vapp-12345678-1234-1234-1234-000000111111'
+        @mock_fog_interface = StubFogInterface.new
+        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+      end
+
+      context "Class public interface" do
+        it { Vapp.should respond_to(:instantiate) }
+        it { Vapp.should respond_to(:get_by_name) }
+        it { Vapp.should respond_to(:get_metadata) }
+      end
+
+      context "Instance public interface" do
+        subject { Vapp.new(@vapp_id) }
+        it { should respond_to(:id) }
+        it { should respond_to(:vcloud_attributes) }
+        it { should respond_to(:name) }
+        it { should respond_to(:href) }
+        it { should respond_to(:vdc_id) }
+        it { should respond_to(:fog_vms) }
+        it { should respond_to(:networks) }
+        it { should respond_to(:power_on) }
+      end
+
+      context "#initialize" do
+
+        it "should be constructable from just an id reference" do
+          obj = Vapp.new(@vapp_id)
+          expect(obj.class).to be(Vcloud::Core::Vapp)
+        end
+
+        it "should store the id specified" do
+          obj = Vapp.new(@vapp_id)
+          expect(obj.id) == @vapp_id
+        end
+
+        it "should raise error if id is not in correct format" do
+          bogus_id = '12314124-ede5-4d07-bad5-000000111111'
+          expect{ Vapp.new(bogus_id) }.to raise_error("vapp id : #{bogus_id} is not in correct format" )
+        end
+
+      end
+
+      context "#get_by_name" do
+
+        it "should return a Vapp object if name exists" do
+          q_results = [
+            { :name => 'vapp-test-1', :href => @vapp_id }
+          ]
+          mock_query = double(:query, :get_all_results => q_results)
+          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==vapp-test-1").and_return(mock_query)
+          obj = Vapp.get_by_name('vapp-test-1')
+          expect(obj.class).to be(Vcloud::Core::Vapp)
+        end
+
+        it "should raise an error if no vApp with that name exists" do
+          q_results = [ ]
+          mock_query = double(:query, :get_all_results => q_results)
+          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==vapp-test-1").and_return(mock_query)
+          expect{ Vapp.get_by_name('vapp-test-1') }.to raise_exception(RuntimeError)
+        end
+
+        it "should raise an error if multiple vApps with that name exists (NB: prescribes unique vApp names!)" do
+          q_results = [
+            { :name => 'vapp-test-1', :href => @vapp_id },
+            { :name => 'vapp-test-1', :href => '/bogus' },
+          ]
+          mock_query = double(:query, :get_all_results => q_results)
+          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==vapp-test-1").and_return(mock_query)
+          expect{ Vapp.get_by_name('vapp-test-1') }.to raise_exception(RuntimeError)
+        end
+
+      end
+
+      context "attributes" do
+        before(:each) {
+          @stub_attrs = {
+              :name => 'Webserver vapp-1',
+              :href => "https://api.vcd.portal.skyscapecloud.com/api/vApp/#{@vapp_id}",
+              :Link => [{
+                            :rel => 'up',
+                            :type => 'application/vnd.vmware.vcloud.vdc+xml',
+                            :href => 'https://api.vcloud-director.example.com/api/vdc/074aea1e-a5e9-4dd1-a028-40db8c98d237'
+                        }],
+              :Children => {:Vm => [{:href => '/vm-123aea1e-a5e9-4dd1-a028-40db8c98d237'}]}
+          }
+          StubFogInterface.any_instance.stub(:get_vapp).and_return(@stub_attrs)
+          @vapp = Vapp.new(@vapp_id)
+        }
+        it { @vapp.name.should == 'Webserver vapp-1' }
+
+        context "id" do
+          it "should extract id correctly" do
+            @vapp.id.should == @vapp_id
+          end
+        end
+
+        context "vapp should have parent vdc" do
+          it "should load parent vdc id from fog attributes" do
+            @vapp.vdc_id.should == '074aea1e-a5e9-4dd1-a028-40db8c98d237'
+          end
+
+          it "should raise error if vapp without parent vdc found" do
+            @stub_attrs[:Link] = []
+            lambda { @vapp.vdc_id }.should raise_error('a vapp without parent vdc found')
+          end
+        end
+
+        it "should return vms" do
+          @vapp.fog_vms.count.should == 1
+          @vapp.fog_vms.first[:href].should == '/vm-123aea1e-a5e9-4dd1-a028-40db8c98d237'
+        end
+      end
+
+      context "power on" do
+        context "successful power on" do
+          before(:each) do
+            @fog_vapp_body = {
+                :name => "Webserver vapp-1",
+                :href => "https://api.vcloud-director.example.com/api/vApp/vapp-63d3be58-2d5c-477d-8410-267e7c3c4a02",
+                :Link => [{
+                              :rel => "up",
+                              :type => "application/vnd.vmware.vcloud.vdc+xml",
+                              :href => "https://api.vcloud-director.example.com/api/vdc/074aea1e-a5e9-4dd1-a028-40db8c98d237"
+                          }]
+            }
+          end
+
+          it "should power on a vapp that is not powered on" do
+            vapp = Vapp.new(@vapp_id)
+            @mock_fog_interface.should_receive(:get_vapp).twice().and_return({:status => 8})
+            @mock_fog_interface.should_receive(:power_on_vapp).with(vapp.id)
+            state = vapp.power_on
+            expect(state) == true
+          end
+
+          it "should not power on a vapp that is already powered on, but should return true" do
+            vapp = Vapp.new(@vapp_id)
+            @mock_fog_interface.should_receive(:get_vapp).and_return({:status => 4})
+            @mock_fog_interface.should_not_receive(:power_on_vapp)
+            state = vapp.power_on
+            expect(state) == true
+          end
+        end
+
+      end
+
+      context "#get_by_name_and_vdc_name" do
+
+        it "should return nil if fog returns nil" do
+          StubFogInterface.any_instance.stub(:get_vapp_by_name_and_vdc_name)
+            .with('vapp_name', 'vdc_name').and_return(nil)
+          Vapp.get_by_name_and_vdc_name('vapp_name', 'vdc_name').should == nil
+        end
+
+        it "should return vapp instance if found" do
+          vcloud_attr_vapp = { :href => "/#{@vapp_id}" }
+          StubFogInterface.any_instance.stub(:get_vapp_by_name_and_vdc_name)
+            .with('vapp_name', 'vdc_name').and_return(vcloud_attr_vapp)
+          Vapp.get_by_name_and_vdc_name('vapp_name', 'vdc_name').class.should == Core::Vapp
+        end
+
+      end
+
+    end
+  end
+end
+

data/spec/vcloud/core/vapp_template_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module Vcloud
+  module Core
+    describe VappTemplate do
+
+      before(:each) do
+        @id = 'vappTemplate-12345678-1234-1234-1234-000000234121'
+        @mock_fog_interface = StubFogInterface.new
+        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+        @test_config = {
+            :catalog => 'test_catalog',
+            :catalog_item => 'test_template'
+        }
+      end
+
+      context "Class public interface" do
+        it { VappTemplate.should respond_to(:get) }
+      end
+
+      context "Instance public interface" do
+        subject { VappTemplate.new(@id) }
+        it { should respond_to(:id) }
+        it { should respond_to(:vcloud_attributes) }
+        it { should respond_to(:name) }
+        it { should respond_to(:href) }
+      end
+
+      context "#initialize" do
+
+        it "should be constructable from just an id reference" do
+          obj = VappTemplate.new(@id)
+          expect(obj.class).to be(Vcloud::Core::VappTemplate)
+        end
+
+        it "should store the id specified" do
+          obj = VappTemplate.new(@id)
+          expect(obj.id) == @id
+        end
+
+        it "should raise error if id is not in correct format" do
+          bogus_id = '12314124-ede5-4d07-bad5-000000111111'
+          expect{ VappTemplate.new(bogus_id) }.to raise_error("vappTemplate id : #{bogus_id} is not in correct format" )
+        end
+
+      end
+
+
+      context '#get' do
+
+        it 'should raise a RuntimeError if there is no template' do
+          @mock_fog_interface.should_receive(:template).
+            with('test_catalog', 'test_template').and_return(nil)
+          expect { VappTemplate.get('test_catalog', 'test_template') }.
+            to raise_error('Could not find template vApp')
+        end
+
+
+        it 'should return a valid template object if it exists' do
+          test_catalog_item_entity = {
+              :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890abcde"
+          }
+          @mock_fog_interface.should_receive(:template).
+            with('test_catalog', 'test_template').
+            and_return(test_catalog_item_entity)
+          Vcloud::Fog::ServiceInterface.should_receive(:new).
+            and_return(@mock_fog_interface)
+
+          test_template = VappTemplate.get('test_catalog', 'test_template')
+          test_template.id.should == 'vappTemplate-12345678-90ab-cdef-0123-4567890abcde'
+        end
+
+      end
+
+    end
+  end
+end

data/spec/vcloud/core/vdc_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module Vcloud
+  module Core
+    describe Vdc do
+
+      before(:each) do
+        @vdc_id = '12345678-1234-1234-1234-000000111232'
+        @mock_fog_interface = StubFogInterface.new
+        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+      end
+
+      context "Class public interface" do
+        it { Vdc.should respond_to(:get_by_name) }
+      end
+
+      context "Instance public interface" do
+        subject { Vdc.new(@vdc_id) }
+        it { should respond_to(:id) }
+        it { should respond_to(:name) }
+        it { should respond_to(:href) }
+      end
+
+      context "#initialize" do
+
+        it "should be constructable from just an id reference" do
+          obj = Vdc.new(@vdc_id)
+          expect(obj.class).to be(Vcloud::Core::Vdc)
+        end
+
+        it "should store the id specified" do
+          obj = Vdc.new(@vdc_id)
+          expect(obj.id) == @vdc_id
+        end
+
+        it "should raise error if id is not in correct format" do
+          bogus_id = '123123-bogus-id-123445'
+          expect{ Vdc.new(bogus_id) }.to raise_error("vdc id : #{bogus_id} is not in correct format" )
+        end
+
+      end
+
+      context "#get_by_name" do
+
+        it "should return a Vdc object if name exists" do
+          q_results = [
+            { :name => 'vdc-test-1', :href => @vdc_id }
+          ]
+          mock_query = double(:query, :get_all_results => q_results)
+          Vcloud::Query.should_receive(:new).with('orgVdc', :filter => "name==vdc-test-1").and_return(mock_query)
+          obj = Vdc.get_by_name('vdc-test-1')
+          expect(obj.class).to be(Vcloud::Core::Vdc)
+        end
+
+        it "should raise an error if no vDC with that name exists" do
+          q_results = [ ]
+          mock_query = double(:query, :get_all_results => q_results)
+          Vcloud::Query.should_receive(:new).with('orgVdc', :filter => "name==vdc-test-1").and_return(mock_query)
+          expect{ Vdc.get_by_name('vdc-test-1') }.to raise_exception(RuntimeError, "vDc vdc-test-1 not found")
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/vcloud/core/vm_spec.rb

@@ -0,0 +1,290 @@
+require 'spec_helper'
+
+module Vcloud
+  module Core
+    describe Vm do
+
+      before(:each) do
+        @vm_id = 'vm-1234'
+        @vapp_id = 'vapp-4321'
+        @vapp_name = 'test-vapp-1'
+        @vm_name = 'test-vm-1'
+        @data_dir = File.join(File.dirname(__FILE__), "../data")
+        @mock_vm_memory_size = 1024
+        @mock_metadata = {
+            :foo => "bar",
+            :false_thing => false,
+            :true_thing => true,
+            :number => 53,
+            :zero => 0,
+        }
+        @mock_vm_cpu_count = 1
+        @fog_interface = StubFogInterface.new
+        @mock_vapp = double(:vappm, :name => @vapp_name, :id => @vapp_id)
+        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@fog_interface)
+        @fog_interface.stub(:get_vapp).with(@vm_id).and_return({
+            :name => "#{@vm_name}",
+            :href => "vm-href/#{@vm_id}",
+            :'ovf:VirtualHardwareSection' => {
+                :'ovf:Item' => [
+                    {
+                        :'rasd:ResourceType' => '4',
+                        :'rasd:VirtualQuantity' => "#{@mock_vm_memory_size}",
+                    },
+                    {
+                        :'rasd:ResourceType' => '3',
+                        :'rasd:VirtualQuantity' => "#{@mock_vm_cpu_count}",
+                    }
+                ]
+            }
+        })
+        @vm =  Vm.new(@vm_id, @mock_vapp)
+      end
+
+      context "Class public interface" do
+      end
+
+      context "Instance public interface" do
+        subject { Vm.new(@vm_id, @mock_vapp) }
+        it { should respond_to(:id) }
+        it { should respond_to(:vcloud_attributes) }
+        it { should respond_to(:name) }
+        it { should respond_to(:href) }
+        it { should respond_to(:vapp_name) }
+        it { should respond_to(:update_name) }
+        it { should respond_to(:update_cpu_count) }
+        it { should respond_to(:update_metadata) }
+        it { should respond_to(:update_storage_profile) }
+        it { should respond_to(:add_extra_disks) }
+        it { should respond_to(:configure_network_interfaces) }
+        it { should respond_to(:configure_guest_customization_section) }
+        it { should respond_to(:generate_preamble) }
+      end
+
+      context "#initialize" do
+
+        it "should be constructable from just an id reference & Vapp object" do
+          obj = Vm.new(@vm_id, @mock_vapp)
+          expect(obj.class).to be(Vcloud::Core::Vm)
+        end
+
+        it "should store the id specified" do
+          obj = Vm.new(@vm_id, @mock_vapp)
+          expect(obj.id) == @vm_id
+        end
+
+        it "should raise error if id is not in correct format" do
+          bogus_id = '12314124-ede5-4d07-bad5-000000111111'
+          expect{ Vm.new(bogus_id, @mock_vapp) }.to raise_error("vm id : #{bogus_id} is not in correct format" )
+        end
+
+      end
+
+      context "update memory in VM" do
+        it "should not allow memory size < 64MB" do
+          @fog_interface.should_not_receive(:put_memory)
+          @vm.update_memory_size_in_mb(63)
+        end
+        it "should not update memory if is size has not changed" do
+          @fog_interface.should_not_receive(:put_memory)
+          @vm.update_memory_size_in_mb(@mock_vm_memory_size)
+        end
+        it "should gracefully handle a nil memory size" do
+          @fog_interface.should_not_receive(:put_memory)
+          @vm.update_memory_size_in_mb(nil)
+        end
+        it "should set memory size 64MB" do
+          @fog_interface.should_receive(:put_memory).with(@vm_id, 64)
+          @vm.update_memory_size_in_mb(64)
+        end
+        it "should set memory size 4096MB" do
+          @fog_interface.should_receive(:put_memory).with(@vm_id, 4096)
+          @vm.update_memory_size_in_mb(4096)
+        end
+      end
+
+      context "update the number of cpus in vm" do
+        it "should gracefully handle nil cpu count" do
+          @fog_interface.should_not_receive(:put_cpu)
+          @vm.update_cpu_count(nil)
+        end
+        it "should not update cpu if is count has not changed" do
+          @fog_interface.should_not_receive(:put_cpu)
+          @vm.update_cpu_count(@mock_vm_cpu_count)
+        end
+        it "should not allow a zero cpu count" do
+          @fog_interface.should_not_receive(:put_cpu)
+          @vm.update_cpu_count(0)
+        end
+        it "should update cpu count in input is ok" do
+          @fog_interface.should_receive(:put_cpu).with(@vm_id, 2)
+          @vm.update_cpu_count(2)
+        end
+      end
+
+      context '#generate_preamble' do
+        it "should interpolate vars hash into template" do
+          vars = {:message => 'hello world'}
+          erbfile = "#{@data_dir}/basic_preamble_test.erb"
+          expected_output = File.read("#{erbfile}.OUT")
+          @vm.generate_preamble(erbfile, nil, vars).should == expected_output
+        end
+
+        it "should interpolate vars hash and post-process template" do
+          vars = {:message => 'hello world'}
+          erbfile = "#{@data_dir}/basic_preamble_test.erb"
+          expected_output = File.read("#{erbfile}.OUT")
+          @vm.generate_preamble(erbfile, '/bin/cat', vars).should == expected_output
+        end
+      end
+
+      context "update metadata" do
+        it "should handle empty metadata hash" do
+          @fog_interface.should_not_receive(:put_vapp_metadata_value)
+          @vm.update_metadata(nil)
+        end
+        it "should handle metadata of multiple types" do
+          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vm_id, :foo, 'bar')
+          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vm_id, :false_thing, false)
+          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vm_id, :true_thing, true)
+          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vm_id, :number, 53)
+          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vm_id, :zero, 0)
+          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vapp_id, :foo, 'bar')
+          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vapp_id, :false_thing, false)
+          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vapp_id, :true_thing, true)
+          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vapp_id, :number, 53)
+          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vapp_id, :zero, 0)
+          @vm.update_metadata(@mock_metadata)
+        end
+      end
+
+      context "configure vm network interfaces" do
+        it "should configure single nic without an IP" do
+          network_config = [{:name => 'Default'}]
+          @fog_interface.should_receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+              :PrimaryNetworkConnectionIndex => 0,
+              :NetworkConnection => [
+                  {
+                      :network => 'Default',
+                      :needsCustomization => true,
+                      :NetworkConnectionIndex => 0,
+                      :IsConnected => true,
+                      :IpAddressAllocationMode => "DHCP"
+                  }
+              ]})
+          @vm.configure_network_interfaces(network_config)
+        end
+
+        it "should configure single nic" do
+          network_config = [{:name => 'Default', :ip_address => '192.168.1.1'}]
+          @fog_interface.should_receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+              :PrimaryNetworkConnectionIndex => 0,
+              :NetworkConnection => [
+                  {
+                      :network => 'Default',
+                      :needsCustomization => true,
+                      :NetworkConnectionIndex => 0,
+                      :IsConnected => true,
+                      :IpAddress => "192.168.1.1",
+                      :IpAddressAllocationMode => "MANUAL"
+                  }
+              ]})
+          @vm.configure_network_interfaces(network_config)
+        end
+
+        it "should configure multiple nics" do
+          network_config = [
+              {:name => 'Default', :ip_address => '192.168.1.1'},
+              {:name => 'Monitoring', :ip_address => '192.168.2.1'}
+          ]
+
+          @fog_interface.should_receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+              :PrimaryNetworkConnectionIndex => 0,
+              :NetworkConnection => [
+                  {
+                      :network => 'Default',
+                      :needsCustomization => true,
+                      :NetworkConnectionIndex => 0,
+                      :IsConnected => true,
+                      :IpAddress => "192.168.1.1",
+                      :IpAddressAllocationMode => "MANUAL"
+                  },
+                  {
+                      :network => 'Monitoring',
+                      :needsCustomization => true,
+                      :NetworkConnectionIndex => 1,
+                      :IsConnected => true,
+                      :IpAddress => "192.168.2.1",
+                      :IpAddressAllocationMode => "MANUAL"
+                  },
+              ]})
+          @vm.configure_network_interfaces(network_config)
+        end
+
+        it "should configure no nics" do
+          network_config = nil
+          @fog_interface.should_not_receive(:put_network_connection_system_section_vapp)
+          @vm.configure_network_interfaces(network_config)
+        end
+
+      end
+
+      context "update storage profiles" do
+        it "should update the storage profile" do
+          storage_profile = 'storage_profile_name'
+          vdc_results = [
+            { :vdcName => 'vdc-test-1' }
+          ]
+          mock_vdc_query = double(:query, :get_all_results => vdc_results)
+
+          storage_profile_results = [
+            { :href => 'test-href' }
+          ]
+          mock_sp_query = double(:query, :get_all_results => storage_profile_results)
+
+          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==#{@vapp_name}").and_return(mock_vdc_query)
+          Vcloud::Query.should_receive(:new).with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").and_return(mock_sp_query)
+
+          generated_storage_profile = { name: 'storage_profile_name', href: 'test-href' }
+          @fog_interface.should_receive(:put_vm).with(@vm_id, @vm_name, { :StorageProfile => generated_storage_profile} ).and_return(true)
+          @vm.update_storage_profile(storage_profile).should == true
+        end
+
+        it "should raise an error if storage profile is not found" do
+          storage_profile = 'storage_profile_name'
+          vdc_results = [
+            { :vdcName => 'vdc-test-1' }
+          ]
+          mock_vdc_query = double(:query, :get_all_results => vdc_results)
+
+          storage_profile_results = []
+          mock_sp_query = double(:query, :get_all_results => storage_profile_results)
+
+          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==#{@vapp_name}").and_return(mock_vdc_query)
+          Vcloud::Query.should_receive(:new).with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").and_return(mock_sp_query)
+
+          expect{ @vm.update_storage_profile(storage_profile) }.to raise_error("storage profile not found" )
+        end
+
+        it "should raise an error if storage profile id is in unexpected format" do
+          storage_profile = 'storage_profile_name'
+          vdc_results = [
+            { :vdcName => 'vdc-test-1' }
+          ]
+          mock_vdc_query = double(:query, :get_all_results => vdc_results)
+
+          storage_profile_results = [ { :id => 'test-href'  }]
+          mock_sp_query = double(:query, :get_all_results => storage_profile_results)
+
+          Vcloud::Query.should_receive(:new).with('vApp', :filter => "name==#{@vapp_name}").and_return(mock_vdc_query)
+          Vcloud::Query.should_receive(:new).with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").and_return(mock_sp_query)
+
+          expect{ @vm.update_storage_profile(storage_profile) }.to raise_error("storage profile not found" )
+        end
+
+      end
+
+    end
+  end
+end
+