ohai 7.6.0.rc.1 → 8.0.1

data/spec/unit/mixin/cloudstack_metadata_spec.rb

@@ -27,7 +27,7 @@ describe Ohai::Mixin::CloudstackMetadata do
 
   context "#best_api_version" do
     it "returns the string latest" do
-      mixin.best_api_version.should == "latest"
+      expect(mixin.best_api_version).to eq("latest")
     end
   end
 end

data/spec/unit/mixin/command_spec.rb

@@ -25,14 +25,14 @@ describe Ohai::Mixin::Command, "popen4" do
   it "should default all commands to be run in the POSIX standard C locale" do
     Ohai::Mixin::Command.popen4("echo $LC_ALL") do |pid, stdin, stdout, stderr|
       stdin.close
-      stdout.read.strip.should == "C"
+      expect(stdout.read.strip).to eq("C")
     end
   end
 
   it "should respect locale when specified explicitly" do
     Ohai::Mixin::Command.popen4("echo $LC_ALL", :environment => {"LC_ALL" => "es"}) do |pid, stdin, stdout, stderr|
       stdin.close
-      stdout.read.strip.should == "es"
+      expect(stdout.read.strip).to eq("es")
     end
   end
 
@@ -53,14 +53,14 @@ describe Ohai::Mixin::Command, "popen4" do
       it "should force encode the string to UTF-8" do
         extend Ohai::Mixin::Command
         snowy = run_command(:command => ("echo '" + ('☃' * 8096) + "'"))[1]
-        snowy.encoding.should == Encoding::UTF_8
+        expect(snowy.encoding).to eq(Encoding::UTF_8)
       end
     end
 
     it "should force encode the string to UTF-8" do
       extend Ohai::Mixin::Command
       snowy = run_command(:command => ("echo '" + ('☃' * 8096) + "'"))[1]
-      snowy.encoding.should == Encoding::UTF_8
+      expect(snowy.encoding).to eq(Encoding::UTF_8)
     end
   end
 
@@ -77,13 +77,13 @@ describe Ohai::Mixin::Command, "popen4" do
         created_procs += 1
       end
     end
-    created_procs.should == 100
+    expect(created_procs).to eq(100)
     reaped_procs = 0
     begin
       loop { Process.wait(-1); reaped_procs += 1 }
     rescue Errno::ECHILD
     end
-    reaped_procs.should == 0
+    expect(reaped_procs).to eq(0)
   end
 
 end

data/spec/unit/mixin/ec2_metadata_spec.rb

@@ -23,8 +23,8 @@ describe Ohai::Mixin::Ec2Metadata do
   let(:mixin) {
     metadata_object = Object.new.extend(Ohai::Mixin::Ec2Metadata)
     http_client = double("Net::HTTP client")
-    http_client.stub(:get).and_return(response)
-    metadata_object.stub(:http_client).and_return(http_client)
+    allow(http_client).to receive(:get).and_return(response)
+    allow(metadata_object).to receive(:http_client).and_return(http_client)
     metadata_object
   }
 
@@ -33,7 +33,7 @@ describe Ohai::Mixin::Ec2Metadata do
       let(:response) { double("Net::HTTP Response", :body => "1.0\n2011-05-01\n2012-01-12\nUnsupported", :code => "200") }
 
       it "returns the most recent version" do
-        mixin.best_api_version.should == "2012-01-12"
+        expect(mixin.best_api_version).to eq("2012-01-12")
       end
     end
 
@@ -41,7 +41,7 @@ describe Ohai::Mixin::Ec2Metadata do
       let(:response) { double("Net::HTTP Response", :body => "1.0\n2009-04-04\n2007-03-01\n2011-05-01\n2008-09-01\nUnsupported", :code => "200") }
 
       it "returns the most recent version (using string sort)" do
-        mixin.best_api_version.should == "2011-05-01"
+        expect(mixin.best_api_version).to eq("2011-05-01")
       end
     end
 
@@ -49,7 +49,7 @@ describe Ohai::Mixin::Ec2Metadata do
       let(:response) { double("Net::HTTP Response", :body => "2020-01-01\nUnsupported", :code => "200") }
 
       it "raises an error" do
-        lambda { mixin.best_api_version}.should raise_error
+        expect { mixin.best_api_version}.to raise_error
       end
     end
 
