ohai 8.6.0.alpha.0 → 8.6.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d20a41244abdf2eac8a236934cbaca93ff7fe05
-  data.tar.gz: c6838defeebaabbae18bfe44b7d2d8eaf5ea68ef
+  metadata.gz: 12feba79315d30d742f71e9c26690a64ad71d11e
+  data.tar.gz: fcf8ae37a2db845807a95a41deccf634a3373ff8
 SHA512:
-  metadata.gz: 1f54bb75351d06a96503d564d031309e73e6369238a6087fe34731271e060fc1e983063db61fa0c4ceba06791d6faa4792c5860db4577c7fd89145a56809141e
-  data.tar.gz: 6065f7b4b78acea7e2c0b9a5b6cdd1080d788548c07747f3d89755776c628d4fe47153f2b5c8ef00f5efeb39f40bd5d92a243bd0dd4e54eec502b9debea90e21
+  metadata.gz: a901bb634ac4cc771412dd23140c7c6af7d52e0123e9ba010d7debe478ccc678e7acfcf8302c7c9be972b4fcccc25c8a73d58872c985640ba66998be96785541
+  data.tar.gz: 4f792e178bf51309803110aad9c9ddb107aa7724417437013b845918d89244f09320389179bb12278ea3e57a86551d1ef2768592345f42a77d34eba40f8b4cff

data/lib/ohai/config.rb

@@ -17,12 +17,8 @@
 # limitations under the License.
 #
 
-require 'ohai/log'
-require 'chef-config/logger'
-
-ChefConfig::Logger = Ohai::Log
-
 require 'chef-config/config'
+require 'ohai/log'
 
 module Ohai
   Config = ChefConfig::Config
@@ -58,7 +54,7 @@ module Ohai
     # (e.g., Ohai::Config[:plugin_path] << some_path) in their config files.
     default :disabled_plugins, []
     default :hints_path, default_hints_path
-    default :log_level, :info
+    default :log_level, :auto
     default :log_location, STDERR
     default :plugin_path, default_plugin_path
 
@@ -95,7 +91,7 @@ module Ohai
     config_context :ohai do
       default :disabled_plugins, []
       default :hints_path, Ohai::Config.default_hints_path
-      default :log_level, :info
+      default :log_level, :auto
       default :log_location, STDERR
       default :plugin_path, Ohai::Config.default_plugin_path
     end

data/lib/ohai/plugins/linux/virtualization.rb

@@ -146,7 +146,7 @@ Ohai.plugin(:Virtualization) do
         virtualization[:system] = "openstack"
         virtualization[:role] = "guest"
         virtualization[:systems][:openstack] = "guest"
-      when /Manufacturer: QEMU/
+      when /Manufacturer: QEMU|Product Name: KVM/
         virtualization[:system] = "kvm"
         virtualization[:role] = "guest"
         virtualization[:systems][:kvm] = "guest"

data/lib/ohai/plugins/solaris2/network.rb

@@ -58,7 +58,7 @@ ETHERNET_ENCAPS = %w{ afe amd8111s arn atge ath bfe bge bnx bnxe ce cxgbe
                       dmfe e1000g efe elxl emlxs eri hermon hme hxge igb
                       iprb ipw iwh iwi iwk iwp ixgb ixgbe mwl mxfe myri10ge
                       nge ntxn nxge pcn platform qfe qlc ral rge rtls rtw rwd
-                      rwn sfe tavor vr wpi xge yge}
+                      rwn sfe tavor vr wpi xge yge} unless defined?(ETHERNET_ENCAPS)
 
 Ohai.plugin(:Network) do
   provides "network", "network/interfaces"

data/lib/ohai/system.rb

@@ -50,6 +50,7 @@ module Ohai
       @v6_dependency_solver = Hash.new
 
       configure_ohai
+      configure_logging
 
       @loader = Ohai::Loader.new(self)
       @runner = Ohai::Runner.new(self, true)
@@ -213,9 +214,16 @@ module Ohai
           !Ohai.config[:plugin_path].include?(Ohai::Config[:directory])
         Ohai.config[:plugin_path] << Ohai.config[:directory]
       end
+    end
 
+    def configure_logging
       Ohai::Log.init(Ohai.config[:log_location])
