chef 10.28.2-x86-mingw32

data/spec/unit/knife/status_spec.rb

@@ -0,0 +1,43 @@
+#
+# Author:: Sahil Muthoo (<sahil.muthoo@gmail.com>)
+# Copyright:: Copyright (c) 2012 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 'spec_helper'
+require 'highline'
+
+describe Chef::Knife::Status do
+  before(:each) do
+    node = Chef::Node.new.tap do |n|
+      n["fqdn"] = "foobar"
+      n["ohai_time"] = 1343845969
+    end
+    query = mock("Chef::Search::Query")
+    query.stub!(:search).and_yield(node)
+    Chef::Search::Query.stub!(:new).and_return(query)
+    @knife  = Chef::Knife::Status.new
+    @stdout = StringIO.new
+    @knife.stub!(:highline).and_return(HighLine.new(StringIO.new, @stdout))
+  end
+
+  describe "run" do
+    it "should not colorize output unless it's writing to a tty" do
+      @knife.run
+      @stdout.string.match(/foobar/).should_not be_nil
+      @stdout.string.match(/\e.*ago/).should be_nil
+    end
+  end
+end

data/spec/unit/knife/tag_create_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Chef::Knife::TagCreate do
+  before(:each) do
+    Chef::Config[:node_name] = "webmonkey.example.com"
+    @knife = Chef::Knife::TagCreate.new
+    @knife.name_args = [ Chef::Config[:node_name], "happytag" ]
+
+    @node = Chef::Node.new
+    @node.stub! :save
+    Chef::Node.stub!(:load).and_return @node
+    @stdout = StringIO.new
+    @knife.ui.stub!(:stdout).and_return(@stdout)
+  end
+
+  describe "run" do
+    it "can create tags on a node" do
+      @knife.run
+      @node.tags.should == ["happytag"]
+      @stdout.string.should match /created tags happytag.+node webmonkey.example.com/i
+    end
+  end
+end

data/spec/unit/knife/tag_delete_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Chef::Knife::TagDelete do
+  before(:each) do
+    Chef::Config[:node_name] = "webmonkey.example.com"
+    @knife = Chef::Knife::TagDelete.new
+    @knife.name_args = [ Chef::Config[:node_name], "sadtag" ]
+
+    @node = Chef::Node.new
+    @node.stub! :save
+    @node.tags << "sadtag" << "happytag"
+    Chef::Node.stub!(:load).and_return @node
+    @stdout = StringIO.new
+    @knife.ui.stub!(:stdout).and_return(@stdout)
+  end
+
+  describe "run" do
+    it "can delete tags on a node" do
+      @node.tags.should == ["sadtag", "happytag"]
+      @knife.run
+      @node.tags.should == ["happytag"]
+      @stdout.string.should match /deleted.+sadtag/i
+    end
+  end
+end

data/spec/unit/knife/tag_list_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Chef::Knife::TagList do
+  before(:each) do
+    Chef::Config[:node_name] = "webmonkey.example.com"
+    @knife = Chef::Knife::TagList.new
+    @knife.name_args = [ Chef::Config[:node_name], "sadtag" ]
+
+    @node = Chef::Node.new
+    @node.stub! :save
+    @node.tags << "sadtag" << "happytag"
+    Chef::Node.stub!(:load).and_return @node
+  end
+
+  describe "run" do
+    it "can list tags on a node" do
+      expected = %w(sadtag happytag)
+      @node.tags.should == expected
+      @knife.should_receive(:output).with(expected)
+      @knife.run
+    end
+  end
+end

data/spec/unit/knife_spec.rb

