ohai 7.6.0.rc.1 → 8.0.1

data/spec/unit/plugins/aix/platform_spec.rb

@@ -20,24 +20,24 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper.rb')
 describe Ohai::System, "Aix plugin platform" do
   before(:each) do
     @plugin = get_plugin("aix/platform")
-    @plugin.stub(:collect_os).and_return(:aix)
+    allow(@plugin).to receive(:collect_os).and_return(:aix)
     kernel = Mash.new
     kernel[:name] = "aix"
     kernel[:version] = "1"
     kernel[:release] = "0"
-    @plugin.stub(:kernel).and_return(kernel)
+    allow(@plugin).to receive(:kernel).and_return(kernel)
     @plugin.run
   end
 
   it "should set platform to aix" do
-    @plugin[:platform].should == "aix"
+    expect(@plugin[:platform]).to eq("aix")
   end
 
   it "should set the platform_version" do
-    @plugin[:platform_version].should == "1.0"
+    expect(@plugin[:platform_version]).to eq("1.0")
   end
 
   it "should set platform_family" do
-    @plugin[:platform_family].should == @plugin[:platform]
+    expect(@plugin[:platform_family]).to eq(@plugin[:platform])
   end
 end

data/spec/unit/plugins/aix/uptime_spec.rb

@@ -21,20 +21,20 @@ describe Ohai::System, "Aix plugin uptime" do
 
   before(:each) do
     @plugin = get_plugin("aix/uptime")
-    @plugin.stub(:collect_os).and_return(:aix)
-    Time.stub_chain(:now, :to_i).and_return(1412072511)
-    Time.stub_chain(:now, :zone).and_return("IST")
-    DateTime.stub_chain(:parse, :strftime, :to_i).and_return(1411561320)
-    @plugin.stub(:shell_out).with("who -b").and_return(mock_shell_out(0, "   .        system boot Sep 24 17:52", nil))
+    allow(@plugin).to receive(:collect_os).and_return(:aix)
+    allow(Time).to receive_message_chain(:now, :to_i).and_return(1412072511)
+    allow(Time).to receive_message_chain(:now, :zone).and_return("IST")
+    allow(DateTime).to receive_message_chain(:parse, :strftime, :to_i).and_return(1411561320)
+    allow(@plugin).to receive(:shell_out).with("who -b").and_return(mock_shell_out(0, "   .        system boot Sep 24 17:52", nil))
 
     @plugin.run
   end
 
   it "should set uptime_seconds to uptime" do
-    @plugin[:uptime_seconds].should == 511191
+    expect(@plugin[:uptime_seconds]).to eq(511191)
   end
 
   it "should set uptime to a human readable date" do
-    @plugin[:uptime].should == "5 days 21 hours 59 minutes 51 seconds"
+    expect(@plugin[:uptime]).to eq("5 days 21 hours 59 minutes 51 seconds")
   end
 end

data/spec/unit/plugins/aix/virtualization_spec.rb

@@ -30,8 +30,8 @@ describe Ohai::System, "AIX virtualization plugin" do
     end
 
     it "uname -L detects the LPAR number and name" do
-      plugin[:virtualization][:lpar_no].should == "29"
-      plugin[:virtualization][:lpar_name].should == "l273pp027"
+      expect(plugin[:virtualization][:lpar_no]).to eq("29")
+      expect(plugin[:virtualization][:lpar_name]).to eq("l273pp027")
     end
   end
 
@@ -46,7 +46,7 @@ describe Ohai::System, "AIX virtualization plugin" do
     end
 
     it "uname -W detects the WPAR number" do
-      plugin[:virtualization][:wpar_no].should == "42"
+      expect(plugin[:virtualization][:wpar_no]).to eq("42")
     end
   end
 

data/spec/unit/plugins/azure_spec.rb

@@ -27,45 +27,45 @@ describe Ohai::System, "plugin azure" do
 
   describe "with azure cloud file" do
     before(:each) do