-      Ohai::Log.level = Ohai.config[:log_level]
+
+      if Ohai.config[:log_level] == :auto
+        Ohai::Log.level = :info
+      else
+        Ohai::Log.level = Ohai.config[:log_level]
+      end
     end
   end
 end

data/lib/ohai/version.rb

@@ -18,5 +18,5 @@
 
 module Ohai
   OHAI_ROOT = File.expand_path(File.dirname(__FILE__))
-  VERSION = '8.6.0.alpha.0'
+  VERSION = '8.6.0.alpha.1'
 end

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

@@ -19,9 +19,10 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper.rb')
 
 describe Ohai::System, "Linux virtualization platform" do
+  let(:plugin) { get_plugin("linux/virtualization") }
+
   before(:each) do
-    @plugin = get_plugin("linux/virtualization")
-    allow(@plugin).to receive(:collect_os).and_return(:linux)
+    allow(plugin).to receive(:collect_os).and_return(:linux)
 
     # default to all requested Files not existing
     allow(File).to receive(:exists?).with("/proc/xen").and_return(false)
@@ -39,109 +40,109 @@ describe Ohai::System, "Linux virtualization platform" do
   end
 
   describe "when we are checking for xen" do
-    it "should set xen guest if /proc/xen exists but /proc/xen/capabilities does not" do
+    it "sets xen guest if /proc/xen exists but /proc/xen/capabilities does not" do
       expect(File).to receive(:exists?).with("/proc/xen").and_return(true)
       expect(File).to receive(:exists?).with("/proc/xen/capabilities").and_return(false)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("xen")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:xen]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("xen")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:xen]).to eq("guest")
     end
 
-    it "should set xen host if /proc/xen/capabilities contains control_d " do
+    it "sets xen host if /proc/xen/capabilities contains control_d " do
       expect(File).to receive(:exists?).with("/proc/xen").and_return(true)
       expect(File).to receive(:exists?).with("/proc/xen/capabilities").and_return(true)
       allow(File).to receive(:read).with("/proc/xen/capabilities").and_return("control_d")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("xen")
-      expect(@plugin[:virtualization][:role]).to eq("host")
-      expect(@plugin[:virtualization][:systems][:xen]).to eq("host")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("xen")
+      expect(plugin[:virtualization][:role]).to eq("host")
+      expect(plugin[:virtualization][:systems][:xen]).to eq("host")
     end
 
-    it "should set xen guest if /proc/xen/capabilities exists but is empty" do
+    it "sets xen guest if /proc/xen/capabilities exists but is empty" do
       expect(File).to receive(:exists?).with("/proc/xen").and_return(true)
       expect(File).to receive(:exists?).with("/proc/xen/capabilities").and_return(true)
       allow(File).to receive(:read).with("/proc/xen/capabilities").and_return("")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("xen")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:xen]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("xen")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:xen]).to eq("guest")
     end
 
-    it "should not set virtualization if xen isn't there" do
+    it "does not set virtualization if xen isn't there" do
       expect(File).to receive(:exists?).at_least(:once).and_return(false)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
   end
 
   describe "when we are checking for kvm" do
-    it "should set kvm host if /proc/modules contains kvm" do
+    it "sets kvm host if /proc/modules contains kvm" do
       expect(File).to receive(:exists?).with("/proc/modules").and_return(true)
       allow(File).to receive(:read).with("/proc/modules").and_return("kvm 165872  1 kvm_intel")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("kvm")
-      expect(@plugin[:virtualization][:role]).to eq("host")
-      expect(@plugin[:virtualization][:systems][:kvm]).to eq("host")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("kvm")
+      expect(plugin[:virtualization][:role]).to eq("host")
+      expect(plugin[:virtualization][:systems][:kvm]).to eq("host")
     end
 
-    it "should set kvm guest if /proc/cpuinfo contains QEMU Virtual CPU" do
+    it "sets kvm guest if /proc/cpuinfo contains QEMU Virtual CPU" do
       expect(File).to receive(:exists?).with("/proc/cpuinfo").and_return(true)
       allow(File).to receive(:read).with("/proc/cpuinfo").and_return("QEMU Virtual CPU")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("kvm")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:kvm]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("kvm")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:kvm]).to eq("guest")
     end
 
