ohai 15.3.1 → 15.6.3

data/spec/unit/hints_spec.rb

@@ -1,65 +0,0 @@
-#
-# Author:: Serdar Sutay (<serdar@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 express or
-# implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-
-describe "Ohai::Hints" do
-  # We are using the plugins directory infrastructure to test hints
-  extend IntegrationSupport
-
-  before do
-    @original_hints = Ohai.config[:hints_path]
-  end
-
-  after do
-    Ohai.config[:hints_path] = @original_hints
-  end
-
-  when_plugins_directory "doesn't contain any hints" do
-    before do
-      Ohai.config[:hints_path] = [ path_to(".") ]
-    end
-
-    it "hint? should return nil" do
-      expect(Ohai::Hints.hint?("cloud")).to be_nil
-    end
-  end
-
-  when_plugins_directory "contains empty and full hints" do
-    with_plugin("cloud.json", <<~EOF)
-      {"name":"circus"}
-    EOF
-
-    with_plugin("cloud_empty.json", <<EOF)
-EOF
-
-    before do
-      Ohai.config[:hints_path] = [ path_to(".") ]
-    end
-
-    it "hint? should return the data for full hints" do
-      expect(Ohai::Hints.hint?("cloud")).to eq({ "name" => "circus" })
-    end
-
-    it "hint? should return empty hash for empty hints" do
-      expect(Ohai::Hints.hint?("cloud_empty")).to eq({})
-    end
-  end
-
-end

data/spec/unit/loader_spec.rb

