ohai 7.6.0.rc.1 → 8.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0d9d3f875c58cc677e9188ec2183e25de5911e3e
+  data.tar.gz: fb59c6094438728c98ff3a9f2c9d4420579096dc
+SHA512:
+  metadata.gz: eab2a721b93ce4e9ccce9d4fce5fec55c191def267ee2ed713f0a859050ea1d4a59b0d583182475669408a3636ca2df3aa2890b7cff49401813220eb476c9e4f
+  data.tar.gz: f076c97eb34c8c66361dfdecb4fd3e418ca367494fcfc025a2c033f046949b64e850304ccd63519699c3b3e20c07acb8b2c7a043a0e99d9454951f3d016adb1d

data/lib/ohai/version.rb

@@ -18,5 +18,5 @@
 
 module Ohai
   OHAI_ROOT = File.expand_path(File.dirname(__FILE__))
-  VERSION = '7.6.0.rc.1'
+  VERSION = '8.0.1'
 end

data/spec/functional/plugins/powershell_spec.rb

@@ -23,10 +23,10 @@ describe Ohai::System, 'languages plugin' do
   describe 'powershell plugin', :windows_only do
     RSpec.shared_examples "a version looking thing" do
       it 'should be present' do
-        subject.should_not be_nil
+        expect(subject).not_to be_nil
       end
       it 'should look like a version' do
-        subject.should match(VERSION_MATCHING_REGEX)
+        expect(subject).to match(VERSION_MATCHING_REGEX)
       end
     end
     before(:all) do
@@ -38,7 +38,7 @@ describe Ohai::System, 'languages plugin' do
     subject { @plugin[:languages][:powershell] }
 
     it 'should have information about powershell' do
-      subject.should_not be_nil
+      expect(subject).not_to be_nil
     end
 
     describe :version do
@@ -74,7 +74,7 @@ describe Ohai::System, 'languages plugin' do
     describe :compatible_versions do
       it 'has compatible_versions that look like versions' do
         @plugin.languages[:powershell][described_class].each do |version|
-          version.should match(VERSION_MATCHING_REGEX)
+          expect(version).to match(VERSION_MATCHING_REGEX)
         end
       end
     end

data/spec/functional/plugins/root_group_spec.rb

@@ -32,7 +32,7 @@ describe Ohai::System, 'root_group plugin' do
       # groups in Active Directory -- not a typical test scenario, but
       # something to watch if you run this test in such an environment.
       groups = wmi.query("select * from Win32_Group where sid = 'S-1-5-32-544'")
-      groups.length.should == 1
+      expect(groups.length).to eq(1)
       administrators_group = groups[0]['name'].downcase
       plugin.run
       expect(plugin[:root_group].downcase).to be == administrators_group

data/spec/ohai_spec.rb

@@ -21,7 +21,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
 describe Ohai do
   
   it "should have a version constant defined" do
-    Ohai::VERSION.should be_a_kind_of(String)
+    expect(Ohai::VERSION).to be_a_kind_of(String)
   end
   
 end

data/spec/spec_helper.rb

@@ -35,34 +35,34 @@ end
 def it_should_check_from(plugin, attribute, from, value)
   it "should set the #{attribute} to the value from '#{from}'" do
     @plugin.run
-    @plugin[attribute].should == value
+    expect(@plugin[attribute]).to eq(value)
   end
 end
 
 def it_should_check_from_mash(plugin, attribute, from, value)
   it "should get the #{plugin}[:#{attribute}] value from '#{from}'" do
-    @plugin.should_receive(:shell_out).with(from).and_return(mock_shell_out(value[0], value[1], value[2]))
+    expect(@plugin).to receive(:shell_out).with(from).and_return(mock_shell_out(value[0], value[1], value[2]))
     @plugin.run
   end
 
   it "should set the #{plugin}[:#{attribute}] to the value from '#{from}'" do
     @plugin.run
-    @plugin[plugin][attribute].should == value[1].split($/)[0]
+    expect(@plugin[plugin][attribute]).to eq(value[1].split($/)[0])
   end
 end
 
 def mock_shell_out(exitstatus, stdout, stderr)
   shell_out = double("mixlib_shell_out")
