Rewrite system specs with OHAI integration testing infra.

Refactor the runner class.
Make sure require_plugin() checks v6 plugins first.
Use partial paths as keys in the v6 dependency solver.

5 files changed, 320 insertions, 401 deletions

diff --git a/lib/ohai/exception.rb b/lib/ohai/exception.rb
index 62af2841..0496573f 100644
--- a/lib/ohai/exception.rb
+++ b/lib/ohai/exception.rb
@@ -22,5 +22,6 @@ module Ohai
     class IllegalPluginDefinition < Exception; end
     class AttributeNotFound < Exception; end
     class DependencyCycle < Exception; end
+    class DependencyNotFound < Exception; end
   end
 end
diff --git a/lib/ohai/runner.rb b/lib/ohai/runner.rb
index e4650319..817518d4 100644
--- a/lib/ohai/runner.rb
+++ b/lib/ohai/runner.rb
@@ -29,14 +29,37 @@ module Ohai
       @safe_run = safe_run
     end
 
-    # runs this plugin and any un-run dependencies. if force is set to
-    # true, then this plugin and its dependencies will be run even if
-    # they have been run before.
+    # Runs plugins and any un-run dependencies.
+    # If force is set to true, then this plugin and its dependencies
+    # will be run even if they have been run before.
     def run_plugin(plugin, force = false)
       unless plugin.kind_of?(Ohai::DSL::Plugin)
         raise ArgumentError, "Invalid plugin #{plugin} (must be an Ohai::DSL::Plugin or subclass)"
       end
-      visited = [plugin]
+
+      if Ohai::Config[:disabled_plugins].include?(plugin.name)
+        Ohai::Log.debug("Skipping disabled plugin #{plugin.name}")
+        return false
+      end
+
+      case plugin.version
+      when :version7
+        run_v7_plugin(plugin, force)
+      when :version6
+        run_v6_plugin(plugin, force)
+      else
+        raise ArgumentError, "Invalid plugin version #{plugin.version} for plugin #{plugin}"
+      end
+    end
+
+    def run_v6_plugin(plugin, force)
+      return true if plugin.has_run? && !force
+
+      @safe_run ? plugin.safe_run : plugin.run
+    end
+
+    def run_v7_plugin(plugin, force)
+      visited = [ plugin ]
       while !visited.empty?
         next_plugin = visited.pop
 
@@ -47,7 +70,12 @@ module Ohai
         end
 
         dependency_providers = fetch_plugins(next_plugin.dependencies)
-        dependency_providers.delete_if { |dep_plugin| (!force && dep_plugin.has_run?) || dep_plugin.eql?(next_plugin) }
+
+        # Remove the already ran plugins from dependencies if force is not set
+        # Also remove the plugin that we are about to run from dependencies as well.
+        dependency_providers.delete_if { |dep_plugin|
+          (!force && dep_plugin.has_run?) || dep_plugin.eql?(next_plugin)
+        }
 
         if dependency_providers.empty?
           @safe_run ? next_plugin.safe_run : next_plugin.run
@@ -62,9 +90,9 @@ module Ohai
       @provides_map.find_providers_for(attributes)
     end
 
-    # given a list of plugins and the first plugin in the cycle,
+    # Given a list of plugins and the first plugin in the cycle,
     # returns the list of plugin source files responsible for the
-    # cycle. does not include plugins that aren't a part of the cycle
+    # cycle. Does not include plugins that aren't a part of the cycle
     def get_cycle(plugins, cycle_start)
       cycle = plugins.drop_while { |plugin| !plugin.eql?(cycle_start) }
       names = []
diff --git a/lib/ohai/system.rb b/lib/ohai/system.rb
index 81664b44..c1467784 100644
--- a/lib/ohai/system.rb
+++ b/lib/ohai/system.rb
@@ -55,9 +55,6 @@ module Ohai
       @data[key]
     end
 
-    #=============================================
-    #  Version 7 system commands
-    #=============================================
     def all_plugins(attribute_filter=nil)
       load_plugins
       run_plugins(true, false, attribute_filter)
@@ -72,11 +69,11 @@ module Ohai
           if plugin && plugin.version == :version6
             # Capture the plugin in @v6_dependency_solver if it is a V6 plugin
             # to be able to resolve V6 dependencies later on.
+            # We are using the partial path in the dep solver as a key.
             partial_path = Pathname.new(plugin_file_path).relative_path_from(Pathname.new(path)).to_s
-            dep_solver_key = nameify_v6_plugin(partial_path)
 
