ohai 7.6.0.rc.1 → 8.0.1

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

@@ -22,10 +22,10 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper.rb')
 describe Ohai::System, "Linux hostname plugin" do
   before(:each) do
     @plugin = get_plugin("hostname")
-    @plugin.stub(:collect_os).and_return(:linux)
-    @plugin.stub(:shell_out).with("hostname -s").and_return(mock_shell_out(0, "katie", ""))
-    @plugin.stub(:shell_out).with("hostname --fqdn").and_return(mock_shell_out(0, "katie.bethell", ""))
-    @plugin.stub(:shell_out).with("hostname").and_return(mock_shell_out(0, "katie.local", ""))
+    allow(@plugin).to receive(:collect_os).and_return(:linux)
+    allow(@plugin).to receive(:shell_out).with("hostname -s").and_return(mock_shell_out(0, "katie", ""))
+    allow(@plugin).to receive(:shell_out).with("hostname --fqdn").and_return(mock_shell_out(0, "katie.bethell", ""))
+    allow(@plugin).to receive(:shell_out).with("hostname").and_return(mock_shell_out(0, "katie.local", ""))
   end
 
   it_should_check_from("linux::hostname", "hostname", "hostname -s", "katie")
@@ -36,16 +36,16 @@ describe Ohai::System, "Linux hostname plugin" do
 
   describe "when domain name is unset" do
     before(:each) do
-      @plugin.should_receive(:shell_out).with("hostname --fqdn").and_raise("Ohai::Exception::Exec")
+      expect(@plugin).to receive(:shell_out).with("hostname --fqdn").and_raise("Ohai::Exception::Exec")
     end
 
     it "should not raise an error" do
-      lambda { @plugin.run }.should_not raise_error
+      expect { @plugin.run }.not_to raise_error
     end
 
     it "should not set fqdn" do
       @plugin.run
-      @plugin.fqdn.should == nil
+      expect(@plugin.fqdn).to eq(nil)
     end
 
   end

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

@@ -32,11 +32,11 @@ virtio_balloon         13168  0
 floppy                 55441  0
 ENV_LSMOD
     @plugin = get_plugin("kernel")
-    @plugin.stub(:collect_os).and_return(:linux)
-    @plugin.stub(:init_kernel).and_return({})
-    @plugin.stub(:shell_out).with("uname -o").and_return(mock_shell_out(0, "Linux", ""))
-    @plugin.stub(:shell_out).with("env lsmod").and_return(mock_shell_out(0, @env_lsmod, ""))
-    @plugin.should_receive(:shell_out).with("env lsmod").at_least(1).times
+    allow(@plugin).to receive(:collect_os).and_return(:linux)
+    allow(@plugin).to receive(:init_kernel).and_return({})
+    allow(@plugin).to receive(:shell_out).with("uname -o").and_return(mock_shell_out(0, "Linux", ""))
+    allow(@plugin).to receive(:shell_out).with("env lsmod").and_return(mock_shell_out(0, @env_lsmod, ""))
+    expect(@plugin).to receive(:shell_out).with("env lsmod").at_least(1).times
     @plugin.run
   end
 

data/spec/unit/plugins/linux/lsb_spec.rb

@@ -24,46 +24,46 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper.rb')
 describe Ohai::System, "Linux lsb plugin" do
   before(:each) do
     @plugin = get_plugin("linux/lsb")
-    @plugin.stub(:collect_os).and_return(:linux)
+    allow(@plugin).to receive(:collect_os).and_return(:linux)
   end
 
   describe "on systems with /etc/lsb-release" do
     before(:each) do
       @double_file = double("/etc/lsb-release")
-      @double_file.stub(:each).
+      allow(@double_file).to receive(:each).
         and_yield("DISTRIB_ID=Ubuntu").
         and_yield("DISTRIB_RELEASE=8.04").
         and_yield("DISTRIB_CODENAME=hardy").
         and_yield('DISTRIB_DESCRIPTION="Ubuntu 8.04"')
-      File.stub(:open).with("/etc/lsb-release").and_return(@double_file) 
-      File.stub(:exists?).with("/etc/lsb-release").and_return(true)
+      allow(File).to receive(:open).with("/etc/lsb-release").and_return(@double_file) 
+      allow(File).to receive(:exists?).with("/etc/lsb-release").and_return(true)
     end
 
     it "should set lsb[:id]" do
       @plugin.run
-      @plugin[:lsb][:id].should == "Ubuntu"
+      expect(@plugin[:lsb][:id]).to eq("Ubuntu")
     end
   
     it "should set lsb[:release]" do
       @plugin.run
-      @plugin[:lsb][:release].should == "8.04"
+      expect(@plugin[:lsb][:release]).to eq("8.04")
     end
   
     it "should set lsb[:codename]" do
       @plugin.run
-      @plugin[:lsb][:codename].should == "hardy"
+      expect(@plugin[:lsb][:codename]).to eq("hardy")
     end
   
     it "should set lsb[:description]" do
       @plugin.run
-      @plugin[:lsb][:description].should == "Ubuntu 8.04"
+      expect(@plugin[:lsb][:description]).to eq("Ubuntu 8.04")
     end
   end
 
   describe "on systems with /usr/bin/lsb_release" do
     before(:each) do
-      File.stub(:exists?).with("/etc/lsb-release").and_return(false)
-      File.stub(:exists?).with("/usr/bin/lsb_release").and_return(true)
+      allow(File).to receive(:exists?).with("/etc/lsb-release").and_return(false)
+      allow(File).to receive(:exists?).with("/usr/bin/lsb_release").and_return(true)
   
       @stdin = double("STDIN", { :close => true })
       @pid = 10
@@ -82,27 +82,27 @@ Description:  CentOS release 5.4 (Final)
 Release:  5.4
 Codename: Final
 LSB_RELEASE
