vcloud-walker 3.2.2 → 3.2.3

data/spec/vcloud/walker/cli_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+class CommandRun
+  attr_accessor :stdout, :stderr, :exitstatus
+
+  def initialize(args)
+    out = StringIO.new
+    err = StringIO.new
+
+    $stdout = out
+    $stderr = err
+
+    begin
+      Vcloud::Walker::Cli.new(args).run
+      @exitstatus = 0
+    rescue SystemExit => e
+      # Capture exit(n) value.
+      @exitstatus = e.status
+    end
+
+    @stdout = out.string.strip
+    @stderr = err.string.strip
+
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+end
+
+describe Vcloud::Walker::Cli do
+  subject { CommandRun.new(args) }
+  let(:mock_output) do
+    [{
+      :name => 'gruffalo',
+      :desc => { :eyes => 'orange', :tongue => 'black' },
+    },{
+      :name => 'mouse',
+      :desc => { :tail => 'scaly', :whiskers => 'wire' },
+    }]
+  end
+
+  describe "normal usage" do
+    context "when given resource_type" do
+      let(:args) { %w{things} }
+
+      it "should pass resource_type and exit normally" do
+        expect(Vcloud::Walker).to receive(:walk).with('things').and_return(mock_output)
+        expect(subject.exitstatus).to eq(0)
+      end
+    end
+
+    context "when asked to display version" do
+      let(:args) { %w{--version} }
+
+      it "should not call Walker" do
+        expect(Vcloud::Walker).not_to receive(:walk)
+      end
+
+      it "should print version and exit normally" do
+        expect(subject.stdout).to eq(Vcloud::Walker::VERSION)
+        expect(subject.exitstatus).to eq(0)
+      end
+    end
+
+    context "when asked to display help" do
+      let(:args) { %w{--help} }
+
+      it "should not call Walker" do
+        expect(Vcloud::Walker).not_to receive(:walk)
+      end
+
+      it "should print usage and exit normally" do
+        expect(subject.stderr).to match(/\AUsage: \S+ \[options\] resource_type\n/)
+        expect(subject.exitstatus).to eq(0)
+      end
+    end
+  end
+
+  describe "output formats" do
+    context "when no format is specified" do
+      let(:args) { %w{things} }
+      let(:expected_stdout) { <<EOS
+[
+  {
+    "name": "gruffalo",
+    "desc": {
+      "eyes": "orange",
+      "tongue": "black"
+    }
+  },
+  {
+    "name": "mouse",
+    "desc": {
+      "tail": "scaly",
+      "whiskers": "wire"
+    }
+  }
+]
+EOS
+      }
+
+      it "should output in JSON with no trailing newline" do
+        expect(Vcloud::Walker).to receive(:walk).with('things').and_return(mock_output)
+        expect(subject.stdout).to eq(expected_stdout.chomp)
+      end
+    end
+
+    context "when given --yaml" do
+      let(:args) { %w{--yaml things} }
+      let(:expected_stdout) { <<EOS
+---
+- :name: gruffalo
+  :desc:
+    :eyes: orange
+    :tongue: black
+- :name: mouse
+  :desc:
+    :tail: scaly
+    :whiskers: wire
+EOS
+      }
+
+      it "should output in YAML with no trailing newline" do
+        expect(Vcloud::Walker).to receive(:walk).with('things').and_return(mock_output)
+        expect(subject.stdout).to eq(expected_stdout.chomp)
+      end
+    end
+  end
+
+  describe "incorrect usage" do
+    shared_examples "print usage and exit abnormally" do |error|
+      it "should not call Walker" do
+        expect(Vcloud::Walker).not_to receive(:walk)
+      end
+
+      it "should print error message and usage" do
+        expect(subject.stderr).to match(/\A\S+: #{error}\nUsage: \S+/)
+      end
+
+      it "should exit abnormally for incorrect usage" do
+        expect(subject.exitstatus).to eq(2)
+      end
+    end
+
+    context "when given more than resource_type argument" do
+      let(:args) { %w{type_one type_two} }
+
+      it_behaves_like "print usage and exit abnormally", "must supply resource_type"
+    end
+
+    context "when given an unrecognised argument" do
+      let(:args) { %w{--this-is-garbage} }
+
+      it_behaves_like "print usage and exit abnormally", "invalid option: --this-is-garbage"
+    end
+  end
+
+  describe "error handling" do
+    context "when underlying code raises an exception" do
+      let(:args) { %w{things} }
+
+      it "should print error without backtrace and exit abnormally" do
+        expect(Vcloud::Walker).to receive(:walk).
+          with('things').and_raise("something went horribly wrong")
+        expect(subject.stderr).to eq("something went horribly wrong")
+        expect(subject.exitstatus).to eq(1)
+      end
+    end
+  end
+end

data/spec/vcloud/walker/resource/catalogs_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'rspec/mocks'
+
+describe Vcloud::Walker::Resource::Catalogs do
+
+    it "should summarize catalogs" do
+      set_login_credential
+      mock_fog_item = double(
+        :catalog_item,
+        :id => "12345",
+        :name => 'ubuntu 11.04',
+        :description => 'image for ubuntu 11.04',
+        :vapp_template_id => 'vapp-template-01'
+      )
+      mock_fog_catalog = double(
+        :catalog,
+        :id => 'catalog_id_1',
+        :name => 'Default catalog',
+        :description => 'default catalog for infrastructure',
+        :catalog_items => double(:catalog_items, :all => [mock_fog_item])
+      )
+      catalog_summary = Vcloud::Walker::Resource::Catalogs.new([mock_fog_catalog]).to_summary
+      expect(catalog_summary.count).to eq(1)
+      expect(catalog_summary.first[:items].count).to eq(1)
+      expect(catalog_summary).to eq([{
+        :id => "catalog_id_1",
+        :name => "Default catalog",
+        :description => "default catalog for infrastructure",
+        :items => [{
+          :id => "12345",
+          :name => "ubuntu 11.04",
+          :description => "image for ubuntu 11.04",
+          :vapp_template_id => "vapp-template-01"
+        }],
+      }])
+    end
+
+end

data/spec/{walk → vcloud/walker/resource}/entity_spec.rb

@@ -44,23 +44,32 @@ module Vcloud
   describe Vcloud::Walker::Resource::Entity do
     it 'should be able to nested collections inside entities' do
       collection = [double(:name => 'collection 1'), double(:name => 'collection 2')]
-      test_class = Vcloud::Walker::Resource::TestClass.new(double(:description => 'test class desc', :collection => collection))
-
-      test_class.to_summary.should == {:test_data => [{:name => "collection 1"}, {:name => "collection 2"}], :description => "test class desc"}
+      test_class = Vcloud::Walker::Resource::TestClass.new(
+        double(:description => 'test class desc', :collection => collection)
+      )
+      expect(test_class.to_summary).to eq({
+        :test_data => [
+          {:name => "collection 1"}, {:name => "collection 2"}
+        ],
+        :description => "test class desc"
+      })
     end
 
     it 'should summaries a class as a hash and remove @ from the symbol names' do
       collection = [double(:name => 'collection 1'), double(:name => 'collection 2')]
-      test_class = Vcloud::Walker::Resource::TestClass.new(double(:description => 'test class desc', :collection => collection))
-      test_class.instance_variables.should eq([:@test_data, :@description])
+      test_class = Vcloud::Walker::Resource::TestClass.new(
+        double(:description => 'test class desc', :collection => collection)
+      )
+      expect(test_class.instance_variables).to eq([:@test_data, :@description])
       test_summary = test_class.to_summary
-      test_summary.keys.should eq([:test_data, :description])
+      expect(test_summary.keys).to eq([:test_data, :description])
     end
 
     it 'should be able to nest entity inside entity' do
-      nested_entities = Vcloud::Walker::Resource::TestNestedEntity.new(double(:data, :name => 'Data 1'))
+      nested_entities = Vcloud::Walker::Resource::TestNestedEntity.new(
+        double(:data, :name => 'Data 1')
+      )
       expect(nested_entities.to_summary).to eq({:test_data=>{:name=>"Data 1"}})
-
     end
 
   end

data/spec/{walk → vcloud/walker/resource}/network_spec.rb

@@ -10,43 +10,33 @@ describe Vcloud::Walker::Resource::Networks do
     end
 
     it "should walk all networks within given org" do
-
       mock_fog_network = mock_fog_network_object
-
       networks = Vcloud::Walker::Resource::Networks.new([mock_fog_network, mock_fog_network])
-
-      networks.count.should == 2
+      expect(networks.count).to eq(2)
     end
 
-
     it "should be happy with one network" do
-
       mock_fog_network = mock_fog_network_object
-
       networks = Vcloud::Walker::Resource::Networks.new([mock_fog_network])
-
-      networks.count.should == 1
+      expect(networks.count).to eq(1)
     end
 
     it "should handle having no networks" do
       networks = Vcloud::Walker::Resource::Networks.new([])
-
-      networks.count.should == 0
+      expect(networks.count).to eq(0)
     end
 
-
     it "should map parameters of a network to the local entity" do
       mock_fog_network = mock_fog_network_object
       expect(mock_fog_network).to receive(:dns1).and_return('sausage')
 
       networks = Vcloud::Walker::Resource::Networks.new([mock_fog_network])
 
-      networks.count.should == 1
-      networks.first.id.should == :network_id_1
-      networks.first.name.should == :name
-      networks.first.dns_suffix == :dns_suffix
-      networks.first.dns1 == 'sausage'
-
+      expect(networks.count).to eq(1)
+      expect(networks.first.id).to eq(:network_id_1)
+      expect(networks.first.name).to eq(:name)
+      expect(networks.first.dns_suffix).to eq(:dns_suffix)
+      expect(networks.first.dns1).to eq('sausage')
     end
 
   end

data/spec/vcloud/walker/resource/organization_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Vcloud::Walker::Resource::Organization do
+
+  it "should retrieve networks" do
+    fog_networks = double(:fog_networks)
+    expect(Vcloud::Walker::FogInterface).to receive(:get_networks).and_return(fog_networks)
+    expect(Vcloud::Walker::Resource::Networks).to receive(:new).with(fog_networks).
+      and_return(double(:walker_networks, :to_summary => [:network => "Network 1"]))
+    expect(Vcloud::Walker::Resource::Organization.networks).to eq([:network => "Network 1"])
+  end
+
+  it "should retrieve catalogs" do
+    fog_catalogs = double(:fog_catalogs)
+    expect(Vcloud::Walker::FogInterface).to receive(:get_catalogs).and_return(fog_catalogs)
+    expect(Vcloud::Walker::Resource::Catalogs).to receive(:new).with(fog_catalogs).
+      and_return(double(:walker_catalogs, :to_summary => [:catalog => "Catalog 1"]))
+    expect(Vcloud::Walker::Resource::Organization.catalogs).to eq([:catalog => "Catalog 1"])
+  end
+
+  it "should retrieve vdcs" do
+    fog_vdcs = double(:fog_vdcs)
+    expect(Vcloud::Walker::FogInterface).to receive(:get_vdcs).and_return(fog_vdcs)
+    expect(Vcloud::Walker::Resource::Vdcs).to receive(:new).with(fog_vdcs).
+      and_return(double(:walker_vdcs, :to_summary => [:vdc => "VDC 1"]))
+    expect(Vcloud::Walker::Resource::Organization.vdcs).to eq([:vdc => "VDC 1"])
+  end
+
+  it "should retrieve edgegateways" do
+    fog_edgegateways = [{
+      :id => 'urn:vcloud:gateway:1',
+      :href => 'host/1',
+      :name => 'Gateway 1',
+      :Configuration => { :EdgeGatewayServiceConfiguration => {}}
+    }]
+    expect(Vcloud::Walker::FogInterface).to receive(:get_edge_gateways).
+      and_return(fog_edgegateways)
+
+    expect(Vcloud::Walker::Resource::Organization.edgegateways).to eq([{
+      :id => '1',
+      :name => 'Gateway 1',
+      :href => 'host/1',
+      :Configuration => { :EdgeGatewayServiceConfiguration => {} },
+    }])
+  end
+
+  it "should retrive entire organization" do
+    expect(Vcloud::Walker::Resource::Organization).to receive(:edgegateways).
+      and_return([:edgegateway => 'Gateway 1'])
+    expect(Vcloud::Walker::Resource::Organization).to receive(:vdcs).
+      and_return([:vdc => "VDC 1"])
+    expect(Vcloud::Walker::Resource::Organization).to receive(:catalogs).
+      and_return([:catalog => "Catalog 1"])
+    expect(Vcloud::Walker::Resource::Organization).to receive(:networks).
+      and_return([:network => "Network 1"])
+
+    expect(Vcloud::Walker::Resource::Organization.organization).to eq({
+        :vdcs => [{ :vdc => "VDC 1" }],
+        :networks => [{ :network => "Network 1" }],
+        :catalogs => [{ :catalog => "Catalog 1" }],
+        :edgegateways => [{ :edgegateway => "Gateway 1" }]
+    })
+  end
+
+end
+

data/spec/vcloud/walker/resource/vapp_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Vcloud::Walker::Resource::VApp do
+
+  context 'populate summary vapp model' do
+    before(:each) do
+      fog_vapp = Fog::ServiceLayerStub.vapp_body
+      @metadata = {:name => 'web-app-1', :shutdown => true}
+      expect(Vcloud::Core::Vapp).to receive(:get_metadata).with("vapp-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee").and_return(@metadata)
+      expect(Vcloud::Walker::Resource::Vms).to receive(:new).with(fog_vapp[:Children][:Vm])
+
+      @vapp_summary = Vcloud::Walker::Resource::VApp.new(fog_vapp)
+    end
+
+    it 'should report id from the href' do
+      expect(@vapp_summary.id).to eq('vapp-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee')
+    end
+
+    it "should report metadata" do
+      expect(@vapp_summary.metadata.count).to eq(2)
+      expect(@vapp_summary.metadata).to eq(@metadata)
+    end
+  end
+
+  context 'malformed vApp with no networks attached' do
+    before(:each) {
+      allow(Vcloud::Core::Vapp).to receive(:get_metadata)
+      allow(Vcloud::Walker::Resource::Vms).to receive(:new)
+    }
+
+    describe "network_config" do
+      shared_examples "network_config" do
+        it 'should report an empty network_config without any errors' do
+          vapp = Vcloud::Walker::Resource::VApp.new(fog_vapp)
+          expect(vapp.network_config).to eq([])
+        end
+      end
+
+      context 'missing vapp[:NetworkConfigSection]' do
+        let(:fog_vapp) {
+          v = Fog::ServiceLayerStub.vapp_body
+          v.delete(:NetworkConfigSection)
+          v
+        }
+
+        include_examples "network_config"
+      end
+
+      context 'missing vapp[:NetworkConfigSection][:NetworkConfig]' do
+        let(:fog_vapp) {
+          v = Fog::ServiceLayerStub.vapp_body
+          v[:NetworkConfigSection].delete(:NetworkConfig)
+          v
+        }
+
+        include_examples "network_config"
+      end
+    end
+
+    describe "network_section" do
+      shared_examples "network_section" do
+        it 'should report an empty network_section without any errors' do
+          vapp = Vcloud::Walker::Resource::VApp.new(fog_vapp)
+          expect(vapp.network_section).to eq({})
+        end
+      end
+
+      context 'missing vapp[:"ovf:NetworkSection"]' do
+        let(:fog_vapp) {
+          v = Fog::ServiceLayerStub.vapp_body
+          v.delete(:"ovf:NetworkSection")
+          v
+        }
+
+        include_examples "network_section"
+      end
+
+      context 'missing vapp[:"ovf:NetworkSection"][:"ovf:Network"]' do
+        let(:fog_vapp) {
+          v = Fog::ServiceLayerStub.vapp_body
+          v[:"ovf:NetworkSection"].delete(:"ovf:Network")
+          v
+        }
+
+        include_examples "network_section"
+      end
+    end
+  end
+end

data/spec/vcloud/walker/resource/vdcs_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'fog'
+
+describe Vcloud::Walker::Resource::Vdcs do
+  let(:api_session) { double(:fog_session) }
+
+  context 'vdcs' do
+
+    it "should summarize vdcs" do
+      expect(Fog::Compute::VcloudDirector).to receive(:new).with(any_args()).and_return(api_session)
+      mock_fog_vdcs = StubCollectionBuilders.vdcs(StubVdc.new.vapps([mock_vapp]).build)
+      expect(api_session).to receive(:get_vapp).with(1).and_return(Fog::ServiceLayerStub.mock_vapp)
+      expect(Vcloud::Core::Vm).to receive(:get_metadata).with("vm-d19d84a5-c950-4497-a638-23eccc4226a5").and_return({})
+      expect(Vcloud::Core::Vapp).to receive(:get_metadata).with("vapp-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee").and_return({})
+
+      vdcs_summary = Vcloud::Walker::Resource::Vdcs.new(mock_fog_vdcs).to_summary
+
+      vdc_summary = vdcs_summary.first
+      expect(vdc_summary[:vapps].count).to eq(1)
+      expect(vdc_summary[:vapps].first[:vms].count).to eq(1)
+    end
+
+    private
+
+    def mock_vapp
+      double(:vapp, :id => 1)
+    end
+
+  end
+end

data/spec/{walk → vcloud/walker/resource}/vm_spec.rb

@@ -7,7 +7,7 @@ describe Vcloud::Walker::Resource::Vm do
       fog_vm = assemble_sample_vm_data Fog::ServiceLayerStub.vcloud_director_five_one_ids
 
       @metadata = {:name => 'web-app-1', :shutdown => true}
-      Vcloud::Core::Vm.should_receive(:get_metadata)
+      expect(Vcloud::Core::Vm).to receive(:get_metadata)
                       .with("vm-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
                       .and_return(@metadata)
 
@@ -15,65 +15,65 @@ describe Vcloud::Walker::Resource::Vm do
     end
 
     it 'should report id from the href' do
-      @vm_summary.id.should == 'vm-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+      expect(@vm_summary.id).to eq('vm-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee')
     end
 
     it "should populate vmware tool version" do
-      @vm_summary.vmware_tools.should == {:version => "2147483647"}
+      expect(@vm_summary.vmware_tools).to eq({:version => "2147483647"})
     end
 
     it "should populate virtual system type" do
-      @vm_summary.virtual_system_type.should == "vmx-08"
+      expect(@vm_summary.virtual_system_type).to eq("vmx-08")
     end
 
     it "should populate operating system" do
-      @vm_summary.operating_system.should == 'Ubuntu Linux (64-bit)'
+      expect(@vm_summary.operating_system).to eq('Ubuntu Linux (64-bit)')
     end
 
     it "should populate network connection interface" do
-      @vm_summary.primary_network_connection_index.should == '0'
-      @vm_summary.network_connections.count.should == 1
-      @vm_summary.network_connections.first[:network].should == 'Default'
+      expect(@vm_summary.primary_network_connection_index).to eq('0')
+      expect(@vm_summary.network_connections.count).to eq(1)
+      expect(@vm_summary.network_connections.first[:network]).to eq('Default')
     end
 
     it "should populate storage profile" do
-      @vm_summary.storage_profile[:name].should == "TEST-STORAGE-PROFILE"
+      expect(@vm_summary.storage_profile[:name]).to eq("TEST-STORAGE-PROFILE")
     end
 
     it "should populate storage profile id" do
-      @vm_summary.storage_profile[:id].should == "00000000-aaaa-bbbb-aaaa-000000000000"
+      expect(@vm_summary.storage_profile[:id]).to eq("00000000-aaaa-bbbb-aaaa-000000000000")
     end
 
     context "hardware resource info" do
 
       it "report cpu" do
-        @vm_summary.cpu.should == '2 virtual CPU(s)'
+        expect(@vm_summary.cpu).to eq('2 virtual CPU(s)')
       end
 
       it "report memory" do
-        @vm_summary.memory.should == '4096 MB of memory'
+        expect(@vm_summary.memory).to eq('4096 MB of memory')
       end
 
       it "report disk info" do
-        @vm_summary.disks.count.should == 2
-        @vm_summary.disks.first.should == {:name => "Hard disk 1", :size => 11265}
-        @vm_summary.disks.last.should == {:name => "Hard disk 2", :size => 307200}
+        expect(@vm_summary.disks.count).to eq(2)
+        expect(@vm_summary.disks.first).to eq({:name => "Hard disk 1", :size => 11265})
+        expect(@vm_summary.disks.last).to eq({:name => "Hard disk 2", :size => 307200})
       end
 
       it "report network card info" do
-        @vm_summary.network_cards.count.should == 1
-        @vm_summary.network_cards[0].should == {
+        expect(@vm_summary.network_cards.count).to eq(1)
+        expect(@vm_summary.network_cards[0]).to eq({
           :mac_address => '00:50:56:00:00:01',
           :name => "Network adapter 0",
           :type => "E1000"
-        }
+        })
       end
 
     end
 
     it "report metadata" do
-      @vm_summary.metadata.count.should == 2
-      @vm_summary.metadata.should == @metadata
+      expect(@vm_summary.metadata.count).to eq(2)
+      expect(@vm_summary.metadata).to eq(@metadata)
     end
 
   end
@@ -84,7 +84,7 @@ describe Vcloud::Walker::Resource::Vm do
       fog_vm = assemble_sample_vm_data  Fog::ServiceLayerStub.vcloud_director_5_5_with_v5_1_api_ids
 
       @metadata = {:name => 'web-app-1', :shutdown => true}
-      Vcloud::Core::Vm.should_receive(:get_metadata)
+      expect(Vcloud::Core::Vm).to receive(:get_metadata)
                       .with("vm-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
                       .and_return(@metadata)
 
@@ -92,9 +92,9 @@ describe Vcloud::Walker::Resource::Vm do
     end
 
     it "report disk info for 5.1 api on 5.5" do
-      @vm_summary.disks.count.should == 2
-      @vm_summary.disks.first.should == {:name => "Hard disk 1", :size => 11265}
-      @vm_summary.disks.last.should == {:name => "Hard disk 2", :size => 307200}
+      expect(@vm_summary.disks.count).to eq(2)
+      expect(@vm_summary.disks.first).to eq({:name => "Hard disk 1", :size => 11265})
+      expect(@vm_summary.disks.last).to eq({:name => "Hard disk 2", :size => 307200})
     end
 
   end

data/spec/vcloud/walker_spec.rb

@@ -9,48 +9,46 @@ module Vcloud
 
         it "should correctly pass catalogs" do
           test_array = [ "name" => "catalogs" ]
-          Vcloud::Walker::Resource::Organization.stub(:catalogs).and_return(test_array)
+          allow(Vcloud::Walker::Resource::Organization).to receive(:catalogs).and_return(test_array)
           result_array = Vcloud::Walker.walk("catalogs")
-          result_array.should include("name" => "catalogs")
+          expect(result_array).to include("name" => "catalogs")
         end
 
         it "should correctly pass vdcs" do
           test_array = [ "name" => "vdcs" ]
-          Vcloud::Walker::Resource::Organization.stub(:vdcs).and_return(test_array)
+          allow(Vcloud::Walker::Resource::Organization).to receive(:vdcs).and_return(test_array)
           result_array = Vcloud::Walker.walk("vdcs")
-          result_array.should include("name" => "vdcs")
+          expect(result_array).to include("name" => "vdcs")
         end
 
         it "should correctly pass networks" do
           test_array = [ "name" => "networks" ]
-          Vcloud::Walker::Resource::Organization.stub(:networks).and_return(test_array)
+          allow(Vcloud::Walker::Resource::Organization).to receive(:networks).and_return(test_array)
           result_array = Vcloud::Walker.walk("networks")
-          result_array.should include("name" => "networks")
+          expect(result_array).to include("name" => "networks")
         end
 
         it "should correctly pass edgegateways" do
           test_array = [ "name" => "edgegateways" ]
-          Vcloud::Walker::Resource::Organization.stub(:edgegateways).and_return(test_array)
+          allow(Vcloud::Walker::Resource::Organization).to receive(:edgegateways).and_return(test_array)
           result_array = Vcloud::Walker.walk("edgegateways")
-          result_array.should include("name" => "edgegateways")
+          expect(result_array).to include("name" => "edgegateways")
         end
 
         it "should correctly pass organization" do
           test_array = [ "name" => "organization" ]
-          Vcloud::Walker::Resource::Organization.stub(:organization).and_return(test_array)
+          allow(Vcloud::Walker::Resource::Organization).to receive(:organization).and_return(test_array)
           result_array = Vcloud::Walker.walk("organization")
-          result_array.should include("name" => "organization")
+          expect(result_array).to include("name" => "organization")
         end
 
       end
 
       context "invalid resources" do
-
         it "should reject input that is not a valid resouce" do
-          result_array = Vcloud::Walker.walk("invalid")
-          result_array.should be_nil
+          expect{ Vcloud::Walker.walk("invalid") }.
+            to raise_error("Invalid resource 'invalid'. Possible options are 'catalogs','vdcs','networks','edgegateways','organization'.")
         end
-
       end
 
     end