-      File.stub(:exist?).with('/etc/chef/ohai/hints/azure.json').and_return(true)
-      File.stub(:read).with('/etc/chef/ohai/hints/azure.json').and_return('{"public_ip":"137.135.46.202","vm_name":"test-vm","public_fqdn":"service.cloudapp.net","public_ssh_port":"22", "public_winrm_port":"5985"}')
-      File.stub(:exist?).with('C:\chef\ohai\hints/azure.json').and_return(true)
-      File.stub(:read).with('C:\chef\ohai\hints/azure.json').and_return('{"public_ip":"137.135.46.202","vm_name":"test-vm","public_fqdn":"service.cloudapp.net","public_ssh_port":"22", "public_winrm_port":"5985"}')
+      allow(File).to receive(:exist?).with('/etc/chef/ohai/hints/azure.json').and_return(true)
+      allow(File).to receive(:read).with('/etc/chef/ohai/hints/azure.json').and_return('{"public_ip":"137.135.46.202","vm_name":"test-vm","public_fqdn":"service.cloudapp.net","public_ssh_port":"22", "public_winrm_port":"5985"}')
+      allow(File).to receive(:exist?).with('C:\chef\ohai\hints/azure.json').and_return(true)
+      allow(File).to receive(:read).with('C:\chef\ohai\hints/azure.json').and_return('{"public_ip":"137.135.46.202","vm_name":"test-vm","public_fqdn":"service.cloudapp.net","public_ssh_port":"22", "public_winrm_port":"5985"}')
       @plugin.run
     end
 
     it 'should set the azure cloud attributes' do
-      @plugin[:azure].should_not be_nil
-      @plugin[:azure]['public_ip'].should  == "137.135.46.202"
-      @plugin[:azure]['vm_name'].should == "test-vm"
-      @plugin[:azure]['public_fqdn'].should == "service.cloudapp.net"
-      @plugin[:azure]['public_ssh_port'].should == "22"
-      @plugin[:azure]['public_winrm_port'].should == "5985"
+      expect(@plugin[:azure]).not_to be_nil
+      expect(@plugin[:azure]['public_ip']).to  eq("137.135.46.202")
+      expect(@plugin[:azure]['vm_name']).to eq("test-vm")
+      expect(@plugin[:azure]['public_fqdn']).to eq("service.cloudapp.net")
+      expect(@plugin[:azure]['public_ssh_port']).to eq("22")
+      expect(@plugin[:azure]['public_winrm_port']).to eq("5985")
     end
 
   end
 
   describe "without azure cloud file" do
     before(:each) do
-      File.stub(:exist?).with('/etc/chef/ohai/hints/azure.json').and_return(false)
-      File.stub(:exist?).with('C:\chef\ohai\hints/azure.json').and_return(false)
+      allow(File).to receive(:exist?).with('/etc/chef/ohai/hints/azure.json').and_return(false)
+      allow(File).to receive(:exist?).with('C:\chef\ohai\hints/azure.json').and_return(false)
     end
 
     it 'should not behave like azure' do
-      @plugin[:azure].should be_nil
+      expect(@plugin[:azure]).to be_nil
     end
   end
 
   describe "with rackspace cloud file" do
     before(:each) do
-      File.stub(:exist?).with('/etc/chef/ohai/hints/rackspace.json').and_return(true)
-      File.stub(:read).with('/etc/chef/ohai/hints/rackspace.json').and_return('')
-      File.stub(:exist?).with('C:\chef\ohai\hints/rackspace.json').and_return(true)
-      File.stub(:read).with('C:\chef\ohai\hints/rackspace.json').and_return('')
+      allow(File).to receive(:exist?).with('/etc/chef/ohai/hints/rackspace.json').and_return(true)
+      allow(File).to receive(:read).with('/etc/chef/ohai/hints/rackspace.json').and_return('')
+      allow(File).to receive(:exist?).with('C:\chef\ohai\hints/rackspace.json').and_return(true)
+      allow(File).to receive(:read).with('C:\chef\ohai\hints/rackspace.json').and_return('')
     end
 
     it 'should not behave like azure' do
-      @plugin[:azure].should be_nil
+      expect(@plugin[:azure]).to be_nil
     end
   end
 

data/spec/unit/plugins/c_spec.rb

@@ -107,202 +107,202 @@ describe Ohai::System, "plugin c" do
 
     @plugin[:languages] = Mash.new
     #gcc
-    @plugin.stub(:shell_out).with("gcc -v").and_return(mock_shell_out(0, "", C_GCC))
+    allow(@plugin).to receive(:shell_out).with("gcc -v").and_return(mock_shell_out(0, "", C_GCC))
     #glibc
-    @plugin.stub(:shell_out).with("/lib/libc.so.6").and_return(mock_shell_out(0, C_GLIBC_2_3_4, ""))
+    allow(@plugin).to receive(:shell_out).with("/lib/libc.so.6").and_return(mock_shell_out(0, C_GLIBC_2_3_4, ""))
     #ms cl