-        @plugin.stub(:shell_out).with("lsb_release -a").and_return(mock_shell_out(0, @stdout, ""))
+        allow(@plugin).to receive(:shell_out).with("lsb_release -a").and_return(mock_shell_out(0, @stdout, ""))
       end
 
       it "should set lsb[:id]" do
         @plugin.run
-        @plugin[:lsb][:id].should == "CentOS"
+        expect(@plugin[:lsb][:id]).to eq("CentOS")
       end
     
       it "should set lsb[:release]" do
         @plugin.run
-        @plugin[:lsb][:release].should == "5.4"
+        expect(@plugin[:lsb][:release]).to eq("5.4")
       end
     
       it "should set lsb[:codename]" do
         @plugin.run
-        @plugin[:lsb][:codename].should == "Final"
+        expect(@plugin[:lsb][:codename]).to eq("Final")
       end
     
       it "should set lsb[:description]" do
         @plugin.run
-        @plugin[:lsb][:description].should == "CentOS release 5.4 (Final)"
+        expect(@plugin[:lsb][:description]).to eq("CentOS release 5.4 (Final)")
       end
     end
 
@@ -115,34 +115,34 @@ Description:    Fedora release 14 (Laughlin)
 Release:        14
 Codename:       Laughlin
 LSB_RELEASE
-        @plugin.stub(:shell_out).with("lsb_release -a").and_return(mock_shell_out(0, @stdout, ""))
+        allow(@plugin).to receive(:shell_out).with("lsb_release -a").and_return(mock_shell_out(0, @stdout, ""))
       end
   
       it "should set lsb[:id]" do
         @plugin.run
-        @plugin[:lsb][:id].should == "Fedora"
+        expect(@plugin[:lsb][:id]).to eq("Fedora")
       end
     
       it "should set lsb[:release]" do
         @plugin.run
-        @plugin[:lsb][:release].should == "14"
+        expect(@plugin[:lsb][:release]).to eq("14")
       end
     
       it "should set lsb[:codename]" do
         @plugin.run
-        @plugin[:lsb][:codename].should == "Laughlin"
+        expect(@plugin[:lsb][:codename]).to eq("Laughlin")
       end
     
       it "should set lsb[:description]" do
         @plugin.run
-        @plugin[:lsb][:description].should == "Fedora release 14 (Laughlin)"
+        expect(@plugin[:lsb][:description]).to eq("Fedora release 14 (Laughlin)")
       end
     end
   end
 
   it "should not set any lsb values if /etc/lsb-release or /usr/bin/lsb_release do not exist " do
-    File.stub(:exists?).with("/etc/lsb-release").and_return(false)
-    File.stub(:exists?).with("/usr/bin/lsb_release").and_return(false)
-    @plugin.attribute?(:lsb).should be(false)
+    allow(File).to receive(:exists?).with("/etc/lsb-release").and_return(false)
+    allow(File).to receive(:exists?).with("/usr/bin/lsb_release").and_return(false)
+    expect(@plugin.attribute?(:lsb)).to be(false)
   end
 end

data/spec/unit/plugins/linux/mdadm_spec.rb

@@ -54,48 +54,48 @@ Working Devices : 6
        5       8      112        5      active sync   /dev/sdh
 MD
     @plugin = get_plugin("linux/mdadm")
-    @plugin.stub(:collect_os).and_return(:linux)
+    allow(@plugin).to receive(:collect_os).and_return(:linux)
     @double_file = double("/proc/mdstat")
-    @double_file.stub(:each).
+    allow(@double_file).to receive(:each).
     and_yield("Personalities : [raid1] [raid6] [raid5] [raid4] [linear] [multipath] [raid0] [raid10]").
     and_yield("md0 : active raid10 sdh[5] sdg[4] sdf[3] sde[2] sdd[1] sdc[0]").
     and_yield("      2929893888 blocks super 1.2 256K chunks 2 near-copies [6/6] [UUUUUU]")
-    File.stub(:open).with("/proc/mdstat").and_return(@double_file)
-    File.stub(:exist?).with("/proc/mdstat").and_return(true)
-    @plugin.stub(:shell_out).with("mdadm --detail /dev/md0").and_return(mock_shell_out(0, @md0, ""))
+    allow(File).to receive(:open).with("/proc/mdstat").and_return(@double_file)
+    allow(File).to receive(:exist?).with("/proc/mdstat").and_return(true)
+    allow(@plugin).to receive(:shell_out).with("mdadm --detail /dev/md0").and_return(mock_shell_out(0, @md0, ""))
   end
 
   describe "gathering Mdadm information via /proc/mdstat and mdadm" do
 
     it "should not raise an error" do
-      lambda { @plugin.run }.should_not raise_error
+      expect { @plugin.run }.not_to raise_error
     end
 
     it "should detect raid level" do
       @plugin.run
-      @plugin[:mdadm][:md0][:level].should == 10
+      expect(@plugin[:mdadm][:md0][:level]).to eq(10)
     end
 
     it "should detect raid state" do
       @plugin.run
-      @plugin[:mdadm][:md0][:state].should == "clean"
+      expect(@plugin[:mdadm][:md0][:state]).to eq("clean")
     end
 
     it "should detect raid size" do
       @plugin.run
-      @plugin[:mdadm][:md0][:size].should == 2794.16
+      expect(@plugin[:mdadm][:md0][:size]).to eq(2794.16)
     end
 
     it "should detect raid metadata level" do
       @plugin.run
-      @plugin[:mdadm][:md0][:version].should == 1.2
+      expect(@plugin[:mdadm][:md0][:version]).to eq(1.2)
     end
 
     device_counts = { :raid => 6, :total => 6, :active => 6, :working => 6, :failed => 0, :spare => 0 }
     device_counts.each_pair do |item, expected_value|
       it "should detect device count of \"#{item}\"" do
         @plugin.run