@@ -58,7 +58,7 @@ describe Ohai::Mixin::Ec2Metadata do
       let(:response) { double("Net::HTTP Response", :code => "404") }
 
       it "returns 'latest' as the version" do
-        mixin.best_api_version.should == 'latest'
+        expect(mixin.best_api_version).to eq('latest')
       end
     end
 
@@ -66,7 +66,7 @@ describe Ohai::Mixin::Ec2Metadata do
       let(:response) { double("Net::HTTP Response", :body => "1.0\n2011-05-01\n2012-01-12\nUnsupported", :code => "418") }
 
       it "raises an error" do
-        lambda { mixin.best_api_version}.should raise_error
+        expect { mixin.best_api_version}.to raise_error
       end
     end
   end
@@ -76,7 +76,7 @@ describe Ohai::Mixin::Ec2Metadata do
       let(:response) { double("Net::HTTP Response", :body => "", :code => "418") }
 
       it "raises an error" do
-        lambda { mixin.metadata_get('', '2012-01-12') }.should raise_error(RuntimeError)
+        expect { mixin.metadata_get('', '2012-01-12') }.to raise_error(RuntimeError)
       end
     end
   end

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

@@ -32,49 +32,49 @@ state       enable         Processor state       False
 type        PowerPC_POWER5 Processor type        False
 LSATTR_EL
     @plugin = get_plugin("aix/cpu")
-    @plugin.stub(:collect_os).and_return(:aix)
+    allow(@plugin).to receive(:collect_os).and_return(:aix)
 
-    @plugin.stub(:shell_out).with("lsdev -Cc processor").and_return(mock_shell_out(0, @lsdev_Cc_processor, nil))
-    @plugin.stub(:shell_out).with("lsattr -El proc0").and_return(mock_shell_out(0, @lsattr_El_proc0, nil))
+    allow(@plugin).to receive(:shell_out).with("lsdev -Cc processor").and_return(mock_shell_out(0, @lsdev_Cc_processor, nil))
+    allow(@plugin).to receive(:shell_out).with("lsattr -El proc0").and_return(mock_shell_out(0, @lsattr_El_proc0, nil))
     @plugin.run
   end
 
 
   it "sets the vendor id to IBM" do
-    @plugin[:cpu][:vendor_id].should == "IBM"
+    expect(@plugin[:cpu][:vendor_id]).to eq("IBM")
   end
 
   it "sets the available attribute" do
-    @plugin[:cpu][:available].should == 1
+    expect(@plugin[:cpu][:available]).to eq(1)
   end
 
   it "sets the total number of devices" do
-    @plugin[:cpu][:total].should == 2
+    expect(@plugin[:cpu][:total]).to eq(2)
   end
 
   it "detects the model" do
-    @plugin[:cpu][:model].should == "PowerPC_POWER5"
+    expect(@plugin[:cpu][:model]).to eq("PowerPC_POWER5")
   end
 
   it "detects the mhz" do
-    @plugin[:cpu][:mhz].should == 1615570
+    expect(@plugin[:cpu][:mhz]).to eq(1615570)
   end
 
   it "detects the status of the device" do
-    @plugin[:cpu][:proc0][:status].should == "Available"
+    expect(@plugin[:cpu][:proc0][:status]).to eq("Available")
   end
 
   it "detects the location of the device" do
-    @plugin[:cpu][:proc0][:location].should == "00-00"
+    expect(@plugin[:cpu][:proc0][:location]).to eq("00-00")
   end
 
   context "lsattr -El device_name" do
     it "detects all the attributes of the device" do
-      @plugin[:cpu][:proc0][:frequency].should == "1654344000"
-      @plugin[:cpu][:proc0][:smt_enabled].should == "true"
-      @plugin[:cpu][:proc0][:smt_threads].should == "2"
-      @plugin[:cpu][:proc0][:state].should == "enable"
-      @plugin[:cpu][:proc0][:type].should == "PowerPC_POWER5"
+      expect(@plugin[:cpu][:proc0][:frequency]).to eq("1654344000")
+      expect(@plugin[:cpu][:proc0][:smt_enabled]).to eq("true")
+      expect(@plugin[:cpu][:proc0][:smt_threads]).to eq("2")
+      expect(@plugin[:cpu][:proc0][:state]).to eq("enable")
+      expect(@plugin[:cpu][:proc0][:type]).to eq("PowerPC_POWER5")
     end
   end
 end

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