-    it "should set kvm guest if /proc/cpuinfo contains Common KVM processor" do
+    it "sets kvm guest if /proc/cpuinfo contains Common KVM processor" do
       expect(File).to receive(:exists?).with("/proc/cpuinfo").and_return(true)
       allow(File).to receive(:read).with("/proc/cpuinfo").and_return("Common KVM processor")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("kvm")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:kvm]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("kvm")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:kvm]).to eq("guest")
     end
 
-    it "should set kvm guest if /proc/cpuinfo contains Common 32-bit KVM processor" do
+    it "sets kvm guest if /proc/cpuinfo contains Common 32-bit KVM processor" do
       expect(File).to receive(:exists?).with("/proc/cpuinfo").and_return(true)
       allow(File).to receive(:read).with("/proc/cpuinfo").and_return("Common 32-bit KVM processor")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("kvm")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:kvm]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("kvm")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:kvm]).to eq("guest")
     end
 
-    it "should not set virtualization if kvm isn't there" do
+    it "does not set virtualization if kvm isn't there" do
       expect(File).to receive(:exists?).at_least(:once).and_return(false)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
   end
 
   describe "when we are checking for VirtualBox" do
-    it "should set vbox host if /proc/modules contains vboxdrv" do
+    it "sets vbox host if /proc/modules contains vboxdrv" do
       expect(File).to receive(:exists?).with("/proc/modules").and_return(true)
       allow(File).to receive(:read).with("/proc/modules").and_return("vboxdrv 268268 3 vboxnetadp,vboxnetflt")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("vbox")
-      expect(@plugin[:virtualization][:role]).to eq("host")
-      expect(@plugin[:virtualization][:systems][:vbox]).to eq("host")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("vbox")
+      expect(plugin[:virtualization][:role]).to eq("host")
+      expect(plugin[:virtualization][:systems][:vbox]).to eq("host")
     end
 
-    it "should set vbox gues if /proc/modules contains vboxguest" do
+    it "sets vbox gues if /proc/modules contains vboxguest" do
       expect(File).to receive(:exists?).with("/proc/modules").and_return(true)
       allow(File).to receive(:read).with("/proc/modules").and_return("vboxguest 214901 2 vboxsf, Live 0xffffffffa00db000 (OF)")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("vbox")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:vbox]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("vbox")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:vbox]).to eq("guest")
     end
 
-    it "should not set virtualization if vbox isn't there" do
+    it "does not set virtualization if vbox isn't there" do
       expect(File).to receive(:exists?).at_least(:once).and_return(false)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
   end
 
@@ -150,7 +151,7 @@ describe Ohai::System, "Linux virtualization platform" do
       expect(File).to receive(:exists?).with("/usr/sbin/dmidecode").and_return(true)
     end
 
-    it "should set virtualpc guest if dmidecode detects Microsoft Virtual Machine" do
+    it "sets virtualpc guest if dmidecode detects Microsoft Virtual Machine" do
       ms_vpc_dmidecode=<<-MSVPC
 System Information
   Manufacturer: Microsoft Corporation
@@ -160,14 +161,14 @@ System Information
   UUID: D29974A4-BE51-044C-BDC6-EFBC4B87A8E9
   Wake-up Type: Power Switch
 MSVPC
-      allow(@plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, ms_vpc_dmidecode, ""))
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("virtualpc")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:virtualpc]).to eq("guest")
+      allow(plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, ms_vpc_dmidecode, ""))
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("virtualpc")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:virtualpc]).to eq("guest")
     end
 
-    it "should set vmware guest if dmidecode detects VMware Virtual Platform" do
+    it "sets vmware guest if dmidecode detects VMware Virtual Platform" do
       vmware_dmidecode=<<-VMWARE
 System Information
   Manufacturer: VMware, Inc.
@@ -179,14 +180,14 @@ System Information
   SKU Number: Not Specified
   Family: Not Specified
 VMWARE
-      allow(@plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, vmware_dmidecode, ""))
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("vmware")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:vmware]).to eq("guest")
+      allow(plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, vmware_dmidecode, ""))
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("vmware")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:vmware]).to eq("guest")
     end
 