-        @plugin[:mdadm][:md0][:device_counts][item].should == expected_value
+        expect(@plugin[:mdadm][:md0][:device_counts][item]).to eq(expected_value)
       end
     end
 

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

@@ -23,20 +23,20 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper.rb')
 describe Ohai::System, "Linux plugin platform" do
   before(:each) do
     @plugin = get_plugin("linux/platform")
-    @plugin.stub(:collect_os).and_return(:linux)
+    allow(@plugin).to receive(:collect_os).and_return(:linux)
     @plugin[:lsb] = Mash.new
-    File.stub(:exists?).with("/etc/debian_version").and_return(false)
-    File.stub(:exists?).with("/etc/redhat-release").and_return(false)
-    File.stub(:exists?).with("/etc/gentoo-release").and_return(false)
-    File.stub(:exists?).with("/etc/exherbo-release").and_return(false)
-    File.stub(:exists?).with("/etc/SuSE-release").and_return(false)
-    File.stub(:exists?).with("/etc/arch-release").and_return(false)
-    File.stub(:exists?).with("/etc/system-release").and_return(false)
-    File.stub(:exists?).with("/etc/slackware-version").and_return(false)
-    File.stub(:exists?).with("/etc/enterprise-release").and_return(false)
-    File.stub(:exists?).with("/etc/oracle-release").and_return(false)
-    File.stub(:exists?).with("/etc/parallels-release").and_return(false)
-    File.stub(:exists?).with("/usr/bin/raspi-config").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/debian_version").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/redhat-release").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/gentoo-release").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/exherbo-release").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/SuSE-release").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/arch-release").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/system-release").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/slackware-version").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/enterprise-release").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/oracle-release").and_return(false)
+    allow(File).to receive(:exists?).with("/etc/parallels-release").and_return(false)
+    allow(File).to receive(:exists?).with("/usr/bin/raspi-config").and_return(false)
   end
 
   describe "on lsb compliant distributions" do
@@ -47,83 +47,83 @@ describe Ohai::System, "Linux plugin platform" do
 
     it "should set platform to lowercased lsb[:id]" do
       @plugin.run
-      @plugin[:platform].should == "ubuntu"
+      expect(@plugin[:platform]).to eq("ubuntu")
     end
 
     it "should set platform_version to lsb[:release]" do
       @plugin.run
-      @plugin[:platform_version].should == "8.04"
+      expect(@plugin[:platform_version]).to eq("8.04")
     end
 
     it "should set platform to ubuntu and platform_family to debian [:lsb][:id] contains Ubuntu" do
       @plugin[:lsb][:id] = "Ubuntu"
       @plugin.run
-      @plugin[:platform].should == "ubuntu"
-      @plugin[:platform_family].should == "debian"
+      expect(@plugin[:platform]).to eq("ubuntu")
+      expect(@plugin[:platform_family]).to eq("debian")
     end
 
     it "should set platform to linuxmint and platform_family to debian [:lsb][:id] contains LinuxMint" do
       @plugin[:lsb][:id] = "LinuxMint"
       @plugin.run
-      @plugin[:platform].should == "linuxmint"
-      @plugin[:platform_family].should == "debian"
+      expect(@plugin[:platform]).to eq("linuxmint")
+      expect(@plugin[:platform_family]).to eq("debian")
     end
 
     it "should set platform to debian and platform_family to debian [:lsb][:id] contains Debian" do
       @plugin[:lsb][:id] = "Debian"
       @plugin.run
-      @plugin[:platform].should == "debian"
-      @plugin[:platform_family].should == "debian"
+      expect(@plugin[:platform]).to eq("debian")
+      expect(@plugin[:platform_family]).to eq("debian")
     end
 
     it "should set platform to redhat and platform_family to rhel when [:lsb][:id] contains Redhat" do
       @plugin[:lsb][:id] = "RedHatEnterpriseServer"
       @plugin[:lsb][:release] = "5.7"
       @plugin.run
-      @plugin[:platform].should == "redhat"
-      @plugin[:platform_family].should == "rhel"
+      expect(@plugin[:platform]).to eq("redhat")
+      expect(@plugin[:platform_family]).to eq("rhel")
     end
 
     it "should set platform to amazon and platform_family to rhel when [:lsb][:id] contains Amazon" do
       @plugin[:lsb][:id] = "AmazonAMI"
       @plugin[:lsb][:release] = "2011.09"
       @plugin.run
-      @plugin[:platform].should == "amazon"
-      @plugin[:platform_family].should == "rhel"
+      expect(@plugin[:platform]).to eq("amazon")
+      expect(@plugin[:platform_family]).to eq("rhel")
     end
 
     it "should set platform to scientific when [:lsb][:id] contains ScientificSL" do
       @plugin[:lsb][:id] = "ScientificSL"
       @plugin[:lsb][:release] = "5.7"
       @plugin.run
-      @plugin[:platform].should == "scientific"
+      expect(@plugin[:platform]).to eq("scientific")
     end
 
     it "should set platform to ibm_powerkvm and platform_family to rhel when [:lsb][:id] contains IBM_PowerKVM" do
       @plugin[:lsb][:id] = "IBM_PowerKVM"
       @plugin[:lsb][:release] = "2.1"
       @plugin.run
-      @plugin[:platform].should == "ibm_powerkvm"
-      @plugin[:platform_family].should == "rhel"
+      expect(@plugin[:platform]).to eq("ibm_powerkvm")
+      expect(@plugin[:platform_family]).to eq("rhel")
     end
   end
 
   describe "on debian" do
     before(:each) do
       @plugin.lsb = nil
-      File.should_receive(:exists?).with("/etc/debian_version").and_return(true)
+      expect(File).to receive(:exists?).with("/etc/debian_version").and_return(true)
     end
 
     it "should read the version from /etc/debian_version" do
