vcloud-core 0.5.0 → 0.6.0

data/spec/vcloud/core/config_validator_spec.rb

@@ -73,6 +73,13 @@ module Vcloud
           expect(v.valid?).to be_true
         end
 
+        it "should return error for nil value with allowed_empty: true)" do
+          data = nil
+          schema = { type: 'string', allowed_empty: true }
+          v = ConfigValidator.validate(:base, data, schema)
+          expect(v.errors).to eq([ 'base:  is not a string'] )
+        end
+
         it "should validate ok with a :matcher regex specified" do
           data = "name-1234"
           schema = { type: 'string', matcher: /^name-\d+$/ }

data/spec/vcloud/core/edge_gateway_spec.rb

@@ -7,12 +7,12 @@ module Vcloud
       before(:each) do
         @edgegw_id = '12345678-1234-1234-1234-000000111454'
         @mock_fog_interface = StubFogInterface.new
-        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+        allow(Vcloud::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
       end
 
       context "Class public interface" do
-        it { EdgeGateway.should respond_to(:get_ids_by_name) }
-        it { EdgeGateway.should respond_to(:get_by_name) }
+        it { expect(EdgeGateway).to respond_to(:get_ids_by_name) }
+        it { expect(EdgeGateway).to respond_to(:get_by_name) }
       end
 
       context "Instance public interface" do
@@ -49,8 +49,8 @@ module Vcloud
             { :name => 'edgegw-test-1', :href => "/#{@edgegw_id}" }
           ]
           mock_query = double(:query_runner)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+          expect(mock_query).to receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
           @obj = EdgeGateway.get_by_name('edgegw-test-1')
           expect(@obj.class).to be(Vcloud::Core::EdgeGateway)
         end
@@ -60,8 +60,8 @@ module Vcloud
             { :name => 'edgegw-test-1', :href => "/#{@edgegw_id}" }
           ]
           mock_query = double(:query_runner)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+          expect(mock_query).to receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
           @obj = EdgeGateway.get_by_name('edgegw-test-1')
           expect(@obj.id).to eq(@edgegw_id)
         end
@@ -69,8 +69,8 @@ module Vcloud
         it "should raise an error if no edgegw with that name exists" do
           q_results = [ ]
           mock_query = double(:query_runner)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+          expect(mock_query).to receive(:run).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(q_results)
           expect{ EdgeGateway.get_by_name('edgegw-test-1') }.to raise_exception(RuntimeError, "edgeGateway edgegw-test-1 not found")
         end
 
@@ -115,7 +115,7 @@ module Vcloud
                 }
               }
           }
-          @mock_fog_interface.should_receive(:get_edge_gateway).
+          expect(@mock_fog_interface).to receive(:get_edge_gateway).
             and_return(edge_gateway_hash)
           @edgegw = EdgeGateway.new(@edgegw_id)
         end

data/spec/vcloud/core/metadata_helper_spec.rb

@@ -55,7 +55,7 @@ module Vcloud
           ]
           metadata = MetadataHelper.extract_metadata(metadata_entries)
           expect(metadata.count).to eq(1)
-          metadata.keys.should_not include :untyped_key
+          expect(metadata.keys).not_to include :untyped_key
         end
 
         it "should include unrecognized metadata types" do
@@ -76,7 +76,7 @@ module Vcloud
           ]
           metadata = MetadataHelper.extract_metadata(metadata_entries)
           expect(metadata.count).to eq(2)
-          metadata.keys.should include :unrecognized_type_key
+          expect(metadata.keys).to include :unrecognized_type_key
         end
 
 

data/spec/vcloud/core/org_vdc_network_spec.rb

@@ -11,14 +11,14 @@ module Vcloud
         @vdc_name  = 'test-vdc-1'
         @net_name  = 'test-net-1'
         @mock_fog_interface = StubFogInterface.new