-    it "should set vbox guest if dmidecode detects Oracle Corporation" do
+    it "sets vbox guest if dmidecode detects Oracle Corporation" do
       vbox_dmidecode=<<-VBOX
 Base Board Information
   Manufacturer: Oracle Corporation
@@ -200,14 +201,14 @@ Base Board Information
   Type: Motherboard
   Contained Object Handles: 0
 VBOX
-      allow(@plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, vbox_dmidecode, ""))
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("vbox")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:vbox]).to eq("guest")
+      allow(plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, vbox_dmidecode, ""))
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("vbox")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:vbox]).to eq("guest")
     end
 
-    it "should set openstack guest if dmidecode detects OpenStack" do
+    it "sets openstack guest if dmidecode detects OpenStack" do
       openstack_dmidecode=<<-OPENSTACK
 System Information
         Manufacturer: Red Hat Inc.
@@ -219,136 +220,155 @@ System Information
         SKU Number: Not Specified
         Family: Red Hat Enterprise Linux
 OPENSTACK
-      allow(@plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, openstack_dmidecode, ""))
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("openstack")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:openstack]).to eq("guest")
+      allow(plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, openstack_dmidecode, ""))
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("openstack")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:openstack]).to eq("guest")
+    end
+
+    it "sets kvm guest if dmidecode detects KVM" do
+      kvm_dmidecode=<<-KVM
+System Information
+  Manufacturer: Red Hat
+  Product Name: KVM
+  Version: RHEL 7.0.0 PC (i440FX + PIIX, 1996)
+  Serial Number: Not Specified
+  UUID: 6E56CFE2-2088-4A46-906A-FC49EDC4072C
+  Wake-up Type: Power Switch
+  SKU Number: Not Specified
+  Family: Red Hat Enterprise Linux
+KVM
+      allow(plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, kvm_dmidecode, ""))
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("kvm")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:kvm]).to eq("guest")
     end
 
     it "should run dmidecode and not set virtualization if nothing is detected" do
-      allow(@plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, "", ""))
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      allow(plugin).to receive(:shell_out).with("dmidecode").and_return(mock_shell_out(0, "", ""))
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
   end
 
   describe "when we are checking for Linux-VServer" do
-    it "should set Linux-VServer host if /proc/self/status contains s_context: 0" do
+    it "sets Linux-VServer host if /proc/self/status contains s_context: 0" do
       expect(File).to receive(:exists?).with("/proc/self/status").and_return(true)
       allow(File).to receive(:read).with("/proc/self/status").and_return("s_context: 0")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("linux-vserver")
-      expect(@plugin[:virtualization][:role]).to eq("host")
-      expect(@plugin[:virtualization][:systems]['linux-vserver']).to eq("host")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("linux-vserver")
+      expect(plugin[:virtualization][:role]).to eq("host")
+      expect(plugin[:virtualization][:systems]['linux-vserver']).to eq("host")
     end
 
-    it "should set Linux-VServer host if /proc/self/status contains VxID: 0" do
+    it "sets Linux-VServer host if /proc/self/status contains VxID: 0" do
       expect(File).to receive(:exists?).with("/proc/self/status").and_return(true)
       allow(File).to receive(:read).with("/proc/self/status").and_return("VxID: 0")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("linux-vserver")
-      expect(@plugin[:virtualization][:role]).to eq("host")
-      expect(@plugin[:virtualization][:systems]['linux-vserver']).to eq("host")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("linux-vserver")
+      expect(plugin[:virtualization][:role]).to eq("host")
+      expect(plugin[:virtualization][:systems]['linux-vserver']).to eq("host")
     end
 
-    it "should set Linux-VServer host if /proc/self/status contains multiple space VxID:   0" do
+    it "sets Linux-VServer host if /proc/self/status contains multiple space VxID:   0" do
       expect(File).to receive(:exists?).with("/proc/self/status").and_return(true)
       allow(File).to receive(:read).with("/proc/self/status").and_return("VxID:   0")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("linux-vserver")
-      expect(@plugin[:virtualization][:role]).to eq("host")
-      expect(@plugin[:virtualization][:systems]['linux-vserver']).to eq("host")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("linux-vserver")
+      expect(plugin[:virtualization][:role]).to eq("host")
+      expect(plugin[:virtualization][:systems]['linux-vserver']).to eq("host")
     end
 