-  shell_out.stub(:exitstatus).and_return(exitstatus)
-  shell_out.stub(:stdout).and_return(stdout)
-  shell_out.stub(:stderr).and_return(stderr)
+  allow(shell_out).to receive(:exitstatus).and_return(exitstatus)
+  allow(shell_out).to receive(:stdout).and_return(stdout)
+  allow(shell_out).to receive(:stderr).and_return(stderr)
   shell_out
 end
 
 # the mash variable may be an array listing multiple levels of Mash hierarchy
 def it_should_check_from_deep_mash(plugin, mash, attribute, from, value)
   it "should get the #{mash.inspect}[:#{attribute}] value from '#{from}'" do
-    @plugin.should_receive(:shell_out).with(from).and_return(mock_shell_out(value[0], value[1], value[2]))
+    expect(@plugin).to receive(:shell_out).with(from).and_return(mock_shell_out(value[0], value[1], value[2]))
     @plugin.run
   end
 
@@ -70,12 +70,12 @@ def it_should_check_from_deep_mash(plugin, mash, attribute, from, value)
     @plugin.run
     value = value[1].split($/)[0]
     if mash.is_a?(String)
-      @plugin[mash][attribute].should == value
+      expect(@plugin[mash][attribute]).to eq(value)
     elsif mash.is_a?(Array)
       if mash.length == 2
-        @plugin[mash[0]][mash[1]][attribute].should == value
+        expect(@plugin[mash[0]][mash[1]][attribute]).to eq value
       elsif mash.length == 3
-        @plugin[mash[0]][mash[1]][mash[2]][attribute].should == value
+        expect(@plugin[mash[0]][mash[1]][mash[2]][attribute]).to eq value
       else
         return nil
       end
@@ -92,10 +92,10 @@ RSpec.configure do |config|
   # `expect` should be preferred for new tests or when refactoring old tests,
   # but we're not going to do a "big bang" change at this time.
   config.expect_with :rspec do |c|
-    c.syntax = [:should, :expect]
+    c.syntax = :expect
   end
   config.mock_with :rspec do |c|
-    c.syntax = [:expect, :should]
+    c.syntax = :expect
   end
 
   config.filter_run :focus => true

data/spec/unit/dsl/plugin_spec.rb

@@ -22,54 +22,54 @@ require File.expand_path("../../../spec_helper.rb", __FILE__)
 shared_examples "Ohai::DSL::Plugin" do
   context "#initialize" do
     it "should set has_run? to false" do
-      plugin.has_run?.should be false
+      expect(plugin.has_run?).to be false
     end
 
     it "should set the correct plugin version" do
-      plugin.version.should eql(version)
+      expect(plugin.version).to eql(version)
     end
   end
 
   context "#run" do
     before do
-      plugin.stub(:run_plugin).and_return(true)
-      plugin.stub(:name).and_return(:TestPlugin)
+      allow(plugin).to receive(:run_plugin).and_return(true)
+      allow(plugin).to receive(:name).and_return(:TestPlugin)
     end
 
     describe "when plugin is enabled" do
       before do
-        Ohai::Config.stub(:[]).with(:disabled_plugins).and_return([ ])
+        allow(Ohai::Config).to receive(:[]).with(:disabled_plugins).and_return([ ])
       end
 
       it "should run the plugin" do
-        plugin.should_receive(:run_plugin)
+        expect(plugin).to receive(:run_plugin)
         plugin.run
       end
 
       it "should set has_run? to true" do
         plugin.run
-        plugin.has_run?.should be true
+        expect(plugin.has_run?).to be true
       end
     end
 
     describe "if the plugin is disabled" do
       before do
-        Ohai::Config.stub(:[]).with(:disabled_plugins).and_return([ :TestPlugin ])
+        allow(Ohai::Config).to receive(:[]).with(:disabled_plugins).and_return([ :TestPlugin ])
       end
 
       it "should not run the plugin" do
-        plugin.should_not_receive(:run_plugin)
+        expect(plugin).not_to receive(:run_plugin)
         plugin.run
       end
 
       it "should log a message to debug" do
-        Ohai::Log.should_receive(:debug).with(/Skipping disabled plugin TestPlugin/)
+        expect(Ohai::Log).to receive(:debug).with(/Skipping disabled plugin TestPlugin/)
         plugin.run
       end
 
       it "should set has_run? to true" do
         plugin.run