-    @plugin.stub(:shell_out).with("cl /\?").and_return(mock_shell_out(0, "", C_CL))
+    allow(@plugin).to receive(:shell_out).with("cl /\?").and_return(mock_shell_out(0, "", C_CL))
     #ms vs
-    @plugin.stub(:shell_out).with("devenv.com /\?").and_return(mock_shell_out(0, C_VS, ""))
+    allow(@plugin).to receive(:shell_out).with("devenv.com /\?").and_return(mock_shell_out(0, C_VS, ""))
     #ibm xlc
-    @plugin.stub(:shell_out).with("xlc -qversion").and_return(mock_shell_out(0, C_XLC, ""))
+    allow(@plugin).to receive(:shell_out).with("xlc -qversion").and_return(mock_shell_out(0, C_XLC, ""))
     #sun pro
-    @plugin.stub(:shell_out).with("cc -V -flags").and_return(mock_shell_out(0, "", C_SUN))
+    allow(@plugin).to receive(:shell_out).with("cc -V -flags").and_return(mock_shell_out(0, "", C_SUN))
     #hpux cc
-    @plugin.stub(:shell_out).with("what /opt/ansic/bin/cc").and_return(mock_shell_out(0, C_HPUX, ""))
+    allow(@plugin).to receive(:shell_out).with("what /opt/ansic/bin/cc").and_return(mock_shell_out(0, C_HPUX, ""))
   end
 
   #gcc
   it "should get the gcc version from running gcc -v" do
-    @plugin.should_receive(:shell_out).with("gcc -v").and_return(mock_shell_out(0, "", C_GCC))
+    expect(@plugin).to receive(:shell_out).with("gcc -v").and_return(mock_shell_out(0, "", C_GCC))
     @plugin.run
   end
 
   it "should set languages[:c][:gcc][:version]" do
     @plugin.run
-    @plugin.languages[:c][:gcc][:version].should eql("3.4.6")
+    expect(@plugin.languages[:c][:gcc][:version]).to eql("3.4.6")
   end
 
   it "should set languages[:c][:gcc][:description]" do
     @plugin.run
-    @plugin.languages[:c][:gcc][:description].should eql(C_GCC.split($/).last)
+    expect(@plugin.languages[:c][:gcc][:description]).to eql(C_GCC.split($/).last)
   end
 
   it "should not set the languages[:c][:gcc] tree up if gcc command fails" do
-    @plugin.stub(:shell_out).with("gcc -v").and_return(mock_shell_out(1, "", ""))
+    allow(@plugin).to receive(:shell_out).with("gcc -v").and_return(mock_shell_out(1, "", ""))
     @plugin.run
-    @plugin[:languages][:c].should_not have_key(:gcc) if @plugin[:languages][:c]
+    expect(@plugin[:languages][:c]).not_to have_key(:gcc) if @plugin[:languages][:c]
   end
 
   #glibc
   it "should get the glibc x.x.x version from running /lib/libc.so.6" do
-    @plugin.should_receive(:shell_out).with("/lib/libc.so.6").and_return(mock_shell_out(0, C_GLIBC_2_3_4, ""))
+    expect(@plugin).to receive(:shell_out).with("/lib/libc.so.6").and_return(mock_shell_out(0, C_GLIBC_2_3_4, ""))
     @plugin.run
   end
 
   it "should set languages[:c][:glibc][:version]" do
     @plugin.run
-    @plugin.languages[:c][:glibc][:version].should eql("2.3.4")
+    expect(@plugin.languages[:c][:glibc][:version]).to eql("2.3.4")
   end
 
   it "should set languages[:c][:glibc][:description]" do
     @plugin.run
-    @plugin.languages[:c][:glibc][:description].should eql(C_GLIBC_2_3_4.split($/).first)
+    expect(@plugin.languages[:c][:glibc][:description]).to eql(C_GLIBC_2_3_4.split($/).first)
   end
 
   it "should not set the languages[:c][:glibc] tree up if glibc command fails" do
-    @plugin.stub(:shell_out).with("/lib/libc.so.6").and_return(mock_shell_out(1, "", ""))
-    @plugin.stub(:shell_out).with("/lib64/libc.so.6").and_return(mock_shell_out(1, "", ""))
+    allow(@plugin).to receive(:shell_out).with("/lib/libc.so.6").and_return(mock_shell_out(1, "", ""))
+    allow(@plugin).to receive(:shell_out).with("/lib64/libc.so.6").and_return(mock_shell_out(1, "", ""))
     @plugin.run