@@ -0,0 +1,295 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2011 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.
+#
+
+# Fixtures for subcommand loading live in this namespace
+module KnifeSpecs
+end
+
+require 'spec_helper'
+
+describe Chef::Knife do
+  before(:each) do
+    Chef::Log.logger = Logger.new(StringIO.new)
+
+    Chef::Config[:node_name]  = "webmonkey.example.com"
+    @knife = Chef::Knife.new
+    @knife.ui.stub!(:puts)
+    @knife.ui.stub!(:print)
+    Chef::Log.stub!(:init)
+    Chef::Log.stub!(:level)
+    [:debug, :info, :warn, :error, :crit].each do |level_sym|
+      Chef::Log.stub!(level_sym)
+    end
+    Chef::Knife.stub!(:puts)
+    @stdout = StringIO.new
+  end
+
+  describe "after loading a subcommand" do
+    before do
+      Chef::Knife.reset_subcommands!
+
+      if KnifeSpecs.const_defined?(:TestNameMapping)
+        KnifeSpecs.send(:remove_const, :TestNameMapping)
+      end
+
+      if KnifeSpecs.const_defined?(:TestExplicitCategory)
+        KnifeSpecs.send(:remove_const, :TestExplicitCategory)
+      end
+
+      Kernel.load(File.join(CHEF_SPEC_DATA, 'knife_subcommand', 'test_name_mapping.rb'))
+      Kernel.load(File.join(CHEF_SPEC_DATA, 'knife_subcommand', 'test_explicit_category.rb'))
+    end
+
+    it "has a category based on its name" do
+      KnifeSpecs::TestNameMapping.subcommand_category.should == 'test'
+    end
+
+    it "has an explictly defined category if set" do
+      KnifeSpecs::TestExplicitCategory.subcommand_category.should == 'cookbook site'
+    end
+
+    it "can reference the subcommand by its snake cased name" do
+      Chef::Knife.subcommands['test_name_mapping'].should equal(KnifeSpecs::TestNameMapping)
+    end
+
+    it "lists subcommands by category" do
+      Chef::Knife.subcommands_by_category['test'].should include('test_name_mapping')
+    end
+
+    it "lists subcommands by category when the subcommands have explicit categories" do
+      Chef::Knife.subcommands_by_category['cookbook site'].should include('test_explicit_category')
+    end
+
+  end
+
+  describe "after loading all subcommands" do
+    before do
+      Chef::Knife.reset_subcommands!
+      Chef::Knife.load_commands
+    end
+
+    it "references a subcommand class by its snake cased name" do
+      class SuperAwesomeCommand < Chef::Knife
+      end
+
+      Chef::Knife.load_commands
+
+      Chef::Knife.subcommands.should have_key("super_awesome_command")
+      Chef::Knife.subcommands["super_awesome_command"].should == SuperAwesomeCommand
+    end
+
+    it "guesses a category from a given ARGV" do
+      Chef::Knife.subcommands_by_category["cookbook"] << :cookbook
+      Chef::Knife.subcommands_by_category["cookbook site"] << :cookbook_site
+      Chef::Knife.guess_category(%w{cookbook foo bar baz}).should == 'cookbook'
+      Chef::Knife.guess_category(%w{cookbook site foo bar baz}).should == 'cookbook site'
+      Chef::Knife.guess_category(%w{cookbook site --help}).should == 'cookbook site'
+    end
+
+    it "finds a subcommand class based on ARGV" do
+      Chef::Knife.subcommands["cookbook_site_vendor"] = :CookbookSiteVendor
+      Chef::Knife.subcommands["cookbook"] = :Cookbook
+      Chef::Knife.subcommand_class_from(%w{cookbook site vendor --help foo bar baz}).should == :CookbookSiteVendor
+    end
+
+  end
+
+  describe "when running a command" do
+    before(:each) do
+      if KnifeSpecs.const_defined?(:TestYourself)
+        KnifeSpecs.send :remove_const, :TestYourself
+      end
+      Kernel.load(File.join(CHEF_SPEC_DATA, 'knife_subcommand', 'test_yourself.rb'))
+      Chef::Knife.subcommands.each { |name, klass| Chef::Knife.subcommands.delete(name) unless klass.kind_of?(Class) }
+    end
+
+    it "merges the global knife CLI options" do
+      extra_opts = {}
+      extra_opts[:editor] = {:long=>"--editor EDITOR",
+                             :description=>"Set the editor to use for interactive commands",
+                             :short=>"-e EDITOR",
+                             :default=>"/usr/bin/vim"}
+
+      # there is special hackery to return the subcommand instance going on here.
+      command = Chef::Knife.run(%w{test yourself}, extra_opts)
+      editor_opts = command.options[:editor]
+      editor_opts[:long].should         == "--editor EDITOR"
+      editor_opts[:description].should  == "Set the editor to use for interactive commands"
+      editor_opts[:short].should        == "-e EDITOR"
+      editor_opts[:default].should      == "/usr/bin/vim"
+    end
+
+    it "creates an instance of the subcommand and runs it" do
+      command = Chef::Knife.run(%w{test yourself})
+      command.should be_an_instance_of(KnifeSpecs::TestYourself)
+      command.ran.should be_true
+    end
+
+    it "passes the command specific args to the subcommand" do
+      command = Chef::Knife.run(%w{test yourself with some args})
+      command.name_args.should == %w{with some args}
+    end
+
+    it "excludes the command name from the name args when parts are joined with underscores" do
+      command = Chef::Knife.run(%w{test_yourself with some args})
+      command.name_args.should == %w{with some args}
+    end
+
+    it "exits if no subcommand matches the CLI args" do
+      Chef::Knife.ui.stub!(:stdout).and_return(@stdout)
+      Chef::Knife.ui.should_receive(:fatal)
+      lambda {Chef::Knife.run(%w{fuuu uuuu fuuuu})}.should raise_error(SystemExit) { |e| e.status.should_not == 0 }
+    end
+
+  end
+
+  describe "when first created" do
+    before do
+      unless KnifeSpecs.const_defined?(:TestYourself)
+        Kernel.load(File.join(CHEF_SPEC_DATA, 'knife_subcommand', 'test_yourself.rb'))
+      end
+      @knife = KnifeSpecs::TestYourself.new(%w{with some args -s scrogramming})
+    end
+
+    it "it parses the options passed to it" do
+      @knife.config[:scro].should == 'scrogramming'
+    end
+
+    it "extracts its command specific args from the full arg list" do
+      @knife.name_args.should == %w{with some args}
+    end
+
+  end
+
+  describe "when formatting exceptions" do
+    before do
+      @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
+      @knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
+      @knife.should_receive(:exit).with(100)
+    end
+
+    it "formats 401s nicely" do
+      response = Net::HTTPUnauthorized.new("1.1", "401", "Unauthorized")
+      response.instance_variable_set(:@read, true) # I hate you, net/http.
+      response.stub!(:body).and_return(Chef::JSONCompat.to_json(:error => "y u no syncronize your clock?"))
+      @knife.stub!(:run).and_raise(Net::HTTPServerException.new("401 Unauthorized", response))
+      @knife.run_with_pretty_exceptions
+      @stderr.string.should match(/ERROR: Failed to authenticate to/)
+      @stdout.string.should match(/Response:  y u no syncronize your clock\?/)
+    end
+
+    it "formats 403s nicely" do
+      response = Net::HTTPForbidden.new("1.1", "403", "Forbidden")
+      response.instance_variable_set(:@read, true) # I hate you, net/http.
+      response.stub!(:body).and_return(Chef::JSONCompat.to_json(:error => "y u no administrator"))
+      @knife.stub!(:run).and_raise(Net::HTTPServerException.new("403 Forbidden", response))
+      @knife.stub!(:username).and_return("sadpanda")
+      @knife.run_with_pretty_exceptions
+      @stderr.string.should match(%r[ERROR: You authenticated successfully to http.+ as sadpanda but you are not authorized for this action])
+      @stdout.string.should match(%r[Response:  y u no administrator])
+    end
+
+    it "formats 400s nicely" do
+      response = Net::HTTPBadRequest.new("1.1", "400", "Bad Request")
+      response.instance_variable_set(:@read, true) # I hate you, net/http.
+      response.stub!(:body).and_return(Chef::JSONCompat.to_json(:error => "y u search wrong"))
+      @knife.stub!(:run).and_raise(Net::HTTPServerException.new("400 Bad Request", response))
+      @knife.run_with_pretty_exceptions
+      @stderr.string.should match(%r[ERROR: The data in your request was invalid])
+      @stdout.string.should match(%r[Response: y u search wrong])
+    end
+
+    it "formats 404s nicely" do
+      response = Net::HTTPNotFound.new("1.1", "404", "Not Found")
+      response.instance_variable_set(:@read, true) # I hate you, net/http.
+      response.stub!(:body).and_return(Chef::JSONCompat.to_json(:error => "nothing to see here"))
+      @knife.stub!(:run).and_raise(Net::HTTPServerException.new("404 Not Found", response))
+      @knife.run_with_pretty_exceptions
+      @stderr.string.should match(%r[ERROR: The object you are looking for could not be found])
+      @stdout.string.should match(%r[Response: nothing to see here])
+    end
+
+    it "formats 500s nicely" do
+      response = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
+      response.instance_variable_set(:@read, true) # I hate you, net/http.
+      response.stub!(:body).and_return(Chef::JSONCompat.to_json(:error => "sad trombone"))
+      @knife.stub!(:run).and_raise(Net::HTTPFatalError.new("500 Internal Server Error", response))
+      @knife.run_with_pretty_exceptions
+      @stderr.string.should match(%r[ERROR: internal server error])
+      @stdout.string.should match(%r[Response: sad trombone])
+    end
+
+    it "formats 502s nicely" do
+      response = Net::HTTPBadGateway.new("1.1", "502", "Bad Gateway")
+      response.instance_variable_set(:@read, true) # I hate you, net/http.
+      response.stub!(:body).and_return(Chef::JSONCompat.to_json(:error => "sadder trombone"))
+      @knife.stub!(:run).and_raise(Net::HTTPFatalError.new("502 Bad Gateway", response))
+      @knife.run_with_pretty_exceptions
+      @stderr.string.should match(%r[ERROR: bad gateway])
+      @stdout.string.should match(%r[Response: sadder trombone])
+    end
+
+    it "formats 503s nicely" do
+      response = Net::HTTPServiceUnavailable.new("1.1", "503", "Service Unavailable")
+      response.instance_variable_set(:@read, true) # I hate you, net/http.
+      response.stub!(:body).and_return(Chef::JSONCompat.to_json(:error => "saddest trombone"))
+      @knife.stub!(:run).and_raise(Net::HTTPFatalError.new("503 Service Unavailable", response))
+      @knife.run_with_pretty_exceptions
+      @stderr.string.should match(%r[ERROR: Service temporarily unavailable])
+      @stdout.string.should match(%r[Response: saddest trombone])
+    end
+
+    it "formats other HTTP errors nicely" do
+      response = Net::HTTPPaymentRequired.new("1.1", "402", "Payment Required")
+      response.instance_variable_set(:@read, true) # I hate you, net/http.
+      response.stub!(:body).and_return(Chef::JSONCompat.to_json(:error => "nobugfixtillyoubuy"))
+      @knife.stub!(:run).and_raise(Net::HTTPServerException.new("402 Payment Required", response))
+      @knife.run_with_pretty_exceptions
+      @stderr.string.should match(%r[ERROR: Payment Required])
+      @stdout.string.should match(%r[Response: nobugfixtillyoubuy])
+    end
+
+    it "formats NameError and NoMethodError nicely" do
+      @knife.stub!(:run).and_raise(NameError.new("Undefined constant FUUU"))
+      @knife.run_with_pretty_exceptions
+      @stderr.string.should match(%r[ERROR: knife encountered an unexpected error])
+      @stdout.string.should match(%r[This may be a bug in the 'knife' knife command or plugin])
+      @stdout.string.should match(%r[Exception: NameError: Undefined constant FUUU])
+    end
+
+    it "formats missing private key errors nicely" do
+      @knife.stub!(:run).and_raise(Chef::Exceptions::PrivateKeyMissing.new('key not there'))
+      @knife.stub!(:api_key).and_return("/home/root/.chef/no-key-here.pem")
+      @knife.run_with_pretty_exceptions
+      @stderr.string.should match(%r[ERROR: Your private key could not be loaded from /home/root/.chef/no-key-here.pem])
+      @stdout.string.should match(%r[Check your configuration file and ensure that your private key is readable])
+    end
+
+    it "formats connection refused errors nicely" do
+      @knife.stub!(:run).and_raise(Errno::ECONNREFUSED.new('y u no shut up'))
+      @knife.run_with_pretty_exceptions
+      # Errno::ECONNREFUSED message differs by platform
+      # *nix = Errno::ECONNREFUSED: Connection refused
+      # win32: Errno::ECONNREFUSED: No connection could be made because the target machine actively refused it.
+      @stderr.string.should match(%r[ERROR: Network Error: .* - y u no shut up])
+      @stdout.string.should match(%r[Check your knife configuration and network settings])
+    end
+  end
+
+end