-        plugin.has_run?.should be true
+        expect(plugin.has_run?).to be true
       end
     end
   end
@@ -77,16 +77,16 @@ shared_examples "Ohai::DSL::Plugin" do
   context "when accessing data via method_missing" do
     it "should take a missing method and store the method name as a key, with its arguments as values" do
       plugin.guns_n_roses("chinese democracy")
-      plugin.data["guns_n_roses"].should eql("chinese democracy")
+      expect(plugin.data["guns_n_roses"]).to eql("chinese democracy")
     end
 
     it "should return the current value of the method name" do
-      plugin.guns_n_roses("chinese democracy").should eql("chinese democracy")
+      expect(plugin.guns_n_roses("chinese democracy")).to eql("chinese democracy")
     end
 
     it "should allow you to get the value of a key by calling method_missing with no arguments" do
       plugin.guns_n_roses("chinese democracy")
-      plugin.guns_n_roses.should eql("chinese democracy")
+      expect(plugin.guns_n_roses).to eql("chinese democracy")
     end
   end
 
@@ -96,18 +96,18 @@ shared_examples "Ohai::DSL::Plugin" do
     end
 
     it "should return true if an attribute exists with the given name" do
-      plugin.attribute?("metallica").should eql(true)
+      expect(plugin.attribute?("metallica")).to eql(true)
     end
 
     it "should return false if an attribute does not exist with the given name" do
-      plugin.attribute?("alice in chains").should eql(false)
+      expect(plugin.attribute?("alice in chains")).to eql(false)
     end
   end
 
   context "when setting attributes" do
     it "should let you set an attribute" do
       plugin.set_attribute(:tea, "is soothing")
-      plugin.data["tea"].should eql("is soothing")
+      expect(plugin.data["tea"]).to eql("is soothing")
     end
   end
 
@@ -117,7 +117,7 @@ shared_examples "Ohai::DSL::Plugin" do
     end
 
     it "should let you get an attribute" do
-      plugin.get_attribute("tea").should eql("is soothing")
+      expect(plugin.get_attribute("tea")).to eql("is soothing")
     end
   end
 end
@@ -125,7 +125,7 @@ end
 describe Ohai::DSL::Plugin::VersionVII do
   it "should not modify the plugin name when the plugin is named correctly" do
     plugin = Ohai.plugin(:FunkyVALIDpluginName) { }.new({ })
-    plugin.name.should eql(:FunkyVALIDpluginName)
+    expect(plugin.name).to eql(:FunkyVALIDpluginName)
   end
 
   describe "when the plugin is named incorrectly" do
@@ -151,19 +151,19 @@ describe Ohai::DSL::Plugin::VersionVII do
   describe "#version" do
     it "should save the plugin version as :version7" do
       plugin = Ohai.plugin(:Test) { }
-      plugin.version.should eql(:version7)
+      expect(plugin.version).to eql(:version7)
     end
   end
 
   describe "#provides" do
     it "should collect a single attribute" do
       plugin = Ohai.plugin(:Test) { provides("one") }
-      plugin.provides_attrs.should eql(["one"])
+      expect(plugin.provides_attrs).to eql(["one"])
     end
 
     it "should collect a list of attributes" do
       plugin = Ohai.plugin(:Test) { provides("one", "two", "three") }
-      plugin.provides_attrs.should eql(["one", "two", "three"])
+      expect(plugin.provides_attrs).to eql(["one", "two", "three"])
     end
 
     it "should collect from multiple provides statements" do
@@ -172,31 +172,31 @@ describe Ohai::DSL::Plugin::VersionVII do
         provides("two", "three")
         provides("four")
       }
-      plugin.provides_attrs.should eql(["one", "two", "three", "four"])
+      expect(plugin.provides_attrs).to eql(["one", "two", "three", "four"])
     end
 
     it "should collect attributes across multiple plugin files" do
       plugin = Ohai.plugin(:Test) { provides("one") }
       plugin = Ohai.plugin(:Test) { provides("two", "three") }
