ohai 15.3.1 → 15.6.3

data/spec/support/platform_helpers.rb

@@ -1,38 +0,0 @@
-#
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you
-# may not use this file except in compliance with the License. You may
-# obtain a copy of the license at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either expressed or
-# implied.
-# See the License for the specific language governing permissions and
-# limitations under the License
-#
-
-def windows?
-  !!(RUBY_PLATFORM =~ /mswin|mingw|windows/)
-end
-
-def unix?
-  !windows?
-end
-
-def os_x?
-  !!(RUBY_PLATFORM =~ /darwin/)
-end
-
-def solaris?
-  !!(RUBY_PLATFORM =~ /solaris/)
-end
-
-def freebsd?
-  !!(RUBY_PLATFORM =~ /freebsd/)
-end
-
-DEV_NULL = windows? ? "NUL" : "/dev/null"

data/spec/unit/application_spec.rb

@@ -1,96 +0,0 @@
-#
-# Author:: Claire McQuin <claire@chef.io>
-# Copyright:: Copyright (c) 2015-2016 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "ohai/application"
-
-RSpec.describe "Ohai::Application" do
-
-  let(:argv) { [] }
-  let(:app) { Ohai::Application.new }
-
-  before do
-    @original_argv = ARGV
-    ARGV.replace(argv)
-  end
-
-  after do
-    ARGV.replace(@original_argv)
-  end
-
-  describe "#configure_ohai" do
-    describe "loading configuration from a file" do
-      let(:config_file) { "/local/workstation/config" }
-      let(:config_loader) { instance_double("ChefConfig::WorkstationConfigLoader") }
-
-      context "when specified on the command line" do
-        let(:argv) { [ "-c", config_file ] }
-
-        before do
-          if windows?
-            expect(ChefConfig::WorkstationConfigLoader).to receive(:new)
-              .with("C:#{config_file}", Ohai::Log)
-              .and_return(config_loader)
-          else
-            expect(ChefConfig::WorkstationConfigLoader).to receive(:new)
-              .with(config_file, Ohai::Log)
-              .and_return(config_loader)
-          end
-        end
-
-        it "loads the configuration file" do
-          expect(config_loader).to receive(:load)
-          app.configure_ohai
-        end
-
-        context "when the configuration file does not exist" do
-          it "terminates the application" do
-            expect(config_loader).to receive(:load).and_raise(ChefConfig::ConfigurationError)
-            expect(Ohai::Application).to receive(:fatal!)
-            app.configure_ohai
-          end
-        end
-      end
-
-      context "when a local workstation config exists" do
-        before do
-          expect(ChefConfig::WorkstationConfigLoader).to receive(:new)
-            .with(nil, Ohai::Log)
-            .and_return(config_loader)
-        end
-
-        it "loads the configuration file" do
-          expect(config_loader).to receive(:load)
-          app.configure_ohai
-        end
-      end
-    end
-
-    context "when CLI options are provided" do
-      let(:argv) { [ "-d", directory ] }
-      let(:directory) { "/some/fantastic/plugins" }
-
-      it "does not generate deprecated config warnings for cli options" do
-        expect(Ohai::Log).not_to receive(:warn)
-          .with(/Ohai::Config\[:directory\] is deprecated/)
-        app.configure_ohai
-      end
-    end
-
-  end
-end

data/spec/unit/config_spec.rb

@@ -1,57 +0,0 @@
-#
-# Author:: Claire McQuin (<claire@chef.io>)
-# Copyright:: Copyright (c) 2015-2016 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "ohai/config"
-
-RSpec.describe Ohai::Config do
-
-  describe "config_context :ohai" do
-    describe "option :plugin" do
-      it "gets configured with a value" do
-        Ohai::Config.ohai[:plugin][:foo] = true
-        expect(Ohai::Config.ohai[:plugin]).to have_key(:foo)
-        expect(Ohai::Config.ohai[:plugin][:foo]).to be true
-      end
-
-      it "gets configured with a Hash" do
-        value = { bar: true, baz: true }
-        Ohai::Config.ohai[:plugin][:foo] = value
-        expect(Ohai::Config.ohai[:plugin]).to have_key(:foo)
-        expect(Ohai::Config.ohai[:plugin][:foo]).to eq(value)
-      end
-
-      it "raises an error if the plugin name is not a symbol" do
-        expect { Ohai::Config.ohai[:plugin]["foo"] = false }
-          .to raise_error(Ohai::Exceptions::PluginConfigError, /Expected Symbol/)
-      end
-
-      it "raises an error if the value Hash has non-Symbol key" do
-        value = { :bar => true, "baz" => true }
-        expect { Ohai::Config.ohai[:plugin][:foo] = value }
-          .to raise_error(Ohai::Exceptions::PluginConfigError, /Expected Symbol/)
-      end
-    end
-  end
-
-  describe "Ohai.config" do
-    it "returns the ohai config context" do
-      expect(Ohai.config).to eq(Ohai::Config.ohai)
-    end
-  end
-end