-      File.should_receive(:read).with("/etc/debian_version").and_return("5.0")
+      expect(File).to receive(:read).with("/etc/debian_version").and_return("5.0")
       @plugin.run
-      @plugin[:platform_version].should == "5.0"
+      expect(@plugin[:platform_version]).to eq("5.0")
     end
 
     it "should correctly strip any newlines" do
-      File.should_receive(:read).with("/etc/debian_version").and_return("5.0\n")
+      expect(File).to receive(:read).with("/etc/debian_version").and_return("5.0\n")
       @plugin.run
-      @plugin[:platform_version].should == "5.0"
+      expect(@plugin[:platform_version]).to eq("5.0")
     end
 
     # Ubuntu has /etc/debian_version as well
@@ -131,43 +131,43 @@ describe Ohai::System, "Linux plugin platform" do
       @plugin[:lsb][:id] = "Ubuntu"
       @plugin[:lsb][:release] = "8.04"
       @plugin.run
-      @plugin[:platform].should == "ubuntu"
+      expect(@plugin[:platform]).to eq("ubuntu")
     end
 
     # Raspbian is a debian clone
     it "should detect Raspbian as itself with debian as the family" do
-      File.should_receive(:exists?).with("/usr/bin/raspi-config").and_return(true)
-      File.should_receive(:read).with("/etc/debian_version").and_return("wheezy/sid")
+      expect(File).to receive(:exists?).with("/usr/bin/raspi-config").and_return(true)
+      expect(File).to receive(:read).with("/etc/debian_version").and_return("wheezy/sid")
       @plugin.run
-      @plugin[:platform].should == "raspbian"
-      @plugin[:platform_family].should == "debian"
+      expect(@plugin[:platform]).to eq("raspbian")
+      expect(@plugin[:platform_family]).to eq("debian")
     end
   end
 
   describe "on slackware" do
     before(:each) do
       @plugin.lsb = nil
-      File.should_receive(:exists?).with("/etc/slackware-version").and_return(true)
+      expect(File).to receive(:exists?).with("/etc/slackware-version").and_return(true)
     end
 
     it "should set platform and platform_family to slackware" do
-      File.should_receive(:read).with("/etc/slackware-version").and_return("Slackware 12.0.0")
+      expect(File).to receive(:read).with("/etc/slackware-version").and_return("Slackware 12.0.0")
       @plugin.run
-      @plugin[:platform].should == "slackware"
-      @plugin[:platform_family].should == "slackware"
+      expect(@plugin[:platform]).to eq("slackware")
+      expect(@plugin[:platform_family]).to eq("slackware")
     end
   end
 
   describe "on arch" do
     before(:each) do
       @plugin.lsb = nil
-      File.should_receive(:exists?).with("/etc/arch-release").and_return(true)
+      expect(File).to receive(:exists?).with("/etc/arch-release").and_return(true)
     end
 
     it "should set platform to arch and platform_family to arch" do
       @plugin.run
-      @plugin[:platform].should == "arch"
-      @plugin[:platform_family].should == "arch"
+      expect(@plugin[:platform]).to eq("arch")
+      expect(@plugin[:platform_family]).to eq("arch")
     end
 
   end
@@ -175,27 +175,27 @@ describe Ohai::System, "Linux plugin platform" do
   describe "on gentoo" do
     before(:each) do
       @plugin.lsb = nil
-      File.should_receive(:exists?).with("/etc/gentoo-release").and_return(true)
+      expect(File).to receive(:exists?).with("/etc/gentoo-release").and_return(true)
     end
 
     it "should set platform and platform_family to gentoo" do
-      File.should_receive(:read).with("/etc/gentoo-release").and_return("Gentoo Base System release 1.20.1.1")
+      expect(File).to receive(:read).with("/etc/gentoo-release").and_return("Gentoo Base System release 1.20.1.1")
       @plugin.run
-      @plugin[:platform].should == "gentoo"
-      @plugin[:platform_family].should == "gentoo"
+      expect(@plugin[:platform]).to eq("gentoo")
+      expect(@plugin[:platform_family]).to eq("gentoo")
     end
   end
 
   describe "on exherbo" do
     before(:each) do
       @plugin.lsb = nil
-      File.should_receive(:exists?).with("/etc/exherbo-release").and_return(true)
+      expect(File).to receive(:exists?).with("/etc/exherbo-release").and_return(true)
     end
 
     it "should set platform and platform_family to exherbo" do
       @plugin.run
-      @plugin[:platform].should == "exherbo"
-      @plugin[:platform_family].should == "exherbo"
+      expect(@plugin[:platform]).to eq("exherbo")
+      expect(@plugin[:platform_family]).to eq("exherbo")
     end
   end
 
@@ -205,96 +205,96 @@ describe Ohai::System, "Linux plugin platform" do
         @plugin[:lsb][:id] = "RedHatEnterpriseServer"
         @plugin[:lsb][:release] = "6.1"
         @plugin.run
-        @plugin[:platform].should == "redhat"
-        @plugin[:platform_version].should == "6.1"
-        @plugin[:platform_family].should == "rhel"
+        expect(@plugin[:platform]).to eq("redhat")
+        expect(@plugin[:platform_version]).to eq("6.1")
+        expect(@plugin[:platform_family]).to eq("rhel")
       end
 
       it "should set the platform to centos and platform_family to rhel" do
         @plugin[:lsb][:id] = "CentOS"
         @plugin[:lsb][:release] = "5.4"
         @plugin.run