-      plugin.provides_attrs.should eql(["one", "two", "three"])
+      expect(plugin.provides_attrs).to eql(["one", "two", "three"])
     end
 
     it "should collect unique attributes" do
       plugin = Ohai.plugin(:Test) { provides("one") }
       plugin = Ohai.plugin(:Test) { provides("one", "two") }
-      plugin.provides_attrs.should eql(["one", "two"])
+      expect(plugin.provides_attrs).to eql(["one", "two"])
     end
   end
 
   describe "#depends" do
     it "should collect a single dependency" do
       plugin = Ohai.plugin(:Test) { depends("one") }
-      plugin.depends_attrs.should eql(["one"])
+      expect(plugin.depends_attrs).to eql(["one"])
     end
 
     it "should collect a list of dependencies" do
       plugin = Ohai.plugin(:Test) { depends("one", "two", "three") }
-      plugin.depends_attrs.should eql(["one", "two", "three"])
+      expect(plugin.depends_attrs).to eql(["one", "two", "three"])
     end
 
     it "should collect from multiple depends statements" do
@@ -205,37 +205,37 @@ describe Ohai::DSL::Plugin::VersionVII do
         depends("two", "three")
         depends("four")
       }
-      plugin.depends_attrs.should eql(["one", "two", "three", "four"])
+      expect(plugin.depends_attrs).to eql(["one", "two", "three", "four"])
     end
 
     it "should collect dependencies across multiple plugin files" do
       plugin = Ohai.plugin(:Test) { depends("one") }
       plugin = Ohai.plugin(:Test) { depends("two", "three") }
-      plugin.depends_attrs.should eql(["one", "two", "three"])
+      expect(plugin.depends_attrs).to eql(["one", "two", "three"])
     end
 
     it "should collect unique attributes" do
       plugin = Ohai.plugin(:Test) { depends("one") }
       plugin = Ohai.plugin(:Test) { depends("one", "two") }
-      plugin.depends_attrs.should eql(["one", "two"])
+      expect(plugin.depends_attrs).to eql(["one", "two"])
     end
   end
 
   describe "#collect_data" do
     it "should save as :default if no platform is given" do
       plugin = Ohai.plugin(:Test) { collect_data { } }
-      plugin.data_collector.should have_key(:default)
+      expect(plugin.data_collector).to have_key(:default)
     end
 
     it "should save a single given platform" do
       plugin = Ohai.plugin(:Test) { collect_data(:ubuntu) { } }
-      plugin.data_collector.should have_key(:ubuntu)
+      expect(plugin.data_collector).to have_key(:ubuntu)
     end
 
     it "should save a list of platforms" do
       plugin = Ohai.plugin(:Test) { collect_data(:freebsd, :netbsd, :openbsd) { } }
       [:freebsd, :netbsd, :openbsd].each do |platform|
-        plugin.data_collector.should have_key(platform)
+        expect(plugin.data_collector).to have_key(platform)
       end
     end
 
@@ -246,7 +246,7 @@ describe Ohai::DSL::Plugin::VersionVII do
         collect_data(:darwin) { }
       }
       [:darwin, :default, :windows].each do |platform|
-        plugin.data_collector.should have_key(platform)
+        expect(plugin.data_collector).to have_key(platform)
       end
     end
 
@@ -254,7 +254,7 @@ describe Ohai::DSL::Plugin::VersionVII do
       plugin = Ohai.plugin(:Test) { collect_data { } }
       plugin = Ohai.plugin(:Test) { collect_data(:aix, :sigar) { } }
       [:aix, :default, :sigar].each do |platform|
-        plugin.data_collector.should have_key(platform)
+        expect(plugin.data_collector).to have_key(platform)
       end
     end
 
@@ -280,7 +280,7 @@ describe Ohai::DSL::Plugin::VersionVII do
   describe "#provides (deprecated)" do
     it "should log a warning" do
       plugin = Ohai::DSL::Plugin::VersionVII.new(Mash.new)
-      Ohai::Log.should_receive(:warn).with(/\[UNSUPPORTED OPERATION\]/)
+      expect(Ohai::Log).to receive(:warn).with(/\[UNSUPPORTED OPERATION\]/)
       plugin.provides("attribute")
     end
   end