-            unless @v6_dependency_solver.has_key?(dep_solver_key)
-              @v6_dependency_solver[dep_solver_key] = plugin
+            unless @v6_dependency_solver.has_key?(partial_path)
+              @v6_dependency_solver[partial_path] = plugin
             else
               Ohai::Log.debug("Plugin '#{plugin_file_path}' is already loaded.")
             end
@@ -86,93 +83,65 @@ module Ohai
     end
 
     def run_plugins(safe = false, force = false, attribute_filter = nil)
-      # collect and run version 6 plugins
-      v6plugins = []
-      @v6_dependency_solver.each { |plugin_name, plugin| v6plugins << plugin if plugin.version.eql?(:version6) }
-      v6plugins.each do |v6plugin|
-        if !v6plugin.has_run? || force
-          safe ? v6plugin.safe_run : v6plugin.run
-        end
+      # First run all the version 6 plugins
+      @v6_dependency_solver.values.each do |v6plugin|
+        @runner.run_plugin(v6plugin, force)
       end
 
-      # collect and run version 7 plugins
-      plugins = @provides_map.all_plugins(attribute_filter)
-
+      # Then run all the version 7 plugins
       begin
-        plugins.each { |plugin| @runner.run_plugin(plugin, force) }
+        @provides_map.all_plugins(attribute_filter).each { |plugin|
+          @runner.run_plugin(plugin, force)
+        }
       rescue Ohai::Exceptions::AttributeNotFound, Ohai::Exceptions::DependencyCycle => e
         Ohai::Log.error("Encountered error while running plugins: #{e.inspect}")
         raise
       end
-      true
     end
 
-    def collect_plugins(plugins)
-      collected = []
-      if plugins.is_a?(Mash)
-        # TODO: remove this branch
-        plugins.keys.each do |plugin|
-          if plugin.eql?("_plugins")
-            collected << plugins[plugin]
-          else
-            collected << collect_plugins(plugins[plugin])
-          end
-        end
-      else
-        collected << plugins
-      end
-      collected.flatten.uniq
+    def pathify_v6_plugin(plugin_name)
+      path_components = plugin_name.split("::")
+      File.join(path_components) + ".rb"
     end
 
-    #=============================================
-    # Version 6 system commands
-    #=============================================
-    def require_plugin(plugin_name, force=false)
-      unless force
-        plugin = @v6_dependency_solver[plugin_name]
-        return true if plugin && plugin.has_run?
-      end
-
-      if Ohai::Config[:disabled_plugins].include?(plugin_name)
-        Ohai::Log.debug("Skipping disabled plugin #{plugin_name}")
-        return false
-      end
-
-      if plugin = @v6_dependency_solver[plugin_name] or plugin = plugin_for(plugin_name)
-        begin
-          plugin.version.eql?(:version7) ? @runner.run_plugin(plugin, force) : plugin.safe_run
-          true
-        rescue SystemExit, Interrupt
-          raise
-        rescue DependencyCycleError, NoAttributeError => e
-          Ohai::Log.error("Encountered error while running plugins: #{e.inspect}")
-          raise
-        rescue Exception,Errno::ENOENT => e
-          Ohai::Log.debug("Plugin #{plugin_name} threw exception #{e.inspect} #{e.backtrace.join("\n")}")
-        end
+    #
+    # Below APIs are from V6.
+    # Make sure that you are not breaking backwards compatibility
+    # if you are changing any of the APIs below.
+    #
+    def require_plugin(plugin_ref, force=false)
+      plugins = [ ]
+      # This method is only callable by version 6 plugins.
+      # First we check if there exists a v6 plugin that fulfills the dependency.
+      if @v6_dependency_solver.has_key? pathify_v6_plugin(plugin_ref)
+        # Note that: partial_path looks like Plugin::Name
+        # keys for @v6_dependency_solver are in form 'plugin/name.rb'
+        plugins << @v6_dependency_solver[pathify_v6_plugin(plugin_ref)]
       else
-        Ohai::Log.debug("No #{plugin_name} found in #{Ohai::Config[:plugin_path]}")
+        # While looking up V7 plugins we need to convert the plugin_ref to an attribute.
+        attribute = plugin_ref.gsub("::", "/")
+        plugins = @provides_map.find_providers_for([attribute])
       end
-    end
-
-    def plugin_for(plugin_name)
-      filename = "#{plugin_name.gsub("::", File::SEPARATOR)}.rb"
 
