ohai 6.24.2 → 7.0.0.rc.0

data/spec/support/integration_helper.rb

@@ -0,0 +1,44 @@
+require 'tmpdir'
+
+module IntegrationSupport 
+  def when_plugins_directory(description, &block)
+    context "When the plugins directory #{description}" do
+
+      before(:each) do
+        @plugins_directory = Dir.mktmpdir('ohai-plugins')
+      end
+
+      after(:each) do
+        if @plugins_directory
+          begin
+            FileUtils.remove_entry_secure(@plugins_directory)
+          ensure
+            @plugins_directory = nil
+          end
+        end
+      end
+
+      def with_plugin(plugin_path, contents)
+        filename = path_to(plugin_path)
+        dir = File.dirname(filename)
+        FileUtils.mkdir_p(dir) unless dir == '.'
+        File.open(filename, 'w') do |file|
+          file.write(contents)
+        end
+      end
+      
+      def path_to(plugin_path)
+        File.expand_path(plugin_path, @plugins_directory)
+      end
+
+      def self.with_plugin(plugin_path, contents)
+        before :each do
+          with_plugin(plugin_path, contents)
+        end
+      end
+    
+      instance_eval(&block)
+    end
+  end
+
+end

data/spec/unit/dsl/plugin_spec.rb

@@ -0,0 +1,298 @@
+#
+# Author:: Claire McQuin (<claire@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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 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
+    end
+
+    it "should set the correct plugin version" do
+      plugin.version.should eql(version)
+    end
+  end
+
+  context "#run" do
+    it "should set has_run? to true" do
+      plugin.stub(:run_plugin).and_return(true)
+      plugin.run
+      plugin.has_run?.should be_true
+    end
+  end
+
+  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")
+    end
+
+    it "should return the current value of the method name" do
+      plugin.guns_n_roses("chinese democracy").should 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")
+    end
+  end
+
+  context "when checking attribute existence" do
+    before(:each) do
+      plugin.metallica("death magnetic")
+    end
+
+    it "should return true if an attribute exists with the given name" do
+      plugin.attribute?("metallica").should 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)
+    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")
+    end
+  end
+
+  context "when getting attributes" do
+    before(:each) do
+      plugin.set_attribute(:tea, "is soothing")
+    end
+
+    it "should let you get an attribute" do
+      plugin.get_attribute("tea").should eql("is soothing")
+    end
+  end
+end
+
+describe Ohai::DSL::Plugin::VersionVII do
+  before(:each) do
+    @name = :Test
+  end
+
+  describe "when the plugin is named incorrectly" do
+    context "because the plugin name doesn't start with a capital letter" do
+      it "should raise 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 "should raise 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 "should raise 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 "should save the plugin version as :version7" do
+      plugin = Ohai.plugin(@name) { }
+      plugin.version.should eql(:version7)
+    end
+  end
+
+  describe "#provides" do
+    it "should collect a single attribute" do
+      plugin = Ohai.plugin(@name) { provides("one") }
+      plugin.provides_attrs.should eql(["one"])
+    end
+
+    it "should collect a list of attributes" do
+      plugin = Ohai.plugin(@name) { provides("one", "two", "three") }
+      plugin.provides_attrs.should eql(["one", "two", "three"])
+    end
+
+    it "should collect from multiple provides statements" do
+      plugin = Ohai.plugin(@name) {
+        provides("one")
+        provides("two", "three")
+        provides("four")
+      }
+      plugin.provides_attrs.should eql(["one", "two", "three", "four"])
+    end
+
+    it "should collect attributes across multiple plugin files" do
+      plugin = Ohai.plugin(@name) { provides("one") }
+      plugin = Ohai.plugin(@name) { provides("two", "three") }
+      plugin.provides_attrs.should eql(["one", "two", "three"])
+    end
+
+    it "should collect unique attributes" do
+      plugin = Ohai.plugin(@name) { provides("one") }
+      plugin = Ohai.plugin(@name) { provides("one", "two") }
+      plugin.provides_attrs.should eql(["one", "two"])
+    end
+  end
+
+  describe "#depends" do
+    it "should collect a single dependency" do
+      plugin = Ohai.plugin(@name) { depends("one") }
+      plugin.depends_attrs.should eql(["one"])
+    end
+
+    it "should collect a list of dependencies" do
+      plugin = Ohai.plugin(@name) { depends("one", "two", "three") }
+      plugin.depends_attrs.should eql(["one", "two", "three"])
+    end
+
+    it "should collect from multiple depends statements" do
+      plugin = Ohai.plugin(@name) {
+        depends("one")
+        depends("two", "three")
+        depends("four")
+      }
+      plugin.depends_attrs.should eql(["one", "two", "three", "four"])
+    end
+
+    it "should collect dependencies across multiple plugin files" do
+      plugin = Ohai.plugin(@name) { depends("one") }
+      plugin = Ohai.plugin(@name) { depends("two", "three") }
+      plugin.depends_attrs.should eql(["one", "two", "three"])
+    end
+
+    it "should collect unique attributes" do
+      plugin = Ohai.plugin(@name) { depends("one") }
+      plugin = Ohai.plugin(@name) { depends("one", "two") }
+      plugin.depends_attrs.should eql(["one", "two"])
+    end
+  end
+
+  describe "#collect_data" do
+    it "should save as :default if no platform is given" do
+      plugin = Ohai.plugin(@name) { collect_data { } }
+      plugin.data_collector.should have_key(:default)
+    end
+
+    it "should save a single given platform" do
+      plugin = Ohai.plugin(@name) { collect_data(:ubuntu) { } }
+      plugin.data_collector.should have_key(:ubuntu)
+    end
+
+    it "should save a list of platforms" do
+      plugin = Ohai.plugin(@name) { collect_data(:freebsd, :netbsd, :openbsd) { } }
+      [:freebsd, :netbsd, :openbsd].each do |platform|
+        plugin.data_collector.should have_key(platform)
+      end
+    end
+
+    it "should save multiple collect_data blocks" do
+      plugin = Ohai.plugin(@name) {
+        collect_data { }
+        collect_data(:windows) { }
+        collect_data(:darwin) { }
+      }
+      [:darwin, :default, :windows].each do |platform|
+        plugin.data_collector.should have_key(platform)
+      end
+    end
+
+    it "should save platforms across multiple plugins" do
+      plugin = Ohai.plugin(@name) { collect_data { } }
+      plugin = Ohai.plugin(@name) { collect_data(:aix, :sigar) { } }
+      [:aix, :default, :sigar].each do |platform|
+        plugin.data_collector.should have_key(platform)
+      end
+    end
+
+    it "should fail a platform has already been defined in the same plugin" do
+      expect {
+        Ohai.plugin(@name) {
+          collect_data { }
+          collect_data { }
+        }
+      }.to raise_error(Ohai::Exceptions::IllegalPluginDefinition, /collect_data already defined/)
+    end
+
+    it "should fail if a platform has already been defined in another plugin file" do
+      Ohai.plugin(@name) { collect_data { } }
+      expect {
+        Ohai.plugin(@name) {
+          collect_data { }
+        }
+      }.to raise_error(Ohai::Exceptions::IllegalPluginDefinition, /collect_data already defined/)
+    end
+  end
+
+  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\]/)
+      plugin.provides("attribute")
+    end
+  end
+
+  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\]/)
+      plugin.require_plugin("plugin")
+    end
+  end
+
+  it_behaves_like "Ohai::DSL::Plugin" do
+    let(:ohai) { Ohai::System.new }
+    let(:plugin) { Ohai::DSL::Plugin::VersionVII.new(ohai.data) }
+    let(:version) { :version7 }
+  end
+end
+
+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)
+    end
+  end
+
+  describe "#provides" do
+    before(:each) do
+      @ohai = Ohai::System.new
+    end
+
+    it "should log a debug message when provides is used" do
+      Ohai::Log.should_receive(:debug).with(/Skipping provides/)
+      plugin = Ohai::DSL::Plugin::VersionVI.new(@ohai, "/some/plugin/path.rb", "/some/plugin")
+      plugin.provides("attribute")
+    end
+
+    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
+    end
+
+  end
+
+  it_behaves_like "Ohai::DSL::Plugin" do
+    let(:ohai) { Ohai::System.new }
+    let(:plugin) { Ohai::DSL::Plugin::VersionVI.new(ohai, "/some/plugin/path.rb", "/some/plugin") }
+    let(:version) { :version6 }
+  end
+end