-    it "should set Linux-VServer host if /proc/self/status contains tabbed VxID:\t0" do
+    it "sets Linux-VServer host if /proc/self/status contains tabbed VxID:\t0" do
       expect(File).to receive(:exists?).with("/proc/self/status").and_return(true)
       allow(File).to receive(:read).with("/proc/self/status").and_return("VxID:\t0")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("linux-vserver")
-      expect(@plugin[:virtualization][:role]).to eq("host")
-      expect(@plugin[:virtualization][:systems]['linux-vserver']).to eq("host")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("linux-vserver")
+      expect(plugin[:virtualization][:role]).to eq("host")
+      expect(plugin[:virtualization][:systems]['linux-vserver']).to eq("host")
     end
 
-    it "should set Linux-VServer guest if /proc/self/status contains s_context > 0" do
+    it "sets Linux-VServer guest if /proc/self/status contains s_context > 0" do
       expect(File).to receive(:exists?).with("/proc/self/status").and_return(true)
       allow(File).to receive(:read).with("/proc/self/status").and_return("s_context: 2")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("linux-vserver")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems]['linux-vserver']).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("linux-vserver")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems]['linux-vserver']).to eq("guest")
     end
 
-    it "should set Linux-VServer guest if /proc/self/status contains VxID > 0" do
+    it "sets Linux-VServer guest if /proc/self/status contains VxID > 0" do
       expect(File).to receive(:exists?).with("/proc/self/status").and_return(true)
       allow(File).to receive(:read).with("/proc/self/status").and_return("VxID: 2")
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("linux-vserver")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems]['linux-vserver']).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("linux-vserver")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems]['linux-vserver']).to eq("guest")
     end
 
-    it "should not set virtualization if Linux-VServer isn't there" do
+    it "does not set virtualization if Linux-VServer isn't there" do
       expect(File).to receive(:exists?).at_least(:once).and_return(false)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
   end
 
   describe "when we are checking for openvz" do
-    it "should set openvz host if /proc/bc/0 exists" do
+    it "sets openvz host if /proc/bc/0 exists" do
       expect(File).to receive(:exists?).with("/proc/bc/0").and_return(true)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("openvz")
-      expect(@plugin[:virtualization][:role]).to eq("host")
-      expect(@plugin[:virtualization][:systems][:openvz]).to eq("host")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("openvz")
+      expect(plugin[:virtualization][:role]).to eq("host")
+      expect(plugin[:virtualization][:systems][:openvz]).to eq("host")
     end
 
-    it "should set openvz guest if /proc/bc/0 doesn't exist and /proc/vz exists" do
+    it "sets openvz guest if /proc/bc/0 does not exist and /proc/vz exists" do
       expect(File).to receive(:exists?).with("/proc/bc/0").and_return(false)
       expect(File).to receive(:exists?).with("/proc/vz").and_return(true)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("openvz")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:openvz]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("openvz")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:openvz]).to eq("guest")
     end
 
-    it "should not set virtualization if openvz isn't there" do
+    it "does not set virtualization if openvz isn't there" do
       expect(File).to receive(:exists?).with("/proc/bc/0").and_return(false)
       expect(File).to receive(:exists?).with("/proc/vz").and_return(false)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
   end
 
   describe "when we are checking for parallels" do
-    it "should set parallels guest if /proc/bus/pci/devices contains 1ab84000" do
+    it "sets parallels guest if /proc/bus/pci/devices contains 1ab84000" do
       devices=<<-DEVICES
 0018	1ab84000	1f	            8001	               0	               0	               0	               0	               0	               0	              20	               0	               0	               0	               0	               0	               0	prl_tg
 0028	1af41000	17	            8201	        ee000000	               0	               0	               0	               0	               0	              40	            1000	               0	               0	               0	               0	               0	virtio-pci
       DEVICES
       expect(File).to receive(:exists?).with("/proc/bus/pci/devices").and_return(true)
       allow(File).to receive(:read).with("/proc/bus/pci/devices").and_return(devices)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("parallels")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:parallels]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("parallels")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:parallels]).to eq("guest")
     end
 