-        @plugin[:platform].should == "centos"
-        @plugin[:platform_version].should == "5.4"
-        @plugin[:platform_family].should == "rhel"
+        expect(@plugin[:platform]).to eq("centos")
+        expect(@plugin[:platform_version]).to eq("5.4")
+        expect(@plugin[:platform_family]).to eq("rhel")
       end
 
       it "should set the platform_family to rhel if the LSB name is oracle-ish" do
         @plugin[:lsb][:id] = "EnterpriseEnterpriseServer"
         @plugin.run
-        @plugin[:platform_family].should == "rhel"
+        expect(@plugin[:platform_family]).to eq("rhel")
       end
 
       it "should set the platform_family to rhel if the LSB name is amazon-ish" do
         @plugin[:lsb][:id] = "Amazon"
         @plugin.run
-        @plugin[:platform_family].should == "rhel"
+        expect(@plugin[:platform_family]).to eq("rhel")
       end
 
       it "should set the platform_family to fedora if the LSB name is fedora-ish" do
         @plugin[:lsb][:id] = "Fedora"
         @plugin.run
-        @plugin[:platform_family].should == "fedora"
+        expect(@plugin[:platform_family]).to eq("fedora")
       end
 
       it "should set the platform_family to redhat if the LSB name is scientific-ish" do
         @plugin[:lsb][:id] = "Scientific"
         @plugin.run
-        @plugin[:platform_family].should == "rhel"
+        expect(@plugin[:platform_family]).to eq("rhel")
       end
 
       it "should set the platform_family to redhat if the LSB name is ibm-ish" do
         @plugin[:lsb][:id] = "IBM_PowerKVM"
         @plugin.run
-        @plugin[:platform_family].should == "rhel"
+        expect(@plugin[:platform_family]).to eq("rhel")
       end
     end
 
     describe "without lsb_release results" do
       before(:each) do
         @plugin.lsb = nil
-        File.should_receive(:exists?).with("/etc/redhat-release").and_return(true)
+        expect(File).to receive(:exists?).with("/etc/redhat-release").and_return(true)
       end
 
       it "should read the platform as centos and version as 5.3" do
-        File.should_receive(:read).with("/etc/redhat-release").and_return("CentOS release 5.3")
+        expect(File).to receive(:read).with("/etc/redhat-release").and_return("CentOS release 5.3")
         @plugin.run
-        @plugin[:platform].should == "centos"
+        expect(@plugin[:platform]).to eq("centos")
       end
 
       it "may be that someone munged Red Hat to be RedHat" do
-        File.should_receive(:read).with("/etc/redhat-release").and_return("RedHat release 5.3")
+        expect(File).to receive(:read).with("/etc/redhat-release").and_return("RedHat release 5.3")
         @plugin.run
-        @plugin[:platform].should == "redhat"
-        @plugin[:platform_version].should == "5.3"
+        expect(@plugin[:platform]).to eq("redhat")
+        expect(@plugin[:platform_version]).to eq("5.3")
       end
 
       it "should read the platform as redhat and version as 5.3" do
-        File.should_receive(:read).with("/etc/redhat-release").and_return("Red Hat release 5.3")
+        expect(File).to receive(:read).with("/etc/redhat-release").and_return("Red Hat release 5.3")
         @plugin.run
-        @plugin[:platform].should == "redhat"
-        @plugin[:platform_version].should == "5.3"
+        expect(@plugin[:platform]).to eq("redhat")
+        expect(@plugin[:platform_version]).to eq("5.3")
       end
 
       it "should read the platform as fedora and version as 13 (rawhide)" do
-        File.should_receive(:read).with("/etc/redhat-release").and_return("Fedora release 13 (Rawhide)")
+        expect(File).to receive(:read).with("/etc/redhat-release").and_return("Fedora release 13 (Rawhide)")
         @plugin.run
-        @plugin[:platform].should == "fedora"
-        @plugin[:platform_version].should == "13 (rawhide)"
+        expect(@plugin[:platform]).to eq("fedora")
+        expect(@plugin[:platform_version]).to eq("13 (rawhide)")
       end
 
       it "should read the platform as fedora and version as 10" do
-        File.should_receive(:read).with("/etc/redhat-release").and_return("Fedora release 10")
+        expect(File).to receive(:read).with("/etc/redhat-release").and_return("Fedora release 10")
         @plugin.run
-        @plugin[:platform].should == "fedora"
-        @plugin[:platform_version].should == "10"
+        expect(@plugin[:platform]).to eq("fedora")
+        expect(@plugin[:platform_version]).to eq("10")
       end
 
       it "should read the platform as fedora and version as 13 using to_i" do
-        File.should_receive(:read).with("/etc/redhat-release").and_return("Fedora release 13 (Rawhide)")
+        expect(File).to receive(:read).with("/etc/redhat-release").and_return("Fedora release 13 (Rawhide)")
         @plugin.run
-        @plugin[:platform].should == "fedora"
-        @plugin[:platform_version].to_i.should == 13
+        expect(@plugin[:platform]).to eq("fedora")
+        expect(@plugin[:platform_version].to_i).to eq(13)
       end
 
     end
@@ -305,14 +305,14 @@ describe Ohai::System, "Linux plugin platform" do
       it "should read the platform as parallels and version as 6.0.5" do
         @plugin[:lsb][:id] = "CloudLinuxServer"
         @plugin[:lsb][:release] = "6.5"
-        File.stub(:exists?).with("/etc/redhat-release").and_return(true)
-        File.stub(:read).with("/etc/redhat-release").and_return("CloudLinux Server release 6.5 (Pavel Popovich)")
-        File.should_receive(:exists?).with("/etc/parallels-release").and_return(true)
-        File.should_receive(:read).with("/etc/parallels-release").and_return("Parallels Cloud Server 6.0.5 (20007)")
+        allow(File).to receive(:exists?).with("/etc/redhat-release").and_return(true)
+        allow(File).to receive(:read).with("/etc/redhat-release").and_return("CloudLinux Server release 6.5 (Pavel Popovich)")
+        expect(File).to receive(:exists?).with("/etc/parallels-release").and_return(true)
+        expect(File).to receive(:read).with("/etc/parallels-release").and_return("Parallels Cloud Server 6.0.5 (20007)")
         @plugin.run