-    @plugin[:languages][:c].should_not have_key(:glibc) if @plugin[:languages][:c]
+    expect(@plugin[:languages][:c]).not_to have_key(:glibc) if @plugin[:languages][:c]
   end
 
   it "should get the glibc x.x version from running /lib/libc.so.6" do
-    @plugin.stub(:shell_out).with("/lib/libc.so.6").and_return(mock_shell_out(0, C_GLIBC_2_5, ""))
-    @plugin.should_receive(:shell_out).with("/lib/libc.so.6").and_return(mock_shell_out(0, C_GLIBC_2_5, ""))
+    allow(@plugin).to receive(:shell_out).with("/lib/libc.so.6").and_return(mock_shell_out(0, C_GLIBC_2_5, ""))
+    expect(@plugin).to receive(:shell_out).with("/lib/libc.so.6").and_return(mock_shell_out(0, C_GLIBC_2_5, ""))
     @plugin.run
-    @plugin.languages[:c][:glibc][:version].should eql("2.5")
+    expect(@plugin.languages[:c][:glibc][:version]).to eql("2.5")
   end
 
   #ms cl
   it "should get the cl version from running cl /?" do
-    @plugin.should_receive(:shell_out).with("cl /\?").and_return(mock_shell_out(0, "", C_CL))
+    expect(@plugin).to receive(:shell_out).with("cl /\?").and_return(mock_shell_out(0, "", C_CL))
     @plugin.run
   end
 
   it "should set languages[:c][:cl][:version]" do
     @plugin.run
-    @plugin.languages[:c][:cl][:version].should eql("14.00.50727.762")
+    expect(@plugin.languages[:c][:cl][:version]).to eql("14.00.50727.762")
   end
 
   it "should set languages[:c][:cl][:description]" do
     @plugin.run
-    @plugin.languages[:c][:cl][:description].should eql(C_CL.split($/).first)
+    expect(@plugin.languages[:c][:cl][:description]).to eql(C_CL.split($/).first)
   end
 
   it "should not set the languages[:c][:cl] tree up if cl command fails" do
-    @plugin.stub(:shell_out).with("cl /\?").and_return(mock_shell_out(1, "", ""))
+    allow(@plugin).to receive(:shell_out).with("cl /\?").and_return(mock_shell_out(1, "", ""))
     @plugin.run
-    @plugin[:languages][:c].should_not have_key(:cl) if @plugin[:languages][:c]
+    expect(@plugin[:languages][:c]).not_to have_key(:cl) if @plugin[:languages][:c]
   end
 
   #ms vs
   it "should get the vs version from running devenv.com /?" do
-    @plugin.should_receive(:shell_out).with("devenv.com /\?").and_return(mock_shell_out(0, C_VS, ""))
+    expect(@plugin).to receive(:shell_out).with("devenv.com /\?").and_return(mock_shell_out(0, C_VS, ""))
     @plugin.run
   end
 
   it "should set languages[:c][:vs][:version]" do
     @plugin.run
-    @plugin.languages[:c][:vs][:version].should eql("8.0.50727.762")
+    expect(@plugin.languages[:c][:vs][:version]).to eql("8.0.50727.762")
   end
 
   it "should set languages[:c][:vs][:description]" do
     @plugin.run
-    @plugin.languages[:c][:vs][:description].should eql(C_VS.split($/)[1])
+    expect(@plugin.languages[:c][:vs][:description]).to eql(C_VS.split($/)[1])
   end
 
   it "should not set the languages[:c][:vs] tree up if devenv command fails" do
-    @plugin.stub(:shell_out).with("devenv.com /\?").and_return(mock_shell_out(1, "", ""))
+    allow(@plugin).to receive(:shell_out).with("devenv.com /\?").and_return(mock_shell_out(1, "", ""))
     @plugin.run
-    @plugin[:languages][:c].should_not have_key(:vs) if @plugin[:languages][:c]
+    expect(@plugin[:languages][:c]).not_to have_key(:vs) if @plugin[:languages][:c]
   end
 
   #ibm xlc
   it "should get the xlc version from running xlc -qversion" do