-    it "should not set virtualization if /proc/bus/pci/devices not contains 1ab84000" do
+    it "does not set virtualization if /proc/bus/pci/devices not contains 1ab84000" do
       devices=<<-DEVICES
 0030	1af41000	a	            8401	        ee040000	               0	               0	               0	               0	               0	              40	            1000	               0	               0	               0	               0	               0	virtio-pci
 0050	10110022	0	               0	               0	               0	               0	               0	               0	               0	               0	               0	               0	               0	               0	               0	               0
       DEVICES
       expect(File).to receive(:exists?).with("/proc/bus/pci/devices").and_return(true)
       allow(File).to receive(:read).with("/proc/bus/pci/devices").and_return(devices)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
   end
 
   describe "when we are checking for lxc" do
-    it "should set lxc guest if /proc/self/cgroup exist and there are /lxc/<hexadecimal> mounts" do
+    it "sets lxc guest if /proc/self/cgroup exist and there are /lxc/<hexadecimal> mounts" do
       self_cgroup=<<-CGROUP
 8:blkio:/lxc/baa660ed81bc81d262ac6e19486142aeec5fce2043e2a173eb2505c6fbed89bc
 7:net_cls:/lxc/baa660ed81bc81d262ac6e19486142aeec5fce2043e2a173eb2505c6fbed89bc
@@ -361,13 +381,13 @@ OPENSTACK
 CGROUP
       expect(File).to receive(:exists?).with("/proc/self/cgroup").and_return(true)
       allow(File).to receive(:read).with("/proc/self/cgroup").and_return(self_cgroup)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("lxc")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:lxc]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("lxc")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:lxc]).to eq("guest")
     end
 
-    it "should set lxc guest if /proc/self/cgroup exist and there are /lxc/<name> mounts" do
+    it "sets lxc guest if /proc/self/cgroup exist and there are /lxc/<name> mounts" do
       self_cgroup=<<-CGROUP
 8:blkio:/lxc/vanilla
 7:net_cls:/lxc/vanilla
@@ -380,13 +400,13 @@ CGROUP
 CGROUP
       expect(File).to receive(:exists?).with("/proc/self/cgroup").and_return(true)
       allow(File).to receive(:read).with("/proc/self/cgroup").and_return(self_cgroup)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("lxc")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:lxc]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("lxc")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:lxc]).to eq("guest")
     end
 
-    it "should set not set anything if /proc/self/cgroup exist and the cgroup is named arbitrarily, it isn't necessarily lxc." do
+    it "sets not set anything if /proc/self/cgroup exist and the cgroup is named arbitrarily, it isn't necessarily lxc." do
       self_cgroup=<<-CGROUP
 8:blkio:/Charlie
 7:net_cls:/Charlie
@@ -399,8 +419,8 @@ CGROUP
 CGROUP
       expect(File).to receive(:exists?).with("/proc/self/cgroup").and_return(true)
       allow(File).to receive(:read).with("/proc/self/cgroup").and_return(self_cgroup)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
 
     context "/proc/self/cgroup only has / mounts" do
@@ -420,42 +440,42 @@ CGROUP
       end
 
       it "sets lxc host if lxc-version exists" do
-        allow(@plugin).to receive(:lxc_version_exists?).and_return("/usr/bin/lxc-version")
-        @plugin.run
-        expect(@plugin[:virtualization][:system]).to eq("lxc")
-        expect(@plugin[:virtualization][:role]).to eq("host")
-        expect(@plugin[:virtualization][:systems][:lxc]).to eq("host")
+        allow(plugin).to receive(:lxc_version_exists?).and_return("/usr/bin/lxc-version")
+        plugin.run
+        expect(plugin[:virtualization][:system]).to eq("lxc")
+        expect(plugin[:virtualization][:role]).to eq("host")
+        expect(plugin[:virtualization][:systems][:lxc]).to eq("host")
       end
 
       it "does not set the old virtualization attributes if they are already set" do