-        @plugin[:platform].should == "parallels"
-        @plugin[:platform_version].should == "6.0.5"
-        @plugin[:platform_family].should == "rhel"
+        expect(@plugin[:platform]).to eq("parallels")
+        expect(@plugin[:platform_version]).to eq("6.0.5")
+        expect(@plugin[:platform_family]).to eq("rhel")
       end
     end
 
@@ -322,14 +322,14 @@ describe Ohai::System, "Linux plugin platform" do
       end
 
       it "should read the platform as parallels and version as 6.0.5" do
-        File.stub(:exists?).with("/etc/redhat-release").and_return(true)
-        File.stub(:read).with("/etc/redhat-release").and_return("CloudLinux Server release 6.5 (Pavel Popovich)")
-        File.should_receive(:exists?).with("/etc/parallels-release").and_return(true)
-        File.should_receive(:read).with("/etc/parallels-release").and_return("Parallels Cloud Server 6.0.5 (20007)")
+        allow(File).to receive(:exists?).with("/etc/redhat-release").and_return(true)
+        allow(File).to receive(:read).with("/etc/redhat-release").and_return("CloudLinux Server release 6.5 (Pavel Popovich)")
+        expect(File).to receive(:exists?).with("/etc/parallels-release").and_return(true)
+        expect(File).to receive(:read).with("/etc/parallels-release").and_return("Parallels Cloud Server 6.0.5 (20007)")
         @plugin.run
-        @plugin[:platform].should == "parallels"
-        @plugin[:platform_version].should == "6.0.5"
-        @plugin[:platform_family].should == "rhel"
+        expect(@plugin[:platform]).to eq("parallels")
+        expect(@plugin[:platform_version]).to eq("6.0.5")
+        expect(@plugin[:platform_family]).to eq("rhel")
       end
     end
   end
@@ -339,25 +339,25 @@ describe Ohai::System, "Linux plugin platform" do
       it "should read the platform as oracle and version as 5.7" do
         @plugin[:lsb][:id] = "EnterpriseEnterpriseServer"
         @plugin[:lsb][:release] = "5.7"
-        File.stub(:exists?).with("/etc/redhat-release").and_return(true)
-        File.stub(:read).with("/etc/redhat-release").and_return("Red Hat Enterprise Linux Server release 5.7 (Tikanga)")
-        File.should_receive(:exists?).with("/etc/enterprise-release").and_return(true)
-        File.should_receive(:read).with("/etc/enterprise-release").and_return("Enterprise Linux Enterprise Linux Server release 5.7 (Carthage)")
+        allow(File).to receive(:exists?).with("/etc/redhat-release").and_return(true)
+        allow(File).to receive(:read).with("/etc/redhat-release").and_return("Red Hat Enterprise Linux Server release 5.7 (Tikanga)")
+        expect(File).to receive(:exists?).with("/etc/enterprise-release").and_return(true)
+        expect(File).to receive(:read).with("/etc/enterprise-release").and_return("Enterprise Linux Enterprise Linux Server release 5.7 (Carthage)")
         @plugin.run
-        @plugin[:platform].should == "oracle"
-        @plugin[:platform_version].should == "5.7"
+        expect(@plugin[:platform]).to eq("oracle")
+        expect(@plugin[:platform_version]).to eq("5.7")
       end
 
       it "should read the platform as oracle and version as 6.1" do
         @plugin[:lsb][:id] = "OracleServer"
         @plugin[:lsb][:release] = "6.1"
-        File.stub(:exists?).with("/etc/redhat-release").and_return(true)
-        File.stub(:read).with("/etc/redhat-release").and_return("Red Hat Enterprise Linux Server release 6.1 (Santiago)")
-        File.should_receive(:exists?).with("/etc/oracle-release").and_return(true)
-        File.should_receive(:read).with("/etc/oracle-release").and_return("Oracle Linux Server release 6.1")
+        allow(File).to receive(:exists?).with("/etc/redhat-release").and_return(true)
+        allow(File).to receive(:read).with("/etc/redhat-release").and_return("Red Hat Enterprise Linux Server release 6.1 (Santiago)")
+        expect(File).to receive(:exists?).with("/etc/oracle-release").and_return(true)
+        expect(File).to receive(:read).with("/etc/oracle-release").and_return("Oracle Linux Server release 6.1")
         @plugin.run
-        @plugin[:platform].should == "oracle"
-        @plugin[:platform_version].should == "6.1"
+        expect(@plugin[:platform]).to eq("oracle")
+        expect(@plugin[:platform_version]).to eq("6.1")
       end
     end
 
@@ -367,60 +367,60 @@ describe Ohai::System, "Linux plugin platform" do
       end
 
       it "should read the platform as oracle and version as 5" do
-        File.stub(:exists?).with("/etc/redhat-release").and_return(true)
-        File.stub(:read).with("/etc/redhat-release").and_return("Enterprise Linux Enterprise Linux Server release 5 (Carthage)")
-        File.should_receive(:exists?).with("/etc/enterprise-release").and_return(true)
-        File.should_receive(:read).with("/etc/enterprise-release").and_return("Enterprise Linux Enterprise Linux Server release 5 (Carthage)")
+        allow(File).to receive(:exists?).with("/etc/redhat-release").and_return(true)
+        allow(File).to receive(:read).with("/etc/redhat-release").and_return("Enterprise Linux Enterprise Linux Server release 5 (Carthage)")
+        expect(File).to receive(:exists?).with("/etc/enterprise-release").and_return(true)
+        expect(File).to receive(:read).with("/etc/enterprise-release").and_return("Enterprise Linux Enterprise Linux Server release 5 (Carthage)")
         @plugin.run