@@ -46,10 +46,10 @@ DF_P
 MOUNT
 
     @plugin = get_plugin("aix/filesystem")
-    @plugin.stub(:collect_os).and_return(:aix)
+    allow(@plugin).to receive(:collect_os).and_return(:aix)
     @plugin[:filesystem] = Mash.new
-    @plugin.stub(:shell_out).with("df -P").and_return(mock_shell_out(0, @df_P, nil))
-    @plugin.stub(:shell_out).with("mount").and_return(mock_shell_out(0, @mount, nil))
+    allow(@plugin).to receive(:shell_out).with("df -P").and_return(mock_shell_out(0, @df_P, nil))
+    allow(@plugin).to receive(:shell_out).with("mount").and_return(mock_shell_out(0, @mount, nil))
 
     @plugin.run
   end
@@ -57,56 +57,56 @@ MOUNT
   describe "df -P" do
 
     it "returns the filesystem block size" do
-      @plugin[:filesystem]["/dev/hd4"]['kb_size'].should == "786432"
+      expect(@plugin[:filesystem]["/dev/hd4"]['kb_size']).to eq("786432")
     end
 
     it "returns the filesystem used space in kb" do
-      @plugin[:filesystem]["/dev/hd4"]['kb_used'].should == "495632"
+      expect(@plugin[:filesystem]["/dev/hd4"]['kb_used']).to eq("495632")
     end
 
     it "returns the filesystem available space in kb" do
-      @plugin[:filesystem]["/dev/hd4"]['kb_available'].should == "290800"
+      expect(@plugin[:filesystem]["/dev/hd4"]['kb_available']).to eq("290800")
     end
 
     it "returns the filesystem capacity in percentage" do
-      @plugin[:filesystem]["/dev/hd4"]['percent_used'].should == "64%"
+      expect(@plugin[:filesystem]["/dev/hd4"]['percent_used']).to eq("64%")
     end
 
     it "returns the filesystem mounted location" do
-      @plugin[:filesystem]["/dev/hd4"]['mount'].should == "/"
+      expect(@plugin[:filesystem]["/dev/hd4"]['mount']).to eq("/")
     end
   end
 
   describe "mount" do
 
     it "returns the filesystem mount location" do
-      @plugin[:filesystem]["/dev/hd4"]['mount'].should == "/"
+      expect(@plugin[:filesystem]["/dev/hd4"]['mount']).to eq("/")
     end
 
     it "returns the filesystem type" do
-      @plugin[:filesystem]["/dev/hd4"]['fs_type'].should == "jfs2"
+      expect(@plugin[:filesystem]["/dev/hd4"]['fs_type']).to eq("jfs2")
     end
 
     it "returns the filesystem mount options" do
-      @plugin[:filesystem]["/dev/hd4"]['mount_options'].should == "rw,log=/dev/hd8"
+      expect(@plugin[:filesystem]["/dev/hd4"]['mount_options']).to eq("rw,log=/dev/hd8")
     end
 
     # For entries like 192.168.1.11 /stage/middleware /stage/middleware nfs3   Jul 17 13:24 ro,bg,hard,intr,sec=sys
     context "having node values" do
       before do
-        @plugin.stub(:shell_out).with("df -P").and_return(mock_shell_out(0, "192.168.1.11 /stage/middleware /stage/middleware nfs3   Jul 17 13:24 ro,bg,hard,intr,sec=sys", nil))
+        allow(@plugin).to receive(:shell_out).with("df -P").and_return(mock_shell_out(0, "192.168.1.11 /stage/middleware /stage/middleware nfs3   Jul 17 13:24 ro,bg,hard,intr,sec=sys", nil))
       end
 
       it "returns the filesystem mount location" do
-        @plugin[:filesystem]["192.168.1.11:/stage/middleware"]['mount'].should == "/stage/middleware"
+        expect(@plugin[:filesystem]["192.168.1.11:/stage/middleware"]['mount']).to eq("/stage/middleware")
       end
 
       it "returns the filesystem type" do