-        allow(@plugin).to receive(:lxc_version_exists?).and_return("/usr/bin/lxc-version")
-        @plugin[:virtualization] = Mash.new
-        @plugin[:virtualization][:system] = "the cloud"
-        @plugin[:virtualization][:role] = "cumulonimbus"
-        @plugin.run
-        expect(@plugin[:virtualization][:system]).not_to eq("lxc")
-        expect(@plugin[:virtualization][:role]).not_to eq("host")
+        allow(plugin).to receive(:lxc_version_exists?).and_return("/usr/bin/lxc-version")
+        plugin[:virtualization] = Mash.new
+        plugin[:virtualization][:system] = "the cloud"
+        plugin[:virtualization][:role] = "cumulonimbus"
+        plugin.run
+        expect(plugin[:virtualization][:system]).not_to eq("lxc")
+        expect(plugin[:virtualization][:role]).not_to eq("host")
       end
 
       it "does not set lxc host if lxc-version does not exist" do
-        allow(@plugin).to receive(:lxc_version_exists?).and_return(false)
-        @plugin.run
-        expect(@plugin[:virtualization][:system]).to be_nil
-        expect(@plugin[:virtualization][:role]).to be_nil
-        expect(@plugin[:virtualization]).to eq({'systems' => {}})
+        allow(plugin).to receive(:lxc_version_exists?).and_return(false)
+        plugin.run
+        expect(plugin[:virtualization][:system]).to be_nil
+        expect(plugin[:virtualization][:role]).to be_nil
+        expect(plugin[:virtualization]).to eq({'systems' => {}})
       end
 
     end
 
-    it "should not set virtualization if /proc/self/cgroup isn't there" do
+    it "does not set virtualization if /proc/self/cgroup isn't there" do
       expect(File).to receive(:exists?).with("/proc/self/cgroup").and_return(false)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
   end
 
   describe "when we are checking for docker" do
-    it "should set docker guest if /proc/self/cgroup exist and there are /docker/<hexadecimal> mounts" do
+    it "sets docker guest if /proc/self/cgroup exist and there are /docker/<hexadecimal> mounts" do
       self_cgroup=<<-CGROUP
 8:blkio:/docker/baa660ed81bc81d262ac6e19486142aeec5fce2043e2a173eb2505c6fbed89bc
 7:net_cls:/docker/baa660ed81bc81d262ac6e19486142aeec5fce2043e2a173eb2505c6fbed89bc
@@ -468,13 +488,13 @@ CGROUP
 CGROUP
       allow(File).to receive(:exists?).with("/proc/self/cgroup").and_return(true)
       allow(File).to receive(:read).with("/proc/self/cgroup").and_return(self_cgroup)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("docker")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:docker]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("docker")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:docker]).to eq("guest")
     end
 
-    it "should set docker guest if /proc/self/cgroup exist and there are /docker/<name> mounts" do
+    it "sets docker guest if /proc/self/cgroup exist and there are /docker/<name> mounts" do
       self_cgroup=<<-CGROUP
 8:blkio:/docker/vanilla
 7:net_cls:/docker/vanilla
@@ -487,13 +507,13 @@ CGROUP
 CGROUP
       allow(File).to receive(:exists?).with("/proc/self/cgroup").and_return(true)
       allow(File).to receive(:read).with("/proc/self/cgroup").and_return(self_cgroup)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("docker")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:docker]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("docker")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:docker]).to eq("guest")
     end
 
-    it "should set not set anything if /proc/self/cgroup exist and the cgroup is named arbitrarily, it isn't necessarily lxc." do
+    it "sets not set anything if /proc/self/cgroup exist and the cgroup is named arbitrarily, it isn't necessarily lxc." do
       self_cgroup=<<-CGROUP
 8:blkio:/Charlie
 7:net_cls:/Charlie
@@ -506,8 +526,8 @@ CGROUP
 CGROUP
       allow(File).to receive(:exists?).with("/proc/self/cgroup").and_return(true)
       allow(File).to receive(:read).with("/proc/self/cgroup").and_return(self_cgroup)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
 
     context "/proc/self/cgroup only has / mounts" do
@@ -524,63 +544,63 @@ CGROUP
 CGROUP
         allow(File).to receive(:exists?).with("/proc/self/cgroup").and_return(true)
         allow(File).to receive(:read).with("/proc/self/cgroup").and_return(self_cgroup)
-        @plugin.run
-        expect(@plugin[:virtualization]).to eq({'systems' => {}})
+        plugin.run
+        expect(plugin[:virtualization]).to eq({'systems' => {}})
       end
 
     end
 
     it "does not set the old virtualization attributes if they are already set" do