-        @plugin[:platform].should == "oracle"
-        @plugin[:platform_version].should == "5"
+        expect(@plugin[:platform]).to eq("oracle")
+        expect(@plugin[:platform_version]).to eq("5")
       end
 
       it "should read the platform as oracle and version as 5.1" do
-        File.stub(:exists?).with("/etc/redhat-release").and_return(true)
-        File.stub(:read).with("/etc/redhat-release").and_return("Enterprise Linux Enterprise Linux Server release 5.1 (Carthage)")
-        File.should_receive(:exists?).with("/etc/enterprise-release").and_return(true)
-        File.should_receive(:read).with("/etc/enterprise-release").and_return("Enterprise Linux Enterprise Linux Server release 5.1 (Carthage)")
+        allow(File).to receive(:exists?).with("/etc/redhat-release").and_return(true)
+        allow(File).to receive(:read).with("/etc/redhat-release").and_return("Enterprise Linux Enterprise Linux Server release 5.1 (Carthage)")
+        expect(File).to receive(:exists?).with("/etc/enterprise-release").and_return(true)
+        expect(File).to receive(:read).with("/etc/enterprise-release").and_return("Enterprise Linux Enterprise Linux Server release 5.1 (Carthage)")
         @plugin.run
-        @plugin[:platform].should == "oracle"
-        @plugin[:platform_version].should == "5.1"
+        expect(@plugin[:platform]).to eq("oracle")
+        expect(@plugin[:platform_version]).to eq("5.1")
       end
 
       it "should read the platform as oracle and version as 5.7" do
-        File.stub(:exists?).with("/etc/redhat-release").and_return(true)
-        File.stub(:read).with("/etc/redhat-release").and_return("Red Hat Enterprise Linux Server release 5.7 (Tikanga)")
-        File.should_receive(:exists?).with("/etc/enterprise-release").and_return(true)
-        File.should_receive(:read).with("/etc/enterprise-release").and_return("Enterprise Linux Enterprise Linux Server release 5.7 (Carthage)")
+        allow(File).to receive(:exists?).with("/etc/redhat-release").and_return(true)
+        allow(File).to receive(:read).with("/etc/redhat-release").and_return("Red Hat Enterprise Linux Server release 5.7 (Tikanga)")
+        expect(File).to receive(:exists?).with("/etc/enterprise-release").and_return(true)
+        expect(File).to receive(:read).with("/etc/enterprise-release").and_return("Enterprise Linux Enterprise Linux Server release 5.7 (Carthage)")
         @plugin.run
-        @plugin[:platform].should == "oracle"
-        @plugin[:platform_version].should == "5.7"
+        expect(@plugin[:platform]).to eq("oracle")
+        expect(@plugin[:platform_version]).to eq("5.7")
       end
 
       it "should read the platform as oracle and version as 6.0" do
-        File.stub(:exists?).with("/etc/redhat-release").and_return(true)
-        File.stub(:read).with("/etc/redhat-release").and_return("Red Hat Enterprise Linux Server release 6.0 (Santiago)")
-        File.should_receive(:exists?).with("/etc/oracle-release").and_return(true)
-        File.should_receive(:read).with("/etc/oracle-release").and_return("Oracle Linux Server release 6.0")
+        allow(File).to receive(:exists?).with("/etc/redhat-release").and_return(true)
+        allow(File).to receive(:read).with("/etc/redhat-release").and_return("Red Hat Enterprise Linux Server release 6.0 (Santiago)")
+        expect(File).to receive(:exists?).with("/etc/oracle-release").and_return(true)
+        expect(File).to receive(:read).with("/etc/oracle-release").and_return("Oracle Linux Server release 6.0")
         @plugin.run
-        @plugin[:platform].should == "oracle"
-        @plugin[:platform_version].should == "6.0"
+        expect(@plugin[:platform]).to eq("oracle")
+        expect(@plugin[:platform_version]).to eq("6.0")
       end
 
       it "should read the platform as oracle and version as 6.1" do
-        File.stub(:exists?).with("/etc/redhat-release").and_return(true)
-        File.stub(:read).with("/etc/redhat-release").and_return("Red Hat Enterprise Linux Server release 6.1 (Santiago)")
-        File.should_receive(:exists?).with("/etc/oracle-release").and_return(true)
-        File.should_receive(:read).with("/etc/oracle-release").and_return("Oracle Linux Server release 6.1")
+        allow(File).to receive(:exists?).with("/etc/redhat-release").and_return(true)
+        allow(File).to receive(:read).with("/etc/redhat-release").and_return("Red Hat Enterprise Linux Server release 6.1 (Santiago)")
+        expect(File).to receive(:exists?).with("/etc/oracle-release").and_return(true)
+        expect(File).to receive(:read).with("/etc/oracle-release").and_return("Oracle Linux Server release 6.1")
         @plugin.run
-        @plugin[:platform].should == "oracle"
-        @plugin[:platform_version].should == "6.1"
+        expect(@plugin[:platform]).to eq("oracle")
+        expect(@plugin[:platform_version]).to eq("6.1")
       end
     end
   end
 
   describe "on suse" do
     before(:each) do
-      File.should_receive(:exists?).with("/etc/SuSE-release").and_return(true)
+      expect(File).to receive(:exists?).with("/etc/SuSE-release").and_return(true)
     end
 
     describe "with lsb_release results" do
@@ -430,10 +430,10 @@ describe Ohai::System, "Linux plugin platform" do
 
       it "should read the platform as opensuse on openSUSE" do
         @plugin[:lsb][:release] = "12.1"
