vcloud-core 1.0.0 → 1.0.1

data/spec/vcloud/core/query_runner_spec.rb

@@ -19,12 +19,12 @@ describe Vcloud::Core::QueryRunner do
       allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {:Link => [
           {:rel  => 'down',
-           :href => 'query?type=alice&format=records'},
-          {:rel  => 'down',
-           :href => 'query?type=bob&format=records'},
-          {:rel  => 'down',
-           :href => 'query?type=charlie&format=records'},
-        ]})
+            :href => 'query?type=alice&format=records'},
+            {:rel  => 'down',
+              :href => 'query?type=bob&format=records'},
+              {:rel  => 'down',
+                :href => 'query?type=charlie&format=records'},
+      ]})
       expect(@query_runner.available_query_types).to eq(['alice', 'bob', 'charlie'])
     end
 
@@ -32,12 +32,12 @@ describe Vcloud::Core::QueryRunner do
       allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {:Link => [
           {:rel  => 'down',
-           :href => 'query?type=alice&format=references'},
-          {:rel  => 'down',
-           :href => 'query?type=bob&format=idrecords'},
-          {:rel  => 'down',
-           :href => 'query?type=charlie&format=records'},
-        ]})
+            :href => 'query?type=alice&format=references'},
+            {:rel  => 'down',
+              :href => 'query?type=bob&format=idrecords'},
+              {:rel  => 'down',
+                :href => 'query?type=charlie&format=records'},
+      ]})
       expect(@query_runner.available_query_types).to eq(['charlie'])
     end
 
@@ -58,8 +58,8 @@ describe Vcloud::Core::QueryRunner do
     it 'return no results when fog results do not include a "Record" or a "Reference"' do
       allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
-          :WibbleBlob => {:field1 => 'Stuff 1'}
-        }
+        :WibbleBlob => {:field1 => 'Stuff 1'}
+      }
       )
       expect(@query_runner.run().size).to eq(0)
     end
@@ -68,8 +68,8 @@ describe Vcloud::Core::QueryRunner do
       fields = {:field1 => 'Stuff 1'}
       allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
-          :WibbleRecord => [fields]
-        }
+        :WibbleRecord => [fields]
+      }
       )
       result = @query_runner.run()
       expect(result.size).to eq(1)
@@ -80,8 +80,8 @@ describe Vcloud::Core::QueryRunner do
       fields = {:field1 => 'Stuff 1'}
       allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
-          :WibbleReference => [fields]
-        }
+        :WibbleReference => [fields]
+      }
       )
       result = @query_runner.run()
       expect(result.size).to eq(1)
@@ -92,8 +92,8 @@ describe Vcloud::Core::QueryRunner do
       fields = {:field1 => 'Stuff 1'}
       allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
-          :WibbleRecord => fields
-        }
+        :WibbleRecord => fields
+      }
       )
       result = @query_runner.run()
       expect(result.size).to eq(1)
@@ -105,8 +105,8 @@ describe Vcloud::Core::QueryRunner do
       more_fields = {:field1 => 'More Stuff 1'}
       allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
-          :WibbleRecord => [fields, more_fields]
-        }
+        :WibbleRecord => [fields, more_fields]
+      }
       )
       result = @query_runner.run()
       expect(result.size).to eq(2)
@@ -119,9 +119,9 @@ describe Vcloud::Core::QueryRunner do
       fields2 = {:field1 => 'Stuff 2'}
       allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
-          :WibbleRecord => [fields1],
-          :WobbleRecord => [fields2]
-        }
+        :WibbleRecord => [fields1],
+        :WobbleRecord => [fields2]
+      }
       )
       result = @query_runner.run()
       expect(result.size).to eq(1)
@@ -131,9 +131,9 @@ describe Vcloud::Core::QueryRunner do
     it 'should raise error if lastPage is not an integer' do
       allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
-          :lastPage     => :qwerty,
-          :WibbleRecord => []
-        }
+        :lastPage     => :qwerty,
+        :WibbleRecord => []
+      }
       )
 
       expect { @query_runner.run() }.to raise_error('Invalid lastPage (qwerty) in query results')