-      plugin = nil
-      Ohai::Config[:plugin_path].each do |path|
-        check_path = File.expand_path(File.join(path, filename))
-        if File.exist?(check_path)
-          plugin = @loader.load_plugin(check_path)
-          @v6_dependency_solver[plugin_name] = plugin
-          break
-        else
-          next
+      if plugins.empty?
+        raise DependencyNotFound, "Can not find a plugin for dependency #{plugin_ref}"
+      else
+        plugins.each do |plugin|
+          begin
+            @runner.run_plugin(plugin, force)
+          rescue SystemExit, Interrupt
+            raise
+          rescue Ohai::Exceptions::DependencyCycle, Ohai::Exceptions::AttributeNotFound => e
+            Ohai::Log.error("Encountered error while running plugins: #{e.inspect}")
+            raise
+          rescue Exception,Errno::ENOENT => e
+            Ohai::Log.debug("Plugin #{plugin.name} threw exception #{e.inspect} #{e.backtrace.join("\n")}")
+          end
         end
       end
-      plugin
     end
 
-    # todo: fix for running w/new internals
+    # TODO: fix for running w/new internals
     # add updated function to v7?
     def refresh_plugins(path = '/')
       Ohai::Hints.refresh_hints()
@@ -200,15 +169,16 @@ module Ohai
       end
     end
 
-    #=============================================
-    # For outputting an Ohai::System object
-    #=============================================
+    #
     # Serialize this object as a hash
+    #
     def to_json
       Yajl::Encoder.new.encode(@data)
     end
 
+    #
     # Pretty Print this object as JSON
+    #
     def json_pretty_print(item=nil)
       Yajl::Encoder.new(:pretty => true).encode(item || @data)
     end
@@ -233,10 +203,5 @@ module Ohai
       end
     end
 
-    def nameify_v6_plugin(partial_path)
-      md = Regexp.new("(.+).rb$").match(partial_path)
-      md[1].gsub(File::SEPARATOR, "::")
-    end
-
   end
 end
diff --git a/spec/unit/runner_spec.rb b/spec/unit/runner_spec.rb
index b2695604..393cbed2 100644
--- a/spec/unit/runner_spec.rb
+++ b/spec/unit/runner_spec.rb
@@ -20,43 +20,146 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
 
 describe Ohai::Runner, "run_plugin" do