-        @plugin[:filesystem]["192.168.1.11:/stage/middleware"]['fs_type'].should == "nfs3"
+        expect(@plugin[:filesystem]["192.168.1.11:/stage/middleware"]['fs_type']).to eq("nfs3")
       end
 
       it "returns the filesystem mount options" do
-        @plugin[:filesystem]["192.168.1.11:/stage/middleware"]['mount_options'].should == "ro,bg,hard,intr,sec=sys"
+        expect(@plugin[:filesystem]["192.168.1.11:/stage/middleware"]['mount_options']).to eq("ro,bg,hard,intr,sec=sys")
       end
     end
   end

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

@@ -20,13 +20,13 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper.rb')
 describe Ohai::System, "Aix hostname plugin" do
   before(:each) do
     @plugin = get_plugin("hostname")
-    @plugin.stub(:collect_os).and_return(:aix)
-    @plugin.stub(:from_cmd).with("hostname").and_return("aix_admin")
+    allow(@plugin).to receive(:collect_os).and_return(:aix)
+    allow(@plugin).to receive(:from_cmd).with("hostname").and_return("aix_admin")
     @plugin.run
   end
 
   it "should set the machinename" do
-    @plugin[:machinename].should eql("aix_admin")
+    expect(@plugin[:machinename]).to eql("aix_admin")
   end
 end
 

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

@@ -20,36 +20,36 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper.rb')
 describe Ohai::System, "AIX kernel plugin" do
   before(:each) do
     @plugin = get_plugin("aix/kernel")
-    @plugin.stub(:collect_os).and_return(:aix)
-    @plugin.stub(:shell_out).with("uname -s").and_return(mock_shell_out(0, "AIX", nil))
-    @plugin.stub(:shell_out).with("uname -r").and_return(mock_shell_out(0, "1", nil))
-    @plugin.stub(:shell_out).with("uname -v").and_return(mock_shell_out(0, "6", nil))
-    @plugin.stub(:shell_out).with("uname -p").and_return(mock_shell_out(0, "powerpc", nil))
-    @plugin.stub(:shell_out).with("genkex -d").and_return(mock_shell_out(0, "    Text address     Size     Data address     Size File\nf1000000c0338000    77000 f1000000c0390000    1ec8c /usr/lib/drivers/cluster\n         6390000    20000          63a0000      ba8 /usr/lib/drivers/if_en", nil))
+    allow(@plugin).to receive(:collect_os).and_return(:aix)
+    allow(@plugin).to receive(:shell_out).with("uname -s").and_return(mock_shell_out(0, "AIX", nil))
+    allow(@plugin).to receive(:shell_out).with("uname -r").and_return(mock_shell_out(0, "1", nil))
+    allow(@plugin).to receive(:shell_out).with("uname -v").and_return(mock_shell_out(0, "6", nil))
+    allow(@plugin).to receive(:shell_out).with("uname -p").and_return(mock_shell_out(0, "powerpc", nil))
+    allow(@plugin).to receive(:shell_out).with("genkex -d").and_return(mock_shell_out(0, "    Text address     Size     Data address     Size File\nf1000000c0338000    77000 f1000000c0390000    1ec8c /usr/lib/drivers/cluster\n         6390000    20000          63a0000      ba8 /usr/lib/drivers/if_en", nil))
     @plugin.run
   end
 
   it "uname -s detects the name" do
-    @plugin[:kernel][:name].should == "aix"
+    expect(@plugin[:kernel][:name]).to eq("aix")
   end
 
   it "uname -r detects the release" do
-    @plugin[:kernel][:release].should == "1"
+    expect(@plugin[:kernel][:release]).to eq("1")
   end
 
   it "uname -v detects the version" do
-    @plugin[:kernel][:version].should == "6"
+    expect(@plugin[:kernel][:version]).to eq("6")
   end
 
   it "uname -p detects the machine" do
-    @plugin[:kernel][:machine].should == "powerpc"
+    expect(@plugin[:kernel][:machine]).to eq("powerpc")
   end
 
   it "detects the modules" do