@@ -143,9 +143,9 @@ describe Vcloud::Core::QueryRunner do
       fields = {:field1 => 'Stuff 1'}
       allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
-          :lastPage     => 2,
-          :WibbleRecord => [fields]
-        }
+        :lastPage     => 2,
+        :WibbleRecord => [fields]
+      }
       )
       result = @query_runner.run()
       expect(result.size).to eq(2)

data/spec/vcloud/core/query_spec.rb

@@ -52,7 +52,7 @@ describe Vcloud::Core::Query do
           [
             {:field1 => "Stuff 1", :field2 => "Stuff 2"},
             {:field1 => "More Stuff 1", :field2 => "More Stuff 2"}
-          ]
+        ]
         }
       end
 

data/spec/vcloud/core/vapp_spec.rb

@@ -1,209 +1,205 @@
 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
-        allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
-      end
+describe Vcloud::Core::Vapp do
+  before(:each) do
+    @vapp_id = 'vapp-12345678-1234-1234-1234-000000111111'
+    @mock_fog_interface = StubFogInterface.new
+    allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
+  end
 
-      context "Class public interface" do
-        it { expect(Vapp).to respond_to(:instantiate) }
-        it { expect(Vapp).to respond_to(:get_by_name) }
-        it { expect(Vapp).to respond_to(:get_metadata) }
-      end
+  context "Class public interface" do
+    it { expect(Vcloud::Core::Vapp).to respond_to(:instantiate) }
+    it { expect(Vcloud::Core::Vapp).to respond_to(:get_by_name) }
+    it { expect(Vcloud::Core::Vapp).to 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(:vms) }
-        it { should respond_to(:networks) }
-        it { should respond_to(:power_on) }
-      end
+  context "Instance public interface" do
+    subject { Vcloud::Core::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(: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 = Vcloud::Core::Vapp.new(@vapp_id)
+      expect(obj.class).to be(Vcloud::Core::Vapp)
+    end
 
-      context "#initialize" do
+    it "should store the id specified" do
+      obj = Vcloud::Core::Vapp.new(@vapp_id)
+      expect(obj.id).to eq(@vapp_id)
+    end
+
+    it "should raise error if id is not in correct format" do
+      bogus_id = '12314124-ede5-4d07-bad5-000000111111'
+      expect{ Vcloud::Core::Vapp.new(bogus_id) }.to raise_error("vapp id : #{bogus_id} is not in correct format" )
+    end
+
+  end
 
-        it "should be constructable from just an id reference" do
-          obj = Vapp.new(@vapp_id)
-          expect(obj.class).to be(Vcloud::Core::Vapp)
-        end
+  context "#get_by_name" do
+
+    it "should return a Vcloud::Core::Vapp object if name exists" do
+      q_results = [
+        { :name => 'vapp-test-1', :href => @vapp_id }
+      ]
+      mock_query = double(:query)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
+      obj = Vcloud::Core::Vapp.get_by_name('vapp-test-1')
+      expect(obj.class).to be(Vcloud::Core::Vapp)
+    end
 
-        it "should store the id specified" do
-          obj = Vapp.new(@vapp_id)
-          expect(obj.id).to eq(@vapp_id)
-        end
+    it "should raise an error if no vApp with that name exists" do
+      q_results = [ ]
+      mock_query = double(:query_runner)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
+      expect{ Vcloud::Core::Vapp.get_by_name('vapp-test-1') }.to raise_exception(RuntimeError)
+    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
+    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)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
+      expect{ Vcloud::Core::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'}]}
+    }
+    allow_any_instance_of(StubFogInterface).to receive(:get_vapp).and_return(@stub_attrs)
+    @vapp = Vcloud::Core::Vapp.new(@vapp_id)
+    }
+    it { expect(@vapp.name).to eq('Webserver vapp-1') }
+
+    context "id" do
+      it "should extract id correctly" do
+        expect(@vapp.id).to eq(@vapp_id)
       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)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