@@ -288,7 +288,7 @@ describe Ohai::DSL::Plugin::VersionVII do
   describe "#require_plugin (deprecated)" do
     it "should log a warning" do
       plugin = Ohai::DSL::Plugin::VersionVII.new(Mash.new)
-      Ohai::Log.should_receive(:warn).with(/\[UNSUPPORTED OPERATION\]/)
+      expect(Ohai::Log).to receive(:warn).with(/\[UNSUPPORTED OPERATION\]/)
       plugin.require_plugin("plugin")
     end
   end
@@ -304,7 +304,7 @@ describe Ohai::DSL::Plugin::VersionVI do
   describe "#version" do
     it "should save the plugin version as :version6" do
       plugin = Class.new(Ohai::DSL::Plugin::VersionVI) { }
-      plugin.version.should eql(:version6)
+      expect(plugin.version).to eql(:version6)
     end
   end
 
@@ -314,7 +314,7 @@ describe Ohai::DSL::Plugin::VersionVI do
     end
 
     it "should log a debug message when provides is used" do
-      Ohai::Log.should_receive(:debug).with(/Skipping provides/)
+      expect(Ohai::Log).to receive(:debug).with(/Skipping provides/)
       plugin = Ohai::DSL::Plugin::VersionVI.new(@ohai, "/some/plugin/path.rb", "/some/plugin")
       plugin.provides("attribute")
     end
@@ -322,7 +322,7 @@ describe Ohai::DSL::Plugin::VersionVI do
     it "should not update the provides map for version 6 plugins." do
       plugin = Ohai::DSL::Plugin::VersionVI.new(@ohai, "/some/plugin/path.rb", "/some/plugin")
       plugin.provides("attribute")
-      @ohai.provides_map.map.should be_empty
+      expect(@ohai.provides_map.map).to be_empty
     end
 
   end

data/spec/unit/hints_spec.rb

@@ -37,7 +37,7 @@ describe "Ohai::Hints" do
     end
 
     it "hint? should return nil" do
-      Ohai::Hints.hint?("cloud").should be_nil
+      expect(Ohai::Hints.hint?("cloud")).to be_nil
     end
   end
 
@@ -54,11 +54,11 @@ EOF
     end
 
     it "hint? should return the data for full hints" do
-      Ohai::Hints.hint?("cloud").should == {"name" => "circus"}
+      expect(Ohai::Hints.hint?("cloud")).to eq({"name" => "circus"})
     end
 
     it "hint? should return empty hash for empty hints" do
-      Ohai::Hints.hint?("cloud_empty").should == { }
+      expect(Ohai::Hints.hint?("cloud_empty")).to eq({ })
     end
   end
 

data/spec/unit/loader_spec.rb

@@ -33,7 +33,7 @@ describe Ohai::Loader do
   describe "#initialize" do
     it "should return an Ohai::Loader object" do
       loader = Ohai::Loader.new(@ohai)
-      loader.should be_a_kind_of(Ohai::Loader)
+      expect(loader).to be_a_kind_of(Ohai::Loader)
     end
   end
 
@@ -61,38 +61,38 @@ EOF
         end          
 
         it "should save the plugin according to its attribute" do          
-          @provides_map.map.keys.should include("seals")
+          expect(@provides_map.map.keys).to include("seals")
         end
 
         it "should save a single plugin source" do
-          @plugin.source.should eql([path_to("zoo.rb")])
+          expect(@plugin.source).to eql([path_to("zoo.rb")])
         end
 
         it "should save all plugin sources" do
           @loader.load_plugin(path_to("zoo_too.rb"))
-          @plugin.source.should eql([path_to("zoo.rb"), path_to("zoo_too.rb")])
+          expect(@plugin.source).to eql([path_to("zoo.rb"), path_to("zoo_too.rb")])
         end
       end
 
       describe "when loading a v6 plugin" do
         before(:each) do
-          Ohai::Log.should_receive(:warn).with(/\[DEPRECATION\]/)
+          expect(Ohai::Log).to receive(:warn).with(/\[DEPRECATION\]/)
           @plugin = @loader.load_plugin(path_to("lake.rb"), path_to("."))
         end
 
         it "should not add this plugin's provided attributes to the provides map" do