-      allow(@plugin).to receive(:docker_exists?).and_return("/usr/bin/docker")
-      @plugin[:virtualization] = Mash.new
-      @plugin[:virtualization][:system] = "the cloud"
-      @plugin[:virtualization][:role] = "cumulonimbus"
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).not_to eq("docker")
-      expect(@plugin[:virtualization][:role]).not_to eq("host")
+      allow(plugin).to receive(:docker_exists?).and_return("/usr/bin/docker")
+      plugin[:virtualization] = Mash.new
+      plugin[:virtualization][:system] = "the cloud"
+      plugin[:virtualization][:role] = "cumulonimbus"
+      plugin.run
+      expect(plugin[:virtualization][:system]).not_to eq("docker")
+      expect(plugin[:virtualization][:role]).not_to eq("host")
     end
 
     it "does not set docker host if docker does not exist" do
-      allow(@plugin).to receive(:docker_exists?).and_return(false)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to be_nil
-      expect(@plugin[:virtualization][:role]).to be_nil
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      allow(plugin).to receive(:docker_exists?).and_return(false)
+      plugin.run
+      expect(plugin[:virtualization][:system]).to be_nil
+      expect(plugin[:virtualization][:role]).to be_nil
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
 
-    it "should not set virtualization if /proc/self/cgroup isn't there" do
+    it "does not set virtualization if /proc/self/cgroup isn't there" do
       allow(File).to receive(:exists?).with("/proc/self/cgroup").and_return(false)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
 
-    it "should set virtualization if /.dockerenv exists" do
+    it "sets virtualization if /.dockerenv exists" do
       allow(File).to receive(:exists?).with("/.dockerenv").and_return(true)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("docker")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:docker]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("docker")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:docker]).to eq("guest")
     end
 
-    it "should set virtualization if /.dockerinit exists" do
+    it "sets virtualization if /.dockerinit exists" do
       allow(File).to receive(:exists?).with("/.dockerinit").and_return(true)
-      @plugin.run
-      expect(@plugin[:virtualization][:system]).to eq("docker")
-      expect(@plugin[:virtualization][:role]).to eq("guest")
-      expect(@plugin[:virtualization][:systems][:docker]).to eq("guest")
+      plugin.run
+      expect(plugin[:virtualization][:system]).to eq("docker")
+      expect(plugin[:virtualization][:role]).to eq("guest")
+      expect(plugin[:virtualization][:systems][:docker]).to eq("guest")
     end
 
-    it "should not set virtualization if /.dockerenv or /.dockerinit doesn't exists" do
+    it "does not set virtualization if /.dockerenv or /.dockerinit does not exists" do
       allow(File).to receive(:exists?).with("/.dockerenv").and_return(false)
       allow(File).to receive(:exists?).with("/.dockerinit").and_return(false)
-      @plugin.run
-      expect(@plugin[:virtualization]).to eq({'systems' => {}})
+      plugin.run
+      expect(plugin[:virtualization]).to eq({'systems' => {}})
     end
 
   end
 
-  it "should not set virtualization if no tests match" do
-    @plugin.run
-    expect(@plugin[:virtualization]).to eq({'systems' => {}})
+  it "does not set virtualization if no tests match" do
+    plugin.run
+    expect(plugin[:virtualization]).to eq({'systems' => {}})
   end
 end

data/spec/unit/system_spec.rb

@@ -96,8 +96,15 @@ describe "Ohai::System" do
     end
 
     it 'configures logging' do
+      log_level = :debug
+      Ohai.config[:log_level] = log_level
       expect(Ohai::Log).to receive(:init).with(Ohai.config[:log_location])
-      expect(Ohai::Log).to receive(:level=).with(Ohai.config[:log_level])
+      expect(Ohai::Log).to receive(:level=).with(log_level)
+      Ohai::System.new
+    end
+
+    it 'resolves log_level when set to :auto' do
+      expect(Ohai::Log).to receive(:level=).with(:info)
       Ohai::System.new
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ohai
 version: !ruby/object:Gem::Version
-  version: 8.6.0.alpha.0
+  version: 8.6.0.alpha.1
 platform: ruby
 authors:
 - Adam Jacob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-24 00:00:00.000000000 Z
+date: 2015-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types