-          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_runner)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
-          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)
-          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
-          expect(mock_query).to receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
-          expect{ Vapp.get_by_name('vapp-test-1') }.to raise_exception(RuntimeError)
-        end
+    context "vapp should have parent vdc" do
+      it "should load parent vdc id from fog attributes" do
+        expect(@vapp.vdc_id).to eq('074aea1e-a5e9-4dd1-a028-40db8c98d237')
+      end
 
+      it "should raise error if vapp without parent vdc found" do
+        @stub_attrs[:Link] = []
+        expect { @vapp.vdc_id }.to raise_error('a vapp without parent vdc found')
       end
+    end
+
+    it "should return vms" do
+      expect(@vapp.vms.count).to eq(1)
+      expect(@vapp.vms.first[:href]).to eq('/vm-123aea1e-a5e9-4dd1-a028-40db8c98d237')
+    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'}]}
-          }
-          allow_any_instance_of(StubFogInterface).to receive(:get_vapp).and_return(@stub_attrs)
-          @vapp = Vapp.new(@vapp_id)
+  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"
+        }]
         }
-        it { expect(@vapp.name).to eq('Webserver vapp-1') }
-
-        context "id" do
-          it "should extract id correctly" do
-            expect(@vapp.id).to eq(@vapp_id)
-          end
-        end
-
-        context "vapp should have parent vdc" do
-          it "should load parent vdc id from fog attributes" do
-            expect(@vapp.vdc_id).to eq('074aea1e-a5e9-4dd1-a028-40db8c98d237')
-          end
-
-          it "should raise error if vapp without parent vdc found" do
-            @stub_attrs[:Link] = []
-            expect { @vapp.vdc_id }.to raise_error('a vapp without parent vdc found')
-          end
-        end
-
-        it "should return vms" do
-          expect(@vapp.vms.count).to eq(1)
-          expect(@vapp.vms.first[:href]).to eq('/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)
-            expect(@mock_fog_interface).to receive(:get_vapp).twice().and_return(
-              {:status => Vcloud::Core::Vapp::STATUS::POWERED_OFF},
-              {:status => Vcloud::Core::Vapp::STATUS::RUNNING}
-            )
-            expect(@mock_fog_interface).to receive(:power_on_vapp).with(vapp.id)
-            state = vapp.power_on
-            expect(state).to be_true
-          end
-
-          it "should not power on a vapp that is already powered on, but should return true" do
-            vapp = Vapp.new(@vapp_id)
-            expect(@mock_fog_interface).to receive(:get_vapp).and_return(
-              {:status => Vcloud::Core::Vapp::STATUS::RUNNING}
-            )
-            expect(@mock_fog_interface).not_to receive(:power_on_vapp)
-            state = vapp.power_on
-            expect(state).to be_true
-          end
-        end
+      it "should power on a vapp that is not powered on" do
+        vapp = Vcloud::Core::Vapp.new(@vapp_id)
+        expect(@mock_fog_interface).to receive(:get_vapp).twice().and_return(
+          {:status => Vcloud::Core::Vapp::STATUS::POWERED_OFF},
+          {:status => Vcloud::Core::Vapp::STATUS::RUNNING}
+        )
+        expect(@mock_fog_interface).to receive(:power_on_vapp).with(vapp.id)
+        state = vapp.power_on
+        expect(state).to be_true
+      end
 
+      it "should not power on a vapp that is already powered on, but should return true" do
+        vapp = Vcloud::Core::Vapp.new(@vapp_id)
+        expect(@mock_fog_interface).to receive(:get_vapp).and_return(
+          {:status => Vcloud::Core::Vapp::STATUS::RUNNING}
+        )
+        expect(@mock_fog_interface).not_to receive(:power_on_vapp)
+        state = vapp.power_on
+        expect(state).to be_true
       end
+    end
 
-      context "#get_by_name_and_vdc_name" do
+  end
 
-        it "should return nil if fog returns nil" do
-          allow_any_instance_of(StubFogInterface).to receive(:get_vapp_by_name_and_vdc_name)
-            .with('vapp_name', 'vdc_name').and_return(nil)
-          expect(Vapp.get_by_name_and_vdc_name('vapp_name', 'vdc_name')).to be_nil
-        end
+  context "#get_by_name_and_vdc_name" do
 
-        it "should return vapp instance if found" do
-          vcloud_attr_vapp = { :href => "/#{@vapp_id}" }
-          allow_any_instance_of(StubFogInterface).to receive(:get_vapp_by_name_and_vdc_name)
-            .with('vapp_name', 'vdc_name').and_return(vcloud_attr_vapp)
-          expect(Vapp.get_by_name_and_vdc_name('vapp_name', 'vdc_name').class).to eq(Core::Vapp)
-        end
+    it "should return nil if fog returns nil" do
+      allow_any_instance_of(StubFogInterface).to receive(:get_vapp_by_name_and_vdc_name)
+      .with('vapp_name', 'vdc_name').and_return(nil)
+      expect(Vcloud::Core::Vapp.get_by_name_and_vdc_name('vapp_name', 'vdc_name')).to be_nil
+    end
 
-      end
+    it "should return vapp instance if found" do
+      vcloud_attr_vapp = { :href => "/#{@vapp_id}" }
+      allow_any_instance_of(StubFogInterface).to receive(:get_vapp_by_name_and_vdc_name)
+      .with('vapp_name', 'vdc_name').and_return(vcloud_attr_vapp)
+      expect(Vcloud::Core::Vapp.get_by_name_and_vdc_name('vapp_name', 'vdc_name').class).to eq(Vcloud::Core::Vapp)
+    end
 
-      context "#get_by_child_vm_id" do
-
-        it "should raise an ArgumentError if an invalid VM id is supplied" do
-          vm_id = 'vapp-12341234-1234-1234-1234-123412341234'
-          expect {Vapp.get_by_child_vm_id(vm_id)}.to raise_error(ArgumentError)
-        end
-
-        it "should return a vApp object if we supply an existing VM id" do
-          vm_id = "vm-12341234-1234-1234-1234-123412340001"
-          vapp_id = "vapp-12341234-1234-1234-1234-123412349999"
-          expect(@mock_fog_interface).to receive(:get_vapp).with(vm_id).and_return({
-            :Link => [
-              { :rel => 'down',
-                :type => "application/vnd.vmware.vcloud.metadata+xml",
-                :href => "/api/vApp/#{vm_id}/metadata"
-              },
-              { :rel => 'up',
-                :type => "application/vnd.vmware.vcloud.vApp+xml",
-                :href => "/api/vApp/#{vapp_id}"
-              }
-            ]
-          })
-          obj = Vapp.get_by_child_vm_id(vm_id)
-          expect(obj.id).to eq(vapp_id)
-        end
+  end
 
-      end
+  context "#get_by_child_vm_id" do
 
+    it "should raise an ArgumentError if an invalid VM id is supplied" do
+      vm_id = 'vapp-12341234-1234-1234-1234-123412341234'
+      expect {Vcloud::Core::Vapp.get_by_child_vm_id(vm_id)}.to raise_error(ArgumentError)
     end
+
+    it "should return a vApp object if we supply an existing VM id" do
+      vm_id = "vm-12341234-1234-1234-1234-123412340001"
+      vapp_id = "vapp-12341234-1234-1234-1234-123412349999"
+      expect(@mock_fog_interface).to receive(:get_vapp).with(vm_id).and_return({
+        :Link => [
+          { :rel => 'down',
+            :type => "application/vnd.vmware.vcloud.metadata+xml",
+            :href => "/api/vApp/#{vm_id}/metadata"
+      },
+        { :rel => 'up',
+          :type => "application/vnd.vmware.vcloud.vApp+xml",
+          :href => "/api/vApp/#{vapp_id}"
+      }
+      ]
+      })
+      obj = Vcloud::Core::Vapp.get_by_child_vm_id(vm_id)
+      expect(obj.id).to eq(vapp_id)
+    end
+
   end
+
 end