-        File.should_receive(:read).with("/etc/SuSE-release").and_return("openSUSE 12.1 (x86_64)\nVERSION = 12.1\nCODENAME = Asparagus\n")
+        expect(File).to receive(:read).with("/etc/SuSE-release").and_return("openSUSE 12.1 (x86_64)\nVERSION = 12.1\nCODENAME = Asparagus\n")
         @plugin.run
-        @plugin[:platform].should == "opensuse"
-        @plugin[:platform_family].should == "suse"
+        expect(@plugin[:platform]).to eq("opensuse")
+        expect(@plugin[:platform_family]).to eq("suse")
       end
     end
 
@@ -443,57 +443,57 @@ describe Ohai::System, "Linux plugin platform" do
       end
 
       it "should set platform and platform_family to suse and bogus verion to 10.0" do
-        File.should_receive(:read).with("/etc/SuSE-release").at_least(:once).and_return("VERSION = 10.0")
+        expect(File).to receive(:read).with("/etc/SuSE-release").at_least(:once).and_return("VERSION = 10.0")
         @plugin.run
-        @plugin[:platform].should == "suse"
-        @plugin[:platform_family].should == "suse"
+        expect(@plugin[:platform]).to eq("suse")
+        expect(@plugin[:platform_family]).to eq("suse")
       end
 
       it "should read the version as 10.1 for bogus SLES 10" do
-        File.should_receive(:read).with("/etc/SuSE-release").and_return("SUSE Linux Enterprise Server 10 (i586)\nVERSION = 10\nPATCHLEVEL = 1\n")
+        expect(File).to receive(:read).with("/etc/SuSE-release").and_return("SUSE Linux Enterprise Server 10 (i586)\nVERSION = 10\nPATCHLEVEL = 1\n")
         @plugin.run
-        @plugin[:platform].should == "suse"
-        @plugin[:platform_version].should == "10.1"
-        @plugin[:platform_family].should == "suse"
+        expect(@plugin[:platform]).to eq("suse")
+        expect(@plugin[:platform_version]).to eq("10.1")
+        expect(@plugin[:platform_family]).to eq("suse")
       end
 
       it "should read the version as 11.2" do
-        File.should_receive(:read).with("/etc/SuSE-release").and_return("SUSE Linux Enterprise Server 11.2 (i586)\nVERSION = 11\nPATCHLEVEL = 2\n")
+        expect(File).to receive(:read).with("/etc/SuSE-release").and_return("SUSE Linux Enterprise Server 11.2 (i586)\nVERSION = 11\nPATCHLEVEL = 2\n")
         @plugin.run
-        @plugin[:platform].should == "suse"
-        @plugin[:platform_version].should == "11.2"
-        @plugin[:platform_family].should == "suse"
+        expect(@plugin[:platform]).to eq("suse")
+        expect(@plugin[:platform_version]).to eq("11.2")
+        expect(@plugin[:platform_family]).to eq("suse")
       end
 
       it "[OHAI-272] should read the version as 11.3" do
-        File.should_receive(:read).with("/etc/SuSE-release").exactly(1).times.and_return("openSUSE 11.3 (x86_64)\nVERSION = 11.3")
+        expect(File).to receive(:read).with("/etc/SuSE-release").exactly(1).times.and_return("openSUSE 11.3 (x86_64)\nVERSION = 11.3")
         @plugin.run
-        @plugin[:platform].should == "opensuse"
-        @plugin[:platform_version].should == "11.3"
-        @plugin[:platform_family].should == "suse"
+        expect(@plugin[:platform]).to eq("opensuse")
+        expect(@plugin[:platform_version]).to eq("11.3")
+        expect(@plugin[:platform_family]).to eq("suse")
       end
 
       it "[OHAI-272] should read the version as 9.1" do
-        File.should_receive(:read).with("/etc/SuSE-release").exactly(1).times.and_return("SuSE Linux 9.1 (i586)\nVERSION = 9.1")
+        expect(File).to receive(:read).with("/etc/SuSE-release").exactly(1).times.and_return("SuSE Linux 9.1 (i586)\nVERSION = 9.1")
         @plugin.run
-        @plugin[:platform].should == "suse"
-        @plugin[:platform_version].should == "9.1"
-        @plugin[:platform_family].should == "suse"
+        expect(@plugin[:platform]).to eq("suse")
+        expect(@plugin[:platform_version]).to eq("9.1")
+        expect(@plugin[:platform_family]).to eq("suse")
       end
 
       it "[OHAI-272] should read the version as 11.4" do
-        File.should_receive(:read).with("/etc/SuSE-release").exactly(1).times.and_return("openSUSE 11.4 (i586)\nVERSION = 11.4\nCODENAME = Celadon")
+        expect(File).to receive(:read).with("/etc/SuSE-release").exactly(1).times.and_return("openSUSE 11.4 (i586)\nVERSION = 11.4\nCODENAME = Celadon")
         @plugin.run
-        @plugin[:platform].should == "opensuse"
-        @plugin[:platform_version].should == "11.4"
-        @plugin[:platform_family].should == "suse"
+        expect(@plugin[:platform]).to eq("opensuse")
+        expect(@plugin[:platform_version]).to eq("11.4")
+        expect(@plugin[:platform_family]).to eq("suse")
       end
 
       it "should read the platform as opensuse on openSUSE" do
-        File.should_receive(:read).with("/etc/SuSE-release").and_return("openSUSE 12.2 (x86_64)\nVERSION = 12.2\nCODENAME = Mantis\n")
+        expect(File).to receive(:read).with("/etc/SuSE-release").and_return("openSUSE 12.2 (x86_64)\nVERSION = 12.2\nCODENAME = Mantis\n")
         @plugin.run
-        @plugin[:platform].should == "opensuse"
-        @plugin[:platform_family].should == "suse"
+        expect(@plugin[:platform]).to eq("opensuse")
+        expect(@plugin[:platform_family]).to eq("suse")
       end
     end
   end