-    @plugin[:kernel][:modules]["/usr/lib/drivers/cluster"]["text"].should == { "address" => "f1000000c0338000", "size" => "77000" }
-    @plugin[:kernel][:modules]["/usr/lib/drivers/cluster"]["data"].should == { "address" => "f1000000c0390000", "size" => "1ec8c" }
-    @plugin[:kernel][:modules]["/usr/lib/drivers/if_en"]["text"].should == { "address" => "6390000", "size" => "20000"}
-    @plugin[:kernel][:modules]["/usr/lib/drivers/if_en"]["data"].should == { "address" => "63a0000", "size" => "ba8"}
+    expect(@plugin[:kernel][:modules]["/usr/lib/drivers/cluster"]["text"]).to eq({ "address" => "f1000000c0338000", "size" => "77000" })
+    expect(@plugin[:kernel][:modules]["/usr/lib/drivers/cluster"]["data"]).to eq({ "address" => "f1000000c0390000", "size" => "1ec8c" })
+    expect(@plugin[:kernel][:modules]["/usr/lib/drivers/if_en"]["text"]).to eq({ "address" => "6390000", "size" => "20000"})
+    expect(@plugin[:kernel][:modules]["/usr/lib/drivers/if_en"]["data"]).to eq({ "address" => "63a0000", "size" => "ba8"})
 
   end
 end

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

@@ -64,15 +64,15 @@ There are 6 entries in the arp table.
 ARP_AN
 
     @plugin = get_plugin("aix/network")
-    @plugin.stub(:collect_os).and_return(:aix)
+    allow(@plugin).to receive(:collect_os).and_return(:aix)
     @plugin[:network] = Mash.new
-    @plugin.stub(:shell_out).with("netstat -rn |grep default").and_return(mock_shell_out(0, @netstat_rn_grep_default, nil))
-    @plugin.stub(:shell_out).with("lsdev -Cc if").and_return(mock_shell_out(0, @lsdev_Cc_if, nil))
-    @plugin.stub(:shell_out).with("ifconfig en0").and_return(mock_shell_out(0, @ifconfig_en0, nil))
-    @plugin.stub(:shell_out).with("entstat -d en0 | grep \"Hardware Address\"").and_return(mock_shell_out(0, "Hardware Address: be:42:80:00:b0:05", nil))
-    @plugin.stub(:shell_out).with("netstat -nrf inet").and_return(mock_shell_out(0, @netstat_nrf_inet, nil))
-    @plugin.stub(:shell_out).with("netstat -nrf inet6").and_return(mock_shell_out(0, "::1%1  ::1%1  UH 1 109392 en0  -  -", nil))
-    @plugin.stub(:shell_out).with("arp -an").and_return(mock_shell_out(0, @aix_arp_an, nil))
+    allow(@plugin).to receive(:shell_out).with("netstat -rn |grep default").and_return(mock_shell_out(0, @netstat_rn_grep_default, nil))
+    allow(@plugin).to receive(:shell_out).with("lsdev -Cc if").and_return(mock_shell_out(0, @lsdev_Cc_if, nil))
+    allow(@plugin).to receive(:shell_out).with("ifconfig en0").and_return(mock_shell_out(0, @ifconfig_en0, nil))
+    allow(@plugin).to receive(:shell_out).with("entstat -d en0 | grep \"Hardware Address\"").and_return(mock_shell_out(0, "Hardware Address: be:42:80:00:b0:05", nil))
+    allow(@plugin).to receive(:shell_out).with("netstat -nrf inet").and_return(mock_shell_out(0, @netstat_nrf_inet, nil))
+    allow(@plugin).to receive(:shell_out).with("netstat -nrf inet6").and_return(mock_shell_out(0, "::1%1  ::1%1  UH 1 109392 en0  -  -", nil))
+    allow(@plugin).to receive(:shell_out).with("arp -an").and_return(mock_shell_out(0, @aix_arp_an, nil))
   end
 
   describe "run" do
@@ -81,15 +81,15 @@ ARP_AN
     end
 
     it "detects network information" do
-      @plugin['network'].should_not be_nil
+      expect(@plugin['network']).not_to be_nil
     end
 
     it "detects the interfaces" do
-      @plugin['network']['interfaces'].keys.sort.should == ["en0"]
+      expect(@plugin['network']['interfaces'].keys.sort).to eq(["en0"])
     end
 
     it "detects the ip addresses of the interfaces" do
-      @plugin['network']['interfaces']['en0']['addresses'].keys.should include('172.29.174.58')
+      expect(@plugin['network']['interfaces']['en0']['addresses'].keys).to include('172.29.174.58')
     end
   end
 