-        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
-        Vdc.any_instance.stub(:id).and_return(@vdc_id)
+        allow(Vcloud::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
+        allow_any_instance_of(Vdc).to receive(:id).and_return(@vdc_id)
         @mock_vdc = double(:vdc, :id => @vdc_id)
-        Vdc.stub(:get_by_name).and_return(@mock_vdc)
+        allow(Vdc).to receive(:get_by_name).and_return(@mock_vdc)
       end
 
       context "Class public interface" do
-        it { OrgVdcNetwork.should respond_to(:provision) }
+        it { expect(OrgVdcNetwork).to respond_to(:provision) }
       end
 
       context "Object public interface" do
@@ -51,7 +51,7 @@ module Vcloud
 
       context "#delete" do
         it "should call down to Fog::ServiceInterface.delete_network with the correct id" do
-          @mock_fog_interface.should_receive(:delete_network).with(@net_id)
+          expect(@mock_fog_interface).to receive(:delete_network).with(@net_id)
           OrgVdcNetwork.new(@net_id).delete
         end
       end
@@ -65,7 +65,7 @@ module Vcloud
             :href => "/#{@vdc_id}",
             :name => @vdc_name
           )
-          Vdc.stub(:get_by_name).and_return(@mock_vdc)
+          allow(Vdc).to receive(:get_by_name).and_return(@mock_vdc)
         end
 
         context "should fail gracefully on bad input" do
@@ -131,8 +131,8 @@ module Vcloud
                 }
               },
             }
-            Vcloud::Core.logger.should_receive(:info)
-            @mock_fog_interface.should_receive(:post_create_org_vdc_network).
+            expect(Vcloud::Core.logger).to receive(:info)
+            expect(@mock_fog_interface).to receive(:post_create_org_vdc_network).
                 with(@vdc_id, @config[:name], expected_vcloud_attrs).
                 and_return({ :href => "/#{@net_id}" })
             obj = Vcloud::Core::OrgVdcNetwork.provision(@config)
@@ -161,8 +161,8 @@ module Vcloud
                 }
               }
             }
-            Vcloud::Core.logger.should_receive(:info)
-            @mock_fog_interface.should_receive(:post_create_org_vdc_network).
+            expect(Vcloud::Core.logger).to receive(:info)
+            expect(@mock_fog_interface).to receive(:post_create_org_vdc_network).
                 with(@vdc_id, @config[:name], expected_vcloud_attrs).
                 and_return({ :href => "/#{@net_id}" })
             Vcloud::Core::OrgVdcNetwork.provision(@config)
@@ -199,8 +199,8 @@ module Vcloud
                 }
               },
             }
-            Vcloud::Core.logger.should_receive(:info)
-            @mock_fog_interface.should_receive(:post_create_org_vdc_network).
+            expect(Vcloud::Core.logger).to receive(:info)
+            expect(@mock_fog_interface).to receive(:post_create_org_vdc_network).
                 with(@vdc_id, @config[:name], expected_vcloud_attrs).
                 and_return({ :href => "/#{@net_id}" })
             Vcloud::Core::OrgVdcNetwork.provision(@config)
@@ -226,7 +226,7 @@ module Vcloud
           it "should handle lack of ip_ranges on natRouted networks" do
             @config[:edge_gateway] = 'test gateway'
             mock_edgegw = Vcloud::Core::EdgeGateway.new(@edgegw_id)
-            Vcloud::Core::EdgeGateway.stub(:get_by_name).and_return(mock_edgegw)
+            allow(Vcloud::Core::EdgeGateway).to receive(:get_by_name).and_return(mock_edgegw)
 
             expected_vcloud_attrs = {
               :IsShared => false,
@@ -241,8 +241,8 @@ module Vcloud
               },
               :EdgeGateway => { :href => "/#{@edgegw_id}" },
             }
-            Vcloud::Core.logger.should_receive(:info)
-            @mock_fog_interface.should_receive(:post_create_org_vdc_network).
+            expect(Vcloud::Core.logger).to receive(:info)
+            expect(@mock_fog_interface).to receive(:post_create_org_vdc_network).
                 with(@vdc_id, @config[:name], expected_vcloud_attrs).
                 and_return({ :href => "/#{@net_id}" })
             Vcloud::Core::OrgVdcNetwork.provision(@config)

data/spec/vcloud/core/query_runner_spec.rb

@@ -3,20 +3,20 @@ require 'spec_helper'
 describe Vcloud::Core::QueryRunner do
   before(:each) do
     @mock_fog_interface = StubFogInterface.new