-    @plugin.should_receive(:shell_out).with("xlc -qversion").and_return(mock_shell_out(0, C_XLC, ""))
+    expect(@plugin).to receive(:shell_out).with("xlc -qversion").and_return(mock_shell_out(0, C_XLC, ""))
     @plugin.run
   end
 
   it "should set languages[:c][:xlc][:version]" do
     @plugin.run
-    @plugin.languages[:c][:xlc][:version].should eql("9.0")
+    expect(@plugin.languages[:c][:xlc][:version]).to eql("9.0")
   end
 
   it "should set languages[:c][:xlc][:description]" do
     @plugin.run
-    @plugin.languages[:c][:xlc][:description].should eql(C_XLC.split($/).first)
+    expect(@plugin.languages[:c][:xlc][:description]).to eql(C_XLC.split($/).first)
   end
 
   it "should not set the languages[:c][:xlc] tree up if xlc command fails" do
-    @plugin.stub(:shell_out).with("xlc -qversion").and_return(mock_shell_out(1, "", ""))
+    allow(@plugin).to receive(:shell_out).with("xlc -qversion").and_return(mock_shell_out(1, "", ""))
     @plugin.run
-    @plugin[:languages][:c].should_not have_key(:xlc) if @plugin[:languages][:c]
+    expect(@plugin[:languages][:c]).not_to have_key(:xlc) if @plugin[:languages][:c]
   end
 
   it "should set the languages[:c][:xlc] tree up if xlc exit status is 249" do
-    @plugin.stub(:shell_out).with("xlc -qversion").and_return(mock_shell_out(63744, "", ""))
+    allow(@plugin).to receive(:shell_out).with("xlc -qversion").and_return(mock_shell_out(63744, "", ""))
     @plugin.run
-    @plugin[:languages][:c].should_not have_key(:xlc) if @plugin[:languages][:c]
+    expect(@plugin[:languages][:c]).not_to have_key(:xlc) if @plugin[:languages][:c]
   end
 
   #sun pro
   it "should get the cc version from running cc -V -flags" do
-    @plugin.should_receive(:shell_out).with("cc -V -flags").and_return(mock_shell_out(0, "", C_SUN))
+    expect(@plugin).to receive(:shell_out).with("cc -V -flags").and_return(mock_shell_out(0, "", C_SUN))
     @plugin.run
   end
 
   it "should set languages[:c][:sunpro][:version]" do
     @plugin.run
-    @plugin.languages[:c][:sunpro][:version].should eql("5.8")
+    expect(@plugin.languages[:c][:sunpro][:version]).to eql("5.8")
   end
 
   it "should set languages[:c][:sunpro][:description]" do
     @plugin.run
-    @plugin.languages[:c][:sunpro][:description].should eql(C_SUN.chomp)
+    expect(@plugin.languages[:c][:sunpro][:description]).to eql(C_SUN.chomp)
   end
 
   it "should not set the languages[:c][:sunpro] tree up if cc command fails" do
-    @plugin.stub(:shell_out).with("cc -V -flags").and_return(mock_shell_out(1, "", ""))
+    allow(@plugin).to receive(:shell_out).with("cc -V -flags").and_return(mock_shell_out(1, "", ""))
     @plugin.run
-    @plugin[:languages][:c].should_not have_key(:sunpro) if @plugin[:languages][:c]
+    expect(@plugin[:languages][:c]).not_to have_key(:sunpro) if @plugin[:languages][:c]
   end
 
   it "should not set the languages[:c][:sunpro] tree if the corresponding cc command fails on linux" do
     fedora_error_message = "cc: error trying to exec 'i686-redhat-linux-gcc--flags': execvp: No such file or directory"
 
-    @plugin.stub(:shell_out).with("cc -V -flags").and_return(mock_shell_out(0, "", fedora_error_message))
+    allow(@plugin).to receive(:shell_out).with("cc -V -flags").and_return(mock_shell_out(0, "", fedora_error_message))
     @plugin.run
-    @plugin[:languages][:c].should_not have_key(:sunpro) if @plugin[:languages][:c]
+    expect(@plugin[:languages][:c]).not_to have_key(:sunpro) if @plugin[:languages][:c]
   end
 
   it "should not set the languages[:c][:sunpro] tree if the corresponding cc command fails on hpux" do
     hpux_error_message = "cc: warning 901: unknown option: `-flags': use +help for online documentation.\ncc: HP C/aC++ B3910B A.06.25 [Nov 30 2009]"