data/spec/unit/log_spec.rb

@@ -0,0 +1,24 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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 'tempfile'
+require 'logger'
+require 'spec_helper'
+
+describe Chef::Log do
+end

data/spec/unit/lwrp_spec.rb

@@ -0,0 +1,256 @@
+#
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2009 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 'spec_helper'
+
+module LwrpConstScopingConflict
+end
+
+describe "override logging" do
+  before :each do
+    $stderr.stub!(:write)
+  end
+
+  it "should log if attempting to load resource of same name" do
+    Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp", "resources", "*"))].each do |file|
+      Chef::Resource.build_from_file("lwrp", file, nil)
+    end
+
+    Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp_override", "resources", "*"))].each do |file|
+      Chef::Log.should_receive(:info).with(/overriding/)
+      Chef::Resource.build_from_file("lwrp", file, nil)
+    end
+  end
+
+  it "should log if attempting to load provider of same name" do
+    Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp", "providers", "*"))].each do |file|
+      Chef::Provider.build_from_file("lwrp", file, nil)
+    end
+
+    Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp_override", "providers", "*"))].each do |file|
+      Chef::Log.should_receive(:info).with(/overriding/)
+      Chef::Provider.build_from_file("lwrp", file, nil)
+    end
+  end
+
+  it "removes the old LRWP resource class from the list of resource subclasses [CHEF-3432]" do
+    # CHEF-3432 regression test:
+    # Chef::Resource keeps a list of all subclasses to assist class inflation
+    # for json parsing (see Chef::JSONCompat). When replacing LWRP resources,
+    # we need to ensure the old resource class is remove from that list.
+    Dir[File.expand_path( "lwrp/resources/*", CHEF_SPEC_DATA)].each do |file|
+      Chef::Resource.build_from_file("lwrp", file, nil)
+    end
+    first_lwr_foo_class = Chef::Resource::LwrpFoo
+    Chef::Resource.resource_classes.should include(first_lwr_foo_class)
+    Dir[File.expand_path( "lwrp/resources/*", CHEF_SPEC_DATA)].each do |file|
+      Chef::Resource.build_from_file("lwrp", file, nil)
+    end
+    Chef::Resource.resource_classes.should_not include(first_lwr_foo_class)
+  end
+
+   it "does not attempt to remove classes from higher up namespaces [CHEF-4117]" do
+     conflicting_lwrp_file = File.expand_path( "lwrp_const_scoping/resources/conflict.rb", CHEF_SPEC_DATA)
+     # The test is that this should not raise an error:
+     Chef::Resource.build_from_file("lwrp_const_scoping", conflicting_lwrp_file, nil)
+   end
+
+end
+
+describe "LWRP" do
+  before do
+    @original_VERBOSE = $VERBOSE
+    $VERBOSE = nil
+  end
+
+  after do
+    $VERBOSE = @original_VERBOSE
+  end
+
+  describe "Lightweight Chef::Resource" do
+
+    before do
+      Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp", "resources", "*"))].each do |file|
+        Chef::Resource.build_from_file("lwrp", file, nil)
+      end
+
+      Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp_override", "resources", "*"))].each do |file|
+        Chef::Resource.build_from_file("lwrp", file, nil)
+      end
+    end
+
+    it "should load the resource into a properly-named class" do
+      Chef::Resource.const_get("LwrpFoo").should be_kind_of(Class)
+    end
+
+    it "should set resource_name" do
+      Chef::Resource::LwrpFoo.new("blah").resource_name.should eql(:lwrp_foo)
+    end
+
+    it "should add the specified actions to the allowed_actions array" do
+      Chef::Resource::LwrpFoo.new("blah").allowed_actions.should include(:pass_buck, :twiddle_thumbs)
+    end
+
+    it "should set the specified action as the default action" do
+      Chef::Resource::LwrpFoo.new("blah").action.should == :pass_buck
+    end
+
+    it "should create a method for each attribute" do
+      Chef::Resource::LwrpFoo.new("blah").methods.map{ |m| m.to_sym}.should include(:monkey)
+    end
+
+    it "should build attribute methods that respect validation rules" do
+      lambda { Chef::Resource::LwrpFoo.new("blah").monkey(42) }.should raise_error(ArgumentError)
+    end
+
+    it "should have access to the run context and node during class definition" do
+      node = Chef::Node.new(nil)
+      node[:penguin_name] = "jackass"
+      run_context = Chef::RunContext.new(node, Chef::CookbookCollection.new, @events)
+
+      Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp", "resources_with_default_attributes", "*"))].each do |file|
+        Chef::Resource.build_from_file("lwrp", file, run_context)
+      end
+
+      cls = Chef::Resource.const_get("LwrpNodeattr")
+      cls.node.should be_kind_of(Chef::Node)
+      cls.run_context.should be_kind_of(Chef::RunContext)
+      cls.node[:penguin_name].should eql("jackass")
+    end
+
+  end
+
+  describe "Lightweight Chef::Provider" do
+    before do
+      @node = Chef::Node.new
+      @node.platform(:ubuntu)
+      @node.platform_version('8.10')
+      @events = Chef::EventDispatch::Dispatcher.new
+      @run_context = Chef::RunContext.new(@node, Chef::CookbookCollection.new({}), @events)
+      @runner = Chef::Runner.new(@run_context)
+    end
+
+    before(:each) do
+      Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp", "resources", "*"))].each do |file|
+        Chef::Resource.build_from_file("lwrp", file, @run_context)
+      end
+
+      Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp_override", "resources", "*"))].each do |file|
+        Chef::Resource.build_from_file("lwrp", file, @run_context)
+      end
+
+      Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp", "providers", "*"))].each do |file|
+        Chef::Provider.build_from_file("lwrp", file, @run_context)
+      end
+
+      Dir[File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "lwrp_override", "providers", "*"))].each do |file|
+        Chef::Provider.build_from_file("lwrp", file, @run_context)
+      end
+
+    end
+
+    it "should properly handle a new_resource reference" do
+      resource = Chef::Resource::LwrpFoo.new("morpheus")
+      resource.monkey("bob")
+      resource.provider(:lwrp_monkey_name_printer)
+      resource.run_context = @run_context
+
+      provider = Chef::Platform.provider_for_resource(resource, :twiddle_thumbs)
+      provider.action_twiddle_thumbs
+    end
+
+    it "should load the provider into a properly-named class" do
+      Chef::Provider.const_get("LwrpBuckPasser").should be_kind_of(Class)
+    end
+
+    it "should create a method for each attribute" do
+      new_resource = mock("new resource", :null_object=>true)
+      Chef::Provider::LwrpBuckPasser.new(nil, new_resource).methods.map{|m|m.to_sym}.should include(:action_pass_buck)
+      Chef::Provider::LwrpThumbTwiddler.new(nil, new_resource).methods.map{|m|m.to_sym}.should include(:action_twiddle_thumbs)
+    end
+
+    it "should insert resources embedded in the provider into the middle of the resource collection" do
+      injector = Chef::Resource::LwrpFoo.new("morpheus", @run_context)
+      injector.action(:pass_buck)
+      injector.provider(:lwrp_buck_passer)
+      dummy = Chef::Resource::ZenMaster.new("keanu reeves", @run_context)
+      dummy.provider(Chef::Provider::Easy)
+      @run_context.resource_collection.insert(injector)
+      @run_context.resource_collection.insert(dummy)
+
+      Chef::Runner.new(@run_context).converge
+
+      @run_context.resource_collection[0].should eql(injector)
+      @run_context.resource_collection[1].name.should eql(:prepared_thumbs)
+      @run_context.resource_collection[2].name.should eql(:twiddled_thumbs)
+      @run_context.resource_collection[3].should eql(dummy)
+    end
+
+    it "should insert embedded resources from multiple providers, including from the last position, properly into the resource collection" do
+      injector = Chef::Resource::LwrpFoo.new("morpheus", @run_context)
+      injector.action(:pass_buck)
+      injector.provider(:lwrp_buck_passer)
+
+      injector2 = Chef::Resource::LwrpBar.new("tank", @run_context)
+      injector2.action(:pass_buck)
+      injector2.provider(:lwrp_buck_passer_2)
+
+      dummy = Chef::Resource::ZenMaster.new("keanu reeves", @run_context)
+      dummy.provider(Chef::Provider::Easy)
+
+      @run_context.resource_collection.insert(injector)
+      @run_context.resource_collection.insert(dummy)
+      @run_context.resource_collection.insert(injector2)
+
+      Chef::Runner.new(@run_context).converge
+
+      @run_context.resource_collection[0].should eql(injector)
+      @run_context.resource_collection[1].name.should eql(:prepared_thumbs)
+      @run_context.resource_collection[2].name.should eql(:twiddled_thumbs)
+      @run_context.resource_collection[3].should eql(dummy)
+      @run_context.resource_collection[4].should eql(injector2)
+      @run_context.resource_collection[5].name.should eql(:prepared_eyes)
+      @run_context.resource_collection[6].name.should eql(:dried_paint_watched)
+    end
+
+    it "should properly handle a new_resource reference" do
+      resource = Chef::Resource::LwrpFoo.new("morpheus", @run_context)
+      resource.monkey("bob")
+      resource.provider(:lwrp_monkey_name_printer)
+
+      provider = Chef::Platform.provider_for_resource(resource, :twiddle_thumbs)
+      provider.action_twiddle_thumbs
+
+      provider.monkey_name.should == "my monkey's name is 'bob'"
+    end
+
+    it "should properly handle an embedded Resource accessing the enclosing Provider's scope" do
+      resource = Chef::Resource::LwrpFoo.new("morpheus", @run_context)
+      resource.monkey("bob")
+      resource.provider(:lwrp_embedded_resource_accesses_providers_scope)
+
+      provider = Chef::Platform.provider_for_resource(resource, :twiddle_thumbs)
+      #provider = @runner.build_provider(resource)
+      provider.action_twiddle_thumbs
+
+      provider.enclosed_resource.monkey.should == 'bob, the monkey'
+    end
+
+  end
+
+end