-    Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+    allow(Vcloud::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
     @query_runner = Vcloud::Core::QueryRunner.new()
   end
 
   context '#available_query_types' do
 
     it 'should return empty array if no query type links are returned from API' do
-      @mock_fog_interface.stub(:get_execute_query).and_return({:Link => {}})
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return({:Link => {}})
       result = @query_runner.available_query_types
       expect(result.size).to eq(0)
     end
 
     it 'returns queriable entity types provided by the API via :href link elements' do
-      @mock_fog_interface.stub(:get_execute_query).and_return(
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {:Link => [
           {:rel  => 'down',
            :href => 'query?type=alice&format=records'},
@@ -29,7 +29,7 @@ describe Vcloud::Core::QueryRunner do
     end
 
     it 'should ignore query links with format=references and format=idrecords' do
-      @mock_fog_interface.stub(:get_execute_query).and_return(
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {:Link => [
           {:rel  => 'down',
            :href => 'query?type=alice&format=references'},
@@ -51,12 +51,12 @@ describe Vcloud::Core::QueryRunner do
     end
 
     it 'should return no results when fog returns no results' do
-      @mock_fog_interface.stub(:get_execute_query).and_return({})
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return({})
       expect(@query_runner.run()).to eq([])
     end
 
     it 'return no results when fog results do not include a "Record" or a "Reference"' do
-      @mock_fog_interface.stub(:get_execute_query).and_return(
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
           :WibbleBlob => {:field1 => 'Stuff 1'}
         }
@@ -66,7 +66,7 @@ describe Vcloud::Core::QueryRunner do
 
     it 'should return a single result when fog returns a single record' do
       fields = {:field1 => 'Stuff 1'}
-      @mock_fog_interface.stub(:get_execute_query).and_return(
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
           :WibbleRecord => [fields]
         }
@@ -78,7 +78,7 @@ describe Vcloud::Core::QueryRunner do
 
     it 'should return a single result when fog returns a single reference' do
       fields = {:field1 => 'Stuff 1'}
-      @mock_fog_interface.stub(:get_execute_query).and_return(
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
           :WibbleReference => [fields]
         }
@@ -90,7 +90,7 @@ describe Vcloud::Core::QueryRunner do
 
     it 'should wrap single result from fog in list' do
       fields = {:field1 => 'Stuff 1'}
-      @mock_fog_interface.stub(:get_execute_query).and_return(
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
           :WibbleRecord => fields
         }
@@ -103,7 +103,7 @@ describe Vcloud::Core::QueryRunner do
     it 'should return all results in a record returned by fog' do
       fields      = {:field1 => 'Stuff 1'}
       more_fields = {:field1 => 'More Stuff 1'}
-      @mock_fog_interface.stub(:get_execute_query).and_return(
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
           :WibbleRecord => [fields, more_fields]
         }
@@ -117,7 +117,7 @@ describe Vcloud::Core::QueryRunner do
     it 'should return the first item if more than one records provided' do
       fields1 = {:field1 => 'Stuff 1'}
       fields2 = {:field1 => 'Stuff 2'}
-      @mock_fog_interface.stub(:get_execute_query).and_return(
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
           :WibbleRecord => [fields1],
           :WobbleRecord => [fields2]
@@ -129,7 +129,7 @@ describe Vcloud::Core::QueryRunner do
     end
 
     it 'should raise error if lastPage is not an integer' do
-      @mock_fog_interface.stub(:get_execute_query).and_return(
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
           :lastPage     => :qwerty,
           :WibbleRecord => []
@@ -141,7 +141,7 @@ describe Vcloud::Core::QueryRunner do
 
     it 'should get each page and collect the results' do
       fields = {:field1 => 'Stuff 1'}
-      @mock_fog_interface.stub(:get_execute_query).and_return(
+      allow(@mock_fog_interface).to receive(:get_execute_query).and_return(
         {
           :lastPage     => 2,
           :WibbleRecord => [fields]

data/spec/vcloud/core/query_spec.rb

@@ -11,8 +11,8 @@ describe Vcloud::Core::Query do
 
         @query = Vcloud::Core::Query.new(nil, {}, query_runner)
 
-        @query.should_receive(:puts).with("alice")
-        @query.should_receive(:puts).with("bob")
+        expect(@query).to receive(:puts).with("alice")
+        expect(@query).to receive(:puts).with("bob")
 
         @query.run
       end
@@ -29,7 +29,7 @@ describe Vcloud::Core::Query do
       it "should not output when given tsv output_format" do
         query = Vcloud::Core::Query.new('bob', {:output_format => 'tsv'}, @query_runner)
 
-        query.should_not_receive(:puts)
+        expect(query).not_to receive(:puts)
 
         query.run()
       end
@@ -37,7 +37,7 @@ describe Vcloud::Core::Query do
       it "should not output when given csv output_format" do
         query = Vcloud::Core::Query.new('bob', {:output_format => 'csv'}, @query_runner)
 
-        query.should_not_receive(:puts)
+        expect(query).not_to receive(:puts)
 
         query.run()
       end
@@ -59,9 +59,9 @@ describe Vcloud::Core::Query do
       it "should output a query in tsv when run with a type" do
         @query = Vcloud::Core::Query.new('bob', {:output_format => 'tsv'}, @query_runner)
 
-        @query.should_receive(:puts).with("field1\tfield2")
-        @query.should_receive(:puts).with("Stuff 1\tStuff 2")
-        @query.should_receive(:puts).with("More Stuff 1\tMore Stuff 2")
+        expect(@query).to receive(:puts).with("field1\tfield2")
+        expect(@query).to receive(:puts).with("Stuff 1\tStuff 2")
+        expect(@query).to receive(:puts).with("More Stuff 1\tMore Stuff 2")
 
         @query.run()
       end
@@ -69,8 +69,8 @@ describe Vcloud::Core::Query do
       it "should output a query in csv when run with a type" do
         @query = Vcloud::Core::Query.new('bob', {:output_format => 'csv'}, @query_runner)
 
-        @query.should_receive(:puts).with("field1,field2\n")
-        @query.should_receive(:puts).with("Stuff 1,Stuff 2\nMore Stuff 1,More Stuff 2\n")
+        expect(@query).to receive(:puts).with("field1,field2\n")
+        expect(@query).to receive(:puts).with("Stuff 1,Stuff 2\nMore Stuff 1,More Stuff 2\n")
 
         @query.run()
       end

data/spec/vcloud/core/vapp_spec.rb

@@ -6,13 +6,13 @@ module Vcloud
       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)
+        allow(Vcloud::Fog::ServiceInterface).to receive(: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) }
+        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 "Instance public interface" do
@@ -53,8 +53,8 @@ module Vcloud
             { :name => 'vapp-test-1', :href => @vapp_id }
           ]
           mock_query = double(:query)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
+          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
@@ -62,8 +62,8 @@ module Vcloud
         it "should raise an error if no vApp with that name exists" do
           q_results = [ ]
           mock_query = double(:query_runner)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
+          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
 
@@ -73,8 +73,8 @@ module Vcloud
             { :name => 'vapp-test-1', :href => '/bogus' },
           ]
           mock_query = double(:query)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).with('vApp', :filter => "name==vapp-test-1").and_return(q_results)
+          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
 
@@ -92,10 +92,10 @@ module Vcloud
                         }],
               :Children => {:Vm => [{:href => '/vm-123aea1e-a5e9-4dd1-a028-40db8c98d237'}]}
           }
-          StubFogInterface.any_instance.stub(:get_vapp).and_return(@stub_attrs)
+          allow_any_instance_of(StubFogInterface).to receive(:get_vapp).and_return(@stub_attrs)
           @vapp = Vapp.new(@vapp_id)
         }
-        it { @vapp.name.should == 'Webserver vapp-1' }
+        it { expect(@vapp.name).to eq('Webserver vapp-1') }
 
         context "id" do
           it "should extract id correctly" do
@@ -110,7 +110,7 @@ module Vcloud
 
           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')
+            expect { @vapp.vdc_id }.to raise_error('a vapp without parent vdc found')
           end
         end
 
@@ -136,21 +136,21 @@ module Vcloud
 
           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(
+            expect(@mock_fog_interface).to receive(:get_vapp).twice().and_return(
               {:status => Vcloud::Core::Vapp::STATUS::POWERED_OFF},
               {:status => Vcloud::Core::Vapp::STATUS::RUNNING}
             )
-            @mock_fog_interface.should_receive(:power_on_vapp).with(vapp.id)
+            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)
-            @mock_fog_interface.should_receive(:get_vapp).and_return(
+            expect(@mock_fog_interface).to receive(:get_vapp).and_return(
               {:status => Vcloud::Core::Vapp::STATUS::RUNNING}
             )
-            @mock_fog_interface.should_not_receive(:power_on_vapp)
+            expect(@mock_fog_interface).not_to receive(:power_on_vapp)
             state = vapp.power_on
             expect(state).to be_true
           end
@@ -161,14 +161,14 @@ module Vcloud
       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)
+          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
 
         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)
+          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