@@ -99,34 +99,34 @@ ARP_AN
     end
 
     it "returns the default gateway of the system's network" do
-      @plugin[:network][:default_gateway].should == '172.31.8.1'
+      expect(@plugin[:network][:default_gateway]).to eq('172.31.8.1')
     end
 
     it "returns the default interface of the system's network" do
-      @plugin[:network][:default_interface].should == 'en0'
+      expect(@plugin[:network][:default_interface]).to eq('en0')
     end
   end
 
   describe "lsdev -Cc if" do
     it "detects the state of the interfaces in the system" do
       @plugin.run
-      @plugin['network']['interfaces']['en0'][:state].should == "up"
+      expect(@plugin['network']['interfaces']['en0'][:state]).to eq("up")
     end
 
     it "detects the description of the interfaces in the system" do
       @plugin.run
-      @plugin['network']['interfaces']['en0'][:description].should == "Standard Ethernet Network Interface"
+      expect(@plugin['network']['interfaces']['en0'][:description]).to eq("Standard Ethernet Network Interface")
     end
 
     describe "ifconfig interface" do
       it "detects the CHAIN network flag" do
         @plugin.run
-        @plugin['network']['interfaces']['en0'][:flags].should include('CHAIN')
+        expect(@plugin['network']['interfaces']['en0'][:flags]).to include('CHAIN')
       end
 
       it "detects the metric network flag" do
         @plugin.run
-        @plugin['network']['interfaces']['en0'][:metric].should == '1'
+        expect(@plugin['network']['interfaces']['en0'][:metric]).to eq('1')
       end
 
       context "inet entries" do
@@ -136,54 +136,54 @@ ARP_AN
         end
 
         it "detects the family" do
-          @inet_entry[:family].should == 'inet'
+          expect(@inet_entry[:family]).to eq('inet')
         end
 
         it "detects the netmask" do
-          @inet_entry[:netmask].should == '255.255.192.0'
+          expect(@inet_entry[:netmask]).to eq('255.255.192.0')
         end
 
         it "detects the broadcast" do
-          @inet_entry[:broadcast].should == '172.29.191.255'
+          expect(@inet_entry[:broadcast]).to eq('172.29.191.255')
         end
 
         it "detects all key-values" do
-          @plugin['network']['interfaces']['en0'][:tcp_sendspace].should == "262144"
-          @plugin['network']['interfaces']['en0'][:tcp_recvspace].should == "262144"
-          @plugin['network']['interfaces']['en0'][:rfc1323].should == "1"
+          expect(@plugin['network']['interfaces']['en0'][:tcp_sendspace]).to eq("262144")
+          expect(@plugin['network']['interfaces']['en0'][:tcp_recvspace]).to eq("262144")
+          expect(@plugin['network']['interfaces']['en0'][:rfc1323]).to eq("1")
         end
 
         # For an output with no netmask like inet 172.29.174.59 broadcast 172.29.191.255
         context "with no netmask in the output" do
           before do
-            @plugin.stub(:shell_out).with("ifconfig en0").and_return(mock_shell_out(0, "inet 172.29.174.59 broadcast 172.29.191.255", nil))
+            allow(@plugin).to receive(:shell_out).with("ifconfig en0").and_return(mock_shell_out(0, "inet 172.29.174.59 broadcast 172.29.191.255", nil))
           end
 
           it "detects the default prefixlen" do
             @inet_entry = @plugin['network']['interfaces']['en0'][:addresses]["172.29.174.59"]
-            @inet_entry[:prefixlen].should == '32'
+            expect(@inet_entry[:prefixlen]).to eq('32')
           end
 
           it "detects the default netmask" do
             @inet_entry = @plugin['network']['interfaces']['en0'][:addresses]["172.29.174.59"]
-            @inet_entry[:netmask].should == '255.255.255.255'
+            expect(@inet_entry[:netmask]).to eq('255.255.255.255')
           end
         end
       end
 
       context "inet6 entries" do
         before do
-          @plugin.stub(:shell_out).with("ifconfig en0").and_return(mock_shell_out(0, "inet6 ::1%1/0", nil))
+          allow(@plugin).to receive(:shell_out).with("ifconfig en0").and_return(mock_shell_out(0, "inet6 ::1%1/0", nil))
           @plugin.run
           @inet_entry = @plugin['network']['interfaces']['en0'][:addresses]["::1"]
         end
 
         it "detects the prefixlen" do