-  describe "when running a plugin with no dependencies, Ohai::Runner" do
-    before(:each) do
-      @ohai = Ohai::System.new
-      @runner = Ohai::Runner.new(@ohai, true)
+  let(:safe_run) { true }
+
+  before(:each) do
+    @ohai = Ohai::System.new
+    @runner = Ohai::Runner.new(@ohai, safe_run)
+  end
+
+  describe "when running an invalid plugin" do
+    it "should raise error" do
+      lambda { @runner.run_plugin(double("Ohai::NotPlugin")) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "when running a plugin" do
+    let(:plugin) { double("Ohai::DSL::Plugin", :kind_of? => true, :version => version, :name => "Test", :has_run? => has_run, :dependencies => [ ]) }
+    let(:version) { :version7 }
+    let(:has_run) { false }
+
+    describe "version 7" do
+      it "should call run_v7_plugin" do
+        @runner.should_receive(:run_v7_plugin)
+        @runner.run_plugin(plugin)
+      end
+
+      describe "if the plugin has run before" do
+        let(:has_run) { true }
+
+        it "plugin should not run when run_plugin is not forced" do
+          plugin.should_not_receive(:safe_run)
+          @runner.run_plugin(plugin)
+        end
+
+        it "plugin should run when run_plugin is not forced" do
+          plugin.should_receive(:safe_run)
+          @runner.run_plugin(plugin, true)
+        end
+
+        describe "if the plugin is disabled" do
+          it "should not run the plugin" do
+            Ohai::Config.should_receive(:[]).with(:disabled_plugins).and_return(["Test"])
+            @runner.should_not_receive(:run_v7_plugin)
+            @runner.run_plugin(plugin)
+          end
+        end
+      end
+    end
+
+    describe "version 6" do
+      let(:version) { :version6 }
+
+      it "should call run_v6_plugin" do
+        @runner.should_receive(:run_v6_plugin)
+        @runner.run_plugin(plugin)
+      end
+
+      describe "if the plugin has not run before" do
+        describe "if safe_run is not set" do
+          it "safe_run should be called" do
+            plugin.should_receive(:safe_run)
+            @runner.run_plugin(plugin)
+          end
+        end
+
+        describe "if safe_run is set" do
+          let(:safe_run) { false }
+
+          it "run should be called" do
+            plugin.should_receive(:run)
+            @runner.run_plugin(plugin)
+          end
+        end
+      end
 
+      describe "if the plugin has run before" do
+        let(:has_run) { true }
+
+        it "plugin should not run when run_plugin is not forced" do
+          plugin.should_not_receive(:safe_run)
+          @runner.run_plugin(plugin)
+        end
+
+        it "plugin should run when run_plugin is not forced" do
+          plugin.should_receive(:safe_run)
+          @runner.run_plugin(plugin, true)
+        end
+      end
+
+      describe "if the plugin is disabled" do
+        it "should not run the plugin" do
+          Ohai::Config.should_receive(:[]).with(:disabled_plugins).and_return(["Test"])
+          @runner.should_not_receive(:run_v7_plugin)
+            @runner.run_plugin(plugin)
+        end
+      end
+    end
+
+    describe "invalid version" do
+      let(:version) { :versionBla }
+
+      it "should raise error" do
+        lambda { @runner.run_plugin(plugin) }.should raise_error(ArgumentError)
+      end
+    end
+
+    describe "when plugin is disabled" do
+      before do
+        Ohai::Config.should_receive(:[]).with(:disabled_plugins).and_return(["Test"])
+      end
+
+      it "should not run the plugin" do
+        @runner.should_not_receive(:run_v7_plugin)
+        @runner.run_plugin(plugin)
+      end
+    end
+  end
+
+  describe "when running a plugin with no dependencies, Ohai::Runner" do
+    let(:plugin) {
       klass = Ohai.plugin(:Test) {
         provides("thing")
         collect_data {
           thing(Mash.new)
         }
       }
-      @plugin = klass.new(@ohai.data)
-    end
-
-    it "should not find dependencies" do
-      @runner.should_receive(:fetch_plugins).with([]).and_return([])
-      @runner.run_plugin(@plugin)
-    end
+      klass.new(@ohai.data)
+    }
 
     it "should run the plugin" do
-      @runner.run_plugin(@plugin)
-      @plugin.has_run?.should be_true
+      @runner.run_plugin(plugin)
+      plugin.has_run?.should be_true
     end
 
     it "should add plugin data to Ohai::System.data" do
-      @runner.run_plugin(@plugin)
+      @runner.run_plugin(plugin)
       @ohai.data.should have_key(:thing)
       @ohai.data[:thing].should eql({})
     end
   end
 
   describe "when running a plugin with one dependency" do
-    before(:each) do
-      @ohai = Ohai::System.new
-      @runner = Ohai::Runner.new(@ohai, true)
-    end
-
     describe "when the dependency does not exist" do
       before(:each) do
         klass = Ohai.plugin(:Test) {
@@ -146,7 +249,7 @@ describe Ohai::Runner, "run_plugin" do
       end
     end
   end
-  
+
   describe "when running a plugin with many dependencies" do
     before(:each) do
       @ohai = Ohai::System.new
diff --git a/spec/unit/system_spec.rb b/spec/unit/system_spec.rb
index b0fd01e7..c07ed836 100644
--- a/spec/unit/system_spec.rb
+++ b/spec/unit/system_spec.rb
@@ -60,7 +60,7 @@ EOF
     it "load_plugins() should load all the plugins" do
       @ohai.load_plugins
       @ohai.provides_map.map.keys.should include("seals")
-      @ohai.v6_dependency_solver.keys.should include("lake")
+      @ohai.v6_dependency_solver.keys.should include("lake.rb")
       Ohai::NamedPlugin.const_get(:Zoo).should == Ohai::NamedPlugin::Zoo
     end
   end
@@ -100,72 +100,42 @@ EOF
       @ohai.load_plugins
       @ohai.provides_map.map.keys.should include("seals")
       @ohai.provides_map.map.keys.should include("crabs")
-      @ohai.v6_dependency_solver.keys.should include("lake")
-      @ohai.v6_dependency_solver.keys.should include("mountain")
+      @ohai.v6_dependency_solver.keys.should include("lake.rb")
+      @ohai.v6_dependency_solver.keys.should include("mountain.rb")
       Ohai::NamedPlugin.const_get(:Zoo).should == Ohai::NamedPlugin::Zoo
       Ohai::NamedPlugin.const_get(:Nature).should == Ohai::NamedPlugin::Nature
     end
   end
 
-  describe "#run_plugins" do
-    describe "with v6 plugins only" do
-      before(:each) do
-        @ohai = Ohai::System.new
-
-        @plugins = []
-        @names = ['one', 'two', 'three', 'four', 'five']
-        @names.each do |name|
-          k = Class.new(Ohai::DSL::Plugin::VersionVI) {
-            collect_contents("")
-          }
-          p = k.new(@ohai, "some/plugin/path.rb")
-          @ohai.v6_dependency_solver[name] = p
-          @plugins << p
-        end
-
-        @ohai.stub(:collect_plugins).and_return([])
-      end
-
-      after(:each) do
-        @ohai.v6_dependency_solver.clear
-      end
-
-      it "should run all version 6 plugins" do
-        @ohai.run_plugins(true)
-        @plugins.each do |plugin|
-          plugin.has_run?.should be_true
-        end
-      end
+  describe "when running plugins" do
+    before do
+      @original_config = Ohai::Config[:plugin_path]
+    end
 
-      it "should force plugins to run again if force is set to true" do
-        @plugins.each do |plugin|
-          plugin.stub(:has_run?).and_return(:true)
-          plugin.should_receive(:safe_run)
-        end
+    after do
+      Ohai::Config[:plugin_path] = @original_config
+    end
 
-        @ohai.run_plugins(true, true)
-      end
+    before(:each) do
+      @ohai = Ohai::System.new
     end
 
-    describe "with v7 plugins only" do
-      describe "when handling an error" do
-        before(:each) do
-          @runner = double('@runner')
-          Ohai::Runner.stub(:new) { @runner }
+    when_plugins_directory "contains v6 plugins only" do
+      with_plugin("zoo.rb", <<EOF)
+provides 'zoo'
+zoo("animals")
+EOF
 
-          @ohai = Ohai::System.new
-          klass = Ohai.plugin(:Empty) { }
-          plugin = klass.new(@ohai.data)
-          @ohai.provides_map.should_receive(:all_plugins).and_return([plugin])
-        end
+      with_plugin("park.rb", <<EOF)
+provides 'park'
+park("plants")
+EOF
 
-        describe "when AttributeNotFound is received" do
-          it "should write an error to Ohai::Log" do
-            @runner.stub(:run_plugin).and_raise(Ohai::Exceptions::AttributeNotFound)
-            Ohai::Log.should_receive(:error).with(/Ohai::Exceptions::AttributeNotFound/)
-            expect { @ohai.run_plugins }.to raise_error(Ohai::Exceptions::AttributeNotFound)
-          end
-        end
+      it "should collect data from all the plugins" do
+        Ohai::Config[:plugin_path] = [ path_to(".") ]
+        @ohai.all_plugins
+        @ohai.data[:zoo].should == "animals"
+        @ohai.data[:park].should == "plants"
       end
 
       describe "when running in whitelist mode" do
@@ -246,38 +216,38 @@ EOF
       end
     end
 
-    describe "when running all loaded plugins" do
-      before(:each) do
-        @runner = double('@runner')
-        Ohai::Runner.stub(:new) { @runner }
-
-        @ohai = Ohai::System.new
-
-        @names = [:One, :Two, :Three, :Four, :Five]
+    when_plugins_directory "contains v7 plugins only" do
+      with_plugin("zoo.rb", <<EOF)
+Ohai.plugin(:Zoo) do
+  provides 'zoo'
 
-        klasses = []
-        @names.each do |name|
-          klasses << Ohai.plugin(name) {
-            provides("itself")
-            collect_data {
-              itself("me")
-            }
-          }
-        end
+  collect_data(:default) do
+    zoo("animals")
+  end
+end
+EOF
 
-        @plugins = []
-        klasses.each do |klass|
-          @plugins << klass.new(@ohai.data)
-        end
+      with_plugin("park.rb", <<EOF)
+Ohai.plugin(:Park) do
+  provides 'park'
+  collect_data(:default) do
+    park("plants")
+  end
+end
+EOF
 
-        @ohai.provides_map.should_receive(:all_plugins).and_return(@plugins)
+      it "should collect data from all the plugins" do
+        Ohai::Config[:plugin_path] = [ path_to(".") ]
+        @ohai.all_plugins
+        @ohai.data[:zoo].should == "animals"
+        @ohai.data[:park].should == "plants"
       end
 
-      it "should run each plugin once from Ohai::System" do
-        @plugins.each do |plugin|
-          @runner.should_receive(:run_plugin).with(plugin, false)
-        end
-        @ohai.run_plugins
+      it "should write an error to Ohai::Log" do
+        Ohai::Config[:plugin_path] = [ path_to(".") ]
+        @ohai.instance_variable_get("@runner").stub(:run_plugin).and_raise(Ohai::Exceptions::AttributeNotFound)
+        Ohai::Log.should_receive(:error).with(/Encountered error while running plugins/)
+        expect { @ohai.all_plugins }.to raise_error(Ohai::Exceptions::AttributeNotFound)
       end
     end
 
@@ -303,7 +273,6 @@ Ohai.plugin(:V7message) do
   provides 'v7message'
 
   collect_data(:default) do
-    puts "I'm running now."
     v7message "v7 plugins are awesome!"
   end
 end
@@ -320,7 +289,6 @@ EOF
       end
 
       it "should collect all data" do
-        pending("Requires some changes to require_plugin() which will be changed in a seperate PR as a next step.")
         @ohai.all_plugins
         [:v6message, :v7message, :messages].each do |attribute|
           @ohai.data.should have_key(attribute)
@@ -336,237 +304,91 @@ EOF
     end
   end
 
-  describe "#collect_plugins" do
-    before(:each) do
-      @ohai = Ohai::System.new
-
-      @names = [:Zero, :One, :Two, :Three]
-      @plugins = []
-      @names.each do |name|
-        k = Ohai.plugin(name) { }
-        @plugins << k.new(@ohai.data)
-      end
-    end
+  describe "require_plugin()" do
+    when_plugins_directory "contains v6 and v7 plugin with the same name" do
+      with_plugin("message.rb", <<EOF)
+provides 'message'
 
-    it "should find all the plugins providing attributes" do
-      provides_map = @ohai.provides_map
-      provides_map.set_providers_for(@plugins[0], ["zero"])
-      provides_map.set_providers_for(@plugins[1], ["one"])
-      provides_map.set_providers_for(@plugins[2], ["two"])
-      provides_map.set_providers_for(@plugins[3], ["stub/three"])
-
-      providers = provides_map.all_plugins
-      providers.size.should eql(@plugins.size)
-      @plugins.each do |plugin|
-        providers.include?(plugin).should be_true
-      end
-    end
-  end
-
-  describe "#require_plugin" do
-    before(:each) do
-      @plugin_path = Ohai::Config[:plugin_path]
-      Ohai::Config[:plugin_path] = ["/tmp/plugins"]
-
-      @ohai = Ohai::System.new
-      klass = Class.new(Ohai::DSL::Plugin::VersionVI) { }
-      @plugin = klass.new(@ohai, "some/plugin/path.rb")
-
-      @ohai.stub(:plugin_for).with("empty").and_return(@plugin)
-    end
+message "From Version 6"
+EOF
 
-    it "should immediately return if force is false and the plugin has already run" do
-      @ohai.v6_dependency_solver['empty'] = @plugin
-      @plugin.stub(:has_run?).and_return(true)
+      with_plugin("v7/message.rb", <<EOF)
+Ohai.plugin(:Message) do
+  provides 'message'
 
-      @ohai.should_not_receive(:plugin_for).with("empty")
-      @ohai.require_plugin("empty", true).should be_true
-    end
+  collect_data(:default) do
+    message "From Version 7"
+  end
+end
+EOF
 
-    context "when a plugin is disabled" do
-      before(:each) do
-        Ohai::Config[:disabled_plugins] = ["empty"]
+      before do
+        @ohai = Ohai::System.new
+        @original_config = Ohai::Config[:plugin_path]
+        Ohai::Config[:plugin_path] = [ path_to(".") ]
       end
 
-      it "should not run the plugin" do
-        Ohai::Log.should_receive(:debug).with(/Skipping disabled plugin/)
-        @ohai.should_not_receive(:plugin_for).with("empty")
-        @ohai.require_plugin("empty").should be_false
+      after do
+         Ohai::Config[:plugin_path] = @original_config
       end
 
-      it "should not run the plugin even if force is true" do
-        Ohai::Log.should_receive(:debug).with(/Skipping disabled plugin/)
-        @ohai.should_not_receive(:plugin_for).with("empty")
-        @ohai.require_plugin("empty", true).should be_false
+      it "version 6 should run" do
+        @ohai.load_plugins
+        @ohai.require_plugin("message")
+        @ohai.data[:message].should eql("From Version 6")
       end
     end
 
-    it "should check for the plugin in v6_dependency_solver first" do
-      @ohai.v6_dependency_solver['empty'] = @plugin
-      @ohai.should_not_receive(:plugin_for).with("empty")
-      @plugin.stub(:safe_run).and_return(true)
-      @ohai.require_plugin("empty").should be_true
-    end
+    when_plugins_directory "a v6 plugin that requires a v7 plugin with dependencies" do
+      with_plugin("message.rb", <<EOF)
+provides 'message'
 
-    it "should load the plugin if not already loaded" do
-      @ohai.stub(:plugin_for).with("empty").and_return(@plugin)
-      @ohai.should_receive(:plugin_for).with("empty")
-      @plugin.stub(:safe_run).and_return(true)
-      @ohai.require_plugin("empty").should be_true
-    end
+require_plugin 'v7message'
 
-    it "should run the plugin if the plugin has not yet run" do
-      @ohai.stub(:plugin_for).with("empty").and_return(@plugin)
-      @plugin.stub(:safe_run).and_return(true)
-      @ohai.require_plugin("empty").should be_true
-    end
+message Mash.new
+message[:v6message] = "Hellos from 6"
+message[:copy_message] = v7message
+EOF
 
-    it "should log a message to debug if a plugin cannot be found" do
-      @ohai.stub(:plugin_for).with("fake").and_return(nil)
-      Ohai::Log.should_receive(:debug).with(/No fake found in/)
-      @ohai.require_plugin("fake")
-    end
+      with_plugin("v7message.rb", <<EOF)
+Ohai.plugin(:V7message) do
+  provides 'v7message'
+  depends 'zoo'
 
-    context "when a v6 plugin requires a v7 plugin" do
-      before(:each) do
-        v6string = <<EOF
-provides 'v6attr'
-require_plugin 'v7plugin'
-v6attr message
+  collect_data(:default) do
+    v7message ("Hellos from 7: " + zoo)
+  end
+end
 EOF
-        v6klass = Class.new(Ohai::DSL::Plugin::VersionVI) { collect_contents(v6string) }
-        v7klass = Ohai.plugin(:V7plugin) {
-          provides("message")
-          collect_data { message("hey.") }
-        }
-        @v6plugin = v6klass.new(@ohai, "some/plugin/path.rb")
-        @v7plugin = v7klass.new(@ohai.data)
-
-        @ohai.v6_dependency_solver['v6plugin'] = @v6plugin
-        @ohai.v6_dependency_solver['v7plugin'] = @v7plugin
-        @ohai.provides_map.set_providers_for(@v7plugin, ["message"])
-      end
-
-      it "should run the plugin it requires" do
-        @ohai.require_plugin('v6plugin')
-        @v7plugin.has_run?.should be_true
-        @v6plugin.has_run?.should be_true
-      end
 
-      it "should be able to access the data set by the v7 plugin" do
-        @ohai.require_plugin('v6plugin')
-        @ohai.data.should have_key(:message)
-        @ohai.data[:message].should eql("hey.")
-        @ohai.data.should have_key(:v6attr)
-        @ohai.data[:v6attr].should eql("hey.")
-      end
-    end
+      with_plugin("zoo.rb", <<EOF)
+Ohai.plugin(:Zoo) do
+  provides 'zoo'
 
-    context "when a v6 plugin requires a v7 plugin with dependencies" do
-      before(:each) do
-        v6string = <<EOF
-provides 'v6attr'
-require_plugin 'v7plugin'
-v6attr message
+  collect_data(:default) do
+    zoo "animals"
+  end
+end
 EOF
-        v6klass = Class.new(Ohai::DSL::Plugin::VersionVI) { collect_contents(v6string) }
-        v7klass = Ohai.plugin(:V7plugin) {
-          provides("message")
-          depends("other")
-          collect_data{ message(other) }
-        }
-        otherklass = Ohai.plugin(:Other) {
-          provides("other")
-          collect_data{ other("o hai") }
-        }
-
-        @v6plugin = v6klass.new(@ohai, "some/plugin/path.rb")
-        @v7plugin = v7klass.new(@ohai.data)
-        @other = otherklass.new(@ohai.data)
-
-        vds = @ohai.v6_dependency_solver
-        vds['v6plugin'] = @v6plugin
-        vds['v7plugin'] = @v7plugin
-        vds['other'] = @other
-
-        dependency_map = @ohai.provides_map
-        #dependency_map[:message][:_plugins] = [@v7plugin]
-        dependency_map.set_providers_for(@v7plugin, ["message"])
-        #dependency_map[:other][:_plugins] = [@other]
-        dependency_map.set_providers_for(@other, ["other"])
-      end
 
-      it "should resolve the v7 plugin dependencies" do
-        @ohai.require_plugin('v6plugin')
-        [@v6plugin, @v7plugin, @other].each do |plugin|
-          plugin.has_run?.should be_true
-        end
+      before do
+        @ohai = Ohai::System.new
+        @original_config = Ohai::Config[:plugin_path]
+        Ohai::Config[:plugin_path] = [ path_to(".") ]
       end
 
-      it "should set all collected data properly" do
-        @ohai.require_plugin('v6plugin')
-        d = @ohai.data
-        d.should have_key(:other)
-        d.should have_key(:message)
-        d.should have_key(:v6attr)
-        [:other, :message, :v6attr].each do |attr|
-          d[attr].should eql("o hai")
-        end
+      after do
+         Ohai::Config[:plugin_path] = @original_config
       end
-    end
-  end
-
-  describe "#plugin_for" do
-    before(:each) do
-      Ohai::Config[:plugin_path] = ["/tmp/plugins"]
 
-      @loader = double('@loader')
-      Ohai::Loader.stub(:new) { @loader }
-
-      @ohai = Ohai::System.new
-      @klass = Class.new(Ohai::DSL::Plugin::VersionVI) { }
-    end
-
-    it "should find a plugin with a simple name" do
-      plugin = @klass.new(@ohai, "/tmp/plugins/empty.rb")
-      File.stub(:join).with("/tmp/plugins", "empty.rb").and_return("/tmp/plugins/empty.rb")
-      File.stub(:expand_path).with("/tmp/plugins/empty.rb").and_return("/tmp/plugins/empty.rb")
-      File.stub(:exist?).with("/tmp/plugins/empty.rb").and_return(true)
-      @loader.stub(:load_plugin).with("/tmp/plugins/empty.rb").and_return(plugin)
-
-      found_plugin = @ohai.plugin_for("empty")
-      found_plugin.should eql(plugin)
-    end
-
-    it "should find a plugin with a complex name" do
-      plugin = @klass.new(@ohai, "/tmp/plugins/empty.rb")
-      File.stub(:join).with("/tmp/plugins", "ubuntu/empty.rb").and_return("/tmp/plugins/ubuntu/empty.rb")
-      File.stub(:expand_path).with("/tmp/plugins/ubuntu/empty.rb").and_return("/tmp/plugins/ubuntu/empty.rb")
-      File.stub(:exist?).with("/tmp/plugins/ubuntu/empty.rb").and_return(true)
-      @loader.stub(:load_plugin).with("/tmp/plugins/ubuntu/empty.rb").and_return(plugin)
-
-      found_plugin = @ohai.plugin_for("ubuntu::empty")
-      found_plugin.should eql(plugin)
-    end
-
-    it "should return nil if a plugin is not found" do
-      File.stub(:join).with("/tmp/plugins", "fake.rb").and_return("/tmp/plugins/fake.rb")
-      File.stub(:expand_path).with("/tmp/plugins/fake.rb").and_return("/tmp/plugins/fake.rb")
-      File.should_receive(:exist?).with("/tmp/plugins/fake.rb").and_return(false)
-
-      @ohai.plugin_for("fake").should be_nil
+      it "should collect all the data properly" do
+        @ohai.all_plugins
+        @ohai.data[:v7message].should == "Hellos from 7: animals"
+        @ohai.data[:zoo].should == "animals"
+        @ohai.data[:message][:v6message].should == "Hellos from 6"
+        @ohai.data[:message][:copy_message].should == "Hellos from 7: animals"
+      end
     end
 
-    it "should add the plugin to the v6_dependency_solver" do
-      plugin = @klass.new(@ohai, "/tmp/plugins/empty.rb")
-      File.stub(:join).with("/tmp/plugins", "empty.rb").and_return("/tmp/plugins/empty.rb")
-      File.stub(:expand_path).with("/tmp/plugins/empty.rb").and_return("/tmp/plugins/empty.rb")
-      File.stub(:exist?).with("/tmp/plugins/empty.rb").and_return(true)
-      @loader.stub(:load_plugin).with("/tmp/plugins/empty.rb").and_return(plugin)
-
-      @ohai.plugin_for("empty")
-      @ohai.v6_dependency_solver.should have_key('empty')
-      @ohai.v6_dependency_solver['empty'].should eql(plugin)
-    end
   end
 end