data/spec/unit/hints_spec.rb

@@ -0,0 +1,65 @@
+#
+# Author:: Serdar Sutay (<serdar@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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 File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+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
+      Ohai::Hints.hint?("cloud").should 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
+      Ohai::Hints.hint?("cloud").should == {"name" => "circus"}
+    end
+
+    it "hint? should return empty hash for empty hints" do
+      Ohai::Hints.hint?("cloud_empty").should == { }
+    end
+  end
+
+end

data/spec/unit/loader_spec.rb

@@ -0,0 +1,226 @@
+#
+# Author:: Claire McQuin (<claire@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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 File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+describe Ohai::Loader do
+  extend IntegrationSupport
+
+  before(:each) do
+    @plugin_data = Mash.new
+    @provides_map = Ohai::ProvidesMap.new
+
+    @ohai = double('Ohai::System', :data => @plugin_data, :provides_map => @provides_map)
+    @loader = Ohai::Loader.new(@ohai)
+  end
+
+  describe "#initialize" do
+    it "should return an Ohai::Loader object" do
+      loader = Ohai::Loader.new(@ohai)
+      loader.should be_a_kind_of(Ohai::Loader)
+    end
+  end
+
+  when_plugins_directory "contains both V6 & V7 plugins" do
+    with_plugin("zoo.rb", <<EOF)
+Ohai.plugin(:Zoo) do
+  provides 'seals'
+end
+EOF
+
+    with_plugin("zoo_too.rb", <<EOF)
+Ohai.plugin(:Zoo) do
+  provides 'elephants'
+end
+EOF
+
+    with_plugin("lake.rb", <<EOF)
+provides 'fish'
+EOF
+
+    describe "load_plugin() method" do
+      describe "when loading a v7 plugin" do
+        before(:each) do
+          @plugin = @loader.load_plugin(path_to("zoo.rb"))
+        end          
+
+        it "should save the plugin according to its attribute" do          
+          @provides_map.map.keys.should include("seals")
+        end
+
+        it "should save a single plugin source" do
+          @plugin.source.should 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")])
+        end
+      end
+
+      describe "when loading a v6 plugin" do
+        before(:each) do
+          Ohai::Log.should_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
+        end
+
+        it "should save the plugin's source" do
+          @plugin.source.should 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/)
+        @loader.load_plugin(path_to("rainier.rb"), path_to("."))
+        @provides_map.map.should be_empty
+      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 "should log an unsupported operation warning" do
+          Ohai::Log.should_receive(:warn).with(/Plugin Method Error: <#{path_to("extra_s.rb")}>:/)
+          @loader.load_plugin(path_to("extra_s.rb"))
+        end
+
+        it "should 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
+          Ohai::Log.should_receive(:warn).with(/Plugin Method Error: <#{path_to("no_method.rb")}>:/)
+          @loader.load_plugin(path_to("no_method.rb"))
+        end
+
+        it "should 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
+          Ohai::Log.should_receive(:warn).with(/Plugin Definition Error: <#{path_to("illegal_def.rb")}>:/)
+          @loader.load_plugin(path_to("illegal_def.rb"))
+        end
+
+        it "should 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 "should log a warning" do
+          Ohai::Log.should_receive(:warn).with(/Plugin Error: <#{path_to("unexpected_error.rb")}>:/)
+          @loader.load_plugin(path_to("unexpected_error.rb"))
+        end
+
+        it "should 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 "should log a syntax error warning" do
+          Ohai::Log.should_receive(:warn).with(/Plugin Syntax Error: <#{path_to("bad_symbol.rb")}>:/)
+          @loader.load_plugin(path_to("bad_symbol.rb"))
+        end
+
+        it "should 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 "should log a syntax error warning" do
+          Ohai::Log.should_receive(:warn).with(/Plugin Syntax Error: <#{path_to("no_end.rb")}>:/)
+          @loader.load_plugin(path_to("no_end.rb"))
+        end
+
+        it "should 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 "should log an invalid plugin name warning" do
+          Ohai::Log.should_receive(:warn).with(/Plugin Name Error: <#{path_to("bad_name.rb")}>:/)
+          @loader.load_plugin(path_to("bad_name.rb"))
+        end
+
+        it "should not raise an error" do
+          expect{ @loader.load_plugin(path_to("bad_name.rb")) }.not_to raise_error
+        end
+      end
+    end
+  end
+end