-    @plugin.stub(:shell_out).with("cc -V -flags").and_return(mock_shell_out(0, "", hpux_error_message))
+    allow(@plugin).to receive(:shell_out).with("cc -V -flags").and_return(mock_shell_out(0, "", hpux_error_message))
     @plugin.run
-    @plugin[:languages][:c].should_not have_key(:sunpro) if @plugin[:languages][:c]
+    expect(@plugin[:languages][:c]).not_to have_key(:sunpro) if @plugin[:languages][:c]
   end
 
   #hpux cc
   it "should get the cc version from running what cc" do
-    @plugin.should_receive(:shell_out).with("what /opt/ansic/bin/cc").and_return(mock_shell_out(0, C_HPUX, ""))
+    expect(@plugin).to receive(:shell_out).with("what /opt/ansic/bin/cc").and_return(mock_shell_out(0, C_HPUX, ""))
     @plugin.run
   end
 
   it "should set languages[:c][:hpcc][:version]" do
     @plugin.run
-    @plugin.languages[:c][:hpcc][:version].should eql("B.11.11.16")
+    expect(@plugin.languages[:c][:hpcc][:version]).to eql("B.11.11.16")
   end
 
   it "should set languages[:c][:hpcc][:description]" do
     @plugin.run
-    @plugin.languages[:c][:hpcc][:description].should eql(C_HPUX.split($/)[3].strip)
+    expect(@plugin.languages[:c][:hpcc][:description]).to eql(C_HPUX.split($/)[3].strip)
   end
 
   it "should not set the languages[:c][:hpcc] tree up if cc command fails" do
-    @plugin.stub(:shell_out).with("what /opt/ansic/bin/cc").and_return(mock_shell_out(1, "", ""))
+    allow(@plugin).to receive(:shell_out).with("what /opt/ansic/bin/cc").and_return(mock_shell_out(1, "", ""))
     @plugin.run
-    @plugin[:languages][:c].should_not have_key(:hpcc) if @plugin[:languages][:c]
+    expect(@plugin[:languages][:c]).not_to have_key(:hpcc) if @plugin[:languages][:c]
   end
 
 end

data/spec/unit/plugins/chef_spec.rb

@@ -30,7 +30,7 @@ begin
 
     it "should set [:chef_packages][:chef][:version] to the current chef version", :if => defined?(Chef) do
       @plugin.run
-      @plugin[:chef_packages][:chef][:version].should == Chef::VERSION
+      expect(@plugin[:chef_packages][:chef][:version]).to eq(Chef::VERSION)
     end
   
     pending "would set [:chef_packages][:chef][:version] if chef was available", :unless => defined?(Chef)

data/spec/unit/plugins/cloud_spec.rb

@@ -31,7 +31,7 @@ describe Ohai::System, "plugin cloud" do
       @plugin[:azure] = nil
       @plugin[:cloudstack] = nil
       @plugin.run
-      @plugin[:cloud].should be_nil
+      expect(@plugin[:cloud]).to be_nil
     end
   end
 
@@ -43,18 +43,18 @@ describe Ohai::System, "plugin cloud" do
     it "populates cloud public ip" do
       @plugin[:ec2]['public_ipv4'] = "174.129.150.8"
       @plugin.run
-      @plugin[:cloud][:public_ips][0].should == @plugin[:ec2]['public_ipv4']
+      expect(@plugin[:cloud][:public_ips][0]).to eq(@plugin[:ec2]['public_ipv4'])
     end
 
     it "populates cloud private ip" do
       @plugin[:ec2]['local_ipv4'] = "10.252.42.149"
       @plugin.run
-      @plugin[:cloud][:private_ips][0].should == @plugin[:ec2]['local_ipv4']
+      expect(@plugin[:cloud][:private_ips][0]).to eq(@plugin[:ec2]['local_ipv4'])
     end
 
     it "populates cloud provider" do
       @plugin.run
-      @plugin[:cloud][:provider].should == "ec2"
+      expect(@plugin[:cloud][:provider]).to eq("ec2")
     end
   end
 
@@ -66,42 +66,42 @@ describe Ohai::System, "plugin cloud" do
     it "populates cloud public ip" do
       @plugin[:rackspace][:public_ipv4] = "174.129.150.8"
       @plugin.run
-      @plugin[:cloud][:public_ipv4].should == @plugin[:rackspace][:public_ipv4]
+      expect(@plugin[:cloud][:public_ipv4]).to eq(@plugin[:rackspace][:public_ipv4])
     end
     
     it "populates cloud public ipv6" do
       @plugin[:rackspace][:public_ipv6] = "2a00:1a48:7805:111:e875:efaf:ff08:75"
       @plugin.run