-          @provides_map.map.should be_empty
+          expect(@provides_map.map).to be_empty
         end
 
         it "should save the plugin's source" do
-          @plugin.source.should eql(path_to("lake.rb"))
+          expect(@plugin.source).to eql(path_to("lake.rb"))
         end
       end
 
       it "should log a warning if a plugin doesn't exist" do
-        Ohai::Log.should_receive(:warn).with(/Unable to open or read plugin/)
+        expect(Ohai::Log).to receive(:warn).with(/Unable to open or read plugin/)
         @loader.load_plugin(path_to("rainier.rb"), path_to("."))
-        @provides_map.map.should be_empty
+        expect(@provides_map.map).to be_empty
       end
     end
   end
@@ -147,7 +147,7 @@ EOF
     describe "load_plugin() method" do
       describe "when the plugin uses Ohai.plugin instead of Ohai.plugins" do
         it "should log an unsupported operation warning" do
-          Ohai::Log.should_receive(:warn).with(/Plugin Method Error: <#{path_to("extra_s.rb")}>:/)
+          expect(Ohai::Log).to receive(:warn).with(/Plugin Method Error: <#{path_to("extra_s.rb")}>:/)
           @loader.load_plugin(path_to("extra_s.rb"))
         end
 
@@ -158,7 +158,7 @@ EOF
 
       describe "when the plugin tries to call an unexisting method" do
         it "shoud log an unsupported operation warning" do
-          Ohai::Log.should_receive(:warn).with(/Plugin Method Error: <#{path_to("no_method.rb")}>:/)
+          expect(Ohai::Log).to receive(:warn).with(/Plugin Method Error: <#{path_to("no_method.rb")}>:/)
           @loader.load_plugin(path_to("no_method.rb"))
         end
 
@@ -169,7 +169,7 @@ EOF
 
       describe "when the plugin defines collect_data on the same platform more than once" do
         it "shoud log an illegal plugin definition warning" do
-          Ohai::Log.should_receive(:warn).with(/Plugin Definition Error: <#{path_to("illegal_def.rb")}>:/)
+          expect(Ohai::Log).to receive(:warn).with(/Plugin Definition Error: <#{path_to("illegal_def.rb")}>:/)
           @loader.load_plugin(path_to("illegal_def.rb"))
         end
 
@@ -180,7 +180,7 @@ EOF
 
       describe "when an unexpected error is encountered" do
         it "should log a warning" do
-          Ohai::Log.should_receive(:warn).with(/Plugin Error: <#{path_to("unexpected_error.rb")}>:/)
+          expect(Ohai::Log).to receive(:warn).with(/Plugin Error: <#{path_to("unexpected_error.rb")}>:/)
           @loader.load_plugin(path_to("unexpected_error.rb"))
         end
 
@@ -191,7 +191,7 @@ EOF
 
       describe "when the plugin name symbol has bad syntax" do
         it "should log a syntax error warning" do
-          Ohai::Log.should_receive(:warn).with(/Plugin Syntax Error: <#{path_to("bad_symbol.rb")}>:/)
+          expect(Ohai::Log).to receive(:warn).with(/Plugin Syntax Error: <#{path_to("bad_symbol.rb")}>:/)
           @loader.load_plugin(path_to("bad_symbol.rb"))
         end
 
@@ -202,7 +202,7 @@ EOF
 
       describe "when the plugin forgets an 'end'" do
         it "should log a syntax error warning" do
-          Ohai::Log.should_receive(:warn).with(/Plugin Syntax Error: <#{path_to("no_end.rb")}>:/)
+          expect(Ohai::Log).to receive(:warn).with(/Plugin Syntax Error: <#{path_to("no_end.rb")}>:/)
           @loader.load_plugin(path_to("no_end.rb"))
         end
 
@@ -213,7 +213,7 @@ EOF
 
       describe "when the plugin has an invalid name" do
         it "should log an invalid plugin name warning" do
-          Ohai::Log.should_receive(:warn).with(/Plugin Name Error: <#{path_to("bad_name.rb")}>:/)
+          expect(Ohai::Log).to receive(:warn).with(/Plugin Name Error: <#{path_to("bad_name.rb")}>:/)
           @loader.load_plugin(path_to("bad_name.rb"))
         end