-          @inet_entry[:prefixlen].should == '0'
+          expect(@inet_entry[:prefixlen]).to eq('0')
         end
 
         it "detects the family" do
-          @inet_entry[:family].should == 'inet6'
+          expect(@inet_entry[:family]).to eq('inet6')
         end
       end
     end
@@ -194,7 +194,7 @@ ARP_AN
         @inet_interface_addresses = @plugin['network']['interfaces']['en0'][:addresses]["BE:42:80:00:B0:05"]
       end
       it "detects the family" do
-        @inet_interface_addresses[:family].should == 'lladdr'
+        expect(@inet_interface_addresses[:family]).to eq('lladdr')
       end
     end
   end
@@ -206,39 +206,39 @@ ARP_AN
 
     context "inet" do
       it "detects the route destinations" do
-        @plugin['network']['interfaces']['en0'][:routes][0][:destination].should == "default"
-        @plugin['network']['interfaces']['en0'][:routes][1][:destination].should == "172.29.128.0"
+        expect(@plugin['network']['interfaces']['en0'][:routes][0][:destination]).to eq("default")
+        expect(@plugin['network']['interfaces']['en0'][:routes][1][:destination]).to eq("172.29.128.0")
       end
 
       it "detects the route family" do
-        @plugin['network']['interfaces']['en0'][:routes][0][:family].should == "inet"
+        expect(@plugin['network']['interfaces']['en0'][:routes][0][:family]).to eq("inet")
       end
 
       it "detects the route gateway" do
-        @plugin['network']['interfaces']['en0'][:routes][0][:via].should == "172.29.128.13"
+        expect(@plugin['network']['interfaces']['en0'][:routes][0][:via]).to eq("172.29.128.13")
       end
 
       it "detects the route flags" do
-        @plugin['network']['interfaces']['en0'][:routes][0][:flags].should == "UG"
+        expect(@plugin['network']['interfaces']['en0'][:routes][0][:flags]).to eq("UG")
       end
     end
 
     context "inet6" do
 
       it "detects the route destinations" do
-        @plugin['network']['interfaces']['en0'][:routes][4][:destination].should == "::1%1"
+        expect(@plugin['network']['interfaces']['en0'][:routes][4][:destination]).to eq("::1%1")
       end
 
       it "detects the route family" do
-        @plugin['network']['interfaces']['en0'][:routes][4][:family].should == "inet6"
+        expect(@plugin['network']['interfaces']['en0'][:routes][4][:family]).to eq("inet6")
       end
 
       it "detects the route gateway" do
-        @plugin['network']['interfaces']['en0'][:routes][4][:via].should == "::1%1"
+        expect(@plugin['network']['interfaces']['en0'][:routes][4][:via]).to eq("::1%1")
       end
 
       it "detects the route flags" do
-        @plugin['network']['interfaces']['en0'][:routes][4][:flags].should == "UH"
+        expect(@plugin['network']['interfaces']['en0'][:routes][4][:flags]).to eq("UH")
       end
     end
   end
@@ -248,15 +248,15 @@ ARP_AN
       @plugin.run
     end
     it "supresses the hostname entries" do
-      @plugin['network']['arp'][0][:remote_host].should == "?"
+      expect(@plugin['network']['arp'][0][:remote_host]).to eq("?")
     end
 
     it "detects the remote ip entry" do
-      @plugin['network']['arp'][0][:remote_ip].should == "172.29.131.16"
+      expect(@plugin['network']['arp'][0][:remote_ip]).to eq("172.29.131.16")
     end
 
     it "detects the remote mac entry" do
-      @plugin['network']['arp'][0][:remote_mac].should == "6e:87:70:0:40:3"
+      expect(@plugin['network']['arp'][0][:remote_mac]).to eq("6e:87:70:0:40:3")
     end
   end
 
@@ -265,7 +265,7 @@ ARP_AN
       @plugin.run
     end
     it "converts a netmask from hexadecimal form to decimal form" do
-      @plugin.hex_to_dec_netmask('0xffff0000').should == "255.255.0.0"
+      expect(@plugin.hex_to_dec_netmask('0xffff0000')).to eq("255.255.0.0")
     end
   end
 end