data/spec/unit/dsl/plugin_spec.rb

@@ -1,634 +0,0 @@
-#
-# Author:: Claire McQuin (<claire@chef.io>)
-# Copyright:: Copyright (c) 2013-2016 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you
-# may not use this file except in compliance with the License. You may
-# obtain a copy of the license at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either expressed or
-# implied.
-# See the License for the specific language governing permissions and
-# limitations under the License
-#
-
-require "spec_helper"
-
-shared_examples "Ohai::DSL::Plugin" do
-  context "#initialize" do
-    it "sets has_run? to false" do
-      expect(plugin.has_run?).to be false
-    end
-
-    it "sets the correct plugin version" do
-      expect(plugin.version).to eql(version)
-    end
-  end
-
-  context "#run" do
-    before do
-      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
-        allow(Ohai.config).to receive(:[]).with(:disabled_plugins).and_return([ ])
-      end
-
-      it "runs the plugin" do
-        expect(plugin).to receive(:run_plugin)
-        plugin.run
-      end
-
-      it "sets has_run? to true" do
-        plugin.run
-        expect(plugin.has_run?).to be true
-      end
-    end
-
-    describe "if the plugin is disabled" do
-      before do
-        allow(Ohai.config).to receive(:[]).with(:disabled_plugins).and_return([ :TestPlugin ])
-      end
-
-      it "does not run the plugin" do
-        expect(plugin).not_to receive(:run_plugin)
-        plugin.run
-      end
-
-      it "logs a message to trace" do
-        expect(plugin.logger).to receive(:trace).with(/Skipping disabled plugin TestPlugin/)
-        plugin.run
-      end
-
-      it "sets has_run? to true" do
-        plugin.run
-        expect(plugin.has_run?).to be true
-      end
-    end
-  end
-
-  context "when accessing data via method_missing" do
-    it "takes a missing method and store the method name as a key, with its arguments as values" do
-      plugin.guns_n_roses("chinese democracy")
-      expect(plugin.data["guns_n_roses"]).to eql("chinese democracy")
-    end
-
-    it "returns the current value of the method name" do
-      expect(plugin.guns_n_roses("chinese democracy")).to eql("chinese democracy")
-    end
-
-    it "allows you to get the value of a key by calling method_missing with no arguments" do
-      plugin.guns_n_roses("chinese democracy")
-      expect(plugin.guns_n_roses).to eql("chinese democracy")
-    end
-  end
-
-  describe "set_attribute" do
-    it "raises an ArgumentError when given one argument" do
-      expect { plugin.set_attribute(:tea) }.to raise_error(ArgumentError)
-    end
-
-    it "lets you set an attribute" do
-      plugin.set_attribute(:tea, "is soothing")
-      expect(plugin.data["tea"]).to eql("is soothing")
-    end
-
-    it "lets you set an attribute to an empty array" do
-      plugin.set_attribute(:tea, [])
-      expect(plugin.data["tea"]).to eql([])
-    end
-
-    it "lets you set an attribute to an empty Mash" do
-      plugin.set_attribute(:tea, {})
-      expect(plugin.data["tea"]).to eql({})
-    end
-
-    it "lets you modify an attribute" do
-      plugin.data["tea"] = "is soothing"
-      plugin.set_attribute(:tea, "tastes like plants")
-      expect(plugin.data["tea"]).to eql("tastes like plants")
-    end
-
-    it "lets you set a subattribute" do
-      plugin.data["tea"] = Mash.new
-      plugin.set_attribute(:tea, :green, "tastes like green")
-      expect(plugin.data["tea"]["green"]).to eql("tastes like green")
-    end
-
-    it "lets you set a subattribute to an empty array" do
-      plugin.set_attribute(:tea, :green, [])
-      expect(plugin.data["tea"]["green"]).to eql([])
-    end
-
-    it "lets you set a subattribute to an empty Mash" do
-      plugin.set_attribute(:tea, :green, {})
-      expect(plugin.data["tea"]["green"]).to eql({})
-    end
-
-    it "lets you modify a subattribute" do
-      plugin.data["tea"] = Mash.new
-      plugin.data["tea"]["green"] = "tastes like green"
-      plugin.set_attribute(:tea, :green, "made from leaves")
-      expect(plugin.data["tea"]["green"]).to eql("made from leaves")
-    end
-
-    it "raises a TypeError when modifying an attribute that is not a Mash" do
-      plugin.data["tea"] = Mash.new
-      plugin.data["tea"] = "is soothing"
-      expect { plugin.set_attribute(:tea, :green, "tastes like green") }.to raise_error(TypeError)
-    end
-
-    it "lets you modify a subattribute with an array" do
-      green = { flavor: "tastes like green" }
-      black = { flavor: "tastes like black" }
-      plugin.data[:tea] = [green, black]
-      plugin.set_attribute(:tea, 0, :source, "made from leaves")
-      expect(plugin.data[:tea][0][:source]).to eq("made from leaves")
-    end
-  end
-
-  context "when getting attributes" do
-    before do
-      plugin.set_attribute(:tea, "is soothing")
-    end
-
-    it "lets you get an attribute" do
-      expect(plugin.get_attribute("tea")).to eql("is soothing")
-    end
-  end
-
-  describe "get_attribute" do
-    it "requires at least one argument" do
-      expect { plugin.get_attribute }.to raise_error(ArgumentError)
-    end
-
-    describe "a top-level attribute" do
-      before do
-        plugin.set_attribute(:tea, "is soothing")
-      end
-
-      describe "as a string" do
-        it "returns nil when the attribute does not exist" do
-          expect(plugin.get_attribute("coffee")).to be nil
-        end
-
-        it "returns the attribute when it exists" do
-          expect(plugin.get_attribute("tea")).to eql("is soothing")
-        end
-      end
-
-      describe "as a symbol" do
-        it "returns false when the attribute does not exist" do
-          expect(plugin.get_attribute(:coffee)).to be nil
-        end
-
-        it "returns true when the attribute exists" do
-          expect(plugin.get_attribute(:tea)).to eql("is soothing")
-        end
-      end
-    end
-
-    describe "a nested attribute" do
-      before do
-        plugin.set_attribute(:the_monarch, { arch_rival: "dr_venture" })
-      end
-
-      describe "as a list" do
-        describe "of strings" do
-          it "returns true when the attribute exists" do
-            expect(plugin.get_attribute("the_monarch", "arch_rival"))
-              .to eql("dr_venture")
-          end
-
-          describe "when the attribute does not exist" do
-            describe "and the subkey is missing" do
-              it "returns nil" do
-                expect(
-                  plugin.get_attribute("the_monarch", "henchmen")
-                ).to be nil
-              end
-            end
-
-            describe "and an intermediate key is missing" do
-              it "returns nil" do
-                expect(
-                  plugin.get_attribute("the_monarch", "henchmen",
-                    "corky_knightrider")
-                ).to be nil
-              end
-            end
-
-            describe "and an intermediate key is not a hash" do
-              it "raises a TypeError" do
-                expect do
-                  plugin.get_attribute("the_monarch", "arch_rival",
-                    "dr_venture", "since")
-                end.to raise_error(TypeError,
-                  "Expected Hash but got String.")
-              end
-            end
-          end
-        end
-
-        describe "of symbols" do
-          it "returns true when the attribute exists" do
-            expect(plugin.get_attribute(:the_monarch, :arch_rival))
-              .to eql("dr_venture")
-          end
-
-          describe "when the attribute does not exist" do
-            describe "and the subkey is missing" do
-              it "returns nil" do
-                expect(plugin.get_attribute(:the_monarch, :henchmen)).to be nil
-              end
-            end
-
-            describe "and an intermediate key is missing" do
-              it "returns nil" do
-                expect(
-                  plugin.get_attribute(:the_monarch, :henchmen,
-                    :corky_knightrider)
-                ).to be nil
-              end
-            end
-
-            describe "and an intermediate key is not a hash" do
-              it "raises a TypeError" do
-                expect do
-                  plugin.get_attribute(:the_monarch, :arch_rival,
-                    :dr_venture, :since)
-                end.to raise_error(TypeError,
-                  "Expected Hash but got String.")
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe "attribute?" do
-    it "requires at least one argument" do
-      expect { plugin.attribute? }.to raise_error(ArgumentError)
-    end
-
-    describe "a top-level attribute" do
-      describe "as a string" do
-        it "returns false when the attribute does not exist" do
-          expect(plugin.attribute?("alice in chains")).to eql(false)
-        end
-
-        it "returns true if an attribute exists with the given name" do
-          plugin.metallica("death magnetic")
-          expect(plugin.attribute?("metallica")).to eql(true)
-        end
-      end
-
-      describe "as a symbol" do
-        it "returns false when the attribute does not exist" do
-          expect(plugin.attribute?(:sparkle_dream)).to be false
-        end
-
-        it "returns true when the attribute exists" do
-          plugin.set_attribute("sparkle_dream", { version: 256 })
-          expect(plugin.attribute?(:sparkle_dream)).to be true
-        end
-      end
-    end
-
-    describe "a nested attribute" do
-      before do
-        plugin.set_attribute(:the_monarch, { arch_rival: "dr_venture" })
-      end
-
-      describe "as a list" do
-        describe "of strings" do
-          it "returns true when the attribute exists" do
-            expect(plugin.attribute?("the_monarch", "arch_rival")).to be true
-          end
-
-          describe "when the attribute does not exist" do
-            describe "and the subkey is missing" do
-              it "returns false" do
-                expect(
-                  plugin.attribute?("the_monarch", "henchmen")
-                ).to be false
-              end
-            end
-
-            describe "and an intermediate key is missing" do
-              it "returns false" do
-                expect(
-                  plugin.attribute?("the_monarch", "henchmen",
-                    "corky_knightrider")
-                ).to be false
-              end
-            end
-
-            describe "and an intermediate key is not a hash" do
-              it "raises a TypeError" do
-                expect do
-                  plugin.attribute?("the_monarch", "arch_rival",
-                    "dr_venture", "since")
-                end.to raise_error(TypeError,
-                  "Expected Hash but got String.")
-              end
-            end
-          end
-        end
-
-        describe "of symbols" do
-          it "returns true when the attribute exists" do
-            expect(plugin.attribute?(:the_monarch, :arch_rival)).to be true
-          end
-
-          describe "when the attribute does not exist" do
-            describe "and the subkey is missing" do
-              it "returns false" do
-                expect(plugin.attribute?(:the_monarch, :henchmen)).to be false
-              end
-            end
-
-            describe "and an intermediate key is missing" do
-              it "returns false" do
-                expect(
-                  plugin.attribute?(:the_monarch, :henchmen,
-                    :corky_knightrider)
-                ).to be false
-              end
-            end
-
-            describe "and an intermediate key is not a hash" do
-              it "raises a TypeError" do
-                expect do
-                  plugin.attribute?(:the_monarch, :arch_rival,
-                    :dr_venture, :since)
-                end.to raise_error(TypeError,
-                  "Expected Hash but got String.")
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-describe Ohai::DSL::Plugin::VersionVII do
-  let(:logger) { Ohai::Log }
-
-  it "does not modify the plugin name when the plugin is named correctly" do
-    plugin = Ohai.plugin(:FunkyVALIDpluginName) {}.new({}, logger)
-    expect(plugin.name).to be(:FunkyVALIDpluginName)
-  end
-
-  describe "when the plugin is named incorrectly" do
-    context "because the plugin name doesn't start with a capital letter" do
-      it "raises an Ohai::Exceptions::InvalidPluginName exception" do
-        expect { Ohai.plugin(:badName) {} }.to raise_error(Ohai::Exceptions::InvalidPluginName, /badName is not a valid plugin name/)
-      end
-    end
-
-    context "because the plugin name contains an underscore" do
-      it "raises an Ohai::Exceptions::InvalidPluginName exception" do
-        expect { Ohai.plugin(:Bad_Name) {} }.to raise_error(Ohai::Exceptions::InvalidPluginName, /Bad_Name is not a valid plugin name/)
-      end
-    end
-
-    context "because the plugin name isn't a symbol" do
-      it "raises an Ohai::Exceptions::InvalidPluginName exception" do
-        expect { Ohai.plugin(1138) {} }.to raise_error(Ohai::Exceptions::InvalidPluginName, /1138 is not a valid plugin name/)
-      end
-    end
-  end
-
-  describe "#version" do
-    it "saves the plugin version as :version7" do
-      plugin = Ohai.plugin(:Test) {}
-      expect(plugin.version).to be(:version7)
-    end
-  end
-
-  describe "#provides" do
-    it "collects a single attribute" do
-      plugin = Ohai.plugin(:Test) { provides("one") }
-      expect(plugin.provides_attrs).to eql(["one"])
-    end
-
-    it "collects a list of attributes" do
-      plugin = Ohai.plugin(:Test) { provides("one", "two", "three") }
-      expect(plugin.provides_attrs).to eql(%w{one two three})
-    end
-
-    it "collects from multiple provides statements" do
-      plugin = Ohai.plugin(:Test) do
-        provides("one")
-        provides("two", "three")
-        provides("four")
-      end
-      expect(plugin.provides_attrs).to eql(%w{one two three four})
-    end
-
-    it "collects attributes across multiple plugin files" do
-      plugin = Ohai.plugin(:Test) { provides("one") } # rubocop: disable Lint/UselessAssignment
-      plugin = Ohai.plugin(:Test) { provides("two", "three") }
-      expect(plugin.provides_attrs).to eql(%w{one two three})
-    end
-
-    it "collects unique attributes" do
-      plugin = Ohai.plugin(:Test) { provides("one") } # rubocop: disable Lint/UselessAssignment
-      plugin = Ohai.plugin(:Test) { provides("one", "two") }
-      expect(plugin.provides_attrs).to eql(%w{one two})
-    end
-  end
-
-  describe "#depends" do
-    it "collects a single dependency" do
-      plugin = Ohai.plugin(:Test) { depends("one") }
-      expect(plugin.depends_attrs).to eql(["one"])
-    end
-
-    it "collects a list of dependencies" do
-      plugin = Ohai.plugin(:Test) { depends("one", "two", "three") }
-      expect(plugin.depends_attrs).to eql(%w{one two three})
-    end
-
-    it "collects from multiple depends statements" do
-      plugin = Ohai.plugin(:Test) do
-        depends("one")
-        depends("two", "three")
-        depends("four")
-      end
-      expect(plugin.depends_attrs).to eql(%w{one two three four})
-    end
-
-    it "collects dependencies across multiple plugin files" do
-      plugin = Ohai.plugin(:Test) { depends("one") } # rubocop: disable Lint/UselessAssignment
-      plugin = Ohai.plugin(:Test) { depends("two", "three") }
-      expect(plugin.depends_attrs).to eql(%w{one two three})
-    end
-
-    it "collects unique attributes" do
-      plugin = Ohai.plugin(:Test) { depends("one") } # rubocop: disable Lint/UselessAssignment
-      plugin = Ohai.plugin(:Test) { depends("one", "two") }
-      expect(plugin.depends_attrs).to eql(%w{one two})
-    end
-  end
-
-  describe "#collect_data" do
-    it "saves as :default if no platform is given" do
-      plugin = Ohai.plugin(:Test) { collect_data {} }
-      expect(plugin.data_collector).to have_key(:default)
-    end
-
-    it "saves a single given platform" do
-      plugin = Ohai.plugin(:Test) { collect_data(:ubuntu) {} }
-      expect(plugin.data_collector).to have_key(:ubuntu)
-    end
-
-    it "saves a list of platforms" do
-      plugin = Ohai.plugin(:Test) { collect_data(:freebsd, :netbsd, :openbsd) {} }
-      %i{freebsd netbsd openbsd}.each do |platform|
-        expect(plugin.data_collector).to have_key(platform)
-      end
-    end
-
-    it "saves multiple collect_data blocks" do
-      plugin = Ohai.plugin(:Test) do
-        collect_data {}
-        collect_data(:windows) {}
-        collect_data(:darwin) {}
-      end
-      %i{darwin default windows}.each do |platform|
-        expect(plugin.data_collector).to have_key(platform)
-      end
-    end
-
-    it "saves platforms across multiple plugins" do
-      plugin = Ohai.plugin(:Test) { collect_data {} }
-      plugin = Ohai.plugin(:Test) { collect_data(:aix, :sigar) {} }
-      %i{aix default sigar}.each do |platform|
-        expect(plugin.data_collector).to have_key(platform)
-      end
-    end
-
-    it "fails a platform has already been defined in the same plugin" do
-      Ohai.plugin(:Test) { collect_data {} }
-      expect(Ohai::Log).to receive(:warn).with(/collect_data already defined on platform/).twice
-      Ohai.plugin(:Test) do
-        collect_data {}
-        collect_data {}
-      end
-    end
-
-    it "fails if a platform has already been defined in another plugin file" do
-      Ohai.plugin(:Test) { collect_data {} }
-      expect(Ohai::Log).to receive(:warn).with(/collect_data already defined on platform/)
-      Ohai.plugin(:Test) do
-        collect_data {}
-      end
-    end
-  end
-
-  describe "#provides (deprecated)" do
-    it "logs a warning" do
-      plugin = Ohai.plugin(:Test).new(Mash.new, logger)
-      expect_any_instance_of(Mixlib::Log::Child).to receive(:warn).with(/\[UNSUPPORTED OPERATION\]/)
-      plugin.provides("attribute")
-    end
-  end
-
-  describe "#require_plugin (deprecated)" do
-    it "logs a warning" do
-      plugin = Ohai.plugin(:Test).new(Mash.new, logger)
-      expect_any_instance_of(Mixlib::Log::Child).to receive(:warn).with(/\[UNSUPPORTED OPERATION\]/)
-      plugin.require_plugin("plugin")
-    end
-  end
-
-  describe "#configuration" do
-    let(:plugin) do
-      klass = Ohai.plugin(camel_name) {}
-      klass.new({}, logger)
-    end
-
-    shared_examples_for "plugin config lookup" do
-      it "returns the configuration option value" do
-        Ohai.config[:plugin][snake_name][:foo] = true
-        expect(plugin.configuration(:foo)).to eq(true)
-      end
-    end
-
-    describe "a plugin named Abc" do
-      let(:camel_name) { :Abc }
-      let(:snake_name) { :abc }
-
-      it "returns nil when the plugin is not configured" do
-        expect(plugin.configuration(:foo)).to eq(nil)
-      end
-
-      it "does not auto-vivify an un-configured plugin" do
-        plugin.configuration(:foo)
-        expect(Ohai.config[:plugin]).not_to have_key(:test)
-      end
-
-      it "returns nil when the option is not configured" do
-        Ohai.config[:plugin][snake_name][:foo] = true
-        expect(plugin.configuration(:bar)).to eq(nil)
-      end
-
-      it "returns nil when the suboption is not configured" do
-        Ohai.config[:plugin][snake_name][:foo] = {}
-        expect(plugin.configuration(:foo, :bar)).to eq(nil)
-      end
-
-      include_examples "plugin config lookup"
-
-      it "returns the configuration sub-option value" do
-        Ohai.config[:plugin][snake_name][:foo] = { bar: true }
-        expect(plugin.configuration(:foo, :bar)).to eq(true)
-      end
-    end
-
-    describe "a plugin named ABC" do
-      let(:camel_name) { :ABC }
-      let(:snake_name) { :abc }
-
-      include_examples "plugin config lookup"
-    end
-
-    describe "a plugin named Abc2" do
-      let(:camel_name) { :Abc2 }
-      let(:snake_name) { :abc_2 }
-
-      include_examples "plugin config lookup"
-    end
-
-    describe "a plugin named AbcAbc" do
-      let(:camel_name) { :AbcXyz }
-      let(:snake_name) { :abc_xyz }
-
-      include_examples "plugin config lookup"
-    end
-
-    describe "a plugin named ABCLmnoXyz" do
-      let(:camel_name) { :ABCLmnoXyz }
-      let(:snake_name) { :abc_lmno_xyz }
-
-      include_examples "plugin config lookup"
-    end
-  end
-
-  it_behaves_like "Ohai::DSL::Plugin" do
-    let(:ohai) { Ohai::System.new }
-    let(:plugin) { Ohai.plugin(:Test).new(ohai.data, ohai.logger) }
-    let(:version) { :version7 }
-  end
-end