@@ -1,195 +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 express or
-# implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-
-describe Ohai::Loader do
-  extend IntegrationSupport
-
-  let(:loader) { Ohai::Loader.new(ohai) }
-  let(:ohai) { double("Ohai::System", data: Mash.new, provides_map: provides_map, logger: Ohai::Log) }
-  let(:provides_map) { Ohai::ProvidesMap.new }
-
-  describe "#initialize" do
-    it "returns an Ohai::Loader object" do
-      loader = Ohai::Loader.new(ohai)
-      expect(loader).to be_a_kind_of(Ohai::Loader)
-    end
-  end
-
-  when_plugins_directory "is an additional plugin path" do
-    with_plugin("cookbook_a/alpha.rb", <<~EOF)
-      Ohai.plugin(:Alpha) do
-        provides "alpha"
-      end
-    EOF
-
-    with_plugin("cookbook_b/beta.rb", <<~EOF)
-      Ohai.plugin(:Beta) do
-        provides "beta"
-      end
-    EOF
-
-    describe "#load_additional" do
-      it "adds the plugins to the map" do
-        loader.load_additional(@plugins_directory)
-        expect(provides_map.map.keys).to include("alpha")
-      end
-
-      it "returns a set of plugins" do
-        expect(loader.load_additional(@plugins_directory)).to include(Ohai::NamedPlugin::Alpha)
-      end
-    end
-  end
-
-  when_plugins_directory "contains invalid plugins" do
-    with_plugin("extra_s.rb", <<~EOF)
-      Ohai.plugins(:ExtraS) do
-        provides "the_letter_s"
-      end
-    EOF
-
-    with_plugin("no_method.rb", <<~EOF)
-      Ohai.plugin(:NoMethod) do
-        really_wants "this_attribute"
-      end
-    EOF
-
-    with_plugin("illegal_def.rb", <<~EOF)
-      Ohai.plugin(:Zoo) do
-        collect_data(:darwin) do
-        end
-        collect_data(:darwin) do
-        end
-      end
-    EOF
-
-    with_plugin("unexpected_error.rb", <<~EOF)
-      Ohai.plugin(:Zoo) do
-        raise "You aren't expecting this."
-      end
-    EOF
-
-    with_plugin("bad_symbol.rb", <<~EOF)
-      Ohai.plugin(:1nval!d) do
-        provides "not_a_symbol"
-      end
-    EOF
-
-    with_plugin("no_end.rb", <<~EOF)
-      Ohai.plugin(:NoEnd) do
-        provides "fish_oil"
-        collect_data do
-      end
-    EOF
-
-    with_plugin("bad_name.rb", <<~EOF)
-      Ohai.plugin(:you_give_plugins_a_bad_name) do
-        provides "that/one/song"
-      end
-    EOF
-
-    describe "load_plugin() method" do
-      describe "when the plugin uses Ohai.plugin instead of Ohai.plugins" do
-        it "logs an unsupported operation warning" do
-          expect(loader.logger).to receive(:warn).with(/Plugin Method Error: <#{path_to("extra_s.rb")}>:/)
-          loader.load_plugin(path_to("extra_s.rb"))
-        end
-
-        it "does not raise an error" do
-          expect { loader.load_plugin(path_to("extra_s.rb")) }.not_to raise_error
-        end
-      end
-
-      describe "when the plugin tries to call an unexisting method" do
-        it "shoud log an unsupported operation warning" do
-          expect(loader.logger).to receive(:warn).with(/Plugin Method Error: <#{path_to("no_method.rb")}>:/)
-          loader.load_plugin(path_to("no_method.rb"))
-        end
-
-        it "does not raise an error" do
-          expect { loader.load_plugin(path_to("no_method.rb")) }.not_to raise_error
-        end
-      end
-
-      describe "when the plugin defines collect_data on the same platform more than once" do
-        it "shoud log an illegal plugin definition warning" do
-          expect(Ohai::Log).to receive(:warn).with(/collect_data already defined on platform/)
-          loader.load_plugin(path_to("illegal_def.rb"))
-        end
-
-        it "does not raise an error" do
-          expect { loader.load_plugin(path_to("illegal_def.rb")) }.not_to raise_error
-        end
-      end
-
-      describe "when an unexpected error is encountered" do
-        it "logs a warning" do
-          expect(loader.logger).to receive(:warn).with(/Plugin Error: <#{path_to("unexpected_error.rb")}>:/)
-          loader.load_plugin(path_to("unexpected_error.rb"))
-        end
-
-        it "does not raise an error" do
-          expect { loader.load_plugin(path_to("unexpected_error.rb")) }.not_to raise_error
-        end
-      end
-
-      describe "when the plugin name symbol has bad syntax" do
-        it "logs a syntax error warning" do
-          expect(loader.logger).to receive(:warn).with(/Plugin Syntax Error: <#{path_to("bad_symbol.rb")}>:/)
-          loader.load_plugin(path_to("bad_symbol.rb"))
-        end
-
-        it "does not raise an error" do
-          expect { loader.load_plugin(path_to("bad_symbol.rb")) }.not_to raise_error
-        end
-      end
-
-      describe "when the plugin forgets an 'end'" do
-        it "logs a syntax error warning" do
-          expect(loader.logger).to receive(:warn).with(/Plugin Syntax Error: <#{path_to("no_end.rb")}>:/)
-          loader.load_plugin(path_to("no_end.rb"))
-        end
-
-        it "does not raise an error" do
-          expect { loader.load_plugin(path_to("no_end.rb")) }.not_to raise_error
-        end
-      end
-
-      describe "when the plugin has an invalid name" do
-        it "logs an invalid plugin name warning" do
-          expect(loader.logger).to receive(:warn).with(/Plugin Name Error: <#{path_to("bad_name.rb")}>:/)
-          loader.load_plugin(path_to("bad_name.rb"))
-        end
-
-        it "does not raise an error" do
-          expect { loader.load_plugin(path_to("bad_name.rb")) }.not_to raise_error
-        end
-      end
-
-      describe "when plugin directory does not exist" do
-        it "logs an invalid plugin path warning" do
-          expect(Ohai::Log).to receive(:debug).with(/The plugin path.*does not exist/)
-          allow(Dir).to receive(:exist?).with("/bogus/dir").and_return(false)
-          loader.plugin_files_by_dir("/bogus/dir")
-        end
-      end
-    end
-  end
-end

data/spec/unit/mixin/azure_metadata_spec.rb

@@ -1,72 +0,0 @@
-#
-# Author:: Tim Smith <tsmith@chef.io>
-# Copyright:: 2017 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 CONDIT"Net::HTTP Response"NS 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/mixin/azure_metadata"
-
-describe Ohai::Mixin::AzureMetadata do
-  let(:mixin) do
-    mixin = Object.new.extend(::Ohai::Mixin::AzureMetadata)
-    mixin
-  end
-
-  before do
-    logger = instance_double("Mixlib::Log::Child", trace: nil, debug: nil, warn: nil)
-    allow(mixin).to receive(:logger).and_return(logger)
-  end
-
-  describe "#http_get" do
-    it "gets the passed URI" do
-      http_mock = double("http")
-      allow(http_mock).to receive(:read_timeout=)
-      allow(Net::HTTP).to receive(:start).with("169.254.169.254").and_return(http_mock)
-
-      expect(http_mock).to receive(:get).with("http://www.chef.io", { "Metadata" => "true" })
-      mixin.http_get("http://www.chef.io")
-    end
-  end
-
-  describe "#fetch_metadata" do
-    it "returns an empty hash given a non-200 response" do
-      http_mock = double("http", { code: "500" })
-      allow(mixin).to receive(:http_get).and_return(http_mock)
-
-      expect(mixin.logger).to receive(:warn)
-      vals = mixin.fetch_metadata
-      expect(vals).to eq(nil)
-    end
-
-    it "returns an empty hash given invalid JSON response" do
-      http_mock = double("http", { code: "200", body: '{ "foo" "bar"}' })
-      allow(mixin).to receive(:http_get).and_return(http_mock)
-
-      expect(mixin.logger).to receive(:warn)
-      vals = mixin.fetch_metadata
-      expect(vals).to eq(nil)
-    end
-
-    it "returns a populated hash given valid JSON response" do
-      http_mock = double("http", { code: "200", body: '{ "foo": "bar"}' })
-      allow(mixin).to receive(:http_get).and_return(http_mock)
-
-      expect(mixin.logger).not_to receive(:warn)
-      vals = mixin.fetch_metadata
-      expect(vals).to eq({ "foo" => "bar" })
-    end
-  end
-end

data/spec/unit/mixin/command_spec.rb

@@ -1,151 +0,0 @@
-# encoding: utf-8
-#
-# Author:: Diego Algorta (diego@oboxodo.com)
-# Copyright:: Copyright (c) 2009 Diego Algorta
-# 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"
-
-describe Ohai::Mixin::Command, "shell_out" do
-  let(:cmd) { "sparkle-dream --version" }
-
-  let(:shell_out) { double("Mixlib::ShellOut") }
-
-  let(:plugin_name) { :OSSparkleDream }
-
-  let(:options) { windows? ? { timeout: 30 } : { timeout: 30, env: { "PATH" => "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" } } }
-
-  let(:logger) { instance_double("Mixlib::Log::Child", trace: nil, debug: nil, warn: nil) }
-
-  before do
-    allow(Ohai::Mixin::Command).to receive(:logger).and_return(logger)
-    allow(Ohai::Mixin::Command).to receive(:name).and_return(plugin_name)
-    @original_env = ENV.to_hash
-    ENV.clear
-  end
-
-  after do
-    ENV.clear
-    ENV.update(@original_env)
-  end
-
-  describe "when the command runs" do
-    it "logs the command and exitstatus" do
-      expect(Mixlib::ShellOut)
-        .to receive(:new)
-        .with(cmd, options)
-        .and_return(shell_out)
-
-      expect(shell_out)
-        .to receive(:run_command)
-
-      expect(shell_out)
-        .to receive(:exitstatus)
-        .and_return(256)
-
-      expect(logger).to receive(:trace)
-        .with("Plugin OSSparkleDream: ran 'sparkle-dream --version' and returned 256")
-
-      Ohai::Mixin::Command.shell_out(cmd)
-    end
-  end
-
-  describe "when the command does not exist" do
-    it "logs the command and error message" do
-      expect(Mixlib::ShellOut)
-        .to receive(:new)
-        .with(cmd, options)
-        .and_return(shell_out)
-
-      expect(shell_out)
-        .to receive(:run_command)
-        .and_raise(Errno::ENOENT, "sparkle-dream")
-
-      expect(logger)
-        .to receive(:trace)
-        .with("Plugin OSSparkleDream: ran 'sparkle-dream --version' and failed " \
-             "#<Errno::ENOENT: No such file or directory - sparkle-dream>")
-
-      expect { Ohai::Mixin::Command.shell_out(cmd) }
-        .to raise_error(Ohai::Exceptions::Exec)
-    end
-  end
-
-  describe "when the command times out" do
-    it "logs the command an timeout error message" do
-      expect(Mixlib::ShellOut)
-        .to receive(:new)
-        .with(cmd, options)
-        .and_return(shell_out)
-
-      expect(shell_out)
-        .to receive(:run_command)
-        .and_raise(Mixlib::ShellOut::CommandTimeout)
-
-      expect(logger)
-        .to receive(:trace)
-        .with("Plugin OSSparkleDream: ran 'sparkle-dream --version' and timed " \
-             "out after 30 seconds")
-
-      expect { Ohai::Mixin::Command.shell_out(cmd) }
-        .to raise_error(Ohai::Exceptions::Exec)
-    end
-  end
-
-  describe "when a timeout option is provided" do
-    let(:options) { windows? ? { timeout: 10 } : { timeout: 10, env: { "PATH" => "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" } } }
-
-    it "runs the command with the provided timeout" do
-      expect(Mixlib::ShellOut)
-        .to receive(:new)
-        .with(cmd, options)
-        .and_return(shell_out)
-
-      expect(shell_out)
-        .to receive(:run_command)
-
-      expect(shell_out)
-        .to receive(:exitstatus)
-        .and_return(256)
-
-      expect(logger).to receive(:trace)
-        .with("Plugin OSSparkleDream: ran 'sparkle-dream --version' and returned 256")
-
-      Ohai::Mixin::Command.shell_out(cmd, options)
-    end
-
-    describe "when the command times out" do
-      it "logs the command an timeout error message" do
-        expect(Mixlib::ShellOut)
-          .to receive(:new)
-          .with(cmd, options)
-          .and_return(shell_out)
-
-        expect(shell_out)
-          .to receive(:run_command)
-          .and_raise(Mixlib::ShellOut::CommandTimeout)
-
-        expect(logger)
-          .to receive(:trace)
-          .with("Plugin OSSparkleDream: ran 'sparkle-dream --version' and timed " \
-               "out after 10 seconds")
-
-        expect { Ohai::Mixin::Command.shell_out(cmd, options) }
-          .to raise_error(Ohai::Exceptions::Exec)
-      end
-    end
-  end
-end