-      @plugin[:cloud][:public_ipv6].should == @plugin[:rackspace][:public_ipv6]
+      expect(@plugin[:cloud][:public_ipv6]).to eq(@plugin[:rackspace][:public_ipv6])
     end
     
     it "populates cloud private ip" do
       @plugin[:rackspace][:local_ipv4] = "10.252.42.149"
       @plugin.run
-      @plugin[:cloud][:local_ipv4].should == @plugin[:rackspace][:local_ipv4]
+      expect(@plugin[:cloud][:local_ipv4]).to eq(@plugin[:rackspace][:local_ipv4])
     end
     
     it "populates cloud private ipv6" do
       @plugin[:rackspace][:local_ipv6] = "2a00:1a48:7805:111:e875:efaf:ff08:75"
       @plugin.run
-      @plugin[:cloud][:local_ipv6].should == @plugin[:rackspace][:local_ipv6]
+      expect(@plugin[:cloud][:local_ipv6]).to eq(@plugin[:rackspace][:local_ipv6])
     end
     
     it "populates first cloud public ip" do
       @plugin[:rackspace][:public_ipv4] = "174.129.150.8"
       @plugin.run
-      @plugin[:cloud][:public_ips].first.should == @plugin[:rackspace][:public_ipv4]
+      expect(@plugin[:cloud][:public_ips].first).to eq(@plugin[:rackspace][:public_ipv4])
     end
     
     it "populates first cloud public ip" do
       @plugin[:rackspace][:local_ipv4] = "174.129.150.8"
       @plugin.run
-      @plugin[:cloud][:private_ips].first.should == @plugin[:rackspace][:local_ipv4]
+      expect(@plugin[:cloud][:private_ips].first).to eq(@plugin[:rackspace][:local_ipv4])
     end
 
     it "populates cloud provider" do
       @plugin.run
-      @plugin[:cloud][:provider].should == "rackspace"
+      expect(@plugin[:cloud][:provider]).to eq("rackspace")
     end
   end
 
@@ -113,24 +113,24 @@ describe Ohai::System, "plugin cloud" do
     it "populates cloud public ip" do
       @plugin[:linode]['public_ip'] = "174.129.150.8"
       @plugin.run
-      @plugin[:cloud][:public_ips][0].should == @plugin[:linode][:public_ip]
+      expect(@plugin[:cloud][:public_ips][0]).to eq(@plugin[:linode][:public_ip])
     end
 
     it "populates cloud private ip" do
       @plugin[:linode]['private_ip'] = "10.252.42.149"
       @plugin.run
-      @plugin[:cloud][:private_ips][0].should == @plugin[:linode][:private_ip]
+      expect(@plugin[:cloud][:private_ips][0]).to eq(@plugin[:linode][:private_ip])
     end
 
     it "populates first cloud public ip" do
       @plugin[:linode]['public_ip'] = "174.129.150.8"
       @plugin.run
-      @plugin[:cloud][:public_ips].first.should == @plugin[:linode][:public_ip]
+      expect(@plugin[:cloud][:public_ips].first).to eq(@plugin[:linode][:public_ip])
     end
 
     it "populates cloud provider" do
       @plugin.run
-      @plugin[:cloud][:provider].should == "linode"
+      expect(@plugin[:cloud][:provider]).to eq("linode")
     end
   end
 
@@ -142,18 +142,18 @@ describe Ohai::System, "plugin cloud" do
     it "populates cloud public ip" do
       @plugin[:eucalyptus]['public_ipv4'] = "174.129.150.8"
       @plugin.run
-      @plugin[:cloud][:public_ips][0].should == @plugin[:eucalyptus]['public_ipv4']
+      expect(@plugin[:cloud][:public_ips][0]).to eq(@plugin[:eucalyptus]['public_ipv4'])
     end
 
     it "populates cloud private ip" do
       @plugin[:eucalyptus]['local_ipv4'] = "10.252.42.149"
       @plugin.run
-      @plugin[:cloud][:private_ips][0].should == @plugin[:eucalyptus]['local_ipv4']
+      expect(@plugin[:cloud][:private_ips][0]).to eq(@plugin[:eucalyptus]['local_ipv4'])
     end
 
     it "populates cloud provider" do
       @plugin.run
-      @plugin[:cloud][:provider].should == "eucalyptus"
+      expect(@plugin[:cloud][:provider]).to eq("eucalyptus")
     end
   end
 
@@ -165,44 +165,44 @@ describe Ohai::System, "plugin cloud" do
     it "populates cloud public ip" do
       @plugin[:azure]['public_ip'] = "174.129.150.8"
       @plugin.run
-      @plugin[:cloud][:public_ips][0].should == @plugin[:azure]['public_ip']
-      @plugin[:cloud][:public_ipv4].should == @plugin[:azure]['public_ip']
+      expect(@plugin[:cloud][:public_ips][0]).to eq(@plugin[:azure]['public_ip'])
+      expect(@plugin[:cloud][:public_ipv4]).to eq(@plugin[:azure]['public_ip'])
     end
 
     it "populates cloud vm_name" do
       @plugin[:azure]['vm_name'] = "linux-vm"
       @plugin.run
-      @plugin[:cloud][:vm_name].should == @plugin[:azure]['vm_name']
+      expect(@plugin[:cloud][:vm_name]).to eq(@plugin[:azure]['vm_name'])
     end
 
     it "populates cloud public_fqdn" do
       @plugin[:azure]['public_fqdn'] = "linux-vm-svc.cloudapp.net"
       @plugin.run
-      @plugin[:cloud][:public_fqdn].should == @plugin[:azure]['public_fqdn']
-      @plugin[:cloud][:public_hostname].should == @plugin[:azure]['public_fqdn']
+      expect(@plugin[:cloud][:public_fqdn]).to eq(@plugin[:azure]['public_fqdn'])
+      expect(@plugin[:cloud][:public_hostname]).to eq(@plugin[:azure]['public_fqdn'])
     end
 
     it "populates cloud public_ssh_port" do
       @plugin[:azure]['public_ssh_port'] = "22"
       @plugin.run
-      @plugin[:cloud][:public_ssh_port].should == @plugin[:azure]['public_ssh_port']
+      expect(@plugin[:cloud][:public_ssh_port]).to eq(@plugin[:azure]['public_ssh_port'])
     end
 
     it "should not populate cloud public_ssh_port when winrm is used" do
       @plugin[:azure]['public_winrm_port'] = "5985"
       @plugin.run
-      @plugin[:cloud][:public_ssh_port].should be_nil
+      expect(@plugin[:cloud][:public_ssh_port]).to be_nil
     end
 
     it "populates cloud public_winrm_port" do
       @plugin[:azure]['public_winrm_port'] = "5985"
       @plugin.run
-      @plugin[:cloud][:public_winrm_port].should == @plugin[:azure]['public_winrm_port']
+      expect(@plugin[:cloud][:public_winrm_port]).to eq(@plugin[:azure]['public_winrm_port'])
     end
 
     it "populates cloud provider" do
       @plugin.run
-      @plugin[:cloud][:provider].should == "azure"
+      expect(@plugin[:cloud][:provider]).to eq("azure")
     end
   end
 
@@ -214,24 +214,24 @@ describe Ohai::System, "plugin cloud" do
     it "populates cloud public ip" do
       @plugin[:cloudstack]['public_ipv4'] = "174.129.150.8"
       @plugin.run
-      @plugin[:cloud][:public_ips][0].should == @plugin[:cloudstack]['public_ipv4']
+      expect(@plugin[:cloud][:public_ips][0]).to eq(@plugin[:cloudstack]['public_ipv4'])
     end
 
     it "populates cloud private ip" do
       @plugin[:cloudstack]['local_ipv4'] = "10.252.42.149"
       @plugin.run
-      @plugin[:cloud][:private_ips][0].should == @plugin[:cloudstack]['local_ipv4']
+      expect(@plugin[:cloud][:private_ips][0]).to eq(@plugin[:cloudstack]['local_ipv4'])
     end
 
     it "populates cloud provider" do
       @plugin.run
-      @plugin[:cloud][:provider].should == "cloudstack"
+      expect(@plugin[:cloud][:provider]).to eq("cloudstack")
     end
 
     it "populates vm id" do
       @plugin[:cloudstack]['vm_id'] = "8983fb85-fb7f-46d6-8af1-c1b6666fec39"
       @plugin.run
-      @plugin[:cloud][:vm_id].should == @plugin[:cloudstack]['vm_id']
+      expect(@plugin[:cloud][:vm_id]).to eq(@plugin[:cloudstack]['vm_id'])
     end
   end