[OC-3564] move core Chef to the repo root \o/ \m/

The opscode/chef repository now only contains the core Chef library code
used by chef-client, knife and chef-solo!

72 files changed, 17944 insertions, 0 deletions

diff --git a/spec/unit/provider/breakpoint_spec.rb b/spec/unit/provider/breakpoint_spec.rb
new file mode 100644
index 0000000000..977624597a
--- /dev/null
+++ b/spec/unit/provider/breakpoint_spec.rb
@@ -0,0 +1,54 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.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 'spec_helper'
+describe Chef::Provider::Breakpoint do
+
+  before do
+    @resource = Chef::Resource::Breakpoint.new
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @collection = mock("resource collection")
+    @run_context.stub!(:resource_collection).and_return(@collection)
+    @provider = Chef::Provider::Breakpoint.new(@resource, @run_context)
+  end
+
+  it "responds to load_current_resource" do
+    @provider.should respond_to(:load_current_resource)
+  end
+
+  it "gets the iterator from @collection and pauses it" do
+    Shell.stub!(:running?).and_return(true)
+    @iterator = mock("stepable_iterator")
+    @collection.stub!(:iterator).and_return(@iterator)
+    @iterator.should_receive(:pause)
+    @provider.action_break
+    @resource.should be_updated
+  end
+
+  it "doesn't pause the iterator if chef-shell isn't running" do
+    Shell.stub!(:running?).and_return(false)
+    @iterator = mock("stepable_iterator")
+    @collection.stub!(:iterator).and_return(@iterator)
+    @iterator.should_not_receive(:pause)
+    @provider.action_break
+  end
+
+end
diff --git a/spec/unit/provider/cookbook_file_spec.rb b/spec/unit/provider/cookbook_file_spec.rb
new file mode 100644
index 0000000000..c70a7d852c
--- /dev/null
+++ b/spec/unit/provider/cookbook_file_spec.rb
@@ -0,0 +1,220 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010 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 'ostruct'
+
+describe Chef::Provider::CookbookFile do
+  before do
+    Chef::FileAccessControl.any_instance.stub(:set_all)
+    Chef::FileAccessControl.any_instance.stub(:modified?).and_return(true)
+    @cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
+    Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, @cookbook_repo) }
+
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    cl = Chef::CookbookLoader.new(@cookbook_repo)
+    cl.load_cookbooks
+    @cookbook_collection = Chef::CookbookCollection.new(cl)
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+
+    @new_resource = Chef::Resource::CookbookFile.new('apache2_module_conf_generate.pl', @run_context)
+    @new_resource.cookbook_name = 'apache2'
+    @provider = Chef::Provider::CookbookFile.new(@new_resource, @run_context)
+
+    @file_content=<<-EXPECTED
+# apache2_module_conf_generate.pl
+# this is just here for show.
+EXPECTED
+
+  end
+
+  it "prefers the explicit cookbook name on the resource to the implicit one" do
+    @new_resource.cookbook('nginx')
+    @provider.resource_cookbook.should == 'nginx'
+  end
+
+  it "falls back to the implicit cookbook name on the resource" do
+    @provider.resource_cookbook.should == 'apache2'
+  end
+
+  describe "when loading the current file state" do
+
+    it "converts windows-y filenames to unix-y ones" do
+      @new_resource.path('windows\stuff')
+      @provider.load_current_resource
+      @new_resource.path.should == 'windows/stuff'
+    end
+
+    it "sets the current resources path to the same as the new resource" do
+      @new_resource.path('/tmp/file')
+      @provider.load_current_resource
+      @provider.current_resource.path.should == '/tmp/file'
+    end
+  end
+
+  describe "when the enclosing directory of the target file location doesn't exist" do
+    before do
+      @new_resource.path("/tmp/no/such/intermediate/path/file.txt")
+    end
+
+    it "raises a specific error alerting the user to the problem" do
+      lambda {@provider.run_action(:create)}.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+    end
+  end
+  describe "when the file doesn't yet exist" do
+    before do
+      @install_to = Dir.tmpdir + '/apache2_modconf.pl'
+
+      @current_resource = @new_resource.dup
+      @provider.current_resource = @current_resource
+    end
+
+    after { ::File.exist?(@install_to) && FileUtils.rm(@install_to) }
+
+    it "loads the current file state" do
+      @provider.load_current_resource
+      @provider.current_resource.checksum.should be_nil
+    end
+
+    it "looks up a file from the cookbook cache" do
+      expected = CHEF_SPEC_DATA + "/cookbooks/apache2/files/default/apache2_module_conf_generate.pl"
+      @provider.file_cache_location.should == expected
+    end
+
+    it "stages the cookbook to a temporary file" do
+      @new_resource.path(@install_to)
+      @provider.should_receive(:deploy_tempfile)
+      @provider.run_action(:create)
+    end
+
+    it "installs the file from the cookbook cache" do
+      @new_resource.path(@install_to)
+      @provider.should_receive(:backup_new_resource)
+      @provider.stub!(:update_new_file_state)
+      @provider.run_action(:create)
+      actual = IO.read(@install_to)
+      actual.should == @file_content
+    end
+
+    it "installs the file for create_if_missing --> from Provider::File" do
+      @new_resource.path(@install_to)
+      @provider.should_receive(:backup_new_resource)
+      @provider.stub!(:update_new_file_state)
+      @provider.run_action(:create_if_missing)
+      actual = IO.read(@install_to)
+      actual.should == @file_content
+    end
+
+    it "marks the resource as updated by the last action --> being tested in the converge framework" do
+      @new_resource.path(@install_to)
+      @provider.stub!(:backup_new_resource)
+      @provider.stub!(:set_file_access_controls)
+      @provider.stub!(:update_new_file_state)
+      @provider.run_action(:create)
+      @new_resource.should be_updated
+      @new_resource.should be_updated_by_last_action
+    end
+
+  end
+
+  describe "when the file exists but has incorrect content" do
+    before do
+      @tempfile = Tempfile.open('cookbook_file_spec')
+      @new_resource.path(@target_file = @tempfile.path)
+      @tempfile.puts "the wrong content"
+      @tempfile.close
+      @current_resource = @new_resource.dup
+      @provider.current_resource = @current_resource
+    end
+
+    it "stages the cookbook to a temporary file" do
+      # prevents file backups where we might not have write access
+      @provider.should_receive(:backup_new_resource) 
+      @new_resource.path(@install_to)
+      @provider.should_receive(:deploy_tempfile)
+      @provider.run_action(:create)
+    end
+
+    it "overwrites it when the create action is called" do
+      @provider.should_receive(:backup_new_resource)
+      @provider.run_action(:create)
+      actual = IO.read(@target_file)
+      actual.should == @file_content
+    end
+
+    it "marks the resource as updated by the last action" do
+      @provider.should_receive(:backup_new_resource)
+      @provider.run_action(:create)
+      @new_resource.should be_updated
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "doesn't overwrite when the create if missing action is called" do
+      @provider.should_not_receive(:set_file_access_controls)
+      @provider.run_action(:create_if_missing)
+      actual = IO.read(@target_file)
+      actual.should == "the wrong content\n"
+    end
+
+    it "doesn't mark the resource as updated by the action for create_if_missing" do
+      @provider.run_action(:create_if_missing)
+      @new_resource.should_not be_updated
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    after { @tempfile && @tempfile.close! }
+  end
+
+  describe "when the file has the correct content" do
+    before do
+      Chef::FileAccessControl.any_instance.stub(:modified?).and_return(false)
+      @tempfile = Tempfile.open('cookbook_file_spec')
+      # CHEF-2991: We handle CRLF very poorly and we don't know what line endings
+      # our source file is going to have, so we use binary mode to preserve CRLF if needed.
+      source_file = CHEF_SPEC_DATA + "/cookbooks/apache2/files/default/apache2_module_conf_generate.pl"
+      @tempfile.binmode unless File.open(source_file, "rb") { |f| f.read =~ /\r/ }
+      @new_resource.path(@target_file = @tempfile.path)
+      @tempfile.write(@file_content)
+      @tempfile.close
+      @current_resource = @new_resource.dup
+      @provider.current_resource = @current_resource
+    end
+
+    after { @tempfile && @tempfile.unlink}
+
+    it "checks access control but does not alter content when action is create" do
+      @provider.should_receive(:set_all_access_controls)
+      @provider.should_not_receive(:stage_file_to_tmpdir)
+      @provider.run_action(:create)
+    end
+
+    it "does not mark the resource as updated by the last action" do
+      @provider.run_action(:create)
+      @new_resource.should_not be_updated
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    it "does not alter content or access control when action is create if missing" do
+      @provider.should_not_receive(:set_all_access_controls)
+      @provider.should_not_receive(:stage_file_to_tmpdir)
+      @provider.run_action(:create_if_missing)
+    end
+
+  end
+end
diff --git a/spec/unit/provider/cron/solaris_spec.rb b/spec/unit/provider/cron/solaris_spec.rb
new file mode 100644
index 0000000000..55516d59e9
--- /dev/null
+++ b/spec/unit/provider/cron/solaris_spec.rb
@@ -0,0 +1,121 @@
+#
+# Author:: Bryan McLellan (btm@loftninjas.org)
+# Author:: Toomas Pelberg (toomasp@gmx.net)
+# Copyright:: Copyright (c) 2009 Bryan McLellan
+# Copyright:: Copyright (c) 2010 Toomas Pelberg
+# 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 Chef::Provider::Cron::Solaris do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Cron.new("cronhole some stuff")
+    @new_resource.user "root"
+    @new_resource.minute "30"
+    @new_resource.command "/bin/true"
+
+    @provider = Chef::Provider::Cron::Solaris.new(@new_resource, @run_context)
+  end
+
+  it "should inherit from Chef::Provider:Cron" do
+    @provider.should be_a(Chef::Provider::Cron)
+  end
+
+  describe "read_crontab" do
+    before :each do
+      @status = mock("Status", :exitstatus => 0)
+      @stdout = StringIO.new(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+* 5 * * * /bin/true
+
+# Another comment
+      CRONTAB
+      @provider.stub!(:popen4).and_yield(1234, StringIO.new, @stdout, StringIO.new).and_return(@status)
+    end
+
+    it "should call crontab -l with the user" do
+      @provider.should_receive(:popen4).with("crontab -l #{@new_resource.user}").and_return(@status)
+      @provider.send(:read_crontab)
+    end
+
+    it "should return the contents of the crontab" do
+      crontab = @provider.send(:read_crontab)
+      crontab.should == <<-CRONTAB
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+* 5 * * * /bin/true
+
+# Another comment
+CRONTAB
+    end
+
+    it "should return nil if the user has no crontab" do
+      status = mock("Status", :exitstatus => 1)
+      @provider.stub!(:popen4).and_return(status)
+      @provider.send(:read_crontab).should == nil
+    end
+
+    it "should raise an exception if another error occurs" do
+      status = mock("Status", :exitstatus => 2)
+      @provider.stub!(:popen4).and_return(status)
+      lambda do
+        @provider.send(:read_crontab)
+      end.should raise_error(Chef::Exceptions::Cron, "Error determining state of #{@new_resource.name}, exit: 2")
+    end
+  end
+
+  describe "write_crontab" do
+    before :each do
+      @status = mock("Status", :exitstatus => 0)
+      @provider.stub!(:run_command).and_return(@status)
+      @tempfile = mock("foo", :path => "/tmp/foo", :close => true, :binmode => nil)
+      Tempfile.stub!(:new).and_return(@tempfile)
+      @tempfile.should_receive(:flush)
+      @tempfile.should_receive(:chmod).with(420)
+      @tempfile.should_receive(:close!)
+    end
+
+    it "should call crontab for the user" do
+      @provider.should_receive(:run_command).with(hash_including(:user => @new_resource.user))
+      @tempfile.should_receive(:<<).with("Foo")
+      @provider.send(:write_crontab, "Foo")
+    end
+
+    it "should call crontab with a file containing the crontab" do
+      @provider.should_receive(:run_command) do |args|
+        (args[:command] =~ %r{\A/usr/bin/crontab (/\S+)\z}).should be_true
+        $1.should == "/tmp/foo"
+        @status
+      end
+      @tempfile.should_receive(:<<).with("Foo\n# wibble\n wah!!")
+      @provider.send(:write_crontab, "Foo\n# wibble\n wah!!")
+    end
+
+    it "should raise an exception if the command returns non-zero" do
+      @tempfile.should_receive(:<<).with("Foo")
+      @status.stub!(:exitstatus).and_return(1)
+      lambda do
+        @provider.send(:write_crontab, "Foo")
+      end.should raise_error(Chef::Exceptions::Cron, "Error updating state of #{@new_resource.name}, exit: 1")
+    end
+  end
+end
diff --git a/spec/unit/provider/cron_spec.rb b/spec/unit/provider/cron_spec.rb
new file mode 100644
index 0000000000..5a848a30e6
--- /dev/null
+++ b/spec/unit/provider/cron_spec.rb
@@ -0,0 +1,812 @@
+#
+# Author:: Bryan McLellan (btm@loftninjas.org)
+# Copyright:: Copyright (c) 2009 Bryan McLellan
+# 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 Chef::Provider::Cron do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Cron.new("cronhole some stuff", @run_context)
+    @new_resource.user "root"
+    @new_resource.minute "30"
+    @new_resource.command "/bin/true"
+
+    @provider = Chef::Provider::Cron.new(@new_resource, @run_context)
+  end
+
+  describe "when examining the current system state" do
+    context "with no crontab for the user" do
+      before :each do
+        @provider.stub!(:read_crontab).and_return(nil)
+      end
+
+      it "should set cron_empty" do
+        @provider.load_current_resource
+        @provider.cron_empty.should == true
+        @provider.cron_exists.should == false
+      end
+
+      it "should report an empty crontab" do
+        Chef::Log.should_receive(:debug).with("Cron empty for '#{@new_resource.user}'")
+        @provider.load_current_resource
+      end
+    end
+
+    context "with no matching entry in the user's crontab" do
+      before :each do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+* 5 * * * /bin/true
+
+# Another comment
+CRONTAB
+      end
+
+      it "should not set cron_exists or cron_empty" do
+        @provider.load_current_resource
+        @provider.cron_exists.should == false
+        @provider.cron_empty.should == false
+      end
+
+      it "should report no entry found" do
+        Chef::Log.should_receive(:debug).with("Cron '#{@new_resource.name}' not found")
+        @provider.load_current_resource
+      end
+
+      it "should not fail if there's an existing cron with a numerical argument" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+# Chef Name: foo[bar] (baz)
+21 */4 * * * some_prog 1234567
+CRONTAB
+        lambda {
+          @provider.load_current_resource
+        }.should_not raise_error
+      end
+    end
+
+    context "with a matching entry in the user's crontab" do
+      before :each do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+* 5 * 1 * /bin/true param1 param2
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+CRONTAB
+      end
+
+      it "should set cron_exists" do
+        @provider.load_current_resource
+        @provider.cron_exists.should == true
+        @provider.cron_empty.should == false
+      end
+
+      it "should pull the details out of the cron line" do
+        cron = @provider.load_current_resource
+        cron.minute.should == '*'
+        cron.hour.should == '5'
+        cron.day.should == '*'
+        cron.month.should == '1'
+        cron.weekday.should == '*'
+        cron.command.should == '/bin/true param1 param2'
+      end
+
+      it "should pull env vars out" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+MAILTO=foo@example.com
+SHELL=/bin/foosh
+PATH=/bin:/foo
+HOME=/home/foo
+* 5 * 1 * /bin/true param1 param2
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+CRONTAB
+        cron = @provider.load_current_resource
+        cron.mailto.should == 'foo@example.com'
+        cron.shell.should == '/bin/foosh'
+        cron.path.should == '/bin:/foo'
+        cron.home.should == '/home/foo'
+        cron.minute.should == '*'
+        cron.hour.should == '5'
+        cron.day.should == '*'
+        cron.month.should == '1'
+        cron.weekday.should == '*'
+        cron.command.should == '/bin/true param1 param2'
+      end
+
+      it "should parse and load generic and standard environment variables from cron entry" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+# Chef Name: cronhole some stuff
+MAILTO=warn@example.com
+TEST=lol
+FLAG=1
+* 5 * * * /bin/true
+CRONTAB
+        cron = @provider.load_current_resource
+
+        cron.mailto.should == "warn@example.com"
+        cron.environment.should == {"TEST" => "lol", "FLAG" => "1"}
+      end
+
+      it "should not break with variabels that match the cron resource internals" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+# Chef Name: cronhole some stuff
+MINUTE=40
+HOUR=midnight
+TEST=lol
+ENVIRONMENT=production
+* 5 * * * /bin/true
+CRONTAB
+        cron = @provider.load_current_resource
+
+        cron.minute.should == '*'
+        cron.hour.should == '5'
+        cron.environment.should == {"MINUTE" => "40", "HOUR" => "midnight", "TEST" => "lol", "ENVIRONMENT" => "production"}
+      end
+
+      it "should report the match" do
+        Chef::Log.should_receive(:debug).with("Found cron '#{@new_resource.name}'")
+        @provider.load_current_resource
+      end
+    end
+
+    context "with a matching entry in the user's crontab using month names and weekday names (#CHEF-3178)" do
+      before :each do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+      
+# Chef Name: cronhole some stuff
+* 5 * Jan Mon /bin/true param1 param2
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+CRONTAB
+      end
+
+      it "should set cron_exists" do
+        @provider.load_current_resource
+        @provider.cron_exists.should == true
+        @provider.cron_empty.should == false
+      end
+        
+      it "should pull the details out of the cron line" do
+        cron = @provider.load_current_resource
+        cron.minute.should == '*'
+        cron.hour.should == '5'
+        cron.day.should == '*'
+        cron.month.should == 'Jan'
+        cron.weekday.should == 'Mon'
+        cron.command.should == '/bin/true param1 param2'
+      end
+
+      it "should report the match" do
+        Chef::Log.should_receive(:debug).with("Found cron '#{@new_resource.name}'")
+        @provider.load_current_resource
+      end
+    end
+
+    context "with a matching entry without a crontab line" do
+      it "should set cron_exists and leave current_resource values at defaults" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+CRONTAB
+        cron = @provider.load_current_resource
+        @provider.cron_exists.should == true
+        cron.minute.should == '*'
+        cron.hour.should == '*'
+        cron.day.should == '*'
+        cron.month.should == '*'
+        cron.weekday.should == '*'
+        cron.command.should == nil
+      end
+
+      it "should not pick up a commented out crontab line" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+#* 5 * 1 * /bin/true param1 param2
+CRONTAB
+        cron = @provider.load_current_resource
+        @provider.cron_exists.should == true
+        cron.minute.should == '*'
+        cron.hour.should == '*'
+        cron.day.should == '*'
+        cron.month.should == '*'
+        cron.weekday.should == '*'
+        cron.command.should == nil
+      end
+
+      it "should not pick up a later crontab entry" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+#* 5 * 1 * /bin/true param1 param2
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+CRONTAB
+        cron = @provider.load_current_resource
+        @provider.cron_exists.should == true
+        cron.minute.should == '*'
+        cron.hour.should == '*'
+        cron.day.should == '*'
+        cron.month.should == '*'
+        cron.weekday.should == '*'
+        cron.command.should == nil
+      end
+    end
+  end
+
+  describe "cron_different?" do
+    before :each do
+      @current_resource = Chef::Resource::Cron.new("cronhole some stuff")
+      @current_resource.user "root"
+      @current_resource.minute "30"
+      @current_resource.command "/bin/true"
+      @provider.current_resource = @current_resource
+    end
+
+    [:minute, :hour, :day, :month, :weekday, :command, :mailto, :path, :shell, :home].each do |attribute|
+      it "should return true if #{attribute} doesn't match" do
+        @new_resource.send(attribute, "something_else")
+        @provider.cron_different?.should eql(true)
+      end
+    end
+
+    it "should return true if environment doesn't match" do
+      @new_resource.environment "FOO" => "something_else"
+      @provider.cron_different?.should eql(true)
+    end
+
+    it "should return false if the objects are identical" do
+      @provider.cron_different?.should == false
+    end
+  end
+
+  describe "action_create" do
+    before :each do
+      @provider.stub!(:write_crontab)
+      @provider.stub!(:read_crontab).and_return(nil)
+    end
+
+    context "when there is no existing crontab" do
+      before :each do
+        @provider.cron_exists = false
+        @provider.cron_empty = true
+      end
+
+      it "should create a crontab with the entry" do
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+# Chef Name: cronhole some stuff
+30 * * * * /bin/true
+        ENDCRON
+        @provider.run_action(:create)
+      end
+
+      it "should include env variables that are set" do
+        @new_resource.mailto 'foo@example.com'
+        @new_resource.path '/usr/bin:/my/custom/path'
+        @new_resource.shell '/bin/foosh'
+        @new_resource.home '/home/foo'
+        @new_resource.environment "TEST" => "LOL"
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+# Chef Name: cronhole some stuff
+MAILTO=foo@example.com
+PATH=/usr/bin:/my/custom/path
+SHELL=/bin/foosh
+HOME=/home/foo
+TEST=LOL
+30 * * * * /bin/true
+        ENDCRON
+        @provider.run_action(:create)
+      end
+
+      it "should mark the resource as updated" do
+        @provider.run_action(:create)
+        @new_resource.should be_updated_by_last_action
+      end
+
+      it "should log the action" do
+        Chef::Log.should_receive(:info).with("cron[cronhole some stuff] added crontab entry")
+        @provider.run_action(:create)
+      end
+    end
+
+    context "when there is a crontab with no matching section" do
+      before :each do
+        @provider.cron_exists = false
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        CRONTAB
+      end
+
+      it "should add the entry to the crontab" do
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+# Chef Name: cronhole some stuff
+30 * * * * /bin/true
+        ENDCRON
+        @provider.run_action(:create)
+      end
+
+      it "should include env variables that are set" do
+        @new_resource.mailto 'foo@example.com'
+        @new_resource.path '/usr/bin:/my/custom/path'
+        @new_resource.shell '/bin/foosh'
+        @new_resource.home '/home/foo'
+        @new_resource.environment "TEST" => "LOL"
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+# Chef Name: cronhole some stuff
+MAILTO=foo@example.com
+PATH=/usr/bin:/my/custom/path
+SHELL=/bin/foosh
+HOME=/home/foo
+TEST=LOL
+30 * * * * /bin/true
+        ENDCRON
+        @provider.run_action(:create)
+      end
+
+      it "should mark the resource as updated" do
+        @provider.run_action(:create)
+        @new_resource.should be_updated_by_last_action
+      end
+
+      it "should log the action" do
+        Chef::Log.should_receive(:info).with("cron[cronhole some stuff] added crontab entry")
+        @provider.run_action(:create)
+      end
+    end
+
+    context "when there is a crontab with a matching but different section" do
+      before :each do
+        @provider.cron_exists = true
+        @provider.stub!(:cron_different?).and_return(true)
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+30 * * 3 * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        CRONTAB
+      end
+
+      it "should update the crontab entry" do
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+30 * * * * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        ENDCRON
+        @provider.run_action(:create)
+      end
+
+      it "should include env variables that are set" do
+        @new_resource.mailto 'foo@example.com'
+        @new_resource.path '/usr/bin:/my/custom/path'
+        @new_resource.shell '/bin/foosh'
+        @new_resource.home '/home/foo'
+        @new_resource.environment "TEST" => "LOL"
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+MAILTO=foo@example.com
+PATH=/usr/bin:/my/custom/path
+SHELL=/bin/foosh
+HOME=/home/foo
+TEST=LOL
+30 * * * * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        ENDCRON
+        @provider.run_action(:create)
+      end
+
+      it "should mark the resource as updated" do
+        @provider.run_action(:create)
+        @new_resource.should be_updated_by_last_action
+      end
+
+      it "should log the action" do
+        Chef::Log.should_receive(:info).with("cron[cronhole some stuff] updated crontab entry")
+        @provider.run_action(:create)
+      end
+    end
+
+    context "when there is a crontab with a matching section with no crontab line in it" do
+      before :each do
+        @provider.cron_exists = true
+        @provider.stub!(:cron_different?).and_return(true)
+      end
+
+      it "should add the crontab to the entry" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+        CRONTAB
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+30 * * * * /bin/true
+        ENDCRON
+        @provider.run_action(:create)
+      end
+
+      it "should not blat any following entries" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+#30 * * * * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        CRONTAB
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+30 * * * * /bin/true
+#30 * * * * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        ENDCRON
+        @provider.run_action(:create)
+      end
+
+      it "should handle env vars with no crontab" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+MAILTO=bar@example.com
+PATH=/usr/bin:/my/custom/path
+SHELL=/bin/barsh
+HOME=/home/foo
+
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        CRONTAB
+        @new_resource.mailto 'foo@example.com'
+        @new_resource.path '/usr/bin:/my/custom/path'
+        @new_resource.shell '/bin/foosh'
+        @new_resource.home '/home/foo'
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+MAILTO=foo@example.com
+PATH=/usr/bin:/my/custom/path
+SHELL=/bin/foosh
+HOME=/home/foo
+30 * * * * /bin/true
+
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        ENDCRON
+        @provider.run_action(:create)
+      end
+    end
+
+    context "when there is a crontab with a matching and identical section" do
+      before :each do
+        @provider.cron_exists = true
+        @provider.stub!(:cron_different?).and_return(false)
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+* 5 * * * /bin/true
+
+# Another comment
+CRONTAB
+      end
+
+      it "should not update the crontab" do
+        @provider.should_not_receive(:write_crontab)
+        @provider.run_action(:create)
+      end
+
+      it "should not mark the resource as updated" do
+        @provider.run_action(:create)
+        @new_resource.should_not be_updated_by_last_action
+      end
+
+      it "should log nothing changed" do
+        Chef::Log.should_receive(:debug).with("Skipping existing cron entry '#{@new_resource.name}'")
+        @provider.run_action(:create)
+      end
+    end
+  end
+
+  describe "action_delete" do
+    before :each do
+      @provider.stub!(:write_crontab)
+      @provider.stub!(:read_crontab).and_return(nil)
+    end
+
+    context "when the user's crontab has no matching section" do
+      before :each do
+        @provider.cron_exists = false
+      end
+
+      it "should do nothing" do
+        @provider.should_not_receive(:write_crontab)
+        Chef::Log.should_not_receive(:info)
+        @provider.run_action(:delete)
+      end
+
+      it "should not mark the resource as updated" do
+        @provider.run_action(:delete)
+        @new_resource.should_not be_updated_by_last_action
+      end
+    end
+
+    context "when the user has a crontab with a matching section" do
+      before :each do
+        @provider.cron_exists = true
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+30 * * 3 * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        CRONTAB
+      end
+
+      it "should remove the entry" do
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        ENDCRON
+        @provider.run_action(:delete)
+      end
+
+      it "should remove any env vars with the entry" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+MAILTO=foo@example.com
+FOO=test
+30 * * 3 * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        CRONTAB
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        ENDCRON
+        @provider.run_action(:delete)
+      end
+
+      it "should mark the resource as updated" do
+        @provider.run_action(:delete)
+        @new_resource.should be_updated_by_last_action
+      end
+
+      it "should log the action" do
+        Chef::Log.should_receive(:info).with("#{@new_resource} deleted crontab entry")
+        @provider.run_action(:delete)
+      end
+    end
+
+    context "when the crontab has a matching section with no crontab line" do
+      before :each do
+        @provider.cron_exists = true
+      end
+
+      it "should remove the section" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+        CRONTAB
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+        ENDCRON
+        @provider.run_action(:delete)
+      end
+
+      it "should not blat following sections" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+#30 * * 3 * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        CRONTAB
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+#30 * * 3 * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        ENDCRON
+        @provider.run_action(:delete)
+      end
+
+      it "should remove any envvars with the section" do
+        @provider.stub!(:read_crontab).and_return(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: cronhole some stuff
+MAILTO=foo@example.com
+#30 * * 3 * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        CRONTAB
+        @provider.should_receive(:write_crontab).with(<<-ENDCRON)
+0 2 * * * /some/other/command
+
+#30 * * 3 * /bin/true
+# Chef Name: something else
+2 * 1 * * /bin/false
+
+# Another comment
+        ENDCRON
+        @provider.run_action(:delete)
+      end
+    end
+  end
+
+  describe "read_crontab" do
+    before :each do
+      @status = mock("Status", :exitstatus => 0)
+      @stdout = StringIO.new(<<-CRONTAB)
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+* 5 * * * /bin/true
+
+# Another comment
+      CRONTAB
+      @provider.stub!(:popen4).and_yield(1234, StringIO.new, @stdout, StringIO.new).and_return(@status)
+    end
+
+    it "should call crontab -l with the user" do
+      @provider.should_receive(:popen4).with("crontab -l -u #{@new_resource.user}").and_return(@status)
+      @provider.send(:read_crontab)
+    end
+
+    it "should return the contents of the crontab" do
+      crontab = @provider.send(:read_crontab)
+      crontab.should == <<-CRONTAB
+0 2 * * * /some/other/command
+
+# Chef Name: something else
+* 5 * * * /bin/true
+
+# Another comment
+      CRONTAB
+    end
+
+    it "should return nil if the user has no crontab" do
+      status = mock("Status", :exitstatus => 1)
+      @provider.stub!(:popen4).and_return(status)
+      @provider.send(:read_crontab).should == nil
+    end
+
+    it "should raise an exception if another error occurs" do
+      status = mock("Status", :exitstatus => 2)
+      @provider.stub!(:popen4).and_return(status)
+      lambda do
+        @provider.send(:read_crontab)
+      end.should raise_error(Chef::Exceptions::Cron, "Error determining state of #{@new_resource.name}, exit: 2")
+    end
+  end
+
+  describe "write_crontab" do
+    before :each do
+      @status = mock("Status", :exitstatus => 0)
+      @stdin = StringIO.new
+      @provider.stub!(:popen4).and_yield(1234, @stdin, StringIO.new, StringIO.new).and_return(@status)
+    end
+
+    it "should call crontab for the user" do
+      @provider.should_receive(:popen4).with("crontab -u #{@new_resource.user} -", :waitlast => true).and_return(@status)
+      @provider.send(:write_crontab, "Foo")
+    end
+
+    it "should write the given string to the crontab command" do
+      @provider.send(:write_crontab, "Foo\n# wibble\n wah!!")
+      @stdin.string.should == "Foo\n# wibble\n wah!!"
+    end
+
+    it "should raise an exception if the command returns non-zero" do
+      @status.stub!(:exitstatus).and_return(1)
+      lambda do
+        @provider.send(:write_crontab, "Foo")
+      end.should raise_error(Chef::Exceptions::Cron, "Error updating state of #{@new_resource.name}, exit: 1")
+    end
+  end
+end
diff --git a/spec/unit/provider/deploy/revision_spec.rb b/spec/unit/provider/deploy/revision_spec.rb
new file mode 100644
index 0000000000..396dd09a8e
--- /dev/null
+++ b/spec/unit/provider/deploy/revision_spec.rb
@@ -0,0 +1,109 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.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 'spec_helper'
+
+describe Chef::Provider::Deploy::Revision do
+
+  before do
+    @temp_dir = Dir.mktmpdir
+    Chef::Config[:file_cache_path] = @temp_dir
+    @resource = Chef::Resource::Deploy.new("/my/deploy/dir")
+    @resource.revision("8a3195bf3efa246f743c5dfa83683201880f935c")
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @provider = Chef::Provider::Deploy::Revision.new(@resource, @run_context)
+    @provider.load_current_resource
+    @runner = mock("runnah")
+    Chef::Runner.stub!(:new).and_return(@runner)
+    @expected_release_dir = "/my/deploy/dir/releases/8a3195bf3efa246f743c5dfa83683201880f935c"
+  end
+
+  after do
+    # Make sure we don't keep any state in our tests
+    FileUtils.rspec_reset
+    FileUtils.rm_rf @temp_dir if File.directory?( @temp_dir )
+  end
+
+
+  it "uses the resolved revision from the SCM as the release slug" do
+    @provider.scm_provider.stub!(:revision_slug).and_return("uglySlugly")
+    @provider.send(:release_slug).should == "uglySlugly"
+  end
+
+  it "deploys to a dir named after the revision" do
+    @provider.release_path.should == @expected_release_dir
+  end
+
+  it "stores the release dir in the file cache when copying the cached repo" do
+    FileUtils.stub!(:mkdir_p)
+    @provider.stub!(:run_command).and_return(true)
+    @provider.copy_cached_repo
+    @provider.converge
+    @provider.stub!(:release_slug).and_return("73219b87e977d9c7ba1aa57e9ad1d88fa91a0ec2")
+    @provider.load_current_resource
+    @provider.copy_cached_repo
+    @provider.converge
+    second_release = "/my/deploy/dir/releases/73219b87e977d9c7ba1aa57e9ad1d88fa91a0ec2"
+
+    @provider.all_releases.should == [@expected_release_dir,second_release]
+  end
+
+  it "removes a release from the file cache when it's used again in another release and append it to the end" do
+    FileUtils.stub!(:mkdir_p)
+    @provider.stub!(:run_command).and_return(true)
+    @provider.copy_cached_repo
+    @provider.converge
+    @provider.stub!(:release_slug).and_return("73219b87e977d9c7ba1aa57e9ad1d88fa91a0ec2")
+    @provider.load_current_resource
+    @provider.copy_cached_repo
+    @provider.converge
+    second_release = "/my/deploy/dir/releases/73219b87e977d9c7ba1aa57e9ad1d88fa91a0ec2"
+    @provider.all_releases.should == [@expected_release_dir,second_release]
+    @provider.copy_cached_repo
+    @provider.converge
+
+    @provider.stub!(:release_slug).and_return("8a3195bf3efa246f743c5dfa83683201880f935c")
+    @provider.load_current_resource
+    @provider.copy_cached_repo
+    @provider.converge
+    @provider.all_releases.should == [second_release, @expected_release_dir]
+  end
+
+  it "removes a release from the file cache when it's deleted by :cleanup!" do
+    %w{first second third fourth fifth latest}.each do |release_name|
+      @provider.send(:release_created, release_name)
+    end
+    @provider.all_releases.should == %w{first second third fourth fifth latest}
+
+    FileUtils.stub!(:rm_rf)
+    @provider.cleanup!
+    @provider.all_releases.should == %w{second third fourth fifth latest}
+  end
+
+  it "regenerates the file cache if it's not available" do
+    oldest = "/my/deploy/dir/releases/oldest"
+    latest = "/my/deploy/dir/releases/latest"
+    Dir.should_receive(:glob).with("/my/deploy/dir/releases/*").and_return([latest, oldest])
+    ::File.should_receive(:ctime).with(oldest).and_return(Time.now - 10)
+    ::File.should_receive(:ctime).with(latest).and_return(Time.now - 1)
+    @provider.all_releases.should == [oldest, latest]
+  end
+
+end
diff --git a/spec/unit/provider/deploy/timestamped_spec.rb b/spec/unit/provider/deploy/timestamped_spec.rb
new file mode 100644
index 0000000000..b891a03ce2
--- /dev/null
+++ b/spec/unit/provider/deploy/timestamped_spec.rb
@@ -0,0 +1,40 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.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 'spec_helper'
+
+describe Chef::Provider::Deploy::Timestamped do
+  
+  before do
+    @release_time = Time.utc( 2004, 8, 15, 16, 23, 42)
+    Time.stub!(:now).and_return(@release_time)
+    @expected_release_dir = "/my/deploy/dir/releases/20040815162342"
+    @resource = Chef::Resource::Deploy.new("/my/deploy/dir")
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @timestamped_deploy = Chef::Provider::Deploy::Timestamped.new(@resource, @run_context)
+    @runner = mock("runnah")
+    Chef::Runner.stub!(:new).and_return(@runner)
+  end
+  
+  it "gives a timestamp for release_slug" do
+    @timestamped_deploy.send(:release_slug).should == "20040815162342"
+  end
+  
+end
diff --git a/spec/unit/provider/deploy_spec.rb b/spec/unit/provider/deploy_spec.rb
new file mode 100644
index 0000000000..6bcd64fbfb
--- /dev/null
+++ b/spec/unit/provider/deploy_spec.rb
@@ -0,0 +1,654 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.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 'spec_helper'
+
+describe Chef::Provider::Deploy do
+
+  before do
+    @release_time = Time.utc( 2004, 8, 15, 16, 23, 42)
+    Time.stub!(:now).and_return(@release_time)
+    @expected_release_dir = "/my/deploy/dir/releases/20040815162342"
+    @resource = Chef::Resource::Deploy.new("/my/deploy/dir")
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @provider = Chef::Provider::Deploy.new(@resource, @run_context)
+    @provider.stub!(:release_slug)
+    @provider.stub!(:release_path).and_return(@expected_release_dir)
+  end
+
+  it "loads scm resource" do
+    @provider.scm_provider.should_receive(:load_current_resource)
+    @provider.load_current_resource
+  end
+
+  it "supports :deploy and :rollback actions" do
+    @provider.should respond_to(:action_deploy)
+    @provider.should respond_to(:action_rollback)
+  end
+
+  context "when the deploy_to dir does not exist yet" do
+    before do
+      FileUtils.should_receive(:mkdir_p).with(@resource.deploy_to).ordered
+      FileUtils.should_receive(:mkdir_p).with(@resource.shared_path).ordered
+      ::File.stub!(:directory?).and_return(false)
+      @provider.stub(:symlink)
+      @provider.stub(:migrate)
+      @provider.stub(:copy_cached_repo)
+    end
+
+    it "creates deploy_to dir" do
+      @provider.stub(:update_cached_repo)
+      @provider.deploy
+    end
+
+    it "creates deploy_to dir before calling update_cached_repo (CHEF-3435)" do
+      @provider.send(:converge_actions).should_receive(:empty?).and_return(false)
+      @provider.should_receive(:update_cached_repo).ordered
+      @provider.deploy
+    end
+  end
+
+  it "does not create deploy_to dir if it exists" do
+    ::File.stub!(:directory?).and_return(true)
+    ::Dir.should_receive(:chdir).with(@expected_release_dir).exactly(4).times
+    FileUtils.should_not_receive(:mkdir_p).with(@resource.deploy_to)
+    FileUtils.should_not_receive(:mkdir_p).with(@resource.shared_path)
+    @provider.stub(:copy_cached_repo)
+    @provider.stub(:update_cached_repo)
+    @provider.stub(:symlink)
+    @provider.stub(:migrate)
+    @provider.deploy
+    @provider.converge
+  end
+
+  it "ensures the deploy_to dir ownership after the verfication that it exists" do
+    @provider.should_receive(:verify_directories_exist).ordered
+    @provider.should_receive(:enforce_ownership).ordered
+    @provider.stub(:copy_cached_repo)
+    @provider.stub(:update_cached_repo)
+    @provider.stub(:install_gems)
+    @provider.stub(:enforce_ownership)
+    @provider.stub(:symlink)
+    @provider.stub(:migrate)
+    @provider.deploy
+  end
+
+  it "updates and copies the repo, then does a migrate, symlink, restart, restart, cleanup on deploy" do
+    FileUtils.stub(:mkdir_p).with("/my/deploy/dir")
+    FileUtils.stub(:mkdir_p).with("/my/deploy/dir/shared")
+    @provider.should_receive(:enforce_ownership).twice
+    @provider.should_receive(:update_cached_repo)
+    @provider.should_receive(:copy_cached_repo)
+    @provider.should_receive(:install_gems)
+    @provider.should_receive(:callback).with(:before_migrate, nil)
+    @provider.should_receive(:migrate)
+    @provider.should_receive(:callback).with(:before_symlink, nil)
+    @provider.should_receive(:symlink)
+    @provider.should_receive(:callback).with(:before_restart, nil)
+    @provider.should_receive(:restart)
+    @provider.should_receive(:callback).with(:after_restart, nil)
+    @provider.should_receive(:cleanup!)
+    @provider.deploy
+    @provider.converge
+  end
+
+  it "should not deploy if there is already a deploy at release_path, and it is the current release" do
+    @provider.stub!(:all_releases).and_return([@expected_release_dir])
+    @provider.stub!(:current_release?).with(@expected_release_dir).and_return(true)
+    @provider.should_not_receive(:deploy)
+    @provider.run_action(:deploy)
+  end
+
+  it "should call action_rollback if there is already a deploy of this revision at release_path, and it is not the current release" do
+    @provider.stub!(:all_releases).and_return([@expected_release_dir, "102021"])
+    @provider.stub!(:current_release?).with(@expected_release_dir).and_return(false)
+    @provider.should_receive(:rollback_to).with(@expected_release_dir)
+    @provider.should_receive(:current_release?)
+    @provider.run_action(:deploy)
+  end
+
+  it "calls deploy when deploying a new release" do
+    @provider.stub!(:all_releases).and_return([])
+    @provider.should_receive(:deploy)
+    @provider.run_action(:deploy)
+  end
+
+  it "runs action svn_force_export when new_resource.svn_force_export is true" do
+    @resource.svn_force_export true
+    @provider.scm_provider.should_receive(:run_action).with(:force_export)
+    @provider.update_cached_repo
+    @provider.converge
+  end
+
+  it "Removes the old release before deploying when force deploying over it" do
+    @provider.stub!(:all_releases).and_return([@expected_release_dir])
+    FileUtils.should_receive(:rm_rf).with(@expected_release_dir)
+    @provider.should_receive(:deploy)
+    @provider.run_action(:force_deploy)
+  end
+
+  it "deploys as normal when force deploying and there's no prior release at the same path" do
+    @provider.stub!(:all_releases).and_return([])
+    @provider.should_receive(:deploy)
+    @provider.run_action(:force_deploy)
+  end
+
+  it "dont care by default if error happens on deploy" do
+    @provider.stub!(:all_releases).and_return(['previous_release'])
+    @provider.stub!(:deploy).and_return{ raise "Unexpected error" }
+    @provider.stub!(:previous_release_path).and_return('previous_release')
+    @provider.should_not_receive(:rollback)
+    lambda { 
+      @provider.run_action(:deploy)
+    }.should raise_exception(RuntimeError, "Unexpected error")
+  end
+  
+  it "rollbacks to previous release if error happens on deploy" do
+    @resource.rollback_on_error true
+    @provider.stub!(:all_releases).and_return(['previous_release'])
+    @provider.stub!(:deploy).and_return{ raise "Unexpected error" }
+    @provider.stub!(:previous_release_path).and_return('previous_release')
+    @provider.should_receive(:rollback)
+    lambda { 
+      @provider.run_action(:deploy)
+    }.should raise_exception(RuntimeError, "Unexpected error")
+  end
+
+  describe "on systems without broken Dir.glob results" do
+    it "sets the release path to the penultimate release when one is not specified, symlinks, and rm's the last release on rollback" do
+      @provider.stub!(:release_path).and_return("/my/deploy/dir/releases/3")
+      all_releases = ["/my/deploy/dir/releases/1", "/my/deploy/dir/releases/2", "/my/deploy/dir/releases/3", "/my/deploy/dir/releases/4", "/my/deploy/dir/releases/5"]
+      Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases)
+      @provider.should_receive(:symlink)
+      FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/4")
+      FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/5")
+      @provider.run_action(:rollback)
+      @provider.release_path.should eql("/my/deploy/dir/releases/3")
+    end
+
+    it "sets the release path to the specified release, symlinks, and rm's any newer releases on rollback" do
+      @provider.unstub!(:release_path)
+      all_releases = ["/my/deploy/dir/releases/20040815162342", "/my/deploy/dir/releases/20040700000000",
+                      "/my/deploy/dir/releases/20040600000000", "/my/deploy/dir/releases/20040500000000"].sort!
+      Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases)
+      @provider.should_receive(:symlink)
+      FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342")
+      @provider.run_action(:rollback)
+      @provider.release_path.should eql("/my/deploy/dir/releases/20040700000000")
+    end
+
+    it "sets the release path to the penultimate release, symlinks, and rm's the last release on rollback" do
+      @provider.unstub!(:release_path)
+      all_releases = [ "/my/deploy/dir/releases/20040815162342",
+                       "/my/deploy/dir/releases/20040700000000",
+                       "/my/deploy/dir/releases/20040600000000",
+                       "/my/deploy/dir/releases/20040500000000"]
+      Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases)
+      @provider.should_receive(:symlink)
+      FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342")
+      @provider.run_action(:rollback)
+      @provider.release_path.should eql("/my/deploy/dir/releases/20040700000000")
+    end
+
+    describe "if there are no releases to fallback to" do
+
+      it "an exception is raised when there is only 1 release" do
+        #@provider.unstub!(:release_path) -- unstub the release path on top to feed our own release path
+        all_releases = [ "/my/deploy/dir/releases/20040815162342"]
+        Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases)
+        #@provider.should_receive(:symlink)
+        #FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342")
+        #@provider.run_action(:rollback)
+        #@provider.release_path.should eql(NIL) -- no check needed since assertions will fail
+        lambda { 
+          @provider.run_action(:rollback)
+        }.should raise_exception(RuntimeError, "There is no release to rollback to!")
+      end
+      
+      it "an exception is raised when there are no releases" do
+        all_releases = []
+        Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases)
+        lambda { 
+          @provider.run_action(:rollback)
+        }.should raise_exception(RuntimeError, "There is no release to rollback to!")
+      end
+    end
+  end
+
+  describe "CHEF-628: on systems with broken Dir.glob results" do
+    it "sets the release path to the penultimate release, symlinks, and rm's the last release on rollback" do
+      @provider.unstub!(:release_path)
+      all_releases = [ "/my/deploy/dir/releases/20040500000000",
+                       "/my/deploy/dir/releases/20040600000000",
+                       "/my/deploy/dir/releases/20040700000000",
+                       "/my/deploy/dir/releases/20040815162342" ]
+      Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases)
+      @provider.should_receive(:symlink)
+      FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342")
+      @provider.run_action(:rollback)
+      @provider.release_path.should eql("/my/deploy/dir/releases/20040700000000")
+    end
+  end
+
+  it "raises a runtime error when there's no release to rollback to" do
+    all_releases = []
+    Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases)
+    lambda {@provider.run_action(:rollback)}.should raise_error(RuntimeError)
+  end
+
+  it "runs the new resource collection in the runner during a callback" do
+    @runner = mock("Runner")
+    Chef::Runner.stub!(:new).and_return(@runner)
+    @runner.should_receive(:converge)
+    callback_code = Proc.new { :noop }
+    @provider.callback(:whatevs, callback_code)
+    @provider.converge
+  end
+
+  it "loads callback files from the release/ dir if the file exists" do
+    foo_callback = @expected_release_dir + "/deploy/foo.rb"
+    ::File.should_receive(:exist?).with(foo_callback).once.and_return(true)
+    ::Dir.should_receive(:chdir).with(@expected_release_dir).and_yield
+    @provider.should_receive(:from_file).with(foo_callback)
+    @provider.callback(:foo, "deploy/foo.rb")
+    @provider.converge
+  end
+
+  it "raises a runtime error if a callback file is explicitly specified but does not exist" do
+    baz_callback =   "/deploy/baz.rb"
+    ::File.should_receive(:exist?).with("#{@expected_release_dir}/#{baz_callback}").and_return(false)
+    @resource.before_migrate  baz_callback
+    @provider.define_resource_requirements
+    @provider.action = :deploy
+    lambda {@provider.process_resource_requirements}.should raise_error(RuntimeError)
+  end
+
+  it "runs a default callback if the callback code is nil" do
+    bar_callback = @expected_release_dir + "/deploy/bar.rb"
+    ::File.should_receive(:exist?).with(bar_callback).and_return(true)
+    ::Dir.should_receive(:chdir).with(@expected_release_dir).and_yield
+    @provider.should_receive(:from_file).with(bar_callback)
+    @provider.callback(:bar, nil)
+    @provider.converge
+  end
+
+  it "skips an eval callback if the file doesn't exist" do
+    barbaz_callback = @expected_release_dir + "/deploy/barbaz.rb"
+    ::File.should_receive(:exist?).with(barbaz_callback).and_return(false)
+    ::Dir.should_receive(:chdir).with(@expected_release_dir).and_yield
+    @provider.should_not_receive(:from_file)
+    @provider.callback(:barbaz, nil)
+    @provider.converge
+  end
+
+  # CHEF-3449 #converge_by is called in #recipe_eval and must happen in sequence
+  # with the other calls to #converge_by to keep the train on the tracks
+  it "evaluates a callback file before the corresponding step" do
+    @provider.should_receive(:verify_directories_exist)
+    @provider.should_receive(:update_cached_repo)
+    @provider.should_receive(:enforce_ownership)
+    @provider.should_receive(:copy_cached_repo)
+    @provider.should_receive(:install_gems)
+    @provider.should_receive(:enforce_ownership)
+    @provider.should_receive(:converge_by).ordered # before_migrate
+    @provider.should_receive(:migrate).ordered
+    @provider.should_receive(:converge_by).ordered # before_symlink
+    @provider.should_receive(:symlink).ordered
+    @provider.should_receive(:converge_by).ordered # before_restart
+    @provider.should_receive(:restart).ordered
+    @provider.should_receive(:converge_by).ordered # after_restart
+    @provider.should_receive(:cleanup!)
+    @provider.deploy
+  end
+
+  it "gets a SCM provider as specified by its resource" do
+    @provider.scm_provider.should be_an_instance_of(Chef::Provider::Git)
+    @provider.scm_provider.new_resource.destination.should eql("/my/deploy/dir/shared/cached-copy")
+  end
+
+  it "syncs the cached copy of the repo" do
+    @provider.scm_provider.should_receive(:run_action).with(:sync)
+    @provider.update_cached_repo
+    @provider.converge
+  end
+
+  it "makes a copy of the cached repo in releases dir" do
+    FileUtils.should_receive(:mkdir_p).with("/my/deploy/dir/releases")
+    @provider.should_receive(:run_command).with({:command => "cp -RPp /my/deploy/dir/shared/cached-copy/. #{@expected_release_dir}"})
+    @provider.copy_cached_repo
+    @provider.converge
+  end
+
+  it "calls the internal callback :release_created when copying the cached repo" do
+    FileUtils.stub!(:mkdir_p)
+    @provider.stub!(:run_command).and_return(true)
+    @provider.should_receive(:release_created)
+    @provider.copy_cached_repo
+    @provider.converge
+  end
+
+  it "chowns the whole release dir to user and group specified in the resource" do
+    @resource.user "foo"
+    @resource.group "bar"
+    FileUtils.should_receive(:chown_R).with("foo", "bar", "/my/deploy/dir")
+    @provider.enforce_ownership
+    @provider.converge
+  end
+
+  it "skips the migration when resource.migrate => false but runs symlinks before migration" do
+    @resource.migrate false
+    @provider.should_not_receive :run_command
+    @provider.should_receive :run_symlinks_before_migrate
+    @provider.migrate
+    @provider.converge
+  end
+
+  it "links the database.yml and runs resource.migration_command when resource.migrate #=> true" do
+    @resource.migrate true
+    @resource.migration_command "migration_foo"
+    @resource.user "deployNinja"
+    @resource.group "deployNinjas"
+    @resource.environment "RAILS_ENV" => "production"
+    FileUtils.should_receive(:ln_sf).with("/my/deploy/dir/shared/config/database.yml", @expected_release_dir + "/config/database.yml")
+    @provider.should_receive(:enforce_ownership)
+
+    STDOUT.stub!(:tty?).and_return(true)
+    Chef::Log.stub!(:info?).and_return(true)
+    @provider.should_receive(:run_command).with(:command => "migration_foo", :cwd => @expected_release_dir,
+                                                :user => "deployNinja", :group => "deployNinjas",
+                                                :log_level => :info, :live_stream => STDOUT,
+                                                :log_tag => "deploy[/my/deploy/dir]",
+                                                :environment => {"RAILS_ENV"=>"production"})
+    @provider.migrate
+    @provider.converge
+  end
+
+  it "purges the current release's /log /tmp/pids/ and /public/system directories" do
+    FileUtils.should_receive(:rm_rf).with(@expected_release_dir + "/log")
+    FileUtils.should_receive(:rm_rf).with(@expected_release_dir + "/tmp/pids")
+    FileUtils.should_receive(:rm_rf).with(@expected_release_dir + "/public/system")
+    @provider.purge_tempfiles_from_current_release
+    @provider.converge
+  end
+
+  it "symlinks temporary files and logs from the shared dir into the current release" do
+    FileUtils.stub(:mkdir_p).with(@resource.shared_path + "/system")
+    FileUtils.stub(:mkdir_p).with(@resource.shared_path + "/pids")
+    FileUtils.stub(:mkdir_p).with(@resource.shared_path + "/log")
+    FileUtils.should_receive(:mkdir_p).with(@expected_release_dir + "/tmp")
+    FileUtils.should_receive(:mkdir_p).with(@expected_release_dir + "/public")
+    FileUtils.should_receive(:mkdir_p).with(@expected_release_dir + "/config")
+    FileUtils.should_receive(:ln_sf).with("/my/deploy/dir/shared/system", @expected_release_dir + "/public/system")
+    FileUtils.should_receive(:ln_sf).with("/my/deploy/dir/shared/pids", @expected_release_dir + "/tmp/pids")
+    FileUtils.should_receive(:ln_sf).with("/my/deploy/dir/shared/log", @expected_release_dir + "/log")
+    FileUtils.should_receive(:ln_sf).with("/my/deploy/dir/shared/config/database.yml", @expected_release_dir + "/config/database.yml")
+    @provider.should_receive(:enforce_ownership)
+    @provider.link_tempfiles_to_current_release
+    @provider.converge
+  end
+
+  it "symlinks the current release dir into production" do
+    FileUtils.should_receive(:rm_f).with("/my/deploy/dir/current")
+    FileUtils.should_receive(:ln_sf).with(@expected_release_dir, "/my/deploy/dir/current")
+    @provider.should_receive(:enforce_ownership)
+    @provider.link_current_release_to_production
+    @provider.converge
+  end
+
+  context "with a customized app layout" do
+
+    before do
+      @resource.purge_before_symlink(%w{foo bar})
+      @resource.create_dirs_before_symlink(%w{baz qux})
+      @resource.symlinks "foo/bar" => "foo/bar", "baz" => "qux/baz"
+      @resource.symlink_before_migrate "radiohead/in_rainbows.yml" => "awesome"
+      @provider.converge
+    end
+
+    it "purges the purge_before_symlink directories" do
+      FileUtils.should_receive(:rm_rf).with(@expected_release_dir + "/foo")
+      FileUtils.should_receive(:rm_rf).with(@expected_release_dir + "/bar")
+      @provider.purge_tempfiles_from_current_release
+      @provider.converge
+    end
+
+    it "symlinks files from the shared directory to the current release directory" do
+      FileUtils.should_receive(:mkdir_p).with(@expected_release_dir + "/baz")
+      FileUtils.should_receive(:mkdir_p).with(@expected_release_dir + "/qux")
+      FileUtils.stub(:mkdir_p).with(@resource.shared_path + "/foo/bar")
+      FileUtils.stub(:mkdir_p).with(@resource.shared_path + "/baz")
+      FileUtils.should_receive(:ln_sf).with("/my/deploy/dir/shared/foo/bar", @expected_release_dir + "/foo/bar")
+      FileUtils.should_receive(:ln_sf).with("/my/deploy/dir/shared/baz", @expected_release_dir + "/qux/baz")
+      FileUtils.should_receive(:ln_sf).with("/my/deploy/dir/shared/radiohead/in_rainbows.yml", @expected_release_dir + "/awesome")
+      @provider.should_receive(:enforce_ownership)
+      @provider.link_tempfiles_to_current_release
+      @provider.converge
+    end
+    
+  end
+
+  it "does nothing for restart if restart_command is empty" do
+    @provider.should_not_receive(:run_command)
+    @provider.restart
+    @provider.converge
+  end
+
+  it "runs the restart command in the current application dir when the resource has a restart_command" do
+    @resource.restart_command "restartcmd"
+    @provider.should_receive(:run_command).with(:command => "restartcmd", :cwd => "/my/deploy/dir/current", :log_tag => "deploy[/my/deploy/dir]", :log_level => :debug)
+    @provider.restart
+    @provider.converge
+  end
+
+  it "lists all available releases" do
+    all_releases = ["/my/deploy/dir/20040815162342", "/my/deploy/dir/20040700000000",
+                    "/my/deploy/dir/20040600000000", "/my/deploy/dir/20040500000000"].sort!
+    Dir.should_receive(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases)
+    @provider.all_releases.should eql(all_releases)
+  end
+
+  it "removes all but the 5 newest releases" do
+    all_releases = ["/my/deploy/dir/20040815162342", "/my/deploy/dir/20040700000000",
+                    "/my/deploy/dir/20040600000000", "/my/deploy/dir/20040500000000",
+                    "/my/deploy/dir/20040400000000", "/my/deploy/dir/20040300000000",
+                    "/my/deploy/dir/20040200000000", "/my/deploy/dir/20040100000000"].sort!
+    @provider.stub!(:all_releases).and_return(all_releases)
+    FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/20040100000000")
+    FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/20040200000000")
+    FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/20040300000000")
+    @provider.cleanup!
+    @provider.converge
+  end
+
+  it "removes all but a certain number of releases when the resource has a keep_releases" do
+    @resource.keep_releases 7
+    all_releases = ["/my/deploy/dir/20040815162342", "/my/deploy/dir/20040700000000",
+                    "/my/deploy/dir/20040600000000", "/my/deploy/dir/20040500000000",
+                    "/my/deploy/dir/20040400000000", "/my/deploy/dir/20040300000000",
+                    "/my/deploy/dir/20040200000000", "/my/deploy/dir/20040100000000"].sort!
+    @provider.stub!(:all_releases).and_return(all_releases)
+    FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/20040100000000")
+    @provider.cleanup!
+    @provider.converge
+  end
+
+  it "fires a callback for :release_deleted when deleting an old release" do
+    all_releases = ["/my/deploy/dir/20040815162342", "/my/deploy/dir/20040700000000",
+                    "/my/deploy/dir/20040600000000", "/my/deploy/dir/20040500000000",
+                    "/my/deploy/dir/20040400000000", "/my/deploy/dir/20040300000000"].sort!
+    @provider.stub!(:all_releases).and_return(all_releases)
+    FileUtils.stub!(:rm_rf)
+    @provider.should_receive(:release_deleted).with("/my/deploy/dir/20040300000000")
+    @provider.cleanup!
+    @provider.converge
+  end
+
+  it "puts resource.to_hash in @configuration for backwards compat with capistano-esque deploy hooks" do
+    @provider.instance_variable_get(:@configuration).should == @resource.to_hash
+  end
+
+  it "sets @configuration[:environment] to the value of RAILS_ENV for backwards compat reasons" do
+    resource = Chef::Resource::Deploy.new("/my/deploy/dir")
+    resource.environment "production"
+    provider = Chef::Provider::Deploy.new(resource, @run_context)
+    provider.instance_variable_get(:@configuration)[:environment].should eql("production")
+    @provider.converge
+  end
+
+  it "shouldn't give a no method error on migrate if the environment is nil" do
+    @provider.stub!(:enforce_ownership)
+    @provider.stub!(:run_symlinks_before_migrate)
+    @provider.stub!(:run_command)
+    @provider.migrate
+    @provider.converge
+  end
+
+  context "using inline recipes for callbacks" do
+
+    it "runs an inline recipe with the provided block for :callback_name == {:recipe => &block} " do
+      snitch = nil
+      recipe_code = Proc.new {snitch = 42}
+      #@provider.should_receive(:instance_eval).with(&recipe_code)
+      @provider.callback(:whateverz, recipe_code)
+      @provider.converge
+      snitch.should == 42
+    end
+
+    it "loads a recipe file from the specified path and from_file evals it" do
+      ::File.should_receive(:exist?).with(@expected_release_dir + "/chefz/foobar_callback.rb").once.and_return(true)
+      ::Dir.should_receive(:chdir).with(@expected_release_dir).and_yield
+      @provider.should_receive(:from_file).with(@expected_release_dir + "/chefz/foobar_callback.rb")
+      @provider.callback(:whateverz, "chefz/foobar_callback.rb")
+      @provider.converge
+    end
+
+    it "instance_evals a block/proc for restart command" do
+      snitch = nil
+      restart_cmd = Proc.new {snitch = 42}
+      @resource.restart(&restart_cmd)
+      @provider.restart
+      @provider.converge
+      snitch.should == 42
+    end
+
+  end
+
+  describe "API bridge to capistrano" do
+    it "defines sudo as a forwarder to execute" do
+      @provider.should_receive(:execute).with("the moon, fool")
+      @provider.sudo("the moon, fool")
+      @provider.converge
+    end
+
+    it "defines run as a forwarder to execute, setting the user, group, cwd and environment to new_resource.user" do
+      mock_execution = mock("Resource::Execute")
+      @provider.should_receive(:execute).with("iGoToHell4this").and_return(mock_execution)
+      @resource.user("notCoolMan")
+      @resource.group("Ggroup")
+      @resource.environment("APP_ENV" => 'staging')
+      @resource.deploy_to("/my/app")
+      mock_execution.should_receive(:user).with("notCoolMan")
+      mock_execution.should_receive(:group).with("Ggroup")
+      mock_execution.should_receive(:cwd){|*args|
+        if args.empty?
+          nil
+        else
+          args.size.should == 1
+          args.first.should == @provider.release_path
+        end
+      }.twice
+      mock_execution.should_receive(:environment){ |*args|
+        if args.empty?
+          nil
+        else
+          args.size.should == 1
+          args.first.should == {"APP_ENV" => "staging"}
+        end
+      }.twice
+      @provider.run("iGoToHell4this")
+      @provider.converge
+    end
+
+    it "defines run as a forwarder to execute, setting cwd and environment but not override" do
+      mock_execution = mock("Resource::Execute")
+      @provider.should_receive(:execute).with("iGoToHell4this").and_return(mock_execution)
+      @resource.user("notCoolMan")
+      mock_execution.should_receive(:user).with("notCoolMan")
+      mock_execution.should_receive(:cwd).with(no_args()).and_return("/some/value")
+      mock_execution.should_receive(:environment).with(no_args()).and_return({})
+      @provider.run("iGoToHell4this")
+      @provider.converge
+    end
+
+
+    it "converts sudo and run to exec resources in hooks" do
+      runner = mock("tehRunner")
+      Chef::Runner.stub!(:new).and_return(runner)
+
+      snitch = nil
+      @resource.user("tehCat")
+
+      callback_code = Proc.new do
+        snitch = 42
+        temp_collection = self.resource_collection
+        run("tehMice")
+        snitch = temp_collection.lookup("execute[tehMice]")
+      end
+
+      runner.should_receive(:converge)
+      #
+      @provider.callback(:phony, callback_code)
+      @provider.converge
+      snitch.should be_an_instance_of(Chef::Resource::Execute)
+      snitch.user.should == "tehCat"
+    end
+  end
+
+  describe "installing gems from a gems.yml" do
+
+    before do
+      ::File.stub!(:exist?).with("#{@expected_release_dir}/gems.yml").and_return(true)
+      @gem_list = [{:name=>"eventmachine", :version=>"0.12.9"}]
+    end
+
+    it "reads a gems.yml file, creating gem providers for each with action :upgrade" do
+      IO.should_receive(:read).with("#{@expected_release_dir}/gems.yml").and_return("cookie")
+      YAML.should_receive(:load).with("cookie").and_return(@gem_list)
+
+      gems = @provider.send(:gem_packages)
+
+      gems.map { |g| g.action }.should == [[:install]]
+      gems.map { |g| g.name }.should == %w{eventmachine}
+      gems.map { |g| g.version }.should == %w{0.12.9}
+    end
+
+    it "takes a list of gem providers converges them" do
+      IO.stub!(:read)
+      YAML.stub!(:load).and_return(@gem_list)
+      expected_gem_resources = @provider.send(:gem_packages).map { |r| [r.name, r.version] }
+      gem_runner = @provider.send(:gem_resource_collection_runner)
+      # no one has heard of defining == to be meaningful so I have use this monstrosity
+      actual = gem_runner.run_context.resource_collection.all_resources.map { |r| [r.name, r.version] }
+      actual.should == expected_gem_resources
+    end
+
+  end
+
+end
diff --git a/spec/unit/provider/directory_spec.rb b/spec/unit/provider/directory_spec.rb
new file mode 100644
index 0000000000..4f297e0115
--- /dev/null
+++ b/spec/unit/provider/directory_spec.rb
@@ -0,0 +1,147 @@
+#
+# 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 'ostruct'
+
+require 'spec_helper'
+
+describe Chef::Provider::Directory do
+  before(:each) do
+    @new_resource = Chef::Resource::Directory.new('/tmp')
+    @new_resource.owner(500)
+    @new_resource.group(500)
+    @new_resource.mode(0644)
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @directory = Chef::Provider::Directory.new(@new_resource, @run_context)
+  end
+
+  it "should load the current resource based on the new resource" do
+    File.stub!(:exist?).and_return(true)
+    cstats = mock("stats")
+    cstats.stub!(:uid).and_return(500)
+    cstats.stub!(:gid).and_return(500)
+    cstats.stub!(:mode).and_return(0755)
+    File.should_receive(:stat).twice.and_return(cstats)
+    @directory.load_current_resource
+    @directory.current_resource.path.should eql(@new_resource.path)
+    @directory.current_resource.owner.should eql(500)
+    @directory.current_resource.group.should eql(500)
+    @directory.current_resource.mode.should == 00755
+  end
+
+  it "should create a new directory on create, setting updated to true" do
+    @new_resource.path "/tmp/foo"
+
+    File.should_receive(:exist?).exactly(3).and_return(false)
+    Dir.should_receive(:mkdir).with(@new_resource.path).once.and_return(true)
+
+    @directory.should_receive(:set_all_access_controls)
+    @directory.stub!(:update_new_file_state)
+    @directory.run_action(:create)
+    @directory.new_resource.should be_updated
+  end
+
+  it "should raise an exception if the parent directory does not exist and recursive is false" do 
+    @new_resource.path "/tmp/some/dir"
+    @new_resource.recursive false
+    lambda { @directory.run_action(:create) }.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist) 
+  end
+
+  it "should create a new directory when parent directory does not exist if recursive is true and permissions are correct" do
+    @new_resource.path "/path/to/dir"
+    @new_resource.recursive true
+    File.should_receive(:exist?).with(@new_resource.path).ordered.and_return(false)
+    File.should_receive(:exist?).with(@new_resource.path).ordered.and_return(false)
+
+    File.should_receive(:exist?).with('/path/to').ordered.and_return(false)
+    File.should_receive(:exist?).with('/path').ordered.and_return(true)
+    File.should_receive(:writable?).with('/path').ordered.and_return(true)
+    File.should_receive(:exist?).with(@new_resource.path).ordered.and_return(false)
+ 
+    FileUtils.should_receive(:mkdir_p).with(@new_resource.path).and_return(true) 
+    @directory.should_receive(:set_all_access_controls)
+    @directory.stub!(:update_new_file_state)
+    @directory.run_action(:create)
+    @new_resource.should be_updated
+  end
+ 
+  # it "should raise an error when creating a directory recursively and permissions do not allow creation" do
+    
+  # end
+
+  it "should raise an error when creating a directory when parent directory is a file" do
+    File.should_receive(:directory?).and_return(false)
+    Dir.should_not_receive(:mkdir).with(@new_resource.path)
+    lambda { @directory.run_action(:create) }.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+    @directory.new_resource.should_not be_updated
+  end
+  
+  it "should not create the directory if it already exists" do
+    stub_file_cstats
+    @new_resource.path "/tmp/foo"
+    File.should_receive(:exist?).exactly(3).and_return(true)
+    Dir.should_not_receive(:mkdir).with(@new_resource.path)
+    @directory.should_receive(:set_all_access_controls)
+    @directory.run_action(:create)
+  end
+
+  it "should delete the directory if it exists, and is writable with action_delete" do
+    File.should_receive(:directory?).and_return(true)
+    File.should_receive(:writable?).once.and_return(true)
+    Dir.should_receive(:delete).with(@new_resource.path).once.and_return(true)
+    @directory.run_action(:delete)
+  end
+
+  it "should raise an exception if it cannot delete the directory due to bad permissions" do
+    File.stub!(:exist?).and_return(true)
+    File.stub!(:writable?).and_return(false)
+    lambda {  @directory.run_action(:delete) }.should raise_error(RuntimeError)
+  end
+
+  it "should take no action when deleting a target directory that does not exist" do
+    @new_resource.path "/an/invalid/path"
+    File.stub!(:exist?).and_return(false)
+    Dir.should_not_receive(:delete).with(@new_resource.path)
+    @directory.run_action(:delete)
+    @directory.new_resource.should_not be_updated
+  end
+
+  it "should raise an exception when deleting a directory when target directory is a file" do
+    stub_file_cstats
+    @new_resource.path "/an/invalid/path"
+    File.stub!(:exist?).and_return(true)
+    File.should_receive(:directory?).and_return(false)
+    Dir.should_not_receive(:delete).with(@new_resource.path)
+    lambda { @directory.run_action(:delete) }.should raise_error(RuntimeError)
+    @directory.new_resource.should_not be_updated
+  end
+
+  def stub_file_cstats
+    cstats = mock("stats")
+    cstats.stub!(:uid).and_return(500)
+    cstats.stub!(:gid).and_return(500)
+    cstats.stub!(:mode).and_return(0755)
+    # File.stat is called in:
+    # - Chef::Provider::File.load_current_resource_attrs
+    # - Chef::ScanAccessControl via Chef::Provider::File.setup_acl
+    File.stub!(:stat).and_return(cstats)
+  end
+end
diff --git a/spec/unit/provider/env_spec.rb b/spec/unit/provider/env_spec.rb
new file mode 100644
index 0000000000..77aea42b43
--- /dev/null
+++ b/spec/unit/provider/env_spec.rb
@@ -0,0 +1,232 @@
+#
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Copyright:: Copyright (c) 2010 VMware, 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 Chef::Provider::Env do
+
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Env.new("FOO")
+    @new_resource.value("bar")
+    @provider = Chef::Provider::Env.new(@new_resource, @run_context)
+  end
+
+  it "assumes the key_name exists by default" do
+    @provider.key_exists.should be_true
+  end
+
+  describe "when loading the current status" do
+    before do
+      #@current_resource = @new_resource.clone
+      #Chef::Resource::Env.stub!(:new).and_return(@current_resource)
+      @provider.current_resource = @current_resource
+      @provider.stub!(:env_value).with("FOO").and_return("bar")
+      @provider.stub!(:env_key_exists).and_return(true)
+    end
+
+    it "should create a current resource with the same name as the new resource" do
+      @provider.load_current_resource
+      @provider.new_resource.name.should == "FOO"
+    end
+
+    it "should set the key_name to the key name of the new resource" do
+      @provider.load_current_resource
+      @provider.current_resource.key_name.should == "FOO"
+    end
+
+    it "should check if the key_name exists" do
+      @provider.should_receive(:env_key_exists).with("FOO").and_return(true)
+      @provider.load_current_resource
+      @provider.key_exists.should be_true
+    end
+
+    it "should flip the value of exists if the key does not exist" do
+      @provider.should_receive(:env_key_exists).with("FOO").and_return(false)
+      @provider.load_current_resource
+      @provider.key_exists.should be_false
+    end
+
+    it "should return the current resource" do
+      @provider.load_current_resource.should be_a_kind_of(Chef::Resource::Env)
+    end
+  end
+
+  describe "action_create" do
+    before do
+      @provider.key_exists = false
+      @provider.stub!(:create_env).and_return(true)
+      @provider.stub!(:modify_env).and_return(true)
+    end
+
+    it "should call create_env if the key does not exist" do
+      @provider.should_receive(:create_env).and_return(true)
+      @provider.action_create
+    end
+
+    it "should set the the new_resources updated flag when it creates the key" do
+      @provider.action_create
+      @new_resource.should be_updated
+    end
+
+    it "should check to see if the values are the same if the key exists" do
+      @provider.key_exists = true
+      @provider.should_receive(:compare_value).and_return(false)
+      @provider.action_create
+    end
+
+    it "should call modify_env if the key exists and values are not equal" do
+      @provider.key_exists = true
+      @provider.stub!(:compare_value).and_return(true)
+      @provider.should_receive(:modify_env).and_return(true)
+      @provider.action_create
+    end
+
+    it "should set the the new_resources updated flag when it updates an existing value" do
+      @provider.key_exists = true
+      @provider.stub!(:compare_value).and_return(true)
+      @provider.stub!(:modify_env).and_return(true)
+      @provider.action_create
+      @new_resource.should be_updated
+    end
+  end
+
+  describe "action_delete" do
+    before(:each) do
+      @provider.current_resource = @current_resource
+      @provider.key_exists = false
+      @provider.stub!(:delete_element).and_return(false)
+      @provider.stub!(:delete_env).and_return(true)
+    end
+
+    it "should not call delete_env if the key does not exist" do
+      @provider.should_not_receive(:delete_env)
+      @provider.action_delete
+    end
+
+    it "should not call delete_element if the key does not exist" do
+      @provider.should_not_receive(:delete_element)
+      @provider.action_delete
+    end
+
+    it "should call delete_env if the key exists" do
+      @provider.key_exists = true
+      @provider.should_receive(:delete_env)
+      @provider.action_delete
+    end
+
+    it "should set the new_resources updated flag to true if the key is deleted" do
+      @provider.key_exists = true
+      @provider.action_delete
+      @new_resource.should be_updated
+    end
+  end
+
+  describe "action_modify" do
+    before(:each) do
+      @provider.current_resource = @current_resource
+      @provider.key_exists = true
+      @provider.stub!(:modify_env).and_return(true)
+    end
+
+    it "should call modify_group if the key exists and values are not equal" do
+      @provider.should_receive(:compare_value).and_return(true)
+      @provider.should_receive(:modify_env).and_return(true)
+      @provider.action_modify
+    end
+
+    it "should set the new resources updated flag to true if modify_env is called" do
+      @provider.stub!(:compare_value).and_return(true)
+      @provider.stub!(:modify_env).and_return(true)
+      @provider.action_modify
+      @new_resource.should be_updated
+    end
+
+    it "should not call modify_env if the key exists but the values are equal" do
+      @provider.should_receive(:compare_value).and_return(false)
+      @provider.should_not_receive(:modify_env)
+      @provider.action_modify
+    end
+
+    it "should raise a Chef::Exceptions::Env if the key doesn't exist" do
+      @provider.key_exists = false
+      lambda { @provider.action_modify }.should raise_error(Chef::Exceptions::Env)
+    end
+  end
+
+  describe "delete_element" do
+    before(:each) do
+      @current_resource = Chef::Resource::Env.new("FOO")
+
+      @new_resource.delim ";"
+      @new_resource.value "C:/bar/bin"
+
+      @current_resource.value "C:/foo/bin;C:/bar/bin"
+      @provider.current_resource = @current_resource
+    end
+
+    it "should return true if the element is not found" do
+      @new_resource.stub!(:value).and_return("C:/baz/bin")
+      @provider.delete_element.should eql(true)
+    end
+
+    it "should return false if the delim not defined" do
+      @new_resource.stub!(:delim).and_return(nil)
+      @provider.delete_element.should eql(false)
+    end
+
+    it "should return true if the element is deleted" do
+      @new_resource.value("C:/foo/bin")
+      @provider.should_receive(:create_env)
+      @provider.delete_element.should eql(true)
+      @new_resource.should be_updated
+    end
+  end
+
+  describe "compare_value" do
+    before(:each) do
+      @new_resource.value("C:/bar")
+      @current_resource = @new_resource.clone
+      @provider.current_resource = @current_resource
+    end
+
+    it "should return false if the values are equal" do
+      @provider.compare_value.should be_false
+    end
+
+    it "should return true if the values not are equal" do
+      @new_resource.value("C:/elsewhere")
+      @provider.compare_value.should be_true
+    end
+
+    it "should return false if the current value contains the element" do
+      @new_resource.delim(";")
+      @current_resource.value("C:/bar;C:/foo;C:/baz")
+
+      @provider.compare_value.should be_false
+    end
+
+    it "should return true if the current value does not contain the element" do
+      @new_resource.delim(";")
+      @current_resource.value("C:/biz;C:/foo/bin;C:/baz")
+      @provider.compare_value.should be_true
+    end
+  end
+end
diff --git a/spec/unit/provider/erl_call_spec.rb b/spec/unit/provider/erl_call_spec.rb
new file mode 100644
index 0000000000..df7910424b
--- /dev/null
+++ b/spec/unit/provider/erl_call_spec.rb
@@ -0,0 +1,88 @@
+#
+# Author:: Joe Williams (<joe@joetify.com>)
+# Copyright:: Copyright (c) 2009 Joe Williams
+# 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 Chef::Provider::ErlCall do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::ErlCall.new("test", @node)
+    @new_resource.code("io:format(\"burritos\", []).")
+    @new_resource.node_name("chef@localhost")
+    @new_resource.name("test")
+
+    @provider = Chef::Provider::ErlCall.new(@new_resource, @run_context)
+
+    @provider.stub!(:popen4).and_return(@status)
+    @stdin = StringIO.new
+    @stdout = StringIO.new('{ok, woohoo}')
+    @stderr = StringIO.new
+    @pid = 2342999
+  end
+
+  it "should return a Chef::Provider::ErlCall object" do
+    provider = Chef::Provider::ErlCall.new(@new_resource, @run_context)
+    provider.should be_a_kind_of(Chef::Provider::ErlCall)
+  end
+
+  it "should return true" do
+    @provider.load_current_resource.should eql(true)
+  end
+
+  describe "when running a distributed erl call resource" do
+    before do
+      @new_resource.cookie("nomnomnom")
+      @new_resource.distributed(true)
+      @new_resource.name_type("sname")
+    end
+
+    it "should write to stdin of the erl_call command" do
+      expected_cmd = "erl_call -e -s -sname chef@localhost -c nomnomnom"
+      @provider.should_receive(:popen4).with(expected_cmd, :waitlast => true).and_return([@pid, @stdin, @stdout, @stderr])
+      Process.should_receive(:wait).with(@pid)
+
+      @provider.action_run
+      @provider.converge
+
+      @stdin.string.should == "#{@new_resource.code}\n"
+    end
+  end
+
+  describe "when running a local erl call resource" do
+    before do
+      @new_resource.cookie(nil)
+      @new_resource.distributed(false)
+      @new_resource.name_type("name")
+    end
+
+    it "should write to stdin of the erl_call command" do
+      @provider.should_receive(:popen4).with("erl_call -e  -name chef@localhost ", :waitlast => true).and_return([@pid, @stdin, @stdout, @stderr])
+      Process.should_receive(:wait).with(@pid)
+
+      @provider.action_run
+      @provider.converge
+
+      @stdin.string.should == "#{@new_resource.code}\n"
+    end
+  end
+
+end
+
diff --git a/spec/unit/provider/execute_spec.rb b/spec/unit/provider/execute_spec.rb
new file mode 100644
index 0000000000..a944793a89
--- /dev/null
+++ b/spec/unit/provider/execute_spec.rb
@@ -0,0 +1,63 @@
+#
+# Author:: Prajakta Purohit (<prajakta@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 File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
+#require 'spec_helper'
+
+describe Chef::Provider::Execute do
+  before do
+    @node = Chef::Node.new
+    @cookbook_collection = Chef::CookbookCollection.new([])
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+    @new_resource = Chef::Resource::Execute.new("foo_resource", @run_context)
+    @new_resource.timeout 3600
+    @new_resource.returns 0
+    @new_resource.creates "foo_resource"
+    @provider = Chef::Provider::Execute.new(@new_resource, @run_context)
+    @current_resource = Chef::Resource::Ifconfig.new("foo_resource", @run_context)
+    @provider.current_resource = @current_resource
+    Chef::Log.level = :info 
+    # FIXME: There should be a test for how STDOUT.tty? changes the live_stream option being passed
+    STDOUT.stub!(:tty?).and_return(true)
+  end
+
+
+  it "should execute foo_resource" do
+    @provider.stub!(:load_current_resource)
+    opts = {}
+    opts[:timeout] = @new_resource.timeout
+    opts[:returns] = @new_resource.returns
+    opts[:log_level] = :info
+    opts[:log_tag] = @new_resource.to_s
+    opts[:live_stream] = STDOUT
+    @provider.should_receive(:shell_out!).with(@new_resource.command, opts)
+
+    @provider.run_action(:run)
+    @new_resource.should be_updated
+  end
+
+  it "should do nothing if the sentinel file exists" do
+    @provider.stub!(:load_current_resource)
+    File.should_receive(:exists?).with(@new_resource.creates).and_return(true)
+    @provider.should_not_receive(:shell_out!)
+
+    @provider.run_action(:run)
+    @new_resource.should_not be_updated
+  end
+end
+
diff --git a/spec/unit/provider/file_spec.rb b/spec/unit/provider/file_spec.rb
new file mode 100644
index 0000000000..13b79e4bd6
--- /dev/null
+++ b/spec/unit/provider/file_spec.rb
@@ -0,0 +1,498 @@
+#
+# 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 'spec_helper'
+require 'tmpdir'
+
+describe Chef::Provider::File do
+  before(:each) do
+    @node = Chef::Node.new
+    @node.name "latte"
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @resource = Chef::Resource::File.new("seattle")
+    @resource.path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates", "seattle.txt")))
+
+    @provider = Chef::Provider::File.new(@resource, @run_context)
+  end
+
+  it "should return a Chef::Provider::File" do
+    @provider.should be_a_kind_of(Chef::Provider::File)
+  end
+
+  it "should store the resource passed to new as new_resource" do
+    @provider.new_resource.should eql(@resource)
+  end
+
+  it "should store the node passed to new as node" do
+    @provider.node.should eql(@node)
+  end
+
+  it "should load a current resource based on the one specified at construction" do
+    @provider.load_current_resource
+    @provider.current_resource.should be_a_kind_of(Chef::Resource::File)
+    @provider.current_resource.name.should eql(@resource.name)
+    @provider.current_resource.path.should eql(@resource.path)
+    @provider.current_resource.content.should eql(nil)
+  end
+
+  it "should collect the current state of the file on the filesystem and populate current_resource" do
+    # test setup
+    stat_struct = mock("::File.stat", :mode => 0600, :uid => 0, :gid => 0, :mtime => 10000) 
+    ::File.should_receive(:stat).exactly(3).with(@resource.path).and_return(stat_struct)
+    
+    # test execution 
+    @provider.load_current_resource
+
+    # post-condition checks
+    @provider.current_resource.mode.should == 0600
+    @provider.current_resource.owner.should == 0
+    @provider.current_resource.group.should == 0
+  end
+
+  it "should NOT update the new_resource state with the current_resourse state if new_resource state is already specified" do
+    # test setup
+    stat_struct = mock("::File.stat", :mode => 0600, :uid => 0, :gid => 0, :mtime => 10000) 
+    ::File.should_receive(:stat).exactly(3).with(@resource.path).and_return(stat_struct)
+
+    @provider.new_resource.group(1)
+    @provider.new_resource.owner(1)
+    @provider.new_resource.mode(0644)
+
+    # test execution 
+    @provider.load_current_resource
+
+    # post-condition checks
+    @provider.new_resource.group.should == 1
+    @provider.new_resource.owner.should == 1
+    @provider.new_resource.mode.should == 0644
+  end
+
+  it "should update the new_resource state with the current_resource state if the new_resource state is not specified." do
+    # test setup
+    stat_struct = mock("::File.stat", :mode => 0600, :uid => 0, :gid => 0, :mtime => 10000) 
+    ::File.should_receive(:stat).exactly(3).with(@resource.path).and_return(stat_struct)
+
+    @provider.new_resource.group(nil)
+    @provider.new_resource.owner(nil)
+    @provider.new_resource.mode(nil)
+
+    # test execution 
+    @provider.load_current_resource
+
+    # post-condition checks
+    @provider.new_resource.group.should eql(@provider.current_resource.group)
+    @provider.new_resource.owner.should eql(@provider.current_resource.owner)
+    @provider.new_resource.mode.should eql(@provider.current_resource.mode)
+  end
+
+  it "should update the new_resource when attempting to set the new state" do
+    # test setup
+    stat_struct = mock("::File.stat", :mode => 0600, :uid => 0, :gid => 0, :mtime => 10000) 
+    # called once in update_new_file_state and once in checksum
+    ::File.should_receive(:stat).twice.with(@provider.new_resource.path).and_return(stat_struct)  
+    ::File.should_receive(:directory?).once.with(@provider.new_resource.path).and_return(false)
+
+    @provider.new_resource.group(nil)
+    @provider.new_resource.owner(nil)
+    @provider.new_resource.mode(nil)
+    
+    # test exectution 
+    @provider.update_new_file_state
+
+    # post-condition checks
+    @provider.new_resource.group.should == 0
+    @provider.new_resource.owner.should == 0
+    @provider.new_resource.mode.should == 0600
+end
+
+  it "should load a mostly blank current resource if the file specified in new_resource doesn't exist/isn't readable" do
+    resource = Chef::Resource::File.new("seattle")
+    resource.path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates", "woot.txt")))
+    node = Chef::Node.new
+    node.name "latte"
+    provider = Chef::Provider::File.new(resource, @run_context)
+    provider.load_current_resource
+    provider.current_resource.should be_a_kind_of(Chef::Resource::File)
+    provider.current_resource.name.should eql(resource.name)
+    provider.current_resource.path.should eql(resource.path)
+  end
+
+  it "should not backup symbolic links on delete" do
+    path = File.expand_path(File.join(CHEF_SPEC_DATA, "detroit.txt"))
+    ::File.open(path, "w") do |file|
+      file.write("Detroit's not so nice, so you should come to Seattle instead and buy me a beer instead.")
+    end
+    @resource = Chef::Resource::File.new("detroit")
+    @resource.path(path)
+    @node = Chef::Node.new
+    @node.name "latte"
+    @provider = Chef::Provider::File.new(@resource, @run_context)
+
+    ::File.stub!(:symlink?).and_return(true)
+    @provider.should_not_receive(:backup)
+    @provider.run_action(:delete)
+    @resource.should be_updated_by_last_action
+  end
+
+  it "should compare the current content with the requested content" do
+    @provider.load_current_resource
+
+    @provider.new_resource.content "foobar"
+    @provider.compare_content.should eql(false)
+
+    @provider.new_resource.content IO.read(@resource.path)
+    @provider.compare_content.should eql(true)
+  end
+
+  it "should set the content of the file to the requested content" do
+    io = StringIO.new
+    @provider.load_current_resource
+    @provider.new_resource.content "foobar"
+    @provider.should_receive(:diff_current_from_content).and_return("")
+    @provider.should_receive(:backup)
+    File.should_receive(:open).with(@provider.new_resource.path, "w").and_yield(io)
+    @provider.set_content
+    lambda { @provider.send(:converge_actions).converge! }.should_not raise_error
+    io.string.should == "foobar"
+  end
+
+  it "should not set the content of the file if it already matches the requested content" do
+    @provider.load_current_resource
+    @provider.new_resource.content IO.read(@resource.path)
+    File.stub!(:open).and_return(1)
+    File.should_not_receive(:open).with(@provider.new_resource.path, "w")
+    lambda { @provider.set_content }.should_not raise_error
+    @resource.should_not be_updated_by_last_action
+  end
+
+  it "should create the file if it is missing, then set the attributes on action_create" do
+    @provider.load_current_resource
+    @provider.stub!(:update_new_file_state)
+    @provider.new_resource.stub!(:path).and_return(File.join(Dir.tmpdir, "monkeyfoo"))
+    @provider.access_controls.should_receive(:set_all)
+    @provider.should_receive(:diff_current_from_content).and_return("")
+    File.stub!(:open).and_return(1)
+    #File.should_receive(:directory?).with("/tmp").and_return(true)
+    File.should_receive(:open).with(@provider.new_resource.path, "w+")
+    @provider.run_action(:create)
+    @resource.should be_updated_by_last_action
+  end
+
+  it "should create the file with the proper content if it is missing, then set attributes on action_create" do
+    io = StringIO.new
+    @provider.load_current_resource
+    @provider.new_resource.content "foobar"
+    @provider.new_resource.stub!(:path).and_return(File.join(Dir.tmpdir, "monkeyfoo"))
+    @provider.should_receive(:diff_current_from_content).and_return("")
+    @provider.stub!(:update_new_file_state)
+    File.should_receive(:open).with(@provider.new_resource.path, "w+").and_yield(io)
+    @provider.access_controls.should_receive(:set_all)
+    @provider.run_action(:create)
+    io.string.should == "foobar"
+    @resource.should be_updated_by_last_action
+  end
+
+  it "should delete the file if it exists and is writable on action_delete" do
+    @provider.new_resource.stub!(:path).and_return(File.join(Dir.tmpdir, "monkeyfoo"))
+    @provider.stub!(:backup).and_return(true)
+    File.should_receive("exists?").exactly(2).times.with(@provider.new_resource.path).and_return(true)
+    File.should_receive("writable?").with(@provider.new_resource.path).and_return(true)
+    File.should_receive(:delete).with(@provider.new_resource.path).and_return(true)
+    @provider.run_action(:delete)
+    @resource.should be_updated_by_last_action
+  end
+
+  it "should not raise an error if it cannot delete the file because it does not exist" do
+    @provider.new_resource.stub!(:path).and_return(File.join(Dir.tmpdir, "monkeyfoo"))
+    @provider.stub!(:backup).and_return(true)
+    File.should_receive("exists?").exactly(2).times.with(@provider.new_resource.path).and_return(false)
+    lambda { @provider.run_action(:delete) }.should_not raise_error()
+    @resource.should_not be_updated_by_last_action
+  end
+
+  it "should update the atime/mtime on action_touch" do
+    @provider.load_current_resource
+    @provider.new_resource.stub!(:path).and_return(File.join(Dir.tmpdir, "monkeyfoo"))
+    @provider.should_receive(:diff_current_from_content).and_return("")
+    @provider.stub!(:update_new_file_state)
+    File.should_receive(:utime).once.and_return(1)
+    File.stub!(:open).and_return(1)
+    @provider.access_controls.should_receive(:set_all).once
+    @provider.run_action(:touch)
+    @resource.should be_updated_by_last_action
+  end
+
+  it "should keep 1 backup copy if specified" do
+    @provider.load_current_resource
+    @provider.new_resource.stub!(:path).and_return("/tmp/s-20080705111233")
+    @provider.new_resource.stub!(:backup).and_return(1)
+    Dir.stub!(:[]).and_return([ "/tmp/s-20080705111233", "/tmp/s-20080705111232", "/tmp/s-20080705111223"])
+    FileUtils.should_receive(:rm).with("/tmp/s-20080705111223").once.and_return(true)
+    FileUtils.should_receive(:rm).with("/tmp/s-20080705111232").once.and_return(true)
+    FileUtils.stub!(:cp).and_return(true)
+    FileUtils.stub!(:mkdir_p).and_return(true)
+    File.stub!(:exist?).and_return(true)
+    @provider.backup
+  end
+
+  it "should backup a file no more than :backup times" do
+    @provider.load_current_resource
+    @provider.new_resource.stub!(:path).and_return("/tmp/s-20080705111233")
+    @provider.new_resource.stub!(:backup).and_return(2)
+    Dir.stub!(:[]).and_return([ "/tmp/s-20080705111233", "/tmp/s-20080705111232", "/tmp/s-20080705111223"])
+    FileUtils.should_receive(:rm).with("/tmp/s-20080705111223").once.and_return(true)
+    FileUtils.stub!(:cp).and_return(true)
+    FileUtils.stub!(:mkdir_p).and_return(true)
+    File.stub!(:exist?).and_return(true)
+    @provider.backup
+  end
+
+  it "should not attempt to backup a file if :backup == 0" do
+    @provider.load_current_resource
+    @provider.new_resource.stub!(:path).and_return("/tmp/s-20080705111233")
+    @provider.new_resource.stub!(:backup).and_return(0)
+    FileUtils.stub!(:cp).and_return(true)
+    File.stub!(:exist?).and_return(true)
+    FileUtils.should_not_receive(:cp)
+    @provider.backup
+  end
+
+  it "should put the backup backup file in the directory specified by Chef::Config[:file_backup_path]" do
+    @provider.load_current_resource
+    @provider.new_resource.stub!(:path).and_return("/tmp/s-20080705111233")
+    @provider.new_resource.stub!(:backup).and_return(1)
+    Chef::Config.stub!(:[]).with(:file_backup_path).and_return("/some_prefix")
+    Dir.stub!(:[]).and_return([ "/some_prefix/tmp/s-20080705111233", "/some_prefix/tmp/s-20080705111232", "/some_prefix/tmp/s-20080705111223"])
+    FileUtils.should_receive(:mkdir_p).with("/some_prefix/tmp").once
+    FileUtils.should_receive(:rm).with("/some_prefix/tmp/s-20080705111232").once.and_return(true)
+    FileUtils.should_receive(:rm).with("/some_prefix/tmp/s-20080705111223").once.and_return(true)
+    FileUtils.stub!(:cp).and_return(true)
+    File.stub!(:exist?).and_return(true)
+    @provider.backup
+  end
+
+  it "should strip the drive letter from the backup resource path (for Windows platforms)" do
+    @provider.load_current_resource
+    @provider.new_resource.stub!(:path).and_return("C:/tmp/s-20080705111233")
+    @provider.new_resource.stub!(:backup).and_return(1)
+    Chef::Config.stub!(:[]).with(:file_backup_path).and_return("C:/some_prefix")
+    Dir.stub!(:[]).and_return([ "C:/some_prefix/tmp/s-20080705111233", "C:/some_prefix/tmp/s-20080705111232", "C:/some_prefix/tmp/s-20080705111223"])
+    FileUtils.should_receive(:mkdir_p).with("C:/some_prefix/tmp").once
+    FileUtils.should_receive(:rm).with("C:/some_prefix/tmp/s-20080705111232").once.and_return(true)
+    FileUtils.should_receive(:rm).with("C:/some_prefix/tmp/s-20080705111223").once.and_return(true)
+    FileUtils.stub!(:cp).and_return(true)
+    File.stub!(:exist?).and_return(true)
+    @provider.backup
+  end
+
+  it "should keep the same ownership on backed up files" do
+    @provider.load_current_resource
+    @provider.new_resource.stub!(:path).and_return("/tmp/s-20080705111233")
+    @provider.new_resource.stub!(:backup).and_return(1)
+    Chef::Config.stub!(:[]).with(:file_backup_path).and_return("/some_prefix")
+    Dir.stub!(:[]).and_return([ "/some_prefix/tmp/s-20080705111233", "/some_prefix/tmp/s-20080705111232", "/some_prefix/tmp/s-20080705111223"])
+    FileUtils.stub!(:mkdir_p).and_return(true)
+    FileUtils.stub!(:rm).and_return(true)
+    File.stub!(:exist?).and_return(true)
+    Time.stub!(:now).and_return(Time.at(1272147455).getgm)
+    FileUtils.should_receive(:cp).with("/tmp/s-20080705111233", "/some_prefix/tmp/s-20080705111233.chef-20100424221735", {:preserve => true}).and_return(true)
+    @provider.backup
+  end
+
+  describe "when the enclosing directory does not exist" do
+    before do
+      @resource.path("/tmp/no-such-path/file.txt")
+    end
+
+    it "raises a specific error describing the problem" do
+      lambda {@provider.run_action(:create)}.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+    end
+  end
+
+  describe "when creating a file which may be missing" do
+    it "should not call action create if the file exists" do
+      @resource.path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates", "seattle.txt")))
+      @provider = Chef::Provider::File.new(@resource, @run_context)
+      File.should_not_receive(:open)
+      @provider.run_action(:create_if_missing)
+      @resource.should_not be_updated_by_last_action
+    end
+
+    it "should call action create if the does not file exist" do
+      @resource.path("/tmp/non_existant_file")
+      @provider = Chef::Provider::File.new(@resource, @run_context)
+      @provider.should_receive(:diff_current_from_content).and_return("")
+      ::File.stub!(:exists?).with(@resource.path).and_return(false)
+      @provider.stub!(:update_new_file_state)
+      io = StringIO.new
+      File.should_receive(:open).with(@provider.new_resource.path, "w+").and_yield(io)
+      #@provider.should_receive(:action_create).and_return(true)
+      @provider.run_action(:create_if_missing)
+      @resource.should be_updated_by_last_action
+    end
+  end
+
+  describe "when a diff is requested" do
+
+    before(:each) do
+      @original_config = Chef::Config.hash_dup
+    end
+
+    after(:each) do
+      Chef::Config.configuration = @original_config if @original_config
+    end
+
+    describe "when identifying files as binary or text" do
+
+      it "should identify zero-length files as text" do
+        Tempfile.open("some-temp") do |file|
+          @resource.path(file.path)
+          @provider = Chef::Provider::File.new(@resource, @run_context)
+          @provider.is_binary?(file.path).should be_false
+        end
+      end
+
+      it "should correctly identify text files as being text" do
+        Tempfile.open("some-temp") do |file|
+          @resource.path(file.path)
+          file.puts("This is a text file.")
+          file.puts("That has a couple of lines in it.")
+          file.puts("And lets make sure that other printable chars work too: ~!@\#$%^&*()`:\"<>?{}|_+,./;'[]\\-=")
+          file.close
+          @provider = Chef::Provider::File.new(@resource, @run_context)
+          @provider.is_binary?(file.path).should be_false
+        end
+      end
+
+      it "should identify a null-terminated string as binary" do
+        Tempfile.open("some-temp") do |file|
+          @resource.path(file.path)
+          file.write("This is a binary file.\0")
+          file.close
+          @provider = Chef::Provider::File.new(@resource, @run_context)
+          @provider.is_binary?(file.path).should be_true
+        end
+      end
+
+    end
+
+    it "should not return diff output when chef config has disabled it" do
+      Chef::Config[:diff_disabled] = true
+      Tempfile.open("some-temp") do |file|
+        @resource.path(file.path)
+        @provider = Chef::Provider::File.new(@resource, @run_context)
+        @provider.load_current_resource
+        result = @provider.diff_current_from_content "foo baz"
+        result.should == [ "(diff output suppressed by config)" ]
+        @resource.diff.should be_nil
+      end
+    end
+
+    it "should not return diff output when there is no new file to compare it to" do
+      Tempfile.open("some-temp") do |file|
+        Tempfile.open("other-temp") do |missing_file|
+          missing_path = missing_file.path
+          missing_file.close
+          missing_file.unlink
+          @resource.path(file.path)
+          @provider = Chef::Provider::File.new(@resource, @run_context)
+          @provider.load_current_resource
+          result = @provider.diff_current missing_path
+          result.should == [ "(no temp file with new content, diff output suppressed)" ]
+          @resource.diff.should be_nil
+        end
+      end
+    end
+
+    it "should produce diff output when the file does not exist yet, but suppress reporting it" do
+      Tempfile.open("some-temp") do |file|
+        @resource.path(file.path)
+        file.close
+        file.unlink
+        @provider = Chef::Provider::File.new(@resource, @run_context)
+        @provider.load_current_resource
+        result = @provider.diff_current_from_content "foo baz"
+        result.length.should == 4
+        @resource.diff.should be_nil
+      end
+    end
+
+    it "should not produce a diff when the current resource file is above the filesize threshold" do
+      Chef::Config[:diff_filesize_threshold] = 5
+      Tempfile.open("some-temp") do |file|
+        @resource.path(file.path)
+        file.puts("this is a line which is longer than 5 characters")
+        file.flush
+        @provider = Chef::Provider::File.new(@resource, @run_context)
+        @provider.load_current_resource
+        result = @provider.diff_current_from_content "foo"  # not longer than 5
+        result.should == [ "(file sizes exceed 5 bytes, diff output suppressed)" ]
+        @resource.diff.should be_nil
+      end
+    end
+
+    it "should not produce a diff when the new content is above the filesize threshold" do
+      Chef::Config[:diff_filesize_threshold] = 5
+      Tempfile.open("some-temp") do |file|
+        @resource.path(file.path)
+        file.puts("foo")
+        file.flush
+        @provider = Chef::Provider::File.new(@resource, @run_context)
+        @provider.load_current_resource
+        result = @provider.diff_current_from_content "this is a line that is longer than 5 characters"
+        result.should == [ "(file sizes exceed 5 bytes, diff output suppressed)" ]
+        @resource.diff.should be_nil
+      end
+    end
+
+    it "should not produce a diff when the generated diff size is above the diff size threshold" do
+      Chef::Config[:diff_output_threshold] = 5
+      Tempfile.open("some-temp") do |file|
+        @resource.path(file.path)
+        file.puts("some text to increase the size of the diff")
+        file.flush
+        @provider = Chef::Provider::File.new(@resource, @run_context)
+        @provider.load_current_resource
+        result = @provider.diff_current_from_content "this is a line that is longer than 5 characters"
+        result.should == [ "(long diff of over 5 characters, diff output suppressed)" ]
+        @resource.diff.should be_nil
+      end
+    end
+
+    it "should return valid diff output when content does not match the string content provided" do
+       Tempfile.open("some-temp") do |file|
+         @resource.path file.path
+         @provider = Chef::Provider::File.new(@resource, @run_context) 
+         @provider.load_current_resource
+         result = @provider.diff_current_from_content "foo baz"
+         # remove the file name info which varies.
+         result.shift(2)
+         # Result appearance seems to vary slightly under solaris diff
+         # So we'll compare the second line which is common to both.
+         # Solaris: -1,1 +1,0 @@, "+foo baz"
+         # Linux/Mac: -1,0, +1 @@, "+foo baz"
+         result.length.should == 2
+         result[1].should == "+foo baz"
+         @resource.diff.should_not be_nil
+       end
+    end
+  end
+end
diff --git a/spec/unit/provider/git_spec.rb b/spec/unit/provider/git_spec.rb
new file mode 100644
index 0000000000..bb8208dc27
--- /dev/null
+++ b/spec/unit/provider/git_spec.rb
@@ -0,0 +1,352 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.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 'spec_helper'
+describe Chef::Provider::Git do
+
+  before(:each) do
+    STDOUT.stub!(:tty?).and_return(true)
+    Chef::Log.level = :info
+
+    @current_resource = Chef::Resource::Git.new("web2.0 app")
+    @current_resource.revision("d35af14d41ae22b19da05d7d03a0bafc321b244c")
+
+    @resource = Chef::Resource::Git.new("web2.0 app")
+    @resource.repository "git://github.com/opscode/chef.git"
+    @resource.destination "/my/deploy/dir"
+    @resource.revision "d35af14d41ae22b19da05d7d03a0bafc321b244c"
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @provider = Chef::Provider::Git.new(@resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+
+  context "determining the revision of the currently deployed checkout" do
+
+    before do
+      @stdout = mock("standard out")
+      @stderr = mock("standard error")
+      @exitstatus = mock("exitstatus")
+    end
+
+    it "sets the current revision to nil if the deploy dir does not exist" do
+      ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(false)
+      @provider.find_current_revision.should be_nil
+    end
+
+    it "determines the current revision when there is one" do
+      ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
+      @stdout = "9b4d8dc38dd471246e7cfb1c3c1ad14b0f2bee13\n"
+      @provider.should_receive(:shell_out!).with('git rev-parse HEAD', {:cwd => '/my/deploy/dir', :returns => [0,128]}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.find_current_revision.should eql("9b4d8dc38dd471246e7cfb1c3c1ad14b0f2bee13")
+    end
+
+    it "gives the current revision as nil when there is no current revision" do
+      ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
+      @stderr = "fatal: Not a git repository (or any of the parent directories): .git"
+      @stdout = ""
+      @provider.should_receive(:shell_out!).with('git rev-parse HEAD', :cwd => '/my/deploy/dir', :returns => [0,128]).and_return(mock("ShellOut result", :stdout => "", :stderr => @stderr))
+      @provider.find_current_revision.should be_nil
+    end
+  end
+
+  it "creates a current_resource with the currently deployed revision when a clone exists in the destination dir" do
+    @provider.stub!(:find_current_revision).and_return("681c9802d1c62a45b490786c18f0b8216b309440")
+    @provider.load_current_resource
+    @provider.current_resource.name.should eql(@resource.name)
+    @provider.current_resource.revision.should eql("681c9802d1c62a45b490786c18f0b8216b309440")
+  end
+
+  it "keeps the node and resource passed to it on initialize" do
+    @provider.node.should equal(@node)
+    @provider.new_resource.should equal(@resource)
+  end
+
+  context "resolving revisions to a SHA" do
+
+    before do
+      @git_ls_remote = "git ls-remote git://github.com/opscode/chef.git "
+    end
+
+    it "returns resource.revision as is if revision is already a full SHA" do
+      @provider.target_revision.should eql("d35af14d41ae22b19da05d7d03a0bafc321b244c")
+    end
+
+    it "converts resource.revision from a tag to a SHA" do
+      @resource.revision "v1.0"
+      @stdout = "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n"
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0", {:log_tag=>"git[web2.0 app]", :log_level=>:debug}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.target_revision.should eql("503c22a5e41f5ae3193460cca044ed1435029f53")
+    end
+
+    it "raises an invalid remote reference error if you try to deploy from ``origin'' and assertions are run" do
+      @resource.revision "origin/"
+      @provider.action = :checkout
+      @provider.define_resource_requirements 
+      ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+      lambda {@provider.process_resource_requirements}.should raise_error(Chef::Exceptions::InvalidRemoteGitReference)
+    end
+
+    it "raises an unresolvable git reference error if the revision can't be resolved to any revision and assertions are run" do
+      @resource.revision "FAIL, that's the revision I want"
+      @provider.action = :checkout
+      @provider.should_receive(:shell_out!).and_return(mock("ShellOut result", :stdout => "\n"))
+      @provider.define_resource_requirements 
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::UnresolvableGitReference)
+    end
+
+    it "does not raise an error if the revision can't be resolved when assertions are not run" do
+      @resource.revision "FAIL, that's the revision I want"
+      @provider.should_receive(:shell_out!).and_return(mock("ShellOut result", :stdout => "\n"))
+      @provider.target_revision.should == nil
+    end
+
+    it "does not raise an error when the revision is valid and assertions are run." do 
+      @resource.revision "v1.0"
+      @stdout = "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n"
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0", {:log_tag=>"git[web2.0 app]", :log_level=>:debug}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.action = :checkout
+      ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+      @provider.define_resource_requirements 
+      lambda { @provider.process_resource_requirements }.should_not raise_error(RuntimeError)
+    end
+
+    it "gives the latest HEAD revision SHA if nothing is specified" do
+      @stdout =<<-SHAS
+28af684d8460ba4793eda3e7ac238c864a5d029a\tHEAD
+503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha
+28af684d8460ba4793eda3e7ac238c864a5d029a\trefs/heads/master
+c44fe79bb5e36941ce799cee6b9de3a2ef89afee\trefs/tags/0.5.2
+14534f0e0bf133dc9ff6dbe74f8a0c863ff3ac6d\trefs/tags/0.5.4
+d36fddb4291341a1ff2ecc3c560494e398881354\trefs/tags/0.5.6
+9e5ce9031cbee81015de680d010b603bce2dd15f\trefs/tags/0.6.0
+9b4d8dc38dd471246e7cfb1c3c1ad14b0f2bee13\trefs/tags/0.6.2
+014a69af1cdce619de82afaf6cdb4e6ac658fede\trefs/tags/0.7.0
+fa8097ff666af3ce64761d8e1f1c2aa292a11378\trefs/tags/0.7.2
+44f9be0b33ba5c10027ddb030a5b2f0faa3eeb8d\trefs/tags/0.7.4
+d7b9957f67236fa54e660cc3ab45ffecd6e0ba38\trefs/tags/0.7.8
+b7d19519a1c15f1c1a324e2683bd728b6198ce5a\trefs/tags/0.7.8^{}
+ebc1b392fe7e8f0fbabc305c299b4d365d2b4d9b\trefs/tags/chef-server-package
+SHAS
+      @resource.revision ''
+      @provider.should_receive(:shell_out!).with(@git_ls_remote, {:log_tag=>"git[web2.0 app]", :log_level=>:debug}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.target_revision.should eql("28af684d8460ba4793eda3e7ac238c864a5d029a")
+    end
+  end
+
+  it "responds to :revision_slug as an alias for target_revision" do
+    @provider.should respond_to(:revision_slug)
+  end
+
+  it "runs a clone command with default git options" do
+    @resource.user "deployNinja"
+    @resource.ssh_wrapper "do_it_this_way.sh"
+    expected_cmd = "git clone  git://github.com/opscode/chef.git /my/deploy/dir"
+    @provider.should_receive(:shell_out!).with(expected_cmd, :user => "deployNinja",
+                                                :environment =>{"GIT_SSH"=>"do_it_this_way.sh"}, :log_level => :info, :log_tag => "git[web2.0 app]", :live_stream => STDOUT)
+
+    @provider.clone
+    @provider.converge
+  end
+
+  it "runs a clone command with escaped destination" do
+    @resource.user "deployNinja"
+    @resource.destination "/Application Support/with/space"
+    @resource.ssh_wrapper "do_it_this_way.sh"
+    expected_cmd = "git clone  git://github.com/opscode/chef.git /Application\\ Support/with/space"
+    @provider.should_receive(:shell_out!).with(expected_cmd, :user => "deployNinja",
+                                                :environment =>{"GIT_SSH"=>"do_it_this_way.sh"}, :log_level => :info, :log_tag => "git[web2.0 app]", :live_stream => STDOUT)
+    @provider.clone
+    @provider.converge
+  end
+
+  it "compiles a clone command using --depth for shallow cloning" do
+    @resource.depth 5
+    expected_cmd = 'git clone --depth 5 git://github.com/opscode/chef.git /my/deploy/dir'
+    @provider.should_receive(:shell_out!).with(expected_cmd, {:log_level => :info, :log_tag => "git[web2.0 app]", :live_stream => STDOUT})
+    @provider.clone
+    @provider.converge
+  end
+
+  it "compiles a clone command with a remote other than ``origin''" do
+    @resource.remote "opscode"
+    expected_cmd = 'git clone -o opscode git://github.com/opscode/chef.git /my/deploy/dir'
+    @provider.should_receive(:shell_out!).with(expected_cmd, {:log_level => :info, :log_tag => "git[web2.0 app]", :live_stream => STDOUT})
+    @provider.clone
+    @provider.converge
+  end
+
+  it "runs a checkout command with default options" do
+    expected_cmd = 'git checkout -b deploy d35af14d41ae22b19da05d7d03a0bafc321b244c'
+    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir", :log_level => :debug, :log_tag => "git[web2.0 app]")
+    @provider.checkout
+    @provider.converge
+  end
+
+  it "runs an enable_submodule command" do
+    @resource.enable_submodules true
+    expected_cmd = "git submodule update --init --recursive"
+    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir", :log_level => :info, :log_tag => "git[web2.0 app]", :live_stream => STDOUT)
+    @provider.enable_submodules
+    @provider.converge
+  end
+
+  it "does nothing for enable_submodules if resource.enable_submodules #=> false" do
+    @provider.should_not_receive(:shell_out!)
+    @provider.enable_submodules
+    @provider.converge
+  end
+
+  it "runs a sync command with default options" do
+    expected_cmd = "git fetch origin && git fetch origin --tags && git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
+    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd=> "/my/deploy/dir", :log_level => :debug, :log_tag => "git[web2.0 app]")
+    @provider.fetch_updates
+    @provider.converge
+  end
+
+  it "runs a sync command with the user and group specified in the resource" do
+    @resource.user("whois")
+    @resource.group("thisis")
+    expected_cmd = "git fetch origin && git fetch origin --tags && git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
+    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir",
+                                                :user => "whois", :group => "thisis", :log_level => :debug, :log_tag => "git[web2.0 app]")
+    @provider.fetch_updates
+    @provider.converge
+  end
+
+  it "configures remote tracking branches when remote is not ``origin''" do
+    @resource.remote "opscode"
+    conf_tracking_branches =  "git config remote.opscode.url git://github.com/opscode/chef.git && " +
+                              "git config remote.opscode.fetch +refs/heads/*:refs/remotes/opscode/*"
+    @provider.should_receive(:shell_out!).with(conf_tracking_branches, :cwd => "/my/deploy/dir", :log_tag => "git[web2.0 app]", :log_level => :debug)
+    fetch_command = "git fetch opscode && git fetch opscode --tags && git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
+    @provider.should_receive(:shell_out!).with(fetch_command, :cwd => "/my/deploy/dir", :log_level => :debug, :log_tag => "git[web2.0 app]")
+    @provider.fetch_updates
+    @provider.converge
+  end
+
+  it "raises an error if the git clone command would fail because the enclosing directory doesn't exist" do
+    @provider.stub!(:shell_out!)
+    lambda {@provider.run_action(:sync)}.should raise_error(Chef::Exceptions::MissingParentDirectory)
+  end
+
+  it "does a checkout by cloning the repo and then enabling submodules" do
+    # will be invoked in load_current_resource 
+    ::File.stub!(:exist?).with("/my/deploy/dir/.git").and_return(false)
+
+    ::File.stub!(:exist?).with("/my/deploy/dir").and_return(true)
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::Dir.stub!(:entries).with("/my/deploy/dir").and_return(['.','..'])
+    @provider.should_receive(:clone)
+    @provider.should_receive(:checkout)
+    @provider.should_receive(:enable_submodules)
+    @provider.run_action(:checkout)
+    # Even though an actual run will cause an update to occur, the fact that we've stubbed out
+    # the actions above will prevent updates from registering
+    # @resource.should be_updated
+  end
+
+  # REGRESSION TEST: on some OSes, the entries from an empty directory will be listed as
+  # ['..', '.'] but this shouldn't change the behavior
+  it "does a checkout by cloning the repo and then enabling submodules when the directory entries are listed as %w{.. .}" do
+    ::File.stub!(:exist?).with("/my/deploy/dir/.git").and_return(false)
+    ::File.stub!(:exist?).with("/my/deploy/dir").and_return(false)
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::Dir.stub!(:entries).with("/my/deploy/dir").and_return(['..','.'])
+    @provider.should_receive(:clone)
+    @provider.should_receive(:checkout)
+    @provider.should_receive(:enable_submodules)
+    @provider.run_action(:checkout)
+   # @resource.should be_updated
+  end
+
+  it "should not checkout if the destination exists or is a non empty directory" do
+    # will be invoked in load_current_resource 
+    ::File.stub!(:exist?).with("/my/deploy/dir/.git").and_return(false)
+
+    ::File.stub!(:exist?).with("/my/deploy/dir").and_return(true)
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::Dir.stub!(:entries).with("/my/deploy/dir").and_return(['.','..','foo','bar'])
+    @provider.should_not_receive(:clone)
+    @provider.should_not_receive(:checkout)
+    @provider.should_not_receive(:enable_submodules)
+    @provider.run_action(:checkout)
+    @resource.should_not be_updated
+  end
+
+  it "syncs the code by updating the source when the repo has already been checked out" do
+    ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    @provider.should_receive(:find_current_revision).exactly(2).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
+    @provider.should_not_receive(:fetch_updates)
+    @provider.run_action(:sync)
+    @resource.should_not be_updated
+  end
+
+  it "marks the resource as updated when the repo is updated and gets a new version" do
+    ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    # invoked twice - first time from load_current_resource
+    @provider.should_receive(:find_current_revision).exactly(2).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
+    @provider.stub!(:target_revision).and_return('28af684d8460ba4793eda3e7ac238c864a5d029a')
+    @provider.should_receive(:fetch_updates)
+    @provider.should_receive(:enable_submodules)
+    @provider.run_action(:sync)
+   # @resource.should be_updated
+  end
+
+  it "does not fetch any updates if the remote revision matches the current revision" do
+    ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    @provider.stub!(:find_current_revision).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
+    @provider.stub!(:target_revision).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
+    @provider.should_not_receive(:fetch_updates)
+    @provider.run_action(:sync)
+    @resource.should_not be_updated
+  end
+
+  it "clones the repo instead of fetching it if the deploy directory doesn't exist" do
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::File.should_receive(:exist?).with("/my/deploy/dir/.git").exactly(2).and_return(false)
+    @provider.should_receive(:action_checkout)
+    @provider.should_not_receive(:shell_out!)
+    @provider.run_action(:sync)
+   # @resource.should be_updated
+  end
+
+  it "clones the repo instead of fetching updates if the deploy directory is empty" do
+    ::File.should_receive(:exist?).with("/my/deploy/dir/.git").exactly(2).and_return(false)
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::File.stub!(:directory?).with("/my/deploy/dir").and_return(true)
+    @provider.stub!(:sync_command).and_return("huzzah!")
+    @provider.should_receive(:action_checkout)
+    @provider.should_not_receive(:shell_out!).with("huzzah!", :cwd => "/my/deploy/dir")
+    @provider.run_action(:sync)
+    #@resource.should be_updated
+  end
+
+  it "does an export by cloning the repo then removing the .git directory" do
+    @provider.should_receive(:action_checkout)
+    FileUtils.should_receive(:rm_rf).with(@resource.destination + "/.git")
+    @provider.run_action(:export)
+    @resource.should be_updated
+  end
+
+end
diff --git a/spec/unit/provider/group/dscl_spec.rb b/spec/unit/provider/group/dscl_spec.rb
new file mode 100644
index 0000000000..b526848dfd
--- /dev/null
+++ b/spec/unit/provider/group/dscl_spec.rb
@@ -0,0 +1,294 @@
+#
+# Author:: Dreamcat4 (<dreamcat4@gmail.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'
+
+describe Chef::Provider::Group::Dscl do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Group.new("aj")
+    @current_resource = Chef::Resource::Group.new("aj")
+    @provider = Chef::Provider::Group::Dscl.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+    @status = mock("Process::Status", :exitstatus => 0) 
+    @pid = 2342
+    @stdin = StringIO.new
+    @stdout = StringIO.new("\n")
+    @stderr = StringIO.new("")
+    @provider.stub!(:popen4).and_yield(@pid,@stdin,@stdout,@stderr).and_return(@status)
+  end
+  
+  it "should run popen4 with the supplied array of arguments appended to the dscl command" do
+    @provider.should_receive(:popen4).with("dscl . -cmd /Path arg1 arg2")
+    @provider.dscl("cmd", "/Path", "arg1", "arg2")
+  end
+
+  it "should return an array of four elements - cmd, status, stdout, stderr" do
+    dscl_retval = @provider.dscl("cmd /Path args")
+    dscl_retval.should be_a_kind_of(Array)
+    dscl_retval.should == ["dscl . -cmd /Path args",@status,"\n",""]
+  end
+
+  describe "safe_dscl" do
+    before do
+      @node = Chef::Node.new
+      @provider = Chef::Provider::Group::Dscl.new(@node, @new_resource)
+      @provider.stub!(:dscl).and_return(["cmd", @status, "stdout", "stderr"])
+    end
+ 
+    it "should run dscl with the supplied cmd /Path args" do
+      @provider.should_receive(:dscl).with("cmd /Path args")
+      @provider.safe_dscl("cmd /Path args")
+    end
+
+    describe "with the dscl command returning a non zero exit status for a delete" do
+      before do
+        @status = mock("Process::Status", :exitstatus => 1)
+        @provider.stub!(:dscl).and_return(["cmd", @status, "stdout", "stderr"])
+      end
+
+      it "should return an empty string of standard output for a delete" do
+        safe_dscl_retval = @provider.safe_dscl("delete /Path args")
+        safe_dscl_retval.should be_a_kind_of(String)
+        safe_dscl_retval.should == ""
+      end
+
+      it "should raise an exception for any other command" do
+        lambda { @provider.safe_dscl("cmd /Path arguments") }.should raise_error(Chef::Exceptions::Group)
+      end
+    end
+
+    describe "with the dscl command returning no such key" do
+      before do
+        @provider.stub!(:dscl).and_return(["cmd", @status, "No such key: ", "stderr"])
+      end
+
+      it "should raise an exception" do
+        lambda { @provider.safe_dscl("cmd /Path arguments") }.should raise_error(Chef::Exceptions::Group)
+      end
+    end
+ 
+    describe "with the dscl command returning a zero exit status" do
+      it "should return the third array element, the string of standard output" do
+        safe_dscl_retval = @provider.safe_dscl("cmd /Path args")
+        safe_dscl_retval.should be_a_kind_of(String)
+        safe_dscl_retval.should == "stdout"
+      end
+    end
+  end
+
+  describe "get_free_gid" do
+    before do
+      @node = Chef::Node.new
+      @provider = Chef::Provider::Group::Dscl.new(@node, @new_resource)
+      @provider.stub!(:safe_dscl).and_return("\naj      200\njt      201\n")
+    end
+  
+    it "should run safe_dscl with list /Groups gid" do
+      @provider.should_receive(:safe_dscl).with("list /Groups gid")
+      @provider.get_free_gid
+    end
+
+    it "should return the first unused gid number on or above 200" do
+      @provider.get_free_gid.should equal(202)
+    end
+  
+    it "should raise an exception when the search limit is exhausted" do
+      search_limit = 1
+      lambda { @provider.get_free_gid(search_limit) }.should raise_error(RuntimeError)
+    end
+  end
+
+  describe "gid_used?" do
+    before do
+      @node = Chef::Node.new
+      @provider = Chef::Provider::Group::Dscl.new(@node, @new_resource)
+      @provider.stub!(:safe_dscl).and_return("\naj      500\n")
+    end
+
+    it "should run safe_dscl with list /Groups gid" do
+      @provider.should_receive(:safe_dscl).with("list /Groups gid")
+      @provider.gid_used?(500)
+    end
+  
+    it "should return true for a used gid number" do
+      @provider.gid_used?(500).should be_true
+    end
+
+    it "should return false for an unused gid number" do
+      @provider.gid_used?(501).should be_false
+    end
+
+    it "should return false if not given any valid gid number" do
+      @provider.gid_used?(nil).should be_false
+    end
+  end
+
+  describe "set_gid" do
+    describe "with the new resource and a gid number which is already in use" do
+      before do
+        @provider.stub!(:gid_used?).and_return(true)
+      end
+
+      it "should raise an exception if the new resources gid is already in use" do
+        lambda { @provider.set_gid }.should raise_error(Chef::Exceptions::Group)
+      end
+    end
+  
+    describe "with no gid number for the new resources" do
+      it "should run get_free_gid and return a valid, unused gid number" do
+        @provider.should_receive(:get_free_gid).and_return(501)
+        @provider.set_gid
+      end
+    end
+
+    describe "with blank gid number for the new resources" do
+      before do
+        @new_resource.instance_variable_set(:@gid, nil)
+        @new_resource.stub!(:safe_dscl)
+      end
+
+      it "should run get_free_gid and return a valid, unused gid number" do
+        @provider.should_receive(:get_free_gid).and_return(501)
+        @provider.set_gid
+      end
+    end
+
+    describe "with a valid gid number which is not already in use" do
+      it "should run safe_dscl with create /Groups/group PrimaryGroupID gid" do
+        @provider.stub(:get_free_gid).and_return(50)
+        @provider.should_receive(:safe_dscl).with("list /Groups gid")
+        @provider.should_receive(:safe_dscl).with("create /Groups/aj PrimaryGroupID 50").and_return(true)
+        @provider.set_gid
+      end
+    end
+  end
+
+  describe "set_members" do
+
+    describe "with existing members in the current resource and append set to false in the new resource" do
+      before do
+        @new_resource.stub!(:members).and_return([])
+        @new_resource.stub!(:append).and_return(false)
+        @current_resource.stub!(:members).and_return(["all", "your", "base"])
+      end
+
+      it "should log an appropriate message" do
+        Chef::Log.should_receive(:debug).with("group[aj] removing group members all your base")
+        @provider.set_members
+      end
+
+      it "should run safe_dscl with create /Groups/group GroupMembership to clear the Group's UID list" do
+        @provider.should_receive(:safe_dscl).with("create /Groups/aj GroupMembers ''").and_return(true)
+        @provider.should_receive(:safe_dscl).with("create /Groups/aj GroupMembership ''").and_return(true)
+        @provider.set_members
+      end
+    end
+
+    describe "with supplied members in the new resource" do
+      before do
+        @new_resource.members(["all", "your", "base"])
+        @current_resource.members([])
+      end
+
+      it "should log an appropriate debug message" do
+        Chef::Log.should_receive(:debug).with("group[aj] setting group members all, your, base")
+        @provider.set_members
+      end
+
+      it "should run safe_dscl with append /Groups/group GroupMembership and group members all, your, base" do
+        @provider.should_receive(:safe_dscl).with("create /Groups/aj GroupMembers ''").and_return(true)
+        @provider.should_receive(:safe_dscl).with("append /Groups/aj GroupMembership all your base").and_return(true)
+        @provider.should_receive(:safe_dscl).with("create /Groups/aj GroupMembership ''").and_return(true)
+        @provider.set_members
+      end
+    end
+  
+    describe "with no members in the new resource" do
+      before do
+        @new_resource.append(true)
+        @new_resource.members([])
+      end
+
+      it "should not call safe_dscl" do
+        @provider.should_not_receive(:safe_dscl)
+        @provider.set_members
+      end
+    end
+  end
+
+  describe "when loading the current system state" do
+    before (:each) do
+      @provider.load_current_resource
+      @provider.define_resource_requirements
+    end
+    it "raises an error if the required binary /usr/bin/dscl doesn't exist" do
+      File.should_receive(:exists?).with("/usr/bin/dscl").and_return(false)
+
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Group)
+    end
+
+    it "doesn't raise an error if /usr/bin/dscl exists" do
+      File.stub!(:exists?).and_return(true)
+      lambda { @provider.process_resource_requirements }.should_not raise_error(Chef::Exceptions::Group)
+    end
+  end
+
+  describe "when creating the group" do
+    it "creates the group, password field, gid, and sets group membership" do
+      @provider.should_receive(:set_gid).and_return(true)
+      @provider.should_receive(:set_members).and_return(true)
+      @provider.should_receive(:safe_dscl).with("create /Groups/aj Password '*'")
+      @provider.should_receive(:safe_dscl).with("create /Groups/aj")
+      @provider.create_group
+    end
+  end
+
+  describe "managing the group" do
+    it "should manage the group_name if it changed and the new resources group_name is not null" do
+      @current_resource.group_name("oldval")
+      @new_resource.group_name("newname")
+      @provider.should_receive(:safe_dscl).with("create /Groups/newname")
+      @provider.should_receive(:safe_dscl).with("create /Groups/newname Password '*'")
+      @provider.manage_group
+    end
+
+    it "should manage the gid if it changed and the new resources gid is not null" do
+      @current_resource.gid(23)
+      @new_resource.gid(42)
+      @provider.should_receive(:set_gid)
+      @provider.manage_group
+    end
+    
+    it "should manage the members if it changed and the new resources members is not null" do
+      @current_resource.members(%{charlie root})
+      @new_resource.members(%{crab revenge})
+      @provider.should_receive(:set_members)
+      @provider.manage_group
+    end
+  end
+
+  describe "remove_group" do
+    it "should run safe_dscl with delete /Groups/group and with the new resources group name" do
+      @provider.should_receive(:safe_dscl).with("delete /Groups/aj").and_return(true)
+      @provider.remove_group
+    end
+  end
+end
diff --git a/spec/unit/provider/group/gpasswd_spec.rb b/spec/unit/provider/group/gpasswd_spec.rb
new file mode 100644
index 0000000000..59da88e851
--- /dev/null
+++ b/spec/unit/provider/group/gpasswd_spec.rb
@@ -0,0 +1,108 @@
+#
+# Author:: AJ Christensen (<aj@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 'spec_helper'
+
+describe Chef::Provider::Group::Gpasswd, "modify_group_members" do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Group.new("wheel")
+    @new_resource.members %w{lobster rage fist}
+    @new_resource.append false
+    @provider = Chef::Provider::Group::Gpasswd.new(@new_resource, @run_context)
+    #@provider.stub!(:run_command).and_return(true)
+  end
+
+  describe "when determining the current group state" do
+    before (:each) do
+      @provider.load_current_resource
+      @provider.define_resource_requirements
+    end
+
+    # Checking for required binaries is already done in the spec 
+    # for Chef::Provider::Group - no need to repeat it here.  We'll 
+    # include only what's specific to this provider.
+    it "should raise an error if the required binary /usr/bin/gpasswd doesn't exist" do
+      File.stub!(:exists?).and_return(true)
+      File.should_receive(:exists?).with("/usr/bin/gpasswd").and_return(false)
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Group)
+    end
+
+    it "shouldn't raise an error if the required binaries exist" do
+      File.stub!(:exists?).and_return(true)
+      lambda { @provider.process_resource_requirements }.should_not raise_error(Chef::Exceptions::Group)
+    end
+  end
+
+  describe "after the group's current state is known" do
+    before do
+      @current_resource = @new_resource.dup
+      @provider.current_resource = @new_resource
+    end
+
+    describe "when no group members are specified and append is not set" do
+      before do
+        @new_resource.append(false)
+        @new_resource.members([])
+      end
+
+      it "logs a message and sets group's members to 'none'" do
+        Chef::Log.should_receive(:debug).with("group[wheel] setting group members to: none")
+        @provider.should_receive(:shell_out!).with("gpasswd -M \"\" wheel")
+        @provider.modify_group_members
+      end
+    end
+
+    describe "when no group members are specified and append is set" do
+      before do
+        @new_resource.append(true)
+        @new_resource.members([])
+      end
+
+      it "logs a message and does not modify group membership" do
+        Chef::Log.should_receive(:debug).with("group[wheel] not changing group members, the group has no members to add")
+        @provider.should_not_receive(:shell_out!)
+        @provider.modify_group_members
+      end
+    end
+
+    describe "when the resource specifies group members" do
+      it "should log an appropriate debug message" do
+        Chef::Log.should_receive(:debug).with("group[wheel] setting group members to lobster, rage, fist")
+        @provider.stub!(:shell_out!)
+        @provider.modify_group_members
+      end
+
+      it "should run gpasswd with the members joined by ',' followed by the target group" do
+        @provider.should_receive(:shell_out!).with("gpasswd -M lobster,rage,fist wheel")
+        @provider.modify_group_members
+      end
+
+      it "should run gpasswd individually for each user when the append option is set" do
+        @new_resource.append(true)
+        @provider.should_receive(:shell_out!).with("gpasswd -a lobster wheel")
+        @provider.should_receive(:shell_out!).with("gpasswd -a rage wheel")
+        @provider.should_receive(:shell_out!).with("gpasswd -a fist wheel")
+        @provider.modify_group_members
+      end
+
+    end
+  end
+end
diff --git a/spec/unit/provider/group/groupadd_spec.rb b/spec/unit/provider/group/groupadd_spec.rb
new file mode 100644
index 0000000000..f08e14f99b
--- /dev/null
+++ b/spec/unit/provider/group/groupadd_spec.rb
@@ -0,0 +1,161 @@
+#
+# Author:: AJ Christensen (<aj@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 'spec_helper'
+
+describe Chef::Provider::Group::Groupadd, "set_options" do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Group.new("aj")
+    @new_resource.gid(50)
+    @new_resource.members(["root", "aj"])
+    @new_resource.system false
+    @current_resource = Chef::Resource::Group.new("aj")
+    @current_resource.gid(50)
+    @current_resource.members(["root", "aj"])
+    @current_resource.system false
+    @provider = Chef::Provider::Group::Groupadd.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+
+  field_list = {
+    :gid => "-g"
+  }
+
+  field_list.each do |attribute, option|
+    it "should check for differences in #{attribute.to_s} between the current and new resources" do
+        @new_resource.should_receive(attribute)
+        @current_resource.should_receive(attribute)
+        @provider.set_options
+    end
+    it "should set the option for #{attribute} if the new resources #{attribute} is not null" do
+      @new_resource.stub!(attribute).and_return("wowaweea")
+      @provider.set_options.should eql(" #{option} '#{@new_resource.send(attribute)}' #{@new_resource.group_name}")
+    end
+  end
+
+  it "should combine all the possible options" do
+    match_string = ""
+    field_list.sort{ |a,b| a[0] <=> b[0] }.each do |attribute, option|
+      @new_resource.stub!(attribute).and_return("hola")
+      match_string << " #{option} 'hola'"
+    end
+    match_string << " aj"
+    @provider.set_options.should eql(match_string)
+  end
+
+  describe "when we want to create a system group" do
+    it "should not set groupadd_options '-r' when system is false" do
+      @new_resource.system(false)
+      @provider.groupadd_options.should_not =~ /-r/
+    end
+
+    it "should set groupadd -r if system is true" do
+      @new_resource.system(true)
+      @provider.groupadd_options.should == " -r"
+    end
+  end
+end
+
+describe Chef::Provider::Group::Groupadd, "create_group" do
+  before do
+    @node = Chef::Node.new
+    @new_resource = Chef::Resource::Group.new("aj")
+    @provider = Chef::Provider::Group::Groupadd.new(@node, @new_resource)
+    @provider.stub!(:run_command).and_return(true)
+    @provider.stub!(:set_options).and_return(" monkey")
+    @provider.stub!(:groupadd_options).and_return("")
+    @provider.stub!(:modify_group_members).and_return(true)
+  end
+
+  it "should run groupadd with the return of set_options" do
+    @provider.should_receive(:run_command).with({ :command => "groupadd monkey" }).and_return(true)
+    @provider.create_group
+  end
+
+  it "should modify the group members" do
+    @provider.should_receive(:modify_group_members).and_return(true)
+    @provider.create_group
+  end
+end
+
+describe Chef::Provider::Group::Groupadd do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Group.new("aj")
+    @provider = Chef::Provider::Group::Groupadd.new(@new_resource, @run_context)
+    @provider.stub!(:run_command).and_return(true)
+    @provider.stub!(:set_options).and_return(" monkey")
+  end
+
+  describe "manage group" do
+
+    it "should run groupmod with the return of set_options" do
+      @provider.stub!(:modify_group_members).and_return(true)
+      @provider.should_receive(:run_command).with({ :command => "groupmod monkey" }).and_return(true)
+      @provider.manage_group
+    end
+
+    it "should modify the group members" do
+      @provider.should_receive(:modify_group_members).and_return(true)
+      @provider.manage_group
+    end
+  end
+
+  describe "remove_group" do
+
+    it "should run groupdel with the new resources group name" do
+      @provider.should_receive(:run_command).with({ :command => "groupdel aj" }).and_return(true)
+      @provider.remove_group
+    end
+  end
+
+  describe "modify_group_members" do
+
+    it "should raise an error when calling modify_group_members" do
+      lambda { @provider.modify_group_members ; @provider.converge }.should raise_error(Chef::Exceptions::Group, "you must override modify_group_members in #{@provider.to_s}")
+    end
+  end
+
+  describe "load_current_resource" do
+    before do
+      File.stub!(:exists?).and_return(false)
+      @provider.define_resource_requirements
+    end
+    it "should raise an error if the required binary /usr/sbin/groupadd doesn't exist" do
+      File.should_receive(:exists?).with("/usr/sbin/groupadd").and_return(false)
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Group)
+    end
+    it "should raise an error if the required binary /usr/sbin/groupmod doesn't exist" do
+      File.should_receive(:exists?).with("/usr/sbin/groupadd").and_return(true)
+      File.should_receive(:exists?).with("/usr/sbin/groupmod").and_return(false)
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Group)
+    end
+    it "should raise an error if the required binary /usr/sbin/groupdel doesn't exist" do
+      File.should_receive(:exists?).with("/usr/sbin/groupadd").and_return(true)
+      File.should_receive(:exists?).with("/usr/sbin/groupmod").and_return(true)
+      File.should_receive(:exists?).with("/usr/sbin/groupdel").and_return(false)
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Group)
+    end
+
+  end
+end
diff --git a/spec/unit/provider/group/groupmod_spec.rb b/spec/unit/provider/group/groupmod_spec.rb
new file mode 100644
index 0000000000..c9c56313b5
--- /dev/null
+++ b/spec/unit/provider/group/groupmod_spec.rb
@@ -0,0 +1,134 @@
+#
+# Author:: Dan Crosta (<dcrosta@late.am>)
+# 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'
+
+describe Chef::Provider::Group::Groupmod do
+    before do
+      @node = Chef::Node.new
+      @events = Chef::EventDispatch::Dispatcher.new
+      @run_context = Chef::RunContext.new(@node, {}, @events)
+      @new_resource = Chef::Resource::Group.new("wheel")
+      @new_resource.gid 123
+      @new_resource.members %w{lobster rage fist}
+      @new_resource.append false
+      @provider = Chef::Provider::Group::Groupmod.new(@new_resource, @run_context)
+    end
+  
+  describe "manage_group" do
+    describe "when determining the current group state" do
+      it "should raise an error if the required binary /usr/sbin/group doesn't exist" do
+        File.should_receive(:exists?).with("/usr/sbin/group").and_return(false)
+        lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Group)
+      end
+      it "should raise an error if the required binary /usr/sbin/user doesn't exist" do
+        File.should_receive(:exists?).with("/usr/sbin/group").and_return(true)
+        File.should_receive(:exists?).with("/usr/sbin/user").and_return(false)
+        lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Group)
+      end
+  
+      it "shouldn't raise an error if the required binaries exist" do
+        File.stub!(:exists?).and_return(true)
+        lambda { @provider.load_current_resource }.should_not raise_error(Chef::Exceptions::Group)
+      end
+    end
+  
+    describe "after the group's current state is known" do
+      before do
+        @current_resource = @new_resource.dup
+        @provider.current_resource = @current_resource
+      end
+  
+      describe "when no group members are specified and append is not set" do
+        before do
+          @new_resource.append(false)
+          @new_resource.members([])
+        end
+  
+        it "logs a message and sets group's members to 'none', then removes existing group members" do
+          Chef::Log.should_receive(:debug).with("group[wheel] setting group members to: none")
+          Chef::Log.should_receive(:debug).with("group[wheel] removing members lobster, rage, fist")
+          @provider.should_receive(:shell_out!).with("group mod -n wheel_bak wheel")
+          @provider.should_receive(:shell_out!).with("group add -g '123' -o wheel")
+          @provider.should_receive(:shell_out!).with("group del wheel_bak")
+          @provider.manage_group
+        end
+      end
+  
+      describe "when no group members are specified and append is set" do
+        before do
+          @new_resource.append(true)
+          @new_resource.members([])
+        end
+   
+        it "logs a message and does not modify group membership" do
+          Chef::Log.should_receive(:debug).with("group[wheel] not changing group members, the group has no members to add")
+          @provider.should_not_receive(:shell_out!)
+          @provider.manage_group
+        end
+      end
+  
+      describe "when removing some group members" do
+        before do
+          @new_resource.append(false)
+          @new_resource.members(%w{ lobster })
+        end
+  
+        it "updates group membership correctly" do
+          Chef::Log.stub!(:debug)
+          @provider.should_receive(:shell_out!).with("group mod -n wheel_bak wheel")
+          @provider.should_receive(:shell_out!).with("user mod -G wheel lobster")
+          @provider.should_receive(:shell_out!).with("group add -g '123' -o wheel")
+          @provider.should_receive(:shell_out!).with("group del wheel_bak")
+          @provider.manage_group
+        end
+      end
+    end
+  end
+  
+  describe "create_group" do
+    describe "when creating a new group" do
+      before do
+        @current_resource = Chef::Resource::Group.new("wheel")
+        @provider.current_resource = @current_resource
+      end
+  
+      it "should run a group add command and some user mod commands" do
+        @provider.should_receive(:shell_out!).with("group add -g '123' wheel")
+        @provider.should_receive(:shell_out!).with("user mod -G wheel lobster")
+        @provider.should_receive(:shell_out!).with("user mod -G wheel rage")
+        @provider.should_receive(:shell_out!).with("user mod -G wheel fist")
+        @provider.create_group
+      end
+    end
+  end
+  
+  describe "remove_group" do
+    describe "when removing an existing group" do
+      before do
+        @current_resource = @new_resource.dup
+        @provider.current_resource = @current_resource
+      end
+  
+      it "should run a group del command" do
+        @provider.should_receive(:shell_out!).with("group del wheel")
+        @provider.remove_group
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/group/pw_spec.rb b/spec/unit/provider/group/pw_spec.rb
new file mode 100644
index 0000000000..a7dbdb8615
--- /dev/null
+++ b/spec/unit/provider/group/pw_spec.rb
@@ -0,0 +1,140 @@
+#
+# Author:: Stephen Haynes (<sh@nomitor.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'
+
+describe Chef::Provider::Group::Pw do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    
+    @new_resource = Chef::Resource::Group.new("wheel")
+    @new_resource.gid 50
+    @new_resource.members [ "root", "aj"]
+
+    @current_resource = Chef::Resource::Group.new("aj")
+    @current_resource.gid 50
+    @current_resource.members [ "root", "aj"]
+    @provider = Chef::Provider::Group::Pw.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+  
+  describe "when setting options for the pw command" do
+    it "does not set the gid option if gids match or are unmanaged" do
+      @provider.set_options.should ==  " wheel"
+    end
+    
+    it "sets the option for gid if it is not nil" do
+      @new_resource.gid(42)
+      @provider.set_options.should eql(" wheel -g '42'")
+    end
+  end
+
+  describe "when creating a group" do
+    it "should run pw groupadd with the return of set_options and set_members_option" do
+      @new_resource.gid(23)
+      @provider.should_receive(:run_command).with({ :command => "pw groupadd wheel -g '23' -M root,aj" }).and_return(true)
+      @provider.create_group
+    end
+  end
+
+  describe "when managing the group" do
+  
+    it "should run pw groupmod with the return of set_options" do
+      @new_resource.gid(42)
+      @provider.should_receive(:run_command).with({ :command => "pw groupmod wheel -g '42' -M root,aj" }).and_return(true)
+      @provider.manage_group
+    end
+
+  end
+
+  describe "when removing the group" do
+    it "should run pw groupdel with the new resources group name" do
+      @provider.should_receive(:run_command).with({ :command => "pw groupdel wheel" }).and_return(true)
+      @provider.remove_group
+    end
+  end
+
+  describe "when setting group membership" do
+  
+    describe "with an empty members array in both the new and current resource" do
+      before do
+        @new_resource.stub!(:members).and_return([])
+        @current_resource.stub!(:members).and_return([])
+      end
+    
+      it "should log an appropriate message" do
+        Chef::Log.should_receive(:debug).with("group[wheel] not changing group members, the group has no members")
+        @provider.set_members_option
+      end
+    
+      it "should set no options" do
+        @provider.set_members_option.should eql("")
+      end
+    end
+
+    describe "with an empty members array in the new resource and existing members in the current resource" do
+      before do
+        @new_resource.stub!(:members).and_return([])
+        @current_resource.stub!(:members).and_return(["all", "your", "base"])
+      end
+    
+      it "should log an appropriate message" do
+        Chef::Log.should_receive(:debug).with("group[wheel] removing group members all, your, base")
+        @provider.set_members_option
+      end
+    
+      it "should set the -d option with the members joined by ','" do
+        @provider.set_members_option.should eql(" -d all,your,base")
+      end
+    end
+  
+    describe "with supplied members array in the new resource and an empty members array in the current resource" do
+      before do
+        @new_resource.stub!(:members).and_return(["all", "your", "base"])
+        @current_resource.stub!(:members).and_return([])
+      end
+    
+      it "should log an appropriate debug message" do
+        Chef::Log.should_receive(:debug).with("group[wheel] setting group members to all, your, base")
+        @provider.set_members_option
+      end
+    
+      it "should set the -M option with the members joined by ','" do
+        @provider.set_members_option.should eql(" -M all,your,base")
+      end
+    end
+  end
+
+  describe"load_current_resource" do
+    before (:each) do 
+      @provider.load_current_resource
+      @provider.define_resource_requirements
+    end
+    it "should raise an error if the required binary /usr/sbin/pw doesn't exist" do
+      File.should_receive(:exists?).with("/usr/sbin/pw").and_return(false)
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Group)
+    end
+  
+    it "shouldn't raise an error if /usr/sbin/pw exists" do
+      File.stub!(:exists?).and_return(true)
+      lambda { @provider.process_resource_requirements }.should_not raise_error(Chef::Exceptions::Group)
+    end
+  end
+end
diff --git a/spec/unit/provider/group/usermod_spec.rb b/spec/unit/provider/group/usermod_spec.rb
new file mode 100644
index 0000000000..6e6e275a7a
--- /dev/null
+++ b/spec/unit/provider/group/usermod_spec.rb
@@ -0,0 +1,95 @@
+#
+# Author:: AJ Christensen (<aj@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 'spec_helper'
+
+describe Chef::Provider::Group::Usermod do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Group.new("wheel")
+    @new_resource.members [ "all", "your", "base" ]
+    @provider = Chef::Provider::Group::Usermod.new(@new_resource, @run_context)
+    @provider.stub!(:run_command)
+  end
+  
+  describe "modify_group_members" do
+  
+    describe "with an empty members array" do
+      before do
+        @new_resource.stub!(:members).and_return([])
+      end
+    
+      it "should log an appropriate message" do
+        Chef::Log.should_receive(:debug).with("group[wheel] not changing group members, the group has no members")
+        @provider.modify_group_members
+      end
+    end
+  
+    describe "with supplied members" do
+      platforms = {
+        "openbsd" => "-G",
+        "netbsd" => "-G",
+        "solaris" => "-a -G"
+      }
+
+      before do
+        @new_resource.stub!(:members).and_return(["all", "your", "base"])
+        File.stub!(:exists?).and_return(true)
+      end
+
+      it "should raise an error when setting the entire group directly" do
+        @provider.define_resource_requirements
+        @provider.load_current_resource
+        @provider.instance_variable_set("@group_exists", true)
+        @provider.action = :modify 
+        lambda { @provider.run_action(@provider.process_resource_requirements) }.should raise_error(Chef::Exceptions::Group, "setting group members directly is not supported by #{@provider.to_s}, must set append true in group")
+      end
+    
+      platforms.each do |platform, flags|
+        it "should usermod each user when the append option is set on #{platform}" do
+          @node.automatic_attrs[:platform] = platform
+          @new_resource.stub!(:append).and_return(true)
+          @provider.should_receive(:run_command).with({:command => "usermod #{flags} wheel all"})
+          @provider.should_receive(:run_command).with({:command => "usermod #{flags} wheel your"})
+          @provider.should_receive(:run_command).with({:command => "usermod #{flags} wheel base"})
+          @provider.modify_group_members
+        end
+      end
+    end
+  end
+
+  describe "when loading the current resource" do
+    before(:each) do
+      File.stub!(:exists?).and_return(false)
+      @provider.define_resource_requirements
+    end
+
+    it "should raise an error if the required binary /usr/sbin/usermod doesn't exist" do
+      File.stub!(:exists?).and_return(true)
+      File.should_receive(:exists?).with("/usr/sbin/usermod").and_return(false)
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Group)
+    end
+  
+    it "shouldn't raise an error if the required binaries exist" do
+      File.stub!(:exists?).and_return(true)
+      lambda { @provider.process_resource_requirements }.should_not raise_error(Chef::Exceptions::Group)
+    end
+  end
+end
diff --git a/spec/unit/provider/group/windows_spec.rb b/spec/unit/provider/group/windows_spec.rb
new file mode 100644
index 0000000000..084d1d0acf
--- /dev/null
+++ b/spec/unit/provider/group/windows_spec.rb
@@ -0,0 +1,94 @@
+#
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Copyright:: Copyright (c) 2010 VMware, 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'
+
+class Chef
+  class Util
+    class Windows
+      class NetGroup
+      end
+    end
+  end
+end
+
+describe Chef::Provider::Group::Windows do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Group.new("staff")
+    @net_group = mock("Chef::Util::Windows::NetGroup")
+    Chef::Util::Windows::NetGroup.stub!(:new).and_return(@net_group)
+    @provider = Chef::Provider::Group::Windows.new(@new_resource, @run_context)
+  end
+
+  describe "when creating the group" do
+    it "should call @net_group.local_add" do
+      @net_group.should_receive(:local_set_members).with([])
+      @net_group.should_receive(:local_add)
+      @provider.create_group
+    end
+  end
+
+  describe "manage_group" do
+    before do
+      @new_resource.members([ "us" ])
+      @current_resource = Chef::Resource::Group.new("staff")
+      @current_resource.members [ "all", "your", "base" ]
+
+      Chef::Util::Windows::NetGroup.stub!(:new).and_return(@net_group)
+      @net_group.stub!(:local_add_members)
+      @net_group.stub!(:local_set_members)
+      @provider.current_resource = @current_resource
+    end
+
+    it "should call @net_group.local_set_members" do
+      @new_resource.stub!(:append).and_return(false)
+      @net_group.should_receive(:local_set_members).with(@new_resource.members)
+      @provider.manage_group
+    end
+
+    it "should call @net_group.local_add_members" do
+      @new_resource.stub!(:append).and_return(true)
+      @net_group.should_receive(:local_add_members).with(@new_resource.members)
+      @provider.manage_group
+    end
+
+    it "should call @net_group.local_set_members if append fails" do
+      @new_resource.stub!(:append).and_return(true)
+      @net_group.stub!(:local_add_members).and_raise(ArgumentError)
+      @net_group.should_receive(:local_add_members).with(@new_resource.members)
+      @net_group.should_receive(:local_set_members).with(@new_resource.members + @current_resource.members)
+      @provider.manage_group
+    end
+
+  end
+
+  describe "remove_group" do
+    before do
+      Chef::Util::Windows::NetGroup.stub!(:new).and_return(@net_group)
+      @provider.stub!(:run_command).and_return(true)
+    end
+
+    it "should call @net_group.local_delete" do
+      @net_group.should_receive(:local_delete)
+      @provider.remove_group
+    end
+  end
+end
diff --git a/spec/unit/provider/group_spec.rb b/spec/unit/provider/group_spec.rb
new file mode 100644
index 0000000000..106a0db14c
--- /dev/null
+++ b/spec/unit/provider/group_spec.rb
@@ -0,0 +1,259 @@
+#
+# Author:: AJ Christensen (<aj@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 'spec_helper'
+
+describe Chef::Provider::User do
+
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Group.new("wheel", @run_context)
+    @new_resource.gid 500
+    @new_resource.members "aj"
+
+    @provider = Chef::Provider::Group.new(@new_resource, @run_context)
+
+    @current_resource = Chef::Resource::Group.new("aj", @run_context)
+    @current_resource.gid 500
+    @current_resource.members "aj"
+    
+    @provider.current_resource = @current_resource
+
+    @pw_group = mock("Struct::Group",
+      :name => "wheel",
+      :gid => 20,
+      :mem => [ "root", "aj" ]
+      )
+    Etc.stub!(:getgrnam).with('wheel').and_return(@pw_group)
+  end
+  
+  it "assumes the group exists by default" do
+    @provider.group_exists.should be_true
+  end
+
+  describe "when establishing the current state of the group" do
+  
+    it "sets the group name of the current resource to the group name of the new resource" do
+      @provider.load_current_resource
+      @provider.current_resource.group_name.should == 'wheel'
+    end
+
+    it "does not modify the desired gid if set" do
+      @provider.load_current_resource
+      @new_resource.gid.should == 500
+    end
+
+    it "sets the desired gid to the current gid if none is set" do
+      @new_resource.instance_variable_set(:@gid, nil)
+      @provider.load_current_resource
+      @new_resource.gid.should == 20
+    end
+  
+    it "looks up the group in /etc/group with getgrnam" do
+      Etc.should_receive(:getgrnam).with(@new_resource.group_name).and_return(@pw_group)
+      @provider.load_current_resource
+      @provider.current_resource.gid.should == 20
+      @provider.current_resource.members.should == %w{root aj}
+    end
+  
+    it "should flip the value of exists if it cannot be found in /etc/group" do
+      Etc.stub!(:getgrnam).and_raise(ArgumentError)
+      @provider.load_current_resource
+      @provider.group_exists.should be_false
+    end
+  
+    it "should return the current resource" do
+      @provider.load_current_resource.should equal(@provider.current_resource)    
+    end
+  end
+
+  describe "when determining if the system is already in the target state" do
+    [ :gid, :members ].each do |attribute|
+      it "should return true if #{attribute} doesn't match" do
+        @current_resource.stub!(attribute).and_return("looooooooooooooooooool")
+        @provider.compare_group.should be_true
+      end
+    end
+  
+    it "should return false if gid and members are equal" do
+      @provider.compare_group.should be_false
+    end
+
+    it "should return false if append is true and the group member(s) already exists" do
+      @current_resource.members << "extra_user"
+      @new_resource.stub!(:append).and_return(true)
+      @provider.compare_group.should be_false
+    end
+
+    it "should return true if append is true and the group member(s) do not already exist" do
+      @new_resource.members << "extra_user"
+      @new_resource.stub!(:append).and_return(true)
+      @provider.compare_group.should be_true
+    end
+
+  end
+
+  describe "when creating a group" do
+    it "should call create_group if the group does not exist" do
+      @provider.group_exists = false
+      @provider.should_receive(:create_group).and_return(true)
+      @provider.run_action(:create)
+    end
+  
+    it "should set the the new_resources updated flag when it creates the group" do
+      @provider.group_exists = false
+      @provider.stub!(:create_group)
+      @provider.run_action(:create)
+      @provider.new_resource.should be_updated
+    end
+  
+    it "should check to see if the group has mismatched attributes if the group exists" do
+      @provider.group_exists = true
+      @provider.stub!(:compare_group).and_return(false)
+      @provider.run_action(:create)
+      @provider.new_resource.should_not be_updated
+    end
+  
+    it "should call manage_group if the group exists and has mismatched attributes" do
+      @provider.group_exists = true
+      @provider.stub!(:compare_group).and_return(true)
+      @provider.should_receive(:manage_group).and_return(true)
+      @provider.run_action(:create)
+    end
+  
+    it "should set the the new_resources updated flag when it creates the group if we call manage_group" do
+      @provider.group_exists = true
+      @provider.stub!(:compare_group).and_return(true)
+      @provider.stub!(:manage_group).and_return(true)
+      @provider.run_action(:create)
+      @new_resource.should be_updated
+    end
+  end
+
+  describe "when removing a group" do
+  
+    it "should not call remove_group if the group does not exist" do
+      @provider.group_exists = false
+      @provider.should_not_receive(:remove_group) 
+      @provider.run_action(:remove)
+      @provider.new_resource.should_not be_updated
+    end
+  
+    it "should call remove_group if the group exists" do
+      @provider.group_exists = true
+      @provider.should_receive(:remove_group)
+      @provider.run_action(:remove)
+      @provider.new_resource.should be_updated
+    end
+  end
+
+  describe "when updating a group" do
+    before(:each) do
+      @provider.group_exists = true
+      @provider.stub!(:manage_group).and_return(true)
+    end
+ 
+    it "should run manage_group if the group exists and has mismatched attributes" do
+      @provider.should_receive(:compare_group).and_return(true)
+      @provider.should_receive(:manage_group).and_return(true)
+      @provider.run_action(:manage)
+    end
+  
+    it "should set the new resources updated flag to true if manage_group is called" do
+      @provider.stub!(:compare_group).and_return(true)
+      @provider.stub!(:manage_group).and_return(true)
+      @provider.run_action(:manage)
+      @new_resource.should be_updated
+    end
+  
+    it "should not run manage_group if the group does not exist" do
+      @provider.group_exists = false
+      @provider.should_not_receive(:manage_group)
+      @provider.run_action(:manage)
+    end
+    
+    it "should not run manage_group if the group exists but has no differing attributes" do
+      @provider.should_receive(:compare_group).and_return(false)
+      @provider.should_not_receive(:manage_group)
+      @provider.run_action(:manage)
+    end
+  end
+
+  describe "when modifying the group" do
+    before(:each) do
+      @provider.group_exists = true
+      @provider.stub!(:manage_group).and_return(true)
+    end
+ 
+    it "should run manage_group if the group exists and has mismatched attributes" do
+      @provider.should_receive(:compare_group).and_return(true)
+      @provider.should_receive(:manage_group).and_return(true)
+      @provider.run_action(:modify)
+    end
+  
+    it "should set the new resources updated flag to true if manage_group is called" do
+      @provider.stub!(:compare_group).and_return(true)
+      @provider.stub!(:manage_group).and_return(true)
+      @provider.run_action(:modify)
+      @new_resource.should be_updated
+    end
+  
+    it "should not run manage_group if the group exists but has no differing attributes" do
+      @provider.should_receive(:compare_group).and_return(false)
+      @provider.should_not_receive(:manage_group)
+      @provider.run_action(:modify)
+    end
+  
+    it "should raise a Chef::Exceptions::Group if the group doesn't exist" do
+      @provider.group_exists = false
+      lambda { @provider.run_action(:modify) }.should raise_error(Chef::Exceptions::Group)
+    end
+  end
+
+  describe "when determining the reason for a change" do
+    it "should report which group members are missing if members are missing and appending to the group" do
+       @new_resource.members << "user1"
+       @new_resource.members << "user2" 
+       @new_resource.stub!(:append).and_return true
+       @provider.compare_group.should be_true
+       @provider.change_desc.should == "add missing member(s): user1, user2"
+    end
+
+    it "should report that the group members will be overwritten if not appending" do
+       @new_resource.members << "user1"
+       @new_resource.stub!(:append).and_return false 
+       @provider.compare_group.should be_true
+       @provider.change_desc.should == "replace group members with new list of members"
+    end
+
+    it "should report the gid will be changed when it does not match" do
+      @current_resource.stub!(:gid).and_return("BADF00D")
+      @provider.compare_group.should be_true
+      @provider.change_desc.should == "change gid #{@current_resource.gid} to #{@new_resource.gid}"
+
+    end
+
+    it "should report no change reason when no change is required" do
+      @provider.compare_group.should be_false
+      @provider.change_desc.should == nil
+    end
+  end
+
+end
diff --git a/spec/unit/provider/http_request_spec.rb b/spec/unit/provider/http_request_spec.rb
new file mode 100644
index 0000000000..26d73cebb4
--- /dev/null
+++ b/spec/unit/provider/http_request_spec.rb
@@ -0,0 +1,178 @@
+#
+# 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 'spec_helper'
+
+describe Chef::Provider::HttpRequest do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::HttpRequest.new('adam')
+    @new_resource.name "adam"
+    @new_resource.url "http://www.opscode.com"
+    @new_resource.message "is cool"
+
+    @provider = Chef::Provider::HttpRequest.new(@new_resource, @run_context)
+  end
+
+  describe "load_current_resource" do  
+
+    it "should set up a Chef::REST client, with no authentication" do
+      Chef::REST.should_receive(:new).with(@new_resource.url, nil, nil)
+      @provider.load_current_resource
+    end
+  end
+
+  describe "when making REST calls" do
+    before(:each) do
+      # run_action(x) forces load_current_resource to run;
+      # that would overwrite our supplied mock Chef::Rest # object
+      @provider.stub!(:load_current_resource).and_return(true)
+      @rest = mock("Chef::REST", :create_url => "http://www.opscode.com", :run_request => "you made it!" )
+      @provider.rest = @rest
+    end
+
+    describe "action_get" do  
+      it "should create the url with a message argument" do
+        @rest.should_receive(:create_url).with("#{@new_resource.url}?message=#{@new_resource.message}")
+        @provider.run_action(:get)
+      end
+
+      it "should inflate a message block at runtime" do
+        @new_resource.stub!(:message).and_return(lambda { "return" })
+        @rest.should_receive(:create_url).with("#{@new_resource.url}?message=return")
+        @provider.run_action(:get)
+      end
+
+      it "should run a GET request" do
+        @rest.should_receive(:run_request).with(:GET, @rest.create_url, {}, false, 10, false)
+        @provider.run_action(:get)
+      end
+
+      it "should update the resource" do
+        @provider.run_action(:get)
+        @new_resource.should be_updated
+      end
+    end
+
+    describe "action_put" do  
+      it "should create the url" do
+        @rest.should_receive(:create_url).with("#{@new_resource.url}")
+        @provider.run_action(:put)
+      end
+
+      it "should run a PUT request with the message as the payload" do
+        @rest.should_receive(:run_request).with(:PUT, @rest.create_url, {}, @new_resource.message, 10, false)
+        @provider.run_action(:put)
+      end
+
+      it "should inflate a message block at runtime" do
+        @new_resource.stub!(:message).and_return(lambda { "return" })
+        @rest.should_receive(:run_request).with(:PUT, @rest.create_url, {}, "return", 10, false)    
+        @provider.run_action(:put)
+      end
+
+      it "should update the resource" do
+        @provider.run_action(:put)
+        @new_resource.should be_updated
+      end
+    end
+
+    describe "action_post" do  
+      it "should create the url" do
+        @rest.should_receive(:create_url).with("#{@new_resource.url}")
+        @provider.run_action(:post)
+      end
+  
+      it "should run a PUT request with the message as the payload" do
+        @rest.should_receive(:run_request).with(:POST, @rest.create_url, {}, @new_resource.message, 10, false)
+        @provider.run_action(:post)
+      end
+  
+      it "should inflate a message block at runtime" do
+        @new_resource.stub!(:message).and_return(lambda { "return" })
+        @rest.should_receive(:run_request).with(:POST, @rest.create_url, {}, "return", 10, false)    
+        @provider.run_action(:post)
+      end
+  
+      it "should update the resource" do
+        @provider.run_action(:post)
+        @new_resource.should be_updated
+      end
+    end
+
+    describe "action_delete" do  
+      it "should create the url" do
+        @rest.should_receive(:create_url).with("#{@new_resource.url}")
+        @provider.run_action(:delete)
+      end
+
+      it "should run a DELETE request" do
+        @rest.should_receive(:run_request).with(:DELETE, @rest.create_url, {}, false, 10, false)
+        @provider.run_action(:delete)
+      end
+
+      it "should update the resource" do
+        @provider.run_action(:delete)
+        @new_resource.should be_updated
+      end
+    end
+
+    describe "action_head" do
+      before do
+        @rest = mock("Chef::REST", :create_url => "http://www.opscode.com", :run_request => true)
+        @provider.rest = @rest
+      end
+
+      it "should create the url with a message argument" do
+        @rest.should_receive(:create_url).with("#{@new_resource.url}?message=#{@new_resource.message}")
+        @provider.run_action(:head)
+      end
+
+      it "should inflate a message block at runtime" do
+        @new_resource.stub!(:message).and_return(lambda { "return" })
+        @rest.should_receive(:create_url).with("#{@new_resource.url}?message=return")
+        @provider.run_action(:head)
+      end
+
+      it "should run a HEAD request" do
+        @rest.should_receive(:run_request).with(:HEAD, @rest.create_url, {}, false, 10, false)
+        @provider.run_action(:head)
+      end
+
+      it "should update the resource" do
+        @provider.run_action(:head)
+        @new_resource.should be_updated
+      end
+
+      it "should run a HEAD request with If-Modified-Since header" do
+        @new_resource.headers "If-Modified-Since" => File.mtime(__FILE__).httpdate
+        @rest.should_receive(:run_request).with(:HEAD, @rest.create_url, @new_resource.headers, false, 10, false)
+        @provider.run_action(:head)
+      end
+
+      it "doesn't call converge_by if HEAD does not return modified" do
+        @rest.should_receive(:run_request).and_return(false)
+        @provider.should_not_receive(:converge_by)
+        @provider.run_action(:head)
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/ifconfig_spec.rb b/spec/unit/provider/ifconfig_spec.rb
new file mode 100644
index 0000000000..1bf702cf6e
--- /dev/null
+++ b/spec/unit/provider/ifconfig_spec.rb
@@ -0,0 +1,213 @@
+#
+# Author:: Prajakta Purohit (prajakta@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 File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
+require 'spec_helper'
+require 'chef/exceptions'
+
+describe Chef::Provider::Ifconfig do
+  before do
+    @node = Chef::Node.new
+    @cookbook_collection = Chef::CookbookCollection.new([])
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+    #This new_resource can be called anything --> it is not the same as in ifconfig.rb
+    @new_resource = Chef::Resource::Ifconfig.new("10.0.0.1", @run_context)
+    @new_resource.mask "255.255.254.0"
+    @new_resource.metric "1"
+    @new_resource.mtu "1500"
+    @new_resource.device "eth0"
+    @provider = Chef::Provider::Ifconfig.new(@new_resource, @run_context)
+    @current_resource = Chef::Resource::Ifconfig.new("10.0.0.1", @run_context)
+
+    status = mock("Status", :exitstatus => 0)
+    @provider.instance_variable_set("@status", status)
+    @provider.current_resource = @current_resource
+    
+ end
+  describe Chef::Provider::Ifconfig, "load_current_resource" do 
+    before do 
+      status = mock("Status", :exitstatus => 1)
+      @provider.should_receive(:popen4).and_return status 
+      @provider.load_current_resource
+    end
+    it "should track state of ifconfig failure." do
+      @provider.instance_variable_get("@status").exitstatus.should_not == 0
+    end
+    it "should thrown an exception when ifconfig fails" do 
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error Chef::Exceptions::Ifconfig 
+    end
+  end
+  describe Chef::Provider::Ifconfig, "action_add" do
+
+    it "should add an interface if it does not exist" do
+      #@provider.stub!(:run_command).and_return(true)
+      @provider.stub!(:load_current_resource)
+      @current_resource.inet_addr nil
+      command = "ifconfig eth0 10.0.0.1 netmask 255.255.254.0 metric 1 mtu 1500"
+      @provider.should_receive(:run_command).with(:command => command)
+      @provider.should_receive(:generate_config)
+
+      @provider.run_action(:add)
+      @new_resource.should be_updated
+    end
+
+    it "should not add an interface if it already exists" do
+      @provider.stub!(:load_current_resource)
+      @provider.should_not_receive(:run_command)
+      @current_resource.inet_addr "10.0.0.1"
+      @provider.should_receive(:generate_config)
+
+      @provider.run_action(:add)
+      @new_resource.should_not be_updated
+    end
+
+    #We are not testing this case with the assumption that anyone writing the cookbook would not make a typo == lo
+    #it "should add a blank command if the #{@new_resource.device} == lo" do
+    #end
+  end
+
+  describe Chef::Provider::Ifconfig, "action_enable" do
+    
+    it "should enable interface if does not exist" do
+      @provider.stub!(:load_current_resource)
+      @current_resource.inet_addr nil
+      command = "ifconfig eth0 10.0.0.1 netmask 255.255.254.0 metric 1 mtu 1500"
+      @provider.should_receive(:run_command).with(:command => command)
+      @provider.should_not_receive(:generate_config)
+
+      @provider.run_action(:enable)
+      @new_resource.should be_updated
+    end
+
+    it "should not enable interface if it already exists" do
+      @provider.stub!(:load_current_resource)
+      @provider.should_not_receive(:run_command)
+      @current_resource.inet_addr "10.0.0.1"
+      @provider.should_not_receive(:generate_config)
+
+      @provider.run_action(:enable)
+      @new_resource.should_not be_updated
+    end
+  end
+
+  describe Chef::Provider::Ifconfig, "action_delete" do
+
+    it "should delete interface if it exists" do
+      @provider.stub!(:load_current_resource)
+      @current_resource.device "eth0"
+      command = "ifconfig #{@new_resource.device} down"
+      @provider.should_receive(:run_command).with(:command => command)
+      @provider.should_receive(:delete_config)
+
+      @provider.run_action(:delete)
+      @new_resource.should be_updated
+    end
+
+    it "should not delete interface if it does not exist" do
+      @provider.stub!(:load_current_resource)
+      @provider.should_not_receive(:run_command)
+      @provider.should_not_receive(:delete_config)
+
+      @provider.run_action(:delete)
+      @new_resource.should_not be_updated
+    end
+  end
+  
+  describe Chef::Provider::Ifconfig, "action_disable" do
+
+    it "should disable interface if it exists" do
+      @provider.stub!(:load_current_resource)
+      @current_resource.device "eth0"
+      command = "ifconfig #{@new_resource.device} down"
+      @provider.should_receive(:run_command).with(:command => command)
+      @provider.should_not_receive(:delete_config)
+
+      @provider.run_action(:disable)
+      @new_resource.should be_updated
+    end
+
+    it "should not delete interface if it does not exist" do
+      @provider.stub!(:load_current_resource)
+      @provider.should_not_receive(:run_command)
+      @provider.should_not_receive(:delete_config)
+
+      @provider.run_action(:disable)
+      @new_resource.should_not be_updated
+    end
+  end
+
+  describe Chef::Provider::Ifconfig, "action_delete" do
+
+    it "should delete interface of it exists" do
+      @provider.stub!(:load_current_resource)
+      @current_resource.device "eth0"
+      command = "ifconfig #{@new_resource.device} down"
+      @provider.should_receive(:run_command).with(:command => command)
+      @provider.should_receive(:delete_config)
+
+      @provider.run_action(:delete)
+      @new_resource.should be_updated
+    end
+
+    it "should not delete interface if it does not exist" do
+      # This is so that our fake values do not get overwritten
+      @provider.stub!(:load_current_resource)
+      # This is so that nothing actually runs
+      @provider.should_not_receive(:run_command)
+      @provider.should_not_receive(:delete_config)
+
+      @provider.run_action(:delete)
+      @new_resource.should_not be_updated
+    end
+  end
+  
+  describe Chef::Provider::Ifconfig, "generate_config for action_add" do
+   #%w[ centos redhat fedora ].each do |platform|
+     
+     it "should write network-script for centos" do
+      @provider.stub!(:load_current_resource)
+      @node.automatic_attrs[:platform] = "centos"
+      @provider.stub!(:run_command)
+      config_filename = "/etc/sysconfig/network-scripts/ifcfg-#{@new_resource.device}"
+      config_file = StringIO.new
+      File.should_receive(:new).with(config_filename, "w").and_return(config_file)
+
+      @provider.run_action(:add)
+      config_file.string.should match(/^\s*DEVICE=eth0\s*$/)
+      config_file.string.should match(/^\s*IPADDR=10.0.0.1\s*$/)
+      config_file.string.should match(/^\s*NETMASK=255.255.254.0\s*$/)
+     end
+  end
+
+  describe Chef::Provider::Ifconfig, "delete_config for action_delete" do
+
+    it "should delete network-script if it exists for centos" do
+      @node.automatic_attrs[:platform] = "centos"
+      @current_resource.device "eth0"
+      @provider.stub!(:load_current_resource)
+      @provider.stub!(:run_command)
+      config_filename =  "/etc/sysconfig/network-scripts/ifcfg-#{@new_resource.device}"
+      File.should_receive(:exist?).with(config_filename).and_return(true)
+      FileUtils.should_receive(:rm_f).with(config_filename, :verbose => false)
+
+      @provider.run_action(:delete)
+    end
+  end
+end
diff --git a/spec/unit/provider/link_spec.rb b/spec/unit/provider/link_spec.rb
new file mode 100644
index 0000000000..bb3f01abbe
--- /dev/null
+++ b/spec/unit/provider/link_spec.rb
@@ -0,0 +1,252 @@
+#
+# Author:: AJ Christensen (<aj@junglist.gen.nz>)
+# Author:: John Keiser (<jkeiser@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 'ostruct'
+
+require 'spec_helper'
+
+if Chef::Platform.windows?
+  require 'chef/win32/file' #probably need this in spec_helper
+end
+
+describe Chef::Resource::Link do
+  let(:provider) do
+    node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    run_context = Chef::RunContext.new(node, {}, @events)
+    Chef::Provider::Link.new(new_resource, run_context)
+  end
+  let(:new_resource) do
+    result = Chef::Resource::Link.new("#{CHEF_SPEC_DATA}/fofile-link")
+    result.to "#{CHEF_SPEC_DATA}/fofile"
+    result
+  end
+
+  def canonicalize(path)
+    Chef::Platform.windows? ? path.gsub('/', '\\') : path
+  end
+
+  describe "when the target is a symlink" do
+    before(:each) do
+      lstat = mock("stats", :ino => 5)
+      lstat.stub!(:uid).and_return(501)
+      lstat.stub!(:gid).and_return(501)
+      lstat.stub!(:mode).and_return(0777)
+      File.stub!(:lstat).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(lstat)
+      provider.file_class.stub!(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
+      provider.file_class.stub!(:readlink).with("#{CHEF_SPEC_DATA}/fofile-link").and_return("#{CHEF_SPEC_DATA}/fofile")
+    end
+
+    describe "to a file that exists" do
+      before do
+        File.stub(:exist?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
+        new_resource.owner 501 # only loaded in current_resource if present in new
+        new_resource.group 501
+        provider.load_current_resource
+      end
+
+      it "should set the symlink target" do
+        provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+      end
+      it "should set the link type" do
+        provider.current_resource.link_type.should == :symbolic
+      end
+      it "should update the source of the existing link with the links target" do
+        provider.current_resource.to.should == canonicalize("#{CHEF_SPEC_DATA}/fofile")
+      end
+      it "should set the owner" do
+        provider.current_resource.owner.should == 501
+      end
+      it "should set the group" do
+        provider.current_resource.group.should == 501
+      end
+
+      # We test create in unit tests because there is no other way to ensure
+      # it does no work.  Other create and delete scenarios are covered in
+      # the functional tests for links.
+      context 'when the desired state is identical' do
+        let(:new_resource) do
+          result = Chef::Resource::Link.new("#{CHEF_SPEC_DATA}/fofile-link")
+          result.to "#{CHEF_SPEC_DATA}/fofile"
+          result
+        end
+        it 'create does no work' do
+          provider.access_controls.should_not_receive(:set_all)
+          provider.run_action(:create)
+        end
+      end
+    end
+
+    describe "to a file that doesn't exist" do
+      before do
+        File.stub!(:exist?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
+        provider.file_class.stub!(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
+        provider.file_class.stub!(:readlink).with("#{CHEF_SPEC_DATA}/fofile-link").and_return("#{CHEF_SPEC_DATA}/fofile")
+        new_resource.owner "501" # only loaded in current_resource if present in new
+        new_resource.group "501"
+        provider.load_current_resource
+      end
+
+      it "should set the symlink target" do
+        provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+      end
+      it "should set the link type" do
+        provider.current_resource.link_type.should == :symbolic
+      end
+      it "should update the source of the existing link to the link's target" do
+        provider.current_resource.to.should == canonicalize("#{CHEF_SPEC_DATA}/fofile")
+      end
+      it "should not set the owner" do
+        provider.current_resource.owner.should be_nil
+      end
+      it "should not set the group" do
+        provider.current_resource.group.should be_nil
+      end
+    end
+  end
+
+  describe "when the target doesn't exist" do
+    before do
+      File.stub!(:exists?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
+      provider.file_class.stub!(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
+      provider.load_current_resource
+    end
+
+    it "should set the symlink target" do
+      provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+    end
+    it "should update the source of the existing link to nil" do
+      provider.current_resource.to.should be_nil
+    end
+    it "should not set the owner" do
+      provider.current_resource.owner.should == nil
+    end
+    it "should not set the group" do
+      provider.current_resource.group.should == nil
+    end
+  end
+
+  describe "when the target is a regular old file" do
+    before do
+      stat = mock("stats", :ino => 5)
+      stat.stub!(:uid).and_return(501)
+      stat.stub!(:gid).and_return(501)
+      stat.stub!(:mode).and_return(0755)
+      provider.file_class.stub!(:stat).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(stat)
+
+      File.stub!(:exists?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
+      provider.file_class.stub!(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
+    end
+
+    describe "and the source does not exist" do
+      before do
+        File.stub!(:exists?).with("#{CHEF_SPEC_DATA}/fofile").and_return(false)
+        provider.load_current_resource
+      end
+
+      it "should set the symlink target" do
+        provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+      end
+      it "should update the current source of the existing link with an empty string" do
+        provider.current_resource.to.should == ''
+      end
+      it "should not set the owner" do
+        provider.current_resource.owner.should == nil
+      end
+      it "should not set the group" do
+        provider.current_resource.group.should == nil
+      end
+    end
+
+    describe "and the source exists" do
+      before do
+        stat = mock("stats", :ino => 6)
+        stat.stub!(:uid).and_return(502)
+        stat.stub!(:gid).and_return(502)
+        stat.stub!(:mode).and_return(0644)
+
+        provider.file_class.stub!(:stat).with("#{CHEF_SPEC_DATA}/fofile").and_return(stat)
+
+        File.stub!(:exists?).with("#{CHEF_SPEC_DATA}/fofile").and_return(true)
+        provider.load_current_resource
+      end
+
+      it "should set the symlink target" do
+        provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+      end
+      it "should update the current source of the existing link with an empty string" do
+        provider.current_resource.to.should == ''
+      end
+      it "should not set the owner" do
+        provider.current_resource.owner.should == nil
+      end
+      it "should not set the group" do
+        provider.current_resource.group.should == nil
+      end
+    end
+
+    describe "and is hardlinked to the source" do
+      before do
+        stat = mock("stats", :ino => 5)
+        stat.stub!(:uid).and_return(502)
+        stat.stub!(:gid).and_return(502)
+        stat.stub!(:mode).and_return(0644)
+
+        provider.file_class.stub!(:stat).with("#{CHEF_SPEC_DATA}/fofile").and_return(stat)
+
+        File.stub!(:exists?).with("#{CHEF_SPEC_DATA}/fofile").and_return(true)
+        provider.load_current_resource
+      end
+
+      it "should set the symlink target" do
+        provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+      end
+      it "should set the link type" do
+        provider.current_resource.link_type.should == :hard
+      end
+      it "should update the source of the existing link to the link's target" do
+        provider.current_resource.to.should == canonicalize("#{CHEF_SPEC_DATA}/fofile")
+      end
+      it "should not set the owner" do
+        provider.current_resource.owner.should == nil
+      end
+      it "should not set the group" do
+        provider.current_resource.group.should == nil
+      end
+
+      # We test create in unit tests because there is no other way to ensure
+      # it does no work.  Other create and delete scenarios are covered in
+      # the functional tests for links.
+      context 'when the desired state is identical' do
+        let(:new_resource) do
+          result = Chef::Resource::Link.new("#{CHEF_SPEC_DATA}/fofile-link")
+          result.to "#{CHEF_SPEC_DATA}/fofile"
+          result.link_type :hard
+          result
+        end
+        it 'create does no work' do
+          provider.file_class.should_not_receive(:symlink) 
+          provider.file_class.should_not_receive(:link) 
+          provider.access_controls.should_not_receive(:set_all)
+          provider.run_action(:create)
+        end
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/log_spec.rb b/spec/unit/provider/log_spec.rb
new file mode 100644
index 0000000000..fe3733240a
--- /dev/null
+++ b/spec/unit/provider/log_spec.rb
@@ -0,0 +1,81 @@
+#
+# Author:: Cary Penniman (<cary@rightscale.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 'spec_helper'
+
+describe Chef::Provider::Log::ChefLog do
+
+  before(:each) do
+    @log_str = "this is my test string to log"
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+  end  
+
+  it "should be registered with the default platform hash" do
+    Chef::Platform.platforms[:default][:log].should_not be_nil
+  end
+
+  it "should write the string to the Chef::Log object at default level (info)" do
+      @new_resource = Chef::Resource::Log.new(@log_str)
+      @provider = Chef::Provider::Log::ChefLog.new(@new_resource, @run_context)
+      Chef::Log.should_receive(:info).with(@log_str).and_return(true)
+      @provider.action_write
+  end
+  
+  it "should write the string to the Chef::Log object at debug level" do
+      @new_resource = Chef::Resource::Log.new(@log_str)
+      @new_resource.level :debug
+      @provider = Chef::Provider::Log::ChefLog.new(@new_resource, @run_context)
+      Chef::Log.should_receive(:debug).with(@log_str).and_return(true)
+      @provider.action_write
+  end
+
+  it "should write the string to the Chef::Log object at info level" do
+      @new_resource = Chef::Resource::Log.new(@log_str)
+      @new_resource.level :info
+      @provider = Chef::Provider::Log::ChefLog.new(@new_resource, @run_context)
+      Chef::Log.should_receive(:info).with(@log_str).and_return(true)
+      @provider.action_write
+  end
+  
+  it "should write the string to the Chef::Log object at warn level" do
+      @new_resource = Chef::Resource::Log.new(@log_str)
+      @new_resource.level :warn
+      @provider = Chef::Provider::Log::ChefLog.new(@new_resource, @run_context)
+      Chef::Log.should_receive(:warn).with(@log_str).and_return(true)
+      @provider.action_write
+  end
+  
+  it "should write the string to the Chef::Log object at error level" do
+      @new_resource = Chef::Resource::Log.new(@log_str)
+      @new_resource.level :error
+      @provider = Chef::Provider::Log::ChefLog.new(@new_resource, @run_context)
+      Chef::Log.should_receive(:error).with(@log_str).and_return(true)
+      @provider.action_write
+  end
+  
+  it "should write the string to the Chef::Log object at fatal level" do
+      @new_resource = Chef::Resource::Log.new(@log_str)
+      @new_resource.level :fatal
+      @provider = Chef::Provider::Log::ChefLog.new(@new_resource, @run_context)
+      Chef::Log.should_receive(:fatal).with(@log_str).and_return(true)
+      @provider.action_write
+  end
+  
+end
diff --git a/spec/unit/provider/mdadm_spec.rb b/spec/unit/provider/mdadm_spec.rb
new file mode 100644
index 0000000000..a818c37101
--- /dev/null
+++ b/spec/unit/provider/mdadm_spec.rb
@@ -0,0 +1,128 @@
+#
+# Author:: Joe Williams (<joe@joetify.com>)
+# Copyright:: Copyright (c) 2009 Joe Williams
+# 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 'ostruct'
+
+describe Chef::Provider::Mdadm do
+
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Mdadm.new('/dev/md1')
+    @new_resource.devices ["/dev/sdz1","/dev/sdz2"]
+    @new_resource.level   1
+    @new_resource.chunk   256
+
+    @provider = Chef::Provider::Mdadm.new(@new_resource, @run_context)
+  end
+
+  describe "when determining the current metadevice status" do
+    it "should set the current resources mount point to the new resources mount point" do
+      @provider.stub!(:shell_out!).and_return(OpenStruct.new(:status => 0))
+      @provider.load_current_resource
+      @provider.current_resource.name.should == '/dev/md1'
+      @provider.current_resource.raid_device.should == '/dev/md1'
+    end
+
+    it "determines that the metadevice exists when mdadm exit code is zero" do
+      @provider.stub!(:shell_out!).with("mdadm --detail --test /dev/md1", :returns => [0,4]).and_return(OpenStruct.new(:status => 0))
+      @provider.load_current_resource
+      @provider.current_resource.exists.should be_true
+    end
+
+    it "determines that the metadevice does not exist when mdadm exit code is 4" do
+      @provider.stub!(:shell_out!).with("mdadm --detail --test /dev/md1", :returns => [0,4]).and_return(OpenStruct.new(:status => 4))
+      @provider.load_current_resource
+      @provider.current_resource.exists.should be_false
+    end
+  end
+
+  describe "after the metadevice status is known" do
+    before(:each) do
+      @current_resource = Chef::Resource::Mdadm.new('/dev/md1')
+      @current_resource.devices ["/dev/sdz1","/dev/sdz2"]
+      @current_resource.level   1
+      @current_resource.chunk   256
+      @provider.stub!(:load_current_resource).and_return(true)
+      @provider.current_resource = @current_resource
+    end
+
+    describe "when creating the metadevice" do
+      it "should create the raid device if it doesnt exist" do
+        @current_resource.exists(false)
+        expected_command = "yes | mdadm --create /dev/md1 --chunk=256 --level 1 --metadata=0.90 --raid-devices 2 /dev/sdz1 /dev/sdz2"
+        @provider.should_receive(:shell_out!).with(expected_command)
+        @provider.run_action(:create)
+      end
+
+      it "should specify a bitmap only if set" do
+        @current_resource.exists(false)
+        @new_resource.bitmap('grow')
+        expected_command = "yes | mdadm --create /dev/md1 --chunk=256 --level 1 --metadata=0.90 --bitmap=grow --raid-devices 2 /dev/sdz1 /dev/sdz2"
+        @provider.should_receive(:shell_out!).with(expected_command)
+        @provider.run_action(:create)
+        @new_resource.should be_updated_by_last_action
+      end
+
+      it "should not create the raid device if it does exist" do
+        @current_resource.exists(true)
+        @provider.should_not_receive(:shell_out!)
+        @provider.run_action(:create)
+        @new_resource.should_not be_updated_by_last_action
+      end
+    end
+
+    describe "when asembling the metadevice" do
+      it "should assemble the raid device if it doesnt exist" do
+        @current_resource.exists(false)
+        expected_mdadm_cmd = "yes | mdadm --assemble /dev/md1 /dev/sdz1 /dev/sdz2"
+        @provider.should_receive(:shell_out!).with(expected_mdadm_cmd)
+        @provider.run_action(:assemble)
+        @new_resource.should be_updated_by_last_action
+      end
+
+        it "should not assemble the raid device if it doesnt exist" do
+        @current_resource.exists(true)
+        @provider.should_not_receive(:shell_out!)
+        @provider.run_action(:assemble)
+        @new_resource.should_not be_updated_by_last_action
+      end
+    end
+
+    describe "when stopping the metadevice" do
+
+      it "should stop the raid device if it exists" do
+        @current_resource.exists(true)
+        expected_mdadm_cmd = "yes | mdadm --stop /dev/md1"
+        @provider.should_receive(:shell_out!).with(expected_mdadm_cmd)
+        @provider.run_action(:stop)
+        @new_resource.should be_updated_by_last_action
+      end
+
+      it "should not attempt to stop the raid device if it does not exist" do
+        @current_resource.exists(false)
+        @provider.should_not_receive(:shell_out!)
+        @provider.run_action(:stop)
+        @new_resource.should_not be_updated_by_last_action
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/mount/mount_spec.rb b/spec/unit/provider/mount/mount_spec.rb
new file mode 100644
index 0000000000..c497a08e40
--- /dev/null
+++ b/spec/unit/provider/mount/mount_spec.rb
@@ -0,0 +1,398 @@
+#
+# Author:: Joshua Timberman (<joshua@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 'spec_helper'
+require 'ostruct'
+
+describe Chef::Provider::Mount::Mount do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Mount.new("/tmp/foo")
+    @new_resource.device      "/dev/sdz1"
+    @new_resource.device_type :device
+    @new_resource.fstype      "ext3"
+
+    @new_resource.supports :remount => false
+
+    @provider = Chef::Provider::Mount::Mount.new(@new_resource, @run_context)
+
+    ::File.stub!(:exists?).with("/dev/sdz1").and_return true
+    ::File.stub!(:exists?).with("/tmp/foo").and_return true
+  end
+
+  describe "when discovering the current fs state" do
+    before do
+      @provider.stub!(:shell_out!).and_return(OpenStruct.new(:stdout => ''))
+      ::File.stub!(:foreach).with("/etc/fstab")
+    end
+
+    it "should create a current resource with the same mount point and device" do
+      @provider.load_current_resource
+      @provider.current_resource.name.should == '/tmp/foo'
+      @provider.current_resource.mount_point.should == '/tmp/foo'
+      @provider.current_resource.device.should == '/dev/sdz1'
+    end
+
+    it "should accecpt device_type :uuid" do
+      @new_resource.device_type :uuid
+      @new_resource.device "d21afe51-a0fe-4dc6-9152-ac733763ae0a"
+      @stdout_findfs = mock("STDOUT", :first => "/dev/sdz1")
+      @provider.should_receive(:popen4).with("/sbin/findfs UUID=d21afe51-a0fe-4dc6-9152-ac733763ae0a").and_yield(@pid,@stdin,@stdout_findfs,@stderr).and_return(@status)
+      @provider.load_current_resource()
+      @provider.mountable?
+    end
+
+    describe "when dealing with network mounts" do
+      { "nfs" => "nfsserver:/vol/path",
+        "cifs" => "//cifsserver/share" }.each do |type, fs_spec|
+        it "should detect network fs_spec (#{type})" do
+          @new_resource.device fs_spec
+          @provider.network_device?.should be_true
+        end
+
+        it "should ignore trailing slash and set mounted to true for network mount (#{type})" do
+          @new_resource.device fs_spec
+          @provider.stub!(:shell_out!).and_return(OpenStruct.new(:stdout => "#{fs_spec}/ on /tmp/foo type #{type} (rw)\n"))
+          @provider.load_current_resource
+          @provider.current_resource.mounted.should be_true
+        end
+      end
+    end
+
+    it "should raise an error if the mount device does not exist" do
+      ::File.stub!(:exists?).with("/dev/sdz1").and_return false
+      lambda { @provider.load_current_resource();@provider.mountable? }.should raise_error(Chef::Exceptions::Mount)
+    end
+
+    it "should not call mountable? with load_current_resource - CHEF-1565" do
+      ::File.stub!(:exists?).with("/dev/sdz1").and_return false
+      @provider.should_receive(:mounted?).and_return(true)
+      @provider.should_receive(:enabled?).and_return(true)
+      @provider.should_not_receive(:mountable?)
+      @provider.load_current_resource
+    end
+
+    it "should raise an error if the mount device (uuid) does not exist" do
+      @new_resource.device_type :uuid
+      @new_resource.device "d21afe51-a0fe-4dc6-9152-ac733763ae0a"
+      status_findfs = mock("Status", :exitstatus => 1)
+      stdout_findfs = mock("STDOUT", :first => nil)
+      @provider.should_receive(:popen4).with("/sbin/findfs UUID=d21afe51-a0fe-4dc6-9152-ac733763ae0a").and_yield(@pid,@stdin,stdout_findfs,@stderr).and_return(status_findfs)
+      ::File.should_receive(:exists?).with("").and_return(false)
+      lambda { @provider.load_current_resource();@provider.mountable? }.should raise_error(Chef::Exceptions::Mount)
+    end
+
+    it "should raise an error if the mount point does not exist" do
+      ::File.stub!(:exists?).with("/tmp/foo").and_return false
+      lambda { @provider.load_current_resource();@provider.mountable? }.should raise_error(Chef::Exceptions::Mount)
+    end
+
+    it "does not expect the device to exist for tmpfs" do
+      @new_resource.fstype("tmpfs")
+      @new_resource.device("whatever")
+      lambda { @provider.load_current_resource() }.should_not raise_error
+    end
+
+    it "does not expect the device to exist for Fuse filesystems" do
+      @new_resource.fstype("fuse")
+      @new_resource.device("nilfs#xxx")
+      lambda { @provider.load_current_resource() }.should_not raise_error
+    end
+
+    it "should set mounted true if the mount point is found in the mounts list" do
+      @provider.stub!(:shell_out!).and_return(OpenStruct.new(:stdout => '/dev/sdz1 on /tmp/foo'))
+      @provider.load_current_resource()
+      @provider.current_resource.mounted.should be_true
+    end
+
+    it "should set mounted true if the symlink target of the device is found in the mounts list" do
+      target = "/dev/mapper/target"
+
+      ::File.stub!(:symlink?).with("#{@new_resource.device}").and_return(true)
+      ::File.stub!(:readlink).with("#{@new_resource.device}").and_return(target)
+
+      @provider.stub!(:shell_out!).and_return(OpenStruct.new(:stdout => "/dev/mapper/target on /tmp/foo type ext3 (rw)\n"))
+      @provider.load_current_resource()
+      @provider.current_resource.mounted.should be_true
+    end
+
+    it "should set mounted true if the mount point is found last in the mounts list" do
+      mount = "/dev/sdy1 on #{@new_resource.mount_point} type ext3 (rw)\n"
+      mount << "#{@new_resource.device} on #{@new_resource.mount_point} type ext3 (rw)\n"
+
+      @provider.stub!(:shell_out!).and_return(OpenStruct.new(:stdout => mount))
+      @provider.load_current_resource()
+      @provider.current_resource.mounted.should be_true
+    end
+
+    it "should set mounted false if the mount point is not last in the mounts list" do
+      mount = "#{@new_resource.device} on #{@new_resource.mount_point} type ext3 (rw)\n"
+      mount << "/dev/sdy1 on #{@new_resource.mount_point} type ext3 (rw)\n"
+
+      @provider.stub!(:shell_out!).and_return(OpenStruct.new(:stdout => mount))
+      @provider.load_current_resource()
+      @provider.current_resource.mounted.should be_false
+    end
+
+    it "mounted should be false if the mount point is not found in the mounts list" do
+      @provider.stub!(:shell_out!).and_return(OpenStruct.new(:stdout => "/dev/sdy1 on /tmp/foo type ext3 (rw)\n"))
+      @provider.load_current_resource()
+      @provider.current_resource.mounted.should be_false
+    end
+
+    it "should set enabled to true if the mount point is last in fstab" do
+      fstab1 = "/dev/sdy1  /tmp/foo  ext3  defaults  1 2\n"
+      fstab2 = "#{@new_resource.device} #{@new_resource.mount_point}  ext3  defaults  1 2\n"
+
+      ::File.stub!(:foreach).with("/etc/fstab").and_yield(fstab1).and_yield(fstab2)
+
+      @provider.load_current_resource
+      @provider.current_resource.enabled.should be_true
+    end
+
+    it "should set enabled to true if the mount point is not last in fstab and mount_point is a substring of another mount" do
+      fstab1 = "#{@new_resource.device} #{@new_resource.mount_point}  ext3  defaults  1 2\n"
+      fstab2 = "/dev/sdy1  /tmp/foo/bar  ext3  defaults  1 2\n"
+
+      ::File.stub!(:foreach).with("/etc/fstab").and_yield(fstab1).and_yield(fstab2)
+
+      @provider.load_current_resource
+      @provider.current_resource.enabled.should be_true
+    end
+
+    it "should set enabled to true if the symlink target is in fstab" do
+      target = "/dev/mapper/target"
+
+      ::File.stub!(:symlink?).with("#{@new_resource.device}").and_return(true)
+      ::File.stub!(:readlink).with("#{@new_resource.device}").and_return(target)
+
+      fstab = "/dev/sdz1  /tmp/foo ext3  defaults  1 2\n"
+
+      ::File.stub!(:foreach).with("/etc/fstab").and_yield fstab
+
+      @provider.load_current_resource
+      @provider.current_resource.enabled.should be_true
+    end
+
+    it "should set enabled to false if the mount point is not in fstab" do
+      fstab = "/dev/sdy1  #{@new_resource.mount_point}  ext3  defaults  1 2\n"
+      ::File.stub!(:foreach).with("/etc/fstab").and_yield fstab
+
+      @provider.load_current_resource
+      @provider.current_resource.enabled.should be_false
+    end
+
+    it "should ignore commented lines in fstab " do
+       fstab = "\# #{@new_resource.device}  #{@new_resource.mount_point}  ext3  defaults  1 2\n"
+       ::File.stub!(:foreach).with("/etc/fstab").and_yield fstab
+
+       @provider.load_current_resource
+       @provider.current_resource.enabled.should be_false
+     end
+
+    it "should set enabled to false if the mount point is not last in fstab" do
+      line_1 = "#{@new_resource.device} #{@new_resource.mount_point}  ext3  defaults  1 2\n"
+      line_2 = "/dev/sdy1 #{@new_resource.mount_point}  ext3  defaults  1 2\n"
+      ::File.stub!(:foreach).with("/etc/fstab").and_yield(line_1).and_yield(line_2)
+
+      @provider.load_current_resource
+      @provider.current_resource.enabled.should be_false
+    end
+  end
+
+  context "after the mount's state has been discovered" do
+    before do
+      @current_resource = Chef::Resource::Mount.new("/tmp/foo")
+      @current_resource.device       "/dev/sdz1"
+      @current_resource.device_type  :device
+      @current_resource.fstype       "ext3"
+
+      @provider.current_resource = @current_resource
+    end
+
+    describe "mount_fs" do
+      it "should mount the filesystem if it is not mounted" do
+        @provider.rspec_reset
+        @provider.should_receive(:shell_out!).with("mount -t ext3 -o defaults /dev/sdz1 /tmp/foo")
+        @provider.mount_fs()
+      end
+
+      it "should mount the filesystem with options if options were passed" do
+        options = "rw,noexec,noauto"
+        @new_resource.options(%w{rw noexec noauto})
+        @provider.should_receive(:shell_out!).with("mount -t ext3 -o rw,noexec,noauto /dev/sdz1 /tmp/foo")
+        @provider.mount_fs()
+      end
+
+      it "should mount the filesystem specified by uuid" do
+        @new_resource.device "d21afe51-a0fe-4dc6-9152-ac733763ae0a"
+        @new_resource.device_type :uuid
+        @stdout_findfs = mock("STDOUT", :first => "/dev/sdz1")
+        @provider.stub!(:popen4).with("/sbin/findfs UUID=d21afe51-a0fe-4dc6-9152-ac733763ae0a").and_yield(@pid,@stdin,@stdout_findfs,@stderr).and_return(@status)
+        @stdout_mock = mock('stdout mock')
+        @stdout_mock.stub!(:each).and_yield("#{@new_resource.device} on #{@new_resource.mount_point}")
+        @provider.should_receive(:shell_out!).with("mount -t #{@new_resource.fstype} -o defaults -U #{@new_resource.device} #{@new_resource.mount_point}").and_return(@stdout_mock)
+        @provider.mount_fs()
+      end
+
+      it "should not mount the filesystem if it is mounted" do
+        @current_resource.stub!(:mounted).and_return(true)
+        @provider.should_not_receive(:shell_out!)
+        @provider.mount_fs()
+      end
+
+    end
+
+    describe "umount_fs" do
+      it "should umount the filesystem if it is mounted" do
+        @current_resource.mounted(true)
+        @provider.should_receive(:shell_out!).with("umount /tmp/foo")
+        @provider.umount_fs()
+      end
+
+      it "should not umount the filesystem if it is not mounted" do
+        @current_resource.mounted(false)
+        @provider.should_not_receive(:shell_out!)
+        @provider.umount_fs()
+      end
+    end
+
+    describe "remount_fs" do
+      it "should use mount -o remount if remount is supported" do
+        @new_resource.supports({:remount => true})
+        @current_resource.mounted(true)
+        @provider.should_receive(:shell_out!).with("mount -o remount #{@new_resource.mount_point}")
+        @provider.remount_fs
+      end
+
+      it "should umount and mount if remount is not supported" do
+        @new_resource.supports({:remount => false})
+        @current_resource.mounted(true)
+        @provider.should_receive(:umount_fs)
+        @provider.should_receive(:sleep).with(1)
+        @provider.should_receive(:mount_fs)
+        @provider.remount_fs()
+      end
+
+      it "should not try to remount at all if mounted is false" do
+        @current_resource.mounted(false)
+        @provider.should_not_receive(:shell_out!)
+        @provider.should_not_receive(:umount_fs)
+        @provider.should_not_receive(:mount_fs)
+        @provider.remount_fs()
+      end
+    end
+
+    describe "when enabling the fs" do
+      it "should enable if enabled isn't true" do
+        @current_resource.enabled(false)
+
+        @fstab = StringIO.new
+        ::File.stub!(:open).with("/etc/fstab", "a").and_yield(@fstab)
+        @provider.enable_fs
+        @fstab.string.should match(%r{^/dev/sdz1\s+/tmp/foo\s+ext3\s+defaults\s+0\s+2\s*$})
+      end
+
+      it "should not enable if enabled is true and resources match" do
+        @current_resource.enabled(true)
+        @current_resource.fstype("ext3")
+        @current_resource.options(["defaults"])
+        @current_resource.dump(0)
+        @current_resource.pass(2)
+        ::File.should_not_receive(:open).with("/etc/fstab", "a")
+
+        @provider.enable_fs
+      end
+
+      it "should enable if enabled is true and resources do not match" do
+        @current_resource.enabled(true)
+        @current_resource.fstype("auto")
+        @current_resource.options(["defaults"])
+        @current_resource.dump(0)
+        @current_resource.pass(2)
+        @fstab = StringIO.new
+        ::File.stub(:readlines).and_return([])
+        ::File.should_receive(:open).once.with("/etc/fstab", "w").and_yield(@fstab)
+        ::File.should_receive(:open).once.with("/etc/fstab", "a").and_yield(@fstab)
+
+        @provider.enable_fs
+      end
+    end
+
+    describe "when disabling the fs" do
+      it "should disable if enabled is true" do
+        @current_resource.enabled(true)
+
+        other_mount = "/dev/sdy1  /tmp/foo  ext3  defaults  1 2\n"
+        this_mount = "/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n"
+
+        @fstab_read = [this_mount, other_mount]
+        ::File.stub!(:readlines).with("/etc/fstab").and_return(@fstab_read)
+        @fstab_write = StringIO.new
+        ::File.stub!(:open).with("/etc/fstab", "w").and_yield(@fstab_write)
+
+        @provider.disable_fs
+        @fstab_write.string.should match(Regexp.escape(other_mount))
+        @fstab_write.string.should_not match(Regexp.escape(this_mount))
+      end
+
+      it "should disable if enabled is true and ignore commented lines" do
+        @current_resource.enabled(true)
+
+        fstab_read = [%q{/dev/sdy1 /tmp/foo  ext3  defaults  1 2},
+                      %q{/dev/sdz1 /tmp/foo  ext3  defaults  1 2},
+                      %q{#/dev/sdz1 /tmp/foo  ext3  defaults  1 2}]
+        fstab_write = StringIO.new
+
+        ::File.stub!(:readlines).with("/etc/fstab").and_return(fstab_read)
+        ::File.stub!(:open).with("/etc/fstab", "w").and_yield(fstab_write)
+
+        @provider.disable_fs
+        fstab_write.string.should match(%r{^/dev/sdy1 /tmp/foo  ext3  defaults  1 2$})
+        fstab_write.string.should match(%r{^#/dev/sdz1 /tmp/foo  ext3  defaults  1 2$})
+        fstab_write.string.should_not match(%r{^/dev/sdz1 /tmp/foo  ext3  defaults  1 2$})
+      end
+
+      it "should disable only the last entry if enabled is true" do
+        @current_resource.stub!(:enabled).and_return(true)
+        fstab_read = ["/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n",
+                      "/dev/sdy1 /tmp/foo  ext3  defaults  1 2\n",
+                      "/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n"]
+
+        fstab_write = StringIO.new
+        ::File.stub!(:readlines).with("/etc/fstab").and_return(fstab_read)
+        ::File.stub!(:open).with("/etc/fstab", "w").and_yield(fstab_write)
+
+        @provider.disable_fs
+        fstab_write.string.should == "/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n/dev/sdy1 /tmp/foo  ext3  defaults  1 2\n"
+      end
+
+      it "should not disable if enabled is false" do
+        @current_resource.stub!(:enabled).and_return(false)
+
+        ::File.stub!(:readlines).with("/etc/fstab").and_return([])
+        ::File.should_not_receive(:open).and_yield(@fstab)
+
+        @provider.disable_fs
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/mount/windows_spec.rb b/spec/unit/provider/mount/windows_spec.rb
new file mode 100644
index 0000000000..f173ebba22
--- /dev/null
+++ b/spec/unit/provider/mount/windows_spec.rb
@@ -0,0 +1,134 @@
+#
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Copyright:: Copyright (c) 2010 VMware, 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'
+
+class Chef
+  class Util
+    class Windows
+      class NetUse
+      end
+      class Volume
+      end
+    end
+  end
+end
+
+GUID = "\\\\?\\Volume{578e72b5-6e70-11df-b5c5-000c29d4a7d9}\\"
+REMOTE = "\\\\server-name\\path"
+
+describe Chef::Provider::Mount::Windows do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Mount.new("X:")
+    @new_resource.device GUID
+    @current_resource = Chef::Resource::Mount.new("X:")
+    Chef::Resource::Mount.stub!(:new).and_return(@current_resource)
+
+    @net_use = mock("Chef::Util::Windows::NetUse")
+    Chef::Util::Windows::NetUse.stub!(:new).and_return(@net_use)
+    @vol = mock("Chef::Util::Windows::Volume")
+    Chef::Util::Windows::Volume.stub!(:new).and_return(@vol)
+
+    @provider = Chef::Provider::Mount::Windows.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+
+  describe "when loading the current resource" do
+    it "should set mounted true if the mount point is found" do
+      @vol.stub!(:device).and_return(@new_resource.device)
+      @current_resource.should_receive(:mounted).with(true)
+      @provider.load_current_resource
+    end
+
+    it "should set mounted false if the mount point is not found" do
+      @vol.stub!(:device).and_raise(ArgumentError)
+      @current_resource.should_receive(:mounted).with(false)
+      @provider.load_current_resource
+    end
+
+    describe "with a local device" do
+      before do
+        @new_resource.device GUID
+        @vol.stub!(:device).and_return(@new_resource.device)
+        @net_use.stub!(:device).and_raise(ArgumentError)
+      end
+
+      it "should determine the device is a volume GUID" do
+        @provider.should_receive(:is_volume).with(@new_resource.device).and_return(true)
+        @provider.load_current_resource
+      end
+    end
+
+    describe "with a remote device" do
+      before do
+        @new_resource.device REMOTE
+        @net_use.stub!(:device).and_return(@new_resource.device)
+        @vol.stub!(:device).and_raise(ArgumentError)
+      end
+
+      it "should determine the device is remote" do
+        @provider.should_receive(:is_volume).with(@new_resource.device).and_return(false)
+        @provider.load_current_resource
+      end
+    end
+
+    describe "when mounting a file system" do
+      before do
+        @new_resource.device GUID
+        @vol.stub!(:add)
+        @vol.stub!(:device).and_raise(ArgumentError)
+        @provider.load_current_resource
+      end
+
+      it "should mount the filesystem if it is not mounted" do
+        @vol.should_receive(:add).with(@new_resource.device)
+        @provider.mount_fs
+      end
+
+      it "should not mount the filesystem if it is mounted" do
+        @vol.should_not_receive(:add)
+        @current_resource.stub!(:mounted).and_return(true)
+        @provider.mount_fs
+      end
+    end
+
+    describe "when unmounting a file system" do
+      before do
+        @new_resource.device GUID
+        @vol.stub!(:delete)
+        @vol.stub!(:device).and_raise(ArgumentError)
+        @provider.load_current_resource
+      end
+
+      it "should umount the filesystem if it is mounted" do
+        @current_resource.stub!(:mounted).and_return(true)
+        @vol.should_receive(:delete)
+        @provider.umount_fs
+      end
+
+      it "should not umount the filesystem if it is not mounted" do
+        @current_resource.stub!(:mounted).and_return(false)
+        @vol.should_not_receive(:delete)
+        @provider.umount_fs
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/mount_spec.rb b/spec/unit/provider/mount_spec.rb
new file mode 100644
index 0000000000..921bde4cc9
--- /dev/null
+++ b/spec/unit/provider/mount_spec.rb
@@ -0,0 +1,160 @@
+#
+# Author:: Joshua Timberman (<joshua@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 'spec_helper'
+
+describe Chef::Provider::Mount do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    
+    @new_resource = Chef::Resource::Mount.new('/tmp/foo')
+    @new_resource.device      "/dev/sdz1"
+    @new_resource.name        "/tmp/foo"
+    @new_resource.mount_point "/tmp/foo"
+    @new_resource.fstype      "ext3"
+    
+    @current_resource = Chef::Resource::Mount.new('/tmp/foo')
+    @current_resource.device      "/dev/sdz1"
+    @current_resource.name        "/tmp/foo"
+    @current_resource.mount_point "/tmp/foo"
+    @current_resource.fstype      "ext3"
+
+    @provider = Chef::Provider::Mount.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+  
+  describe "when the target state is a mounted filesystem" do
+
+    it "should mount the filesystem if it isn't mounted" do
+      @current_resource.stub!(:mounted).and_return(false)
+      @provider.should_receive(:mount_fs).with.and_return(true)
+      @provider.run_action(:mount)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should not mount the filesystem if it is mounted" do
+      @current_resource.stub!(:mounted).and_return(true)
+      @provider.should_not_receive(:mount_fs).and_return(true)
+      @provider.run_action(:mount)
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+  end
+
+  describe "when the target state is an unmounted filesystem" do
+    it "should umount the filesystem if it is mounted" do
+      @current_resource.stub!(:mounted).and_return(true)
+      @provider.should_receive(:umount_fs).with.and_return(true)
+      @provider.run_action(:umount)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should not umount the filesystem if it is not mounted" do
+      @current_resource.stub!(:mounted).and_return(false)
+      @provider.should_not_receive(:umount_fs).and_return(true)
+      @provider.run_action(:umount)
+      @new_resource.should_not be_updated_by_last_action
+    end
+  end
+
+  describe "when the filesystem should be remounted and the resource supports remounting" do
+    before do
+      @new_resource.supports[:remount] = true
+    end
+    
+    it "should remount the filesystem if it is mounted" do
+      @current_resource.stub!(:mounted).and_return(true)
+      @provider.should_receive(:remount_fs).and_return(true)
+      @provider.run_action(:remount)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should not remount the filesystem if it is not mounted" do
+      @current_resource.stub!(:mounted).and_return(false)
+      @provider.should_not_receive(:remount_fs)
+      @provider.run_action(:remount)
+      @new_resource.should_not be_updated_by_last_action
+    end
+  end
+  describe "when the filesystem should be remounted and the resource does not support remounting" do 
+    before do 
+      @new_resource.supports[:remount] = false
+    end
+
+    it "should fail to remount the filesystem" do
+      @provider.should_not_receive(:remount_fs)
+      lambda {@provider.run_action(:remount)}.should raise_error(Chef::Exceptions::UnsupportedAction)
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+  end
+  describe "when enabling the filesystem to be mounted" do
+    it "should enable the mount if it isn't enable" do
+      @current_resource.stub!(:enabled).and_return(false)
+      @provider.should_receive(:enable_fs).with.and_return(true)
+      @provider.run_action(:enable)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should not enable the mount if it is enabled" do
+      @current_resource.stub!(:enabled).and_return(true)
+      @provider.should_not_receive(:enable_fs).with.and_return(true)
+      @provider.run_action(:enable)
+      @new_resource.should_not be_updated_by_last_action
+    end
+  end
+
+  describe "when the target state is to disable the mount" do
+    it "should disable the mount if it is enabled" do
+      @current_resource.stub!(:enabled).and_return(true)
+      @provider.should_receive(:disable_fs).with.and_return(true)
+      @provider.run_action(:disable)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should not disable the mount if it isn't enabled" do
+      @current_resource.stub!(:enabled).and_return(false)
+      @provider.should_not_receive(:disable_fs).with.and_return(true)
+      @provider.run_action(:disable)
+      @new_resource.should_not be_updated_by_last_action
+    end
+  end
+
+
+  it "should delegates the mount implementation to subclasses" do
+    lambda { @provider.mount_fs }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+
+  it "should delegates the umount implementation to subclasses" do
+    lambda { @provider.umount_fs }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+
+  it "should delegates the remount implementation to subclasses" do
+    lambda { @provider.remount_fs }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+
+  it "should delegates the enable implementation to subclasses" do
+    lambda { @provider.enable_fs }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+
+  it "should delegates the disable implementation to subclasses" do
+    lambda { @provider.disable_fs }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+end
diff --git a/spec/unit/provider/ohai_spec.rb b/spec/unit/provider/ohai_spec.rb
new file mode 100644
index 0000000000..8402c92e97
--- /dev/null
+++ b/spec/unit/provider/ohai_spec.rb
@@ -0,0 +1,85 @@
+#
+# Author:: Michael Leinartas (<mleinartas@gmail.com>)
+# Copyright:: Copyright (c) 2010 Michael Leinartas
+# 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 'chef/run_context'
+
+describe Chef::Provider::Ohai do
+  before(:each) do
+    # Copied from client_spec
+    @fqdn = "hostname.domainname"
+    @hostname = "hostname"
+    @platform = "example-platform"
+    @platform_version = "example-platform"
+    Chef::Config[:node_name] = @fqdn
+    mock_ohai = {
+      :fqdn => @fqdn,
+      :hostname => @hostname,
+      :platform => @platform,
+      :platform_version => @platform_version,
+      :data => {
+        :origdata => "somevalue"
+      },
+      :data2 => {
+        :origdata => "somevalue",
+        :newdata => "somevalue"
+      }
+    }
+    mock_ohai.stub!(:all_plugins).and_return(true)
+    mock_ohai.stub!(:require_plugin).and_return(true)
+    mock_ohai.stub!(:data).and_return(mock_ohai[:data],
+                                      mock_ohai[:data2])
+    Ohai::System.stub!(:new).and_return(mock_ohai)
+    Chef::Platform.stub!(:find_platform_and_version).and_return({ "platform" => @platform,
+                                                                  "platform_version" => @platform_version})
+    # Fake node with a dummy save
+    @node = Chef::Node.new
+    @node.name(@fqdn)
+    @node.stub!(:save).and_return(@node)
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Ohai.new("ohai_reload")
+    ohai = Ohai::System.new
+    ohai.all_plugins
+    @node.consume_external_attrs(ohai.data,{})
+
+    @provider = Chef::Provider::Ohai.new(@new_resource, @run_context)
+  end
+
+  describe "when reloading ohai" do
+    before do
+      @node.automatic_attrs[:origdata] = 'somevalue'
+    end
+
+    it "applies updated ohai data to the node" do
+      @node[:origdata].should == 'somevalue'
+      @node[:newdata].should be_nil
+      @provider.run_action(:reload)
+      @node[:origdata].should == 'somevalue'
+      @node[:newdata].should == 'somevalue'
+    end
+
+    it "should reload a specific plugin and cause node to pick up new values" do
+      @new_resource.plugin "someplugin"
+      @provider.run_action(:reload)
+      @node[:origdata].should == 'somevalue'
+      @node[:newdata].should == 'somevalue'
+    end
+  end
+end
diff --git a/spec/unit/provider/package/apt_spec.rb b/spec/unit/provider/package/apt_spec.rb
new file mode 100644
index 0000000000..06ada5189e
--- /dev/null
+++ b/spec/unit/provider/package/apt_spec.rb
@@ -0,0 +1,351 @@
+#
+# 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 'spec_helper'
+require 'ostruct'
+
+describe Chef::Provider::Package::Apt do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Package.new("irssi", @run_context)
+    @current_resource = Chef::Resource::Package.new("irssi", @run_context)
+
+    @status = mock("Status", :exitstatus => 0)
+    @provider = Chef::Provider::Package::Apt.new(@new_resource, @run_context)
+    Chef::Resource::Package.stub!(:new).and_return(@current_resource)
+    @stdin = StringIO.new
+    @stdout =<<-PKG_STATUS
+irssi:
+  Installed: (none)
+  Candidate: 0.8.14-1ubuntu4
+  Version table:
+     0.8.14-1ubuntu4 0
+        500 http://us.archive.ubuntu.com/ubuntu/ lucid/main Packages
+PKG_STATUS
+    @stderr = StringIO.new
+    @pid = 12345
+    @shell_out = OpenStruct.new(:stdout => @stdout,:stdin => @stdin,:stderr => @stderr,:status => @status,:exitstatus => 0)
+  end
+
+  describe "when loading current resource" do
+
+    it "should create a current resource with the name of the new_resource" do
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      Chef::Resource::Package.should_receive(:new).and_return(@current_resource)
+      @provider.load_current_resource
+    end
+
+    it "should set the current resources package name to the new resources package name" do
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      @current_resource.should_receive(:package_name).with(@new_resource.package_name)
+      @provider.load_current_resource
+    end
+
+    it "should run apt-cache policy with the package name" do
+      @provider.should_receive(:shell_out!).with("apt-cache policy #{@new_resource.package_name}").and_return(@shell_out)
+      @provider.load_current_resource
+    end
+
+    it "should set the installed version to nil on the current resource if package state is not installed" do
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      @current_resource.should_receive(:version).with(nil).and_return(true)
+      @provider.load_current_resource
+    end
+
+    it "should set the installed version if package has one" do
+      @stdout.replace(<<-INSTALLED)
+sudo:
+  Installed: 1.7.2p1-1ubuntu5.3
+  Candidate: 1.7.2p1-1ubuntu5.3
+  Version table:
+ *** 1.7.2p1-1ubuntu5.3 0
+        500 http://us.archive.ubuntu.com/ubuntu/ lucid-updates/main Packages
+        500 http://security.ubuntu.com/ubuntu/ lucid-security/main Packages
+        100 /var/lib/dpkg/status
+     1.7.2p1-1ubuntu5 0
+        500 http://us.archive.ubuntu.com/ubuntu/ lucid/main Packages
+INSTALLED
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      @provider.load_current_resource
+      @current_resource.version.should == "1.7.2p1-1ubuntu5.3"
+      @provider.candidate_version.should eql("1.7.2p1-1ubuntu5.3")
+    end
+
+    it "should return the current resouce" do
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      @provider.load_current_resource.should eql(@current_resource)
+    end
+
+    # libmysqlclient-dev is a real package in newer versions of debian + ubuntu
+    # list of virtual packages: http://www.debian.org/doc/packaging-manuals/virtual-package-names-list.txt
+    it "should not install the virtual package there is a single provider package and it is installed" do
+      @new_resource.package_name("libmysqlclient15-dev")
+      virtual_package_out=<<-VPKG_STDOUT
+libmysqlclient15-dev:
+  Installed: (none)
+  Candidate: (none)
+  Version table:
+VPKG_STDOUT
+      virtual_package = mock(:stdout => virtual_package_out,:exitstatus => 0)
+      @provider.should_receive(:shell_out!).with("apt-cache policy libmysqlclient15-dev").and_return(virtual_package)
+      showpkg_out =<<-SHOWPKG_STDOUT
+Package: libmysqlclient15-dev
+Versions: 
+
+Reverse Depends: 
+  libmysqlclient-dev,libmysqlclient15-dev
+  libmysqlclient-dev,libmysqlclient15-dev
+  libmysqlclient-dev,libmysqlclient15-dev
+  libmysqlclient-dev,libmysqlclient15-dev
+  libmysqlclient-dev,libmysqlclient15-dev
+  libmysqlclient-dev,libmysqlclient15-dev
+Dependencies: 
+Provides: 
+Reverse Provides: 
+libmysqlclient-dev 5.1.41-3ubuntu12.7
+libmysqlclient-dev 5.1.41-3ubuntu12.10
+libmysqlclient-dev 5.1.41-3ubuntu12
+SHOWPKG_STDOUT
+      showpkg = mock(:stdout => showpkg_out,:exitstatus => 0)
+      @provider.should_receive(:shell_out!).with("apt-cache showpkg libmysqlclient15-dev").and_return(showpkg)
+      real_package_out=<<-RPKG_STDOUT
+libmysqlclient-dev:
+  Installed: 5.1.41-3ubuntu12.10
+  Candidate: 5.1.41-3ubuntu12.10
+  Version table:
+ *** 5.1.41-3ubuntu12.10 0
+        500 http://us.archive.ubuntu.com/ubuntu/ lucid-updates/main Packages
+        100 /var/lib/dpkg/status
+     5.1.41-3ubuntu12.7 0
+        500 http://security.ubuntu.com/ubuntu/ lucid-security/main Packages
+     5.1.41-3ubuntu12 0
+        500 http://us.archive.ubuntu.com/ubuntu/ lucid/main Packages
+RPKG_STDOUT
+      real_package = mock(:stdout => real_package_out,:exitstatus => 0)
+      @provider.should_receive(:shell_out!).with("apt-cache policy libmysqlclient-dev").and_return(real_package)
+      @provider.should_not_receive(:run_command_with_systems_locale)
+      @provider.load_current_resource
+    end
+
+    it "should raise an exception if you specify a virtual package with multiple provider packages" do
+      @new_resource.package_name("mp3-decoder")
+      virtual_package_out=<<-VPKG_STDOUT
+mp3-decoder:
+  Installed: (none)
+  Candidate: (none)
+  Version table:
+VPKG_STDOUT
+      virtual_package = mock(:stdout => virtual_package_out,:exitstatus => 0)
+      @provider.should_receive(:shell_out!).with("apt-cache policy mp3-decoder").and_return(virtual_package)
+      showpkg_out=<<-SHOWPKG_STDOUT
+Package: mp3-decoder
+Versions: 
+
+Reverse Depends: 
+  nautilus,mp3-decoder
+  vux,mp3-decoder
+  plait,mp3-decoder
+  ecasound,mp3-decoder
+  nautilus,mp3-decoder
+Dependencies: 
+Provides: 
+Reverse Provides: 
+vlc-nox 1.0.6-1ubuntu1.8
+vlc 1.0.6-1ubuntu1.8
+vlc-nox 1.0.6-1ubuntu1
+vlc 1.0.6-1ubuntu1
+opencubicplayer 1:0.1.17-2
+mpg321 0.2.10.6
+mpg123 1.12.1-0ubuntu1
+SHOWPKG_STDOUT
+      showpkg = mock(:stdout => showpkg_out,:exitstatus => 0)
+      @provider.should_receive(:shell_out!).with("apt-cache showpkg mp3-decoder").and_return(showpkg)
+      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should run apt-cache policy with the default_release option, if there is one and provider is explicitly defined" do
+      @new_resource = Chef::Resource::AptPackage.new("irssi", @run_context)
+      @provider = Chef::Provider::Package::Apt.new(@new_resource, @run_context)
+
+      @new_resource.stub!(:default_release).and_return("lenny-backports")
+      @new_resource.stub!(:provider).and_return("Chef::Provider::Package::Apt")
+      @provider.should_receive(:shell_out!).with("apt-cache -o APT::Default-Release=lenny-backports policy irssi").and_return(@shell_out)
+      @provider.load_current_resource
+    end
+
+  end
+
+  describe "install_package" do
+    it "should run apt-get install with the package name and version" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "apt-get -q -y install irssi=0.8.12-7",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @provider.install_package("irssi", "0.8.12-7")
+    end
+
+    it "should run apt-get install with the package name and version and options if specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "apt-get -q -y --force-yes install irssi=0.8.12-7",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @new_resource.stub!(:options).and_return("--force-yes")
+
+      @provider.install_package("irssi", "0.8.12-7")
+    end
+
+    it "should run apt-get install with the package name and version and default_release if there is one and provider is explicitly defined" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "apt-get -q -y -o APT::Default-Release=lenny-backports install irssi=0.8.12-7",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @new_resource.stub!(:default_release).and_return("lenny-backports")
+      @new_resource.stub!(:provider).and_return("Chef::Provider::Package::Apt")
+
+      @provider.install_package("irssi", "0.8.12-7")
+    end
+  end
+
+  describe Chef::Provider::Package::Apt, "upgrade_package" do
+
+    it "should run install_package with the name and version" do
+      @provider.should_receive(:install_package).with("irssi", "0.8.12-7")
+      @provider.upgrade_package("irssi", "0.8.12-7")
+    end
+  end
+
+  describe Chef::Provider::Package::Apt, "remove_package" do
+
+    it "should run apt-get remove with the package name" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "apt-get -q -y remove irssi",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @provider.remove_package("irssi", "0.8.12-7")
+    end
+
+    it "should run apt-get remove with the package name and options if specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "apt-get -q -y --force-yes remove irssi",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @new_resource.stub!(:options).and_return("--force-yes")
+
+      @provider.remove_package("irssi", "0.8.12-7")
+    end
+  end
+
+  describe "when purging a package" do
+
+    it "should run apt-get purge with the package name" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "apt-get -q -y purge irssi",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @provider.purge_package("irssi", "0.8.12-7")
+    end
+
+    it "should run apt-get purge with the package name and options if specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "apt-get -q -y --force-yes purge irssi",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @new_resource.stub!(:options).and_return("--force-yes")
+
+      @provider.purge_package("irssi", "0.8.12-7")
+    end
+  end
+
+  describe "when preseeding a package" do
+    before(:each) do
+      @provider.stub!(:get_preseed_file).and_return("/tmp/irssi-0.8.12-7.seed")
+      @provider.stub!(:run_command_with_systems_locale).and_return(true)
+    end
+
+    it "should get the full path to the preseed response file" do
+      @provider.should_receive(:get_preseed_file).with("irssi", "0.8.12-7").and_return("/tmp/irssi-0.8.12-7.seed")
+      file = @provider.get_preseed_file("irssi", "0.8.12-7")
+      @provider.preseed_package(file)
+    end
+
+    it "should run debconf-set-selections on the preseed file if it has changed" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "debconf-set-selections /tmp/irssi-0.8.12-7.seed",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      }).and_return(true)
+      file = @provider.get_preseed_file("irssi", "0.8.12-7")
+      @provider.preseed_package(file)
+    end
+
+    it "should not run debconf-set-selections if the preseed file has not changed" do
+      @provider.stub(:check_package_state)
+      @current_resource.version "0.8.11"
+      @new_resource.response_file "/tmp/file"
+      @provider.stub!(:get_preseed_file).and_return(false)
+      @provider.should_not_receive(:run_command_with_systems_locale)
+      @provider.run_action(:reconfig)
+    end
+  end
+
+  describe "when reconfiguring a package" do
+    before(:each) do
+      @provider.stub!(:run_command_with_systems_locale).and_return(true)
+    end
+
+    it "should run dpkg-reconfigure package" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "dpkg-reconfigure irssi",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      }).and_return(true)
+      @provider.reconfig_package("irssi", "0.8.12-7")
+    end
+  end
+
+  describe "when installing a virtual package" do
+    it "should install the package without specifying a version" do
+        @provider.is_virtual_package = true
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "apt-get -q -y install libmysqlclient-dev",
+          :environment => {
+            "DEBIAN_FRONTEND" => "noninteractive"
+          }
+        })
+        @provider.install_package("libmysqlclient-dev", "not_a_real_version")
+    end
+  end
+end
diff --git a/spec/unit/provider/package/dpkg_spec.rb b/spec/unit/provider/package/dpkg_spec.rb
new file mode 100644
index 0000000000..aa22e0a2a3
--- /dev/null
+++ b/spec/unit/provider/package/dpkg_spec.rb
@@ -0,0 +1,216 @@
+#
+# Author:: Bryan McLellan (btm@loftninjas.org)
+# Copyright:: Copyright (c) 2009 Bryan McLellan
+# 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 Chef::Provider::Package::Dpkg do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Package.new("wget")
+    @new_resource.source "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
+
+    @provider = Chef::Provider::Package::Dpkg.new(@new_resource, @run_context)
+
+    @stdin = StringIO.new
+    @stdout = StringIO.new
+    @status = mock("Status", :exitstatus => 0)
+    @stderr = StringIO.new
+    @pid = mock("PID")
+    @provider.stub!(:popen4).and_return(@status)
+
+    ::File.stub!(:exists?).and_return(true)
+  end
+
+  describe "when loading the current resource state" do
+
+    it "should create a current resource with the name of the new_resource" do
+      @provider.load_current_resource
+      @provider.current_resource.package_name.should == "wget"
+    end
+
+    it "should raise an exception if a source is supplied but not found" do
+      @provider.load_current_resource
+      @provider.define_resource_requirements
+      ::File.stub!(:exists?).and_return(false)
+      lambda { @provider.run_action(:install) }.should raise_error(Chef::Exceptions::Package)
+    end
+
+    describe 'gets the source package version from dpkg-deb' do
+      def check_version(version)
+        @stdout = StringIO.new("wget\t#{version}")
+        @provider.stub!(:popen4).with("dpkg-deb -W #{@new_resource.source}").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        @provider.current_resource.package_name.should == "wget"
+        @new_resource.version.should == version
+      end
+      
+      it 'if short version provided' do
+        check_version('1.11.4')
+      end
+      
+      it 'if extended version provided' do
+        check_version('1.11.4-1ubuntu1')
+      end
+      
+      it 'if distro-specific version provided' do
+        check_version('1.11.4-1ubuntu1~lucid')
+      end
+    end
+
+    it "gets the source package name from dpkg-deb correctly when the package name has `-', `+' or `.' characters" do
+      @stdout = StringIO.new("f.o.o-pkg++2\t1.11.4-1ubuntu1")
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.package_name.should == "f.o.o-pkg++2"
+    end
+
+    it "should raise an exception if the source is not set but we are installing" do
+      @new_resource = Chef::Resource::Package.new("wget")
+      @provider.new_resource = @new_resource
+      @provider.define_resource_requirements
+      @provider.load_current_resource
+      lambda { @provider.run_action(:install)}.should raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should return the current version installed if found by dpkg" do
+      @stdout = StringIO.new(<<-DPKG_S)
+Package: wget
+Status: install ok installed
+Priority: important
+Section: web
+Installed-Size: 1944
+Maintainer: Ubuntu Core developers <ubuntu-devel-discuss@lists.ubuntu.com>
+Architecture: amd64
+Version: 1.11.4-1ubuntu1
+Config-Version: 1.11.4-1ubuntu1
+Depends: libc6 (>= 2.8~20080505), libssl0.9.8 (>= 0.9.8f-5)
+Conflicts: wget-ssl
+DPKG_S
+      @provider.stub!(:popen4).with("dpkg -s wget").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+
+      @provider.load_current_resource
+      @provider.current_resource.version.should == "1.11.4-1ubuntu1"
+    end
+
+    it "should raise an exception if dpkg fails to run" do
+      @status = mock("Status", :exitstatus => -1)
+      @provider.stub!(:popen4).and_return(@status)
+      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Package)
+    end
+  end
+
+  describe Chef::Provider::Package::Dpkg, "install and upgrade" do
+    it "should run dpkg -i with the package source" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "dpkg -i /tmp/wget_1.11.4-1ubuntu1_amd64.deb",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @provider.install_package("wget", "1.11.4-1ubuntu1")
+    end
+
+    it "should run dpkg -i if the package is a path and the source is nil" do
+      @new_resource = Chef::Resource::Package.new("/tmp/wget_1.11.4-1ubuntu1_amd64.deb")
+      @provider = Chef::Provider::Package::Dpkg.new(@new_resource, @run_context)
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "dpkg -i /tmp/wget_1.11.4-1ubuntu1_amd64.deb",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @provider.install_package("/tmp/wget_1.11.4-1ubuntu1_amd64.deb", "1.11.4-1ubuntu1")
+    end
+
+    it "should run dpkg -i if the package is a path and the source is nil for an upgrade" do
+      @new_resource = Chef::Resource::Package.new("/tmp/wget_1.11.4-1ubuntu1_amd64.deb")
+      @provider = Chef::Provider::Package::Dpkg.new(@new_resource, @run_context)
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "dpkg -i /tmp/wget_1.11.4-1ubuntu1_amd64.deb",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @provider.upgrade_package("/tmp/wget_1.11.4-1ubuntu1_amd64.deb", "1.11.4-1ubuntu1")
+    end
+
+    it "should run dpkg -i with the package source and options if specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "dpkg -i --force-yes /tmp/wget_1.11.4-1ubuntu1_amd64.deb",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @new_resource.stub!(:options).and_return("--force-yes")
+
+      @provider.install_package("wget", "1.11.4-1ubuntu1")
+    end
+    it "should upgrade by running install_package" do
+      @provider.should_receive(:install_package).with("wget", "1.11.4-1ubuntu1")
+      @provider.upgrade_package("wget", "1.11.4-1ubuntu1")
+    end
+  end
+
+  describe Chef::Provider::Package::Dpkg, "remove and purge" do
+    it "should run dpkg -r to remove the package" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "dpkg -r wget",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @provider.remove_package("wget", "1.11.4-1ubuntu1")
+    end
+
+    it "should run dpkg -r to remove the package with options if specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "dpkg -r --force-yes wget",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @new_resource.stub!(:options).and_return("--force-yes")
+
+      @provider.remove_package("wget", "1.11.4-1ubuntu1")
+    end
+
+    it "should run dpkg -P to purge the package" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "dpkg -P wget",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @provider.purge_package("wget", "1.11.4-1ubuntu1")
+    end
+
+    it "should run dpkg -P to purge the package with options if specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "dpkg -P --force-yes wget",
+        :environment => {
+          "DEBIAN_FRONTEND" => "noninteractive"
+        }
+      })
+      @new_resource.stub!(:options).and_return("--force-yes")
+
+      @provider.purge_package("wget", "1.11.4-1ubuntu1")
+    end
+  end
+end
diff --git a/spec/unit/provider/package/easy_install_spec.rb b/spec/unit/provider/package/easy_install_spec.rb
new file mode 100644
index 0000000000..02f8399af8
--- /dev/null
+++ b/spec/unit/provider/package/easy_install_spec.rb
@@ -0,0 +1,112 @@
+#
+# Author:: Joe Williams (<joe@joetify.com>)
+# Copyright:: Copyright (c) 2009 Joe Williams
+# 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 Chef::Provider::Package::EasyInstall do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::EasyInstallPackage.new('boto')
+    @new_resource.version('1.8d')
+
+    @current_resource = Chef::Resource::EasyInstallPackage.new('boto')
+    @current_resource.version('1.8d')
+
+    @provider = Chef::Provider::Package::EasyInstall.new(@new_resource, @run_context)
+    Chef::Resource::Package.stub!(:new).and_return(@current_resource)
+
+    @stdin = StringIO.new
+    @stdout = StringIO.new
+    @status = mock("Status", :exitstatus => 0)
+    @stderr = StringIO.new
+    @pid = 2342
+    @provider.stub!(:popen4).and_return(@status)
+  end
+
+  describe "easy_install_binary_path" do
+    it "should return a Chef::Provider::EasyInstall object" do
+      provider = Chef::Provider::Package::EasyInstall.new(@node, @new_resource)
+      provider.should be_a_kind_of(Chef::Provider::Package::EasyInstall)
+    end
+
+    it "should set the current resources package name to the new resources package name" do
+      $stdout.stub!(:write)
+      @current_resource.should_receive(:package_name).with(@new_resource.package_name)
+      @provider.load_current_resource
+    end
+
+    it "should return a relative path to easy_install if no easy_install_binary is given" do
+      @provider.easy_install_binary_path.should eql("easy_install")
+    end
+
+    it "should return a specific path to easy_install if a easy_install_binary is given" do
+      @new_resource.should_receive(:easy_install_binary).and_return("/opt/local/bin/custom/easy_install")
+      @provider.easy_install_binary_path.should eql("/opt/local/bin/custom/easy_install")
+    end
+
+  end
+
+  describe "actions_on_package" do
+    it "should run easy_install with the package name and version" do
+      @provider.should_receive(:run_command).with({
+        :command => "easy_install \"boto==1.8d\""
+      })
+      @provider.install_package("boto", "1.8d")
+    end
+
+    it "should run easy_install with the package name and version and specified options" do
+      @provider.should_receive(:run_command).with({
+        :command => "easy_install --always-unzip \"boto==1.8d\""
+      })
+      @new_resource.stub!(:options).and_return("--always-unzip")
+      @provider.install_package("boto", "1.8d")
+    end
+
+    it "should run easy_install with the package name and version" do
+      @provider.should_receive(:run_command).with({
+        :command => "easy_install \"boto==1.8d\""
+      })
+      @provider.upgrade_package("boto", "1.8d")
+    end
+
+    it "should run easy_install -m with the package name and version" do
+      @provider.should_receive(:run_command).with({
+        :command => "easy_install -m boto"
+      })
+      @provider.remove_package("boto", "1.8d")
+    end
+
+    it "should run easy_install -m with the package name and version and specified options" do
+      @provider.should_receive(:run_command).with({
+        :command => "easy_install -x -m boto"
+      })
+      @new_resource.stub!(:options).and_return("-x")
+      @provider.remove_package("boto", "1.8d")
+    end
+
+    it "should run easy_install -m with the package name and version" do
+      @provider.should_receive(:run_command).with({
+        :command => "easy_install -m boto"
+      })
+      @provider.purge_package("boto", "1.8d")
+    end
+
+  end
+end
diff --git a/spec/unit/provider/package/freebsd_spec.rb b/spec/unit/provider/package/freebsd_spec.rb
new file mode 100644
index 0000000000..270c85d934
--- /dev/null
+++ b/spec/unit/provider/package/freebsd_spec.rb
@@ -0,0 +1,259 @@
+#
+# Authors:: Bryan McLellan (btm@loftninjas.org)
+#           Matthew Landauer (matthew@openaustralia.org)
+# Copyright:: Copyright (c) 2009 Bryan McLellan, Matthew Landauer
+# 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 'ostruct'
+
+describe Chef::Provider::Package::Freebsd, "load_current_resource" do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource     = Chef::Resource::Package.new("zsh")
+    @current_resource = Chef::Resource::Package.new("zsh")
+
+    @provider = Chef::Provider::Package::Freebsd.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+    ::File.stub!(:exist?).with('/usr/ports/Makefile').and_return(false)
+  end
+
+  describe "when determining the current package state" do
+    before do
+      @provider.stub!(:ports_candidate_version).and_return("4.3.6")
+    end
+
+    it "should create a current resource with the name of the new_resource" do
+      current_resource = Chef::Provider::Package::Freebsd.new(@new_resource, @run_context).current_resource
+      current_resource.name.should == "zsh"
+    end
+
+    it "should return a version if the package is installed" do
+      @provider.should_receive(:current_installed_version).and_return("4.3.6_7")
+      @provider.load_current_resource
+      @current_resource.version.should == "4.3.6_7"
+    end
+
+    it "should return nil if the package is not installed" do
+      @provider.should_receive(:current_installed_version).and_return(nil)
+      @provider.load_current_resource
+      @current_resource.version.should be_nil
+    end
+
+    it "should return a candidate version if it exists" do
+      @provider.should_receive(:current_installed_version).and_return(nil)
+      @provider.load_current_resource
+      @provider.candidate_version.should eql("4.3.6")
+    end
+  end
+
+  describe "when querying for package state and attributes" do
+    before do
+      #@new_resource = Chef::Resource::Package.new("zsh")
+
+      #@provider = Chef::Provider::Package::Freebsd.new(@node, @new_resource)
+
+      #@status = mock("Status", :exitstatus => 0)
+      #@stdin = mock("STDIN", :null_object => true)
+      #@stdout = mock("STDOUT", :null_object => true)
+      #@stderr = mock("STDERR", :null_object => true)
+      #@pid = mock("PID", :null_object => true)
+    end
+
+    it "should return the version number when it is installed" do
+      pkg_info = OpenStruct.new(:stdout => "zsh-4.3.6_7")
+      @provider.should_receive(:shell_out!).with('pkg_info -E "zsh*"', :env => nil, :returns => [0,1]).and_return(pkg_info)
+      #@provider.should_receive(:popen4).with('pkg_info -E "zsh*"').and_yield(@pid, @stdin, ["zsh-4.3.6_7"], @stderr).and_return(@status)
+      @provider.stub!(:package_name).and_return("zsh")
+      @provider.current_installed_version.should == "4.3.6_7"
+    end
+
+    it "does not set the current version number when the package is not installed" do
+      pkg_info = OpenStruct.new(:stdout => "")
+      @provider.should_receive(:shell_out!).with('pkg_info -E "zsh*"', :env => nil, :returns => [0,1]).and_return(pkg_info)
+      @provider.stub!(:package_name).and_return("zsh")
+      @provider.current_installed_version.should be_nil
+    end
+
+    it "should return the port path for a valid port name" do
+      whereis = OpenStruct.new(:stdout => "zsh: /usr/ports/shells/zsh")
+      @provider.should_receive(:shell_out!).with("whereis -s zsh", :env => nil).and_return(whereis)
+      #@provider.should_receive(:popen4).with("whereis -s zsh").and_yield(@pid, @stdin, ["zsh: /usr/ports/shells/zsh"], @stderr).and_return(@status)
+      @provider.stub!(:port_name).and_return("zsh")
+      @provider.port_path.should == "/usr/ports/shells/zsh"
+    end
+
+    # Not happy with the form of these tests as they are far too closely tied to the implementation and so very fragile.
+    it "should return the ports candidate version when given a valid port path" do
+      @provider.stub!(:port_path).and_return("/usr/ports/shells/zsh")
+      make_v = OpenStruct.new(:stdout => "4.3.6\n")
+      @provider.should_receive(:shell_out!).with("make -V PORTVERSION", {:cwd=>"/usr/ports/shells/zsh", :returns=>[0, 1], :env=>nil}).and_return(make_v)
+      @provider.ports_candidate_version.should == "4.3.6"
+    end
+
+    it "should figure out the package name when we have ports" do
+      ::File.stub!(:exist?).with('/usr/ports/Makefile').and_return(true)
+      @provider.stub!(:port_path).and_return("/usr/ports/shells/zsh")
+      make_v = OpenStruct.new(:stdout => "zsh-4.3.6_7\n")
+      @provider.should_receive(:shell_out!).with("make -V PKGNAME", {:cwd=>"/usr/ports/shells/zsh", :env=>nil, :returns=>[0, 1]}).and_return(make_v)
+      #@provider.should_receive(:ports_makefile_variable_value).with("PKGNAME").and_return("zsh-4.3.6_7")
+      @provider.package_name.should == "zsh"
+    end
+  end
+
+  describe Chef::Provider::Package::Freebsd, "install_package" do
+    before(:each) do
+      @cmd_result = OpenStruct.new(:status => true)
+
+      @provider.current_resource = @current_resource
+      @provider.stub!(:package_name).and_return("zsh")
+      @provider.stub!(:latest_link_name).and_return("zsh")
+      @provider.stub!(:port_path).and_return("/usr/ports/shells/zsh")
+    end
+
+    it "should run pkg_add -r with the package name" do
+      @provider.should_receive(:shell_out!).with("pkg_add -r zsh", :env => nil).and_return(@cmd_result)
+      @provider.install_package("zsh", "4.3.6_7")
+    end
+
+    it "should run make install when installing from ports" do
+      @new_resource.stub!(:source).and_return("ports")
+      @provider.should_not_receive(:shell_out!).with("make -DBATCH -f /usr/ports/shells/zsh/Makefile install", :timeout => 1200, :env=>nil)
+      @provider.should_receive(:shell_out!).with("make -DBATCH install", :timeout => 1200, :env=>nil, :cwd => @provider.port_path).and_return(@cmd_result)
+      @provider.install_package("zsh", "4.3.6_7")
+    end
+  end
+
+  describe Chef::Provider::Package::Freebsd, "port path" do
+    before do
+      #@node = Chef::Node.new
+      @new_resource = Chef::Resource::Package.new("zsh")
+      @new_resource.cookbook_name = "adventureclub"
+      @provider = Chef::Provider::Package::Freebsd.new(@new_resource, @run_context)
+    end
+
+    it "should figure out the port path from the package_name using whereis" do
+      whereis = OpenStruct.new(:stdout => "zsh: /usr/ports/shells/zsh")
+      @provider.should_receive(:shell_out!).with("whereis -s zsh", :env=>nil).and_return(whereis)
+      @provider.port_path.should == "/usr/ports/shells/zsh"
+    end
+
+    it "should use the package_name as the port path when it starts with /" do
+      new_resource = Chef::Resource::Package.new("/usr/ports/www/wordpress")
+      provider = Chef::Provider::Package::Freebsd.new(new_resource, @run_context)
+      provider.should_not_receive(:popen4)
+      provider.port_path.should == "/usr/ports/www/wordpress"
+    end
+
+    it "should use the package_name as a relative path from /usr/ports when it contains / but doesn't start with it" do
+      # @new_resource = mock( "Chef::Resource::Package",
+      #                       :package_name => "www/wordpress",
+      #                       :cookbook_name => "xenoparadox")
+      new_resource = Chef::Resource::Package.new("www/wordpress")
+      provider = Chef::Provider::Package::Freebsd.new(new_resource, @run_context)
+      provider.should_not_receive(:popen4)
+      provider.port_path.should == "/usr/ports/www/wordpress"
+    end
+  end
+
+  describe Chef::Provider::Package::Freebsd, "ruby-iconv (package with a dash in the name)" do
+    before(:each) do
+      @new_resource     = Chef::Resource::Package.new("ruby-iconv")
+      @current_resource = Chef::Resource::Package.new("ruby-iconv")
+      @provider = Chef::Provider::Package::Freebsd.new(@new_resource, @run_context)
+      @provider.current_resource = @current_resource
+      @provider.stub!(:port_path).and_return("/usr/ports/converters/ruby-iconv")
+      @provider.stub!(:package_name).and_return("ruby18-iconv")
+      @provider.stub!(:latest_link_name).and_return("ruby18-iconv")
+
+      @install_result = OpenStruct.new(:status => true)
+    end
+
+    it "should run pkg_add -r with the package name" do
+      @provider.should_receive(:shell_out!).with("pkg_add -r ruby18-iconv", :env => nil).and_return(@install_result)
+      @provider.install_package("ruby-iconv", "1.0")
+    end
+
+    it "should run make install when installing from ports" do
+      @new_resource.stub!(:source).and_return("ports")
+      @provider.should_receive(:shell_out!).with("make -DBATCH install", :timeout => 1200, :env=>nil, :cwd => @provider.port_path).and_return(@install_result)
+      @provider.install_package("ruby-iconv", "1.0")
+    end
+  end
+
+  describe Chef::Provider::Package::Freebsd, "remove_package" do
+    before(:each) do
+      @pkg_delete = OpenStruct.new(:status => true)
+      @new_resource.version "4.3.6_7"
+      @current_resource.version "4.3.6_7"
+      @provider.current_resource = @current_resource
+      @provider.stub!(:package_name).and_return("zsh")
+    end
+
+    it "should run pkg_delete with the package name and version" do
+      @provider.should_receive(:shell_out!).with("pkg_delete zsh-4.3.6_7", :env => nil).and_return(@pkg_delete)
+      @provider.remove_package("zsh", "4.3.6_7")
+    end
+  end
+
+  # A couple of examples to show up the difficulty of determining the command to install the binary package given the port:
+  # PORT DIRECTORY                        INSTALLED PACKAGE NAME  COMMAND TO INSTALL PACKAGE
+  # /usr/ports/lang/perl5.8               perl-5.8.8_1            pkg_add -r perl
+  # /usr/ports/databases/mysql50-server   mysql-server-5.0.45_1   pkg_add -r mysql50-server
+  #
+  # So, in one case it appears the command to install the package can be derived from the name of the port directory and in the
+  # other case it appears the command can be derived from the package name. Very confusing!
+  # Well, luckily, after much poking around, I discovered that the two can be disambiguated through the use of the LATEST_LINK
+  # variable which is set by the ports Makefile
+  #
+  # PORT DIRECTORY                        LATEST_LINK     INSTALLED PACKAGE NAME  COMMAND TO INSTALL PACKAGE
+  # /usr/ports/lang/perl5.8               perl            perl-5.8.8_1            pkg_add -r perl
+  # /usr/ports/databases/mysql50-server   mysql50-server  mysql-server-5.0.45_1   pkg_add -r mysql50-server
+  #
+  # The variable LATEST_LINK is named that way because the directory that "pkg_add -r" downloads from is called "Latest" and
+  # contains the "latest" versions of package as symbolic links to the files in the "All" directory.
+
+  describe Chef::Provider::Package::Freebsd, "install_package latest link fixes" do
+    it "should install the perl binary package with the correct name" do
+      @new_resource = Chef::Resource::Package.new("perl5.8")
+      @current_resource = Chef::Resource::Package.new("perl5.8")
+      @provider = Chef::Provider::Package::Freebsd.new(@new_resource, @run_context)
+      @provider.current_resource = @current_resource
+      @provider.stub!(:package_name).and_return("perl")
+      @provider.stub!(:latest_link_name).and_return("perl")
+
+      cmd = OpenStruct.new(:status => true)
+      @provider.should_receive(:shell_out!).with("pkg_add -r perl", :env => nil).and_return(cmd)
+      @provider.install_package("perl5.8", "5.8.8_1")
+    end
+
+    it "should install the mysql50-server binary package with the correct name" do
+
+      @new_resource     = Chef::Resource::Package.new("mysql50-server")
+      @current_resource = Chef::Resource::Package.new("mysql50-server")
+      @provider = Chef::Provider::Package::Freebsd.new(@new_resource, @run_context)
+      @provider.current_resource = @current_resource
+      @provider.stub!(:package_name).and_return("mysql-server")
+      @provider.stub!(:latest_link_name).and_return("mysql50-server")
+
+      cmd = OpenStruct.new(:status => true)
+      @provider.should_receive(:shell_out!).with("pkg_add -r mysql50-server", :env=>nil).and_return(cmd)
+      @provider.install_package("mysql50-server", "5.0.45_1")
+    end
+  end
+end
diff --git a/spec/unit/provider/package/ips_spec.rb b/spec/unit/provider/package/ips_spec.rb
new file mode 100644
index 0000000000..641a527012
--- /dev/null
+++ b/spec/unit/provider/package/ips_spec.rb
@@ -0,0 +1,209 @@
+#
+# Author:: Bryan McLellan <btm@opscode.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 'ostruct'
+
+# based on the apt specs
+
+describe Chef::Provider::Package::Ips do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Package.new("crypto/gnupg", @run_context)
+    @current_resource = Chef::Resource::Package.new("crypto/gnupg", @run_context)
+    Chef::Resource::Package.stub!(:new).and_return(@current_resource)
+    @provider = Chef::Provider::Package::Ips.new(@new_resource, @run_context)
+
+    @stdin = StringIO.new
+    @stderr = StringIO.new
+    @stdout =<<-PKG_STATUS
+          Name: crypto/gnupg
+       Summary: GNU Privacy Guard
+   Description: A complete and free implementation of the OpenPGP Standard as
+                defined by RFC4880.
+      Category: Applications/System Utilities
+         State: Not installed
+     Publisher: solaris
+       Version: 2.0.17
+ Build Release: 5.11
+        Branch: 0.175.0.0.0.2.537
+Packaging Date: October 19, 2011 09:14:50 AM
+          Size: 8.07 MB
+          FMRI: pkg://solaris/crypto/gnupg@2.0.17,5.11-0.175.0.0.0.2.537:20111019T091450Z
+PKG_STATUS
+    @pid = 12345
+    @shell_out = OpenStruct.new(:stdout => @stdout,:stdin => @stdin,:stderr => @stderr,:status => @status,:exitstatus => 0)
+  end
+
+  context "when loading current resource" do
+    it "should create a current resource with the name of the new_resource" do
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      Chef::Resource::Package.should_receive(:new).and_return(@current_resource)
+      @provider.load_current_resource
+    end
+
+    it "should set the current resources package name to the new resources package name" do
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      @current_resource.should_receive(:package_name).with(@new_resource.package_name)
+      @provider.load_current_resource
+    end
+
+    it "should run pkg info with the package name" do
+      @provider.should_receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(@shell_out)
+      @provider.load_current_resource
+    end
+
+    it "should set the installed version to nil on the current resource if package state is not installed" do
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      @current_resource.should_receive(:version).with(nil).and_return(true)
+      @provider.load_current_resource
+    end
+
+    it "should set the installed version if package has one" do
+      @stdout.replace(<<-INSTALLED)
+          Name: crypto/gnupg
+       Summary: GNU Privacy Guard
+   Description: A complete and free implementation of the OpenPGP Standard as
+                defined by RFC4880.
+      Category: Applications/System Utilities
+         State: Installed
+     Publisher: solaris
+       Version: 2.0.17
+ Build Release: 5.11
+        Branch: 0.175.0.0.0.2.537
+Packaging Date: October 19, 2011 09:14:50 AM
+          Size: 8.07 MB
+          FMRI: pkg://solaris/crypto/gnupg@2.0.17,5.11-0.175.0.0.0.2.537:20111019T091450Z
+INSTALLED
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      @provider.load_current_resource
+      @current_resource.version.should == "2.0.17"
+      @provider.candidate_version.should eql("2.0.17")
+    end
+
+    it "should return the current resouce" do
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      @provider.load_current_resource.should eql(@current_resource)
+    end
+  end
+
+  context "when installing a package" do
+    it "should run pkg install with the package name and version" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pkg install -q crypto/gnupg@2.0.17"
+      })
+      @provider.install_package("crypto/gnupg", "2.0.17")
+    end
+
+
+    it "should run pkg install with the package name and version and options if specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pkg --no-refresh install -q crypto/gnupg@2.0.17"
+      })
+      @new_resource.stub!(:options).and_return("--no-refresh")
+      @provider.install_package("crypto/gnupg", "2.0.17")
+    end
+
+    it "should not contain invalid characters for the version string" do
+      @stdout.replace(<<-PKG_STATUS)
+          Name: security/sudo
+       Summary: sudo - authority delegation tool
+         State: Not Installed
+     Publisher: omnios
+       Version: 1.8.4.1 (1.8.4p1)
+ Build Release: 5.11
+        Branch: 0.151002
+Packaging Date: April  1, 2012 05:55:52 PM
+          Size: 2.57 MB
+          FMRI: pkg://omnios/security/sudo@1.8.4.1,5.11-0.151002:20120401T175552Z
+PKG_STATUS
+      @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "pkg install -q security/sudo@1.8.4.1"
+      })
+      @provider.install_package("security/sudo", "1.8.4.1")
+    end
+
+    it "should not include the human-readable version in the candidate_version" do
+      @stdout.replace(<<-PKG_STATUS)
+          Name: security/sudo
+       Summary: sudo - authority delegation tool
+         State: Not Installed
+     Publisher: omnios
+       Version: 1.8.4.1 (1.8.4p1)
+ Build Release: 5.11
+        Branch: 0.151002
+Packaging Date: April  1, 2012 05:55:52 PM
+          Size: 2.57 MB
+          FMRI: pkg://omnios/security/sudo@1.8.4.1,5.11-0.151002:20120401T175552Z
+PKG_STATUS
+      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      @provider.load_current_resource
+      @current_resource.version.should be_nil
+      @provider.candidate_version.should eql("1.8.4.1")
+    end
+
+    context "using the ips_package resource" do
+      before do
+        @new_resource = Chef::Resource::IpsPackage.new("crypto/gnupg", @run_context)
+        @current_resource = Chef::Resource::IpsPackage.new("crypto/gnupg", @run_context)
+        @provider = Chef::Provider::Package::Ips.new(@new_resource, @run_context)
+      end
+
+      context "when accept_license is true" do
+        before do
+          @new_resource.stub!(:accept_license).and_return(true)
+        end
+  
+        it "should run pkg install with the --accept flag" do
+          @provider.should_receive(:run_command_with_systems_locale).with({
+            :command => "pkg install -q --accept crypto/gnupg@2.0.17"
+          })
+          @provider.install_package("crypto/gnupg", "2.0.17")
+        end
+      end
+    end
+  end
+
+  context "when upgrading a package" do
+    it "should run pkg install with the package name and version" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pkg install -q crypto/gnupg@2.0.17"
+      })
+      @provider.upgrade_package("crypto/gnupg", "2.0.17")
+    end
+  end
+
+  context "when uninstalling a package" do
+    it "should run pkg uninstall with the package name and version" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pkg uninstall -q crypto/gnupg@2.0.17"
+      })
+      @provider.remove_package("crypto/gnupg", "2.0.17")
+    end
+
+    it "should run pkg uninstall with the package name and version and options if specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pkg --no-refresh uninstall -q crypto/gnupg@2.0.17"
+      })
+      @new_resource.stub!(:options).and_return("--no-refresh")
+      @provider.remove_package("crypto/gnupg", "2.0.17")
+    end
+  end
+end
diff --git a/spec/unit/provider/package/macports_spec.rb b/spec/unit/provider/package/macports_spec.rb
new file mode 100644
index 0000000000..2f0db3f7a8
--- /dev/null
+++ b/spec/unit/provider/package/macports_spec.rb
@@ -0,0 +1,203 @@
+#
+# Author:: David Balatero (<dbalatero@gmail.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'
+
+describe Chef::Provider::Package::Macports do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Package.new("zsh")
+    @current_resource = Chef::Resource::Package.new("zsh")
+
+    @provider = Chef::Provider::Package::Macports.new(@new_resource, @run_context)
+    Chef::Resource::Package.stub!(:new).and_return(@current_resource)
+
+    @status = mock("Status", :exitstatus => 0)
+    @stdin = StringIO.new
+    @stdout = StringIO.new
+    @stderr = StringIO.new
+    @pid = 2342
+  end
+
+  describe "load_current_resource" do
+    it "should create a current resource with the name of the new_resource" do
+      @provider.should_receive(:current_installed_version).and_return(nil)
+      @provider.should_receive(:macports_candidate_version).and_return("4.2.7")
+
+      @provider.load_current_resource
+      @provider.current_resource.name.should == "zsh"
+    end
+
+    it "should create a current resource with the version if the package is installed" do
+      @provider.should_receive(:macports_candidate_version).and_return("4.2.7")
+      @provider.should_receive(:current_installed_version).and_return("4.2.7")
+
+      @provider.load_current_resource
+      @provider.candidate_version.should == "4.2.7"
+    end
+
+    it "should create a current resource with a nil version if the package is not installed" do
+      @provider.should_receive(:current_installed_version).and_return(nil)
+      @provider.should_receive(:macports_candidate_version).and_return("4.2.7")
+      @provider.load_current_resource
+      @provider.current_resource.version.should be_nil
+    end
+
+    it "should set a candidate version if one exists" do
+      @provider.should_receive(:current_installed_version).and_return(nil)
+      @provider.should_receive(:macports_candidate_version).and_return("4.2.7")
+      @provider.load_current_resource
+      @provider.candidate_version.should == "4.2.7"
+    end
+  end
+
+  describe "current_installed_version" do
+    it "should return the current version if the package is installed" do
+      @stdout.should_receive(:read).and_return(<<EOF
+The following ports are currently installed:
+  openssl @0.9.8k_0 (active)
+EOF
+      )
+
+      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.current_installed_version.should == "0.9.8k_0"
+    end
+
+    it "should return nil if a package is not currently installed" do
+      @stdout.should_receive(:read).and_return("       \n")
+      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.current_installed_version.should be_nil
+    end
+  end
+
+  describe "macports_candidate_version" do
+    it "should return the latest available version of a given package" do
+      @stdout.should_receive(:read).and_return("version: 4.2.7\n")
+      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.macports_candidate_version.should == "4.2.7"
+    end
+
+    it "should return nil if there is no version for a given package" do
+      @stdout.should_receive(:read).and_return("Error: port fadsfadsfads not found\n")
+      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.macports_candidate_version.should be_nil
+    end
+  end
+
+  describe "install_package" do
+    it "should run the port install command with the correct version" do
+      @current_resource.should_receive(:version).and_return("4.1.6")
+      @provider.current_resource = @current_resource
+      @provider.should_receive(:run_command_with_systems_locale).with(:command => "port install zsh @4.2.7")
+
+      @provider.install_package("zsh", "4.2.7")
+    end
+
+    it "should not do anything if a package already exists with the same version" do
+      @current_resource.should_receive(:version).and_return("4.2.7")
+      @provider.current_resource = @current_resource
+      @provider.should_not_receive(:run_command_with_systems_locale)
+
+      @provider.install_package("zsh", "4.2.7")
+    end
+
+    it "should add options to the port command when specified" do
+      @current_resource.should_receive(:version).and_return("4.1.6")
+      @provider.current_resource = @current_resource
+      @new_resource.stub!(:options).and_return("-f")
+      @provider.should_receive(:run_command_with_systems_locale).with(:command => "port -f install zsh @4.2.7")
+
+      @provider.install_package("zsh", "4.2.7")
+    end
+  end
+
+  describe "purge_package" do
+    it "should run the port uninstall command with the correct version" do
+      @provider.should_receive(:run_command_with_systems_locale).with(:command => "port uninstall zsh @4.2.7")
+      @provider.purge_package("zsh", "4.2.7")
+    end
+
+    it "should purge the currently active version if no explicit version is passed in" do
+      @provider.should_receive(:run_command_with_systems_locale).with(:command => "port uninstall zsh")
+      @provider.purge_package("zsh", nil)
+    end
+
+    it "should add options to the port command when specified" do
+      @new_resource.stub!(:options).and_return("-f")
+      @provider.should_receive(:run_command_with_systems_locale).with(:command => "port -f uninstall zsh @4.2.7")
+      @provider.purge_package("zsh", "4.2.7")
+    end
+  end
+
+  describe "remove_package" do
+    it "should run the port deactivate command with the correct version" do
+      @provider.should_receive(:run_command_with_systems_locale).with(:command => "port deactivate zsh @4.2.7")
+      @provider.remove_package("zsh", "4.2.7")
+    end
+
+    it "should remove the currently active version if no explicit version is passed in" do
+      @provider.should_receive(:run_command_with_systems_locale).with(:command => "port deactivate zsh")
+      @provider.remove_package("zsh", nil)
+    end
+
+    it "should add options to the port command when specified" do
+      @new_resource.stub!(:options).and_return("-f")
+      @provider.should_receive(:run_command_with_systems_locale).with(:command => "port -f deactivate zsh @4.2.7")
+      @provider.remove_package("zsh", "4.2.7")
+    end
+  end
+
+  describe "upgrade_package" do
+    it "should run the port upgrade command with the correct version" do
+      @current_resource.should_receive(:version).at_least(:once).and_return("4.1.6")
+      @provider.current_resource = @current_resource
+
+      @provider.should_receive(:run_command_with_systems_locale).with(:command => "port upgrade zsh @4.2.7")
+
+      @provider.upgrade_package("zsh", "4.2.7")
+    end
+
+    it "should not run the port upgrade command if the version is already installed" do
+      @current_resource.should_receive(:version).at_least(:once).and_return("4.2.7")
+      @provider.current_resource = @current_resource
+      @provider.should_not_receive(:run_command_with_systems_locale)
+
+      @provider.upgrade_package("zsh", "4.2.7")
+    end
+
+    it "should call install_package if the package isn't currently installed" do
+      @current_resource.should_receive(:version).at_least(:once).and_return(nil)
+      @provider.current_resource = @current_resource
+      @provider.should_receive(:install_package).and_return(true)
+
+      @provider.upgrade_package("zsh", "4.2.7")
+    end
+
+    it "should add options to the port command when specified" do
+      @new_resource.stub!(:options).and_return("-f")
+      @current_resource.should_receive(:version).at_least(:once).and_return("4.1.6")
+      @provider.current_resource = @current_resource
+
+      @provider.should_receive(:run_command_with_systems_locale).with(:command => "port -f upgrade zsh @4.2.7")
+
+      @provider.upgrade_package("zsh", "4.2.7")
+    end
+  end
+end
diff --git a/spec/unit/provider/package/pacman_spec.rb b/spec/unit/provider/package/pacman_spec.rb
new file mode 100644
index 0000000000..7e4abcb6d5
--- /dev/null
+++ b/spec/unit/provider/package/pacman_spec.rb
@@ -0,0 +1,206 @@
+#
+# Author:: Jan Zimmek (<jan.zimmek@web.de>)
+# Copyright:: Copyright (c) 2010 Jan Zimmek
+# 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 Chef::Provider::Package::Pacman do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Package.new("nano")
+    @current_resource = Chef::Resource::Package.new("nano")
+
+    @status = mock("Status", :exitstatus => 0)
+    @provider = Chef::Provider::Package::Pacman.new(@new_resource, @run_context)
+    Chef::Resource::Package.stub!(:new).and_return(@current_resource)
+    @provider.stub!(:popen4).and_return(@status)
+    @stdin = StringIO.new
+    @stdout = StringIO.new(<<-ERR)
+error: package "nano" not found
+ERR
+    @stderr = StringIO.new
+    @pid = 2342
+  end
+
+  describe "when determining the current package state" do
+    it "should create a current resource with the name of the new_resource" do
+      Chef::Resource::Package.should_receive(:new).and_return(@current_resource)
+      @provider.load_current_resource
+    end
+
+    it "should set the current resources package name to the new resources package name" do
+      @current_resource.should_receive(:package_name).with(@new_resource.package_name)
+      @provider.load_current_resource
+    end
+
+    it "should run pacman query with the package name" do
+      @provider.should_receive(:popen4).with("pacman -Qi #{@new_resource.package_name}").and_return(@status)
+      @provider.load_current_resource
+    end
+
+    it "should read stdout on pacman" do
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @stdout.should_receive(:each).and_return(true)
+      @provider.load_current_resource
+    end
+
+    it "should set the installed version to nil on the current resource if pacman installed version not exists" do
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @current_resource.should_receive(:version).with(nil).and_return(true)
+      @provider.load_current_resource
+    end
+
+    it "should set the installed version if pacman has one" do
+      @stdout = StringIO.new(<<-PACMAN)
+Name           : nano
+Version        : 2.2.2-1
+URL            : http://www.nano-editor.org
+Licenses       : GPL
+Groups         : base
+Provides       : None
+Depends On     : glibc  ncurses
+Optional Deps  : None
+Required By    : None
+Conflicts With : None
+Replaces       : None
+Installed Size : 1496.00 K
+Packager       : Andreas Radke <andyrtr@archlinux.org>
+Architecture   : i686
+Build Date     : Mon 18 Jan 2010 06:16:16 PM CET
+Install Date   : Mon 01 Feb 2010 10:06:30 PM CET
+Install Reason : Explicitly installed
+Install Script : Yes
+Description    : Pico editor clone with enhancements
+PACMAN
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.load_current_resource
+      @current_resource.version.should == "2.2.2-1"
+    end
+
+    it "should set the candidate version if pacman has one" do
+      @stdout.stub!(:each).and_yield("core/nano 2.2.3-1 (base)").
+                            and_yield("    Pico editor clone with enhancements").
+                            and_yield("community/nanoblogger 3.4.1-1").
+                            and_yield("    NanoBlogger is a small weblog engine written in Bash for the command line")
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.load_current_resource
+      @provider.candidate_version.should eql("2.2.3-1")
+    end
+
+    it "should use pacman.conf to determine valid repo names for package versions" do
+     @pacman_conf = <<-PACMAN_CONF
+[options]
+HoldPkg      = pacman glibc
+Architecture = auto
+
+[customrepo]
+Server = https://my.custom.repo
+
+[core]
+Include = /etc/pacman.d/mirrorlist
+
+[extra]
+Include = /etc/pacman.d/mirrorlist
+
+[community]
+Include = /etc/pacman.d/mirrorlist
+PACMAN_CONF
+
+      ::File.stub!(:exists?).with("/etc/pacman.conf").and_return(true)
+      ::File.stub!(:read).with("/etc/pacman.conf").and_return(@pacman_conf)
+      @stdout.stub!(:each).and_yield("customrepo/nano 1.2.3-4").
+                            and_yield("    My custom package")
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+
+      @provider.load_current_resource
+      @provider.candidate_version.should eql("1.2.3-4")
+    end
+
+    it "should raise an exception if pacman fails" do
+      @status.should_receive(:exitstatus).and_return(2)
+      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should not raise an exception if pacman succeeds" do
+      @status.should_receive(:exitstatus).and_return(0)
+      lambda { @provider.load_current_resource }.should_not raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should raise an exception if pacman does not return a candidate version" do
+      @stdout.stub!(:each).and_yield("")
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      lambda { @provider.candidate_version }.should raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should return the current resouce" do
+      @provider.load_current_resource.should eql(@current_resource)
+    end
+  end
+
+  describe Chef::Provider::Package::Pacman, "install_package" do
+    it "should run pacman install with the package name and version" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pacman --sync --noconfirm --noprogressbar nano"
+      })
+      @provider.install_package("nano", "1.0")
+    end
+
+    it "should run pacman install with the package name and version and options if specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pacman --sync --noconfirm --noprogressbar --debug nano"
+      })
+      @new_resource.stub!(:options).and_return("--debug")
+
+      @provider.install_package("nano", "1.0")
+    end
+  end
+
+  describe Chef::Provider::Package::Pacman, "upgrade_package" do
+    it "should run install_package with the name and version" do
+      @provider.should_receive(:install_package).with("nano", "1.0")
+      @provider.upgrade_package("nano", "1.0")
+    end
+  end
+
+  describe Chef::Provider::Package::Pacman, "remove_package" do
+    it "should run pacman remove with the package name" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pacman --remove --noconfirm --noprogressbar nano"
+      })
+      @provider.remove_package("nano", "1.0")
+    end
+
+    it "should run pacman remove with the package name and options if specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pacman --remove --noconfirm --noprogressbar --debug nano"
+      })
+      @new_resource.stub!(:options).and_return("--debug")
+
+      @provider.remove_package("nano", "1.0")
+    end
+  end
+
+  describe Chef::Provider::Package::Pacman, "purge_package" do
+    it "should run remove_package with the name and version" do
+      @provider.should_receive(:remove_package).with("nano", "1.0")
+      @provider.purge_package("nano", "1.0")
+    end
+
+  end
+end
diff --git a/spec/unit/provider/package/portage_spec.rb b/spec/unit/provider/package/portage_spec.rb
new file mode 100644
index 0000000000..e963934f4f
--- /dev/null
+++ b/spec/unit/provider/package/portage_spec.rb
@@ -0,0 +1,276 @@
+#
+# Author:: Caleb Tennis (<caleb.tennis@gmail.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 'spec_helper'
+
+describe Chef::Provider::Package::Portage, "load_current_resource" do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Package.new("dev-util/git")
+    @new_resource_without_category = Chef::Resource::Package.new("git")
+    @current_resource = Chef::Resource::Package.new("dev-util/git")
+
+    @provider = Chef::Provider::Package::Portage.new(@new_resource, @run_context)
+    Chef::Resource::Package.stub!(:new).and_return(@current_resource)
+  end
+
+  describe "when determining the current state of the package" do
+
+    it "should create a current resource with the name of new_resource" do
+      ::Dir.stub!(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0"])
+      Chef::Resource::Package.should_receive(:new).and_return(@current_resource)
+      @provider.load_current_resource
+    end
+
+    it "should set the current resource package name to the new resource package name" do
+      ::Dir.stub!(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0"])
+      @current_resource.should_receive(:package_name).with(@new_resource.package_name)
+      @provider.load_current_resource
+    end
+
+    it "should return a current resource with the correct version if the package is found" do
+      ::Dir.stub!(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-foobar-0.9", "/var/db/pkg/dev-util/git-1.0.0"])
+      @provider.load_current_resource
+      @provider.current_resource.version.should == "1.0.0"
+    end
+
+    it "should return a current resource with the correct version if the package is found with revision" do
+      ::Dir.stub!(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0-r1"])
+      @provider.load_current_resource
+      @provider.current_resource.version.should == "1.0.0-r1"
+    end
+
+    it "should return a current resource with a nil version if the package is not found" do
+      ::Dir.stub!(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/notgit-1.0.0"])
+      @provider.load_current_resource
+      @provider.current_resource.version.should be_nil
+    end
+
+    it "should return a package name match from /var/db/pkg/* if a category isn't specified and a match is found" do
+      ::Dir.stub!(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/git-foobar-0.9", "/var/db/pkg/dev-util/git-1.0.0"])
+      @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
+      @provider.load_current_resource
+      @provider.current_resource.version.should == "1.0.0"
+    end
+
+    it "should return a current resource with a nil version if a category isn't specified and a name match from /var/db/pkg/* is not found" do
+      ::Dir.stub!(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/notgit-1.0.0"])
+      @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
+      @provider.load_current_resource
+      @provider.current_resource.version.should be_nil
+    end
+
+    it "should throw an exception if a category isn't specified and multiple packages are found" do
+      ::Dir.stub!(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0", "/var/db/pkg/funny-words/git-1.0.0"])
+      @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
+      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should return a current resource with a nil version if a category is specified and multiple packages are found" do
+      ::Dir.stub!(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0", "/var/db/pkg/funny-words/git-1.0.0"])
+      @provider = Chef::Provider::Package::Portage.new(@new_resource, @run_context)
+      @provider.load_current_resource
+      @provider.current_resource.version.should be_nil
+    end
+
+    it "should return a current resource with a nil version if a category is not specified and multiple packages from the same category are found" do
+      ::Dir.stub!(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0", "/var/db/pkg/dev-util/git-1.0.1"])
+      @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
+      @provider.load_current_resource
+      @provider.current_resource.version.should be_nil
+    end
+  end
+
+  describe "once the state of the package is known" do
+
+    describe Chef::Provider::Package::Portage, "candidate_version" do
+      it "should return the candidate_version variable if already set" do
+        @provider.candidate_version = "1.0.0"
+        @provider.should_not_receive(:popen4)
+        @provider.candidate_version
+      end
+
+      it "should throw an exception if the exitstatus is not 0" do
+        @status = mock("Status", :exitstatus => 1)
+        @provider.stub!(:popen4).and_return(@status)
+        lambda { @provider.candidate_version }.should raise_error(Chef::Exceptions::Package)
+      end
+
+      it "should find the candidate_version if a category is specifed and there are no duplicates" do
+        output = <<EOF
+Searching...
+[ Results for search key : git ]
+[ Applications found : 14 ]
+
+*  app-misc/digitemp [ Masked ]
+      Latest version available: 3.5.0
+      Latest version installed: [ Not Installed ]
+      Size of files: 261 kB
+      Homepage:      http://www.digitemp.com/ http://www.ibutton.com/
+      Description:   Temperature logging and reporting using Dallas Semiconductor's iButtons and 1-Wire protocol
+      License:       GPL-2
+
+*  dev-util/git
+      Latest version available: 1.6.0.6
+      Latest version installed: ignore
+      Size of files: 2,725 kB
+      Homepage:      http://git.or.cz/
+      Description:   GIT - the stupid content tracker, the revision control system heavily used by the Linux kernel team
+      License:       GPL-2
+
+*  dev-util/gitosis [ Masked ]
+      Latest version available: 0.2_p20080825
+      Latest version installed: [ Not Installed ]
+      Size of files: 31 kB
+      Homepage:      http://eagain.net/gitweb/?p=gitosis.git;a=summary
+      Description:   gitosis -- software for hosting git repositories
+      License:       GPL-2
+EOF
+
+        @status = mock("Status", :exitstatus => 0)
+        @provider.should_receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
+        @provider.candidate_version.should == "1.6.0.6"
+      end
+
+      it "should find the candidate_version if a category is not specifed and there are no duplicates" do
+        output = <<EOF
+Searching...
+[ Results for search key : git ]
+[ Applications found : 14 ]
+
+*  app-misc/digitemp [ Masked ]
+      Latest version available: 3.5.0
+      Latest version installed: [ Not Installed ]
+      Size of files: 261 kB
+      Homepage:      http://www.digitemp.com/ http://www.ibutton.com/
+      Description:   Temperature logging and reporting using Dallas Semiconductor's iButtons and 1-Wire protocol
+      License:       GPL-2
+
+*  dev-util/git
+      Latest version available: 1.6.0.6
+      Latest version installed: ignore
+      Size of files: 2,725 kB
+      Homepage:      http://git.or.cz/
+      Description:   GIT - the stupid content tracker, the revision control system heavily used by the Linux kernel team
+      License:       GPL-2
+
+*  dev-util/gitosis [ Masked ]
+      Latest version available: 0.2_p20080825
+      Latest version installed: [ Not Installed ]
+      Size of files: 31 kB
+      Homepage:      http://eagain.net/gitweb/?p=gitosis.git;a=summary
+      Description:   gitosis -- software for hosting git repositories
+      License:       GPL-2
+EOF
+
+        @status = mock("Status", :exitstatus => 0)
+        @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
+        @provider.should_receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
+        @provider.candidate_version.should == "1.6.0.6"
+      end
+
+      it "should throw an exception if a category is not specified and there are duplicates" do
+        output = <<EOF
+Searching...
+[ Results for search key : git ]
+[ Applications found : 14 ]
+
+*  app-misc/digitemp [ Masked ]
+      Latest version available: 3.5.0
+      Latest version installed: [ Not Installed ]
+      Size of files: 261 kB
+      Homepage:      http://www.digitemp.com/ http://www.ibutton.com/
+      Description:   Temperature logging and reporting using Dallas Semiconductor's iButtons and 1-Wire protocol
+      License:       GPL-2
+
+*  app-misc/git
+      Latest version available: 4.3.20
+      Latest version installed: [ Not Installed ]
+      Size of files: 416 kB
+      Homepage:      http://www.gnu.org/software/git/
+      Description:   GNU Interactive Tools - increase speed and efficiency of most daily task
+      License:       GPL-2
+
+*  dev-util/git
+      Latest version available: 1.6.0.6
+      Latest version installed: ignore
+      Size of files: 2,725 kB
+      Homepage:      http://git.or.cz/
+      Description:   GIT - the stupid content tracker, the revision control system heavily used by the Linux kernel team
+      License:       GPL-2
+
+*  dev-util/gitosis [ Masked ]
+      Latest version available: 0.2_p20080825
+      Latest version installed: [ Not Installed ]
+      Size of files: 31 kB
+      Homepage:      http://eagain.net/gitweb/?p=gitosis.git;a=summary
+      Description:   gitosis -- software for hosting git repositories
+      License:       GPL-2
+EOF
+
+        @status = mock("Status", :exitstatus => 0)
+        @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
+        @provider.should_receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
+        lambda { @provider.candidate_version }.should raise_error(Chef::Exceptions::Package)
+      end
+
+    end
+
+    describe Chef::Provider::Package::Portage, "install_package" do
+      it "should install a normally versioned package using portage" do
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "emerge -g --color n --nospinner --quiet =dev-util/git-1.0.0"
+        })
+        @provider.install_package("dev-util/git", "1.0.0")
+      end
+
+      it "should install a tilde versioned package using portage" do
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "emerge -g --color n --nospinner --quiet ~dev-util/git-1.0.0"
+        })
+        @provider.install_package("dev-util/git", "~1.0.0")
+      end
+
+      it "should add options to the emerge command when specified" do
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "emerge -g --color n --nospinner --quiet --oneshot =dev-util/git-1.0.0"
+        })
+        @new_resource.stub!(:options).and_return("--oneshot")
+
+        @provider.install_package("dev-util/git", "1.0.0")
+      end
+    end
+
+    describe Chef::Provider::Package::Portage, "remove_package" do
+      it "should un-emerge the package with no version specified" do
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "emerge --unmerge --color n --nospinner --quiet dev-util/git"
+        })
+        @provider.remove_package("dev-util/git", nil)
+      end
+
+      it "should un-emerge the package with a version specified" do
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "emerge --unmerge --color n --nospinner --quiet =dev-util/git-1.0.0"
+        })
+        @provider.remove_package("dev-util/git", "1.0.0")
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/package/rpm_spec.rb b/spec/unit/provider/package/rpm_spec.rb
new file mode 100644
index 0000000000..9dd94a7441
--- /dev/null
+++ b/spec/unit/provider/package/rpm_spec.rb
@@ -0,0 +1,152 @@
+#
+# Author:: Joshua Timberman (<joshua@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2010 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'
+
+describe Chef::Provider::Package::Rpm do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    
+    @new_resource = Chef::Resource::Package.new("emacs")
+    @new_resource.source "/tmp/emacs-21.4-20.el5.i386.rpm"
+    
+    @provider = Chef::Provider::Package::Rpm.new(@new_resource, @run_context)
+    
+    @status = mock("Status", :exitstatus => 0)
+    ::File.stub!(:exists?).and_return(true)
+  end
+  
+  describe "when determining the current state of the package" do
+  
+    it "should create a current resource with the name of new_resource" do
+      @provider.stub!(:popen4).and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.name.should == "emacs"
+    end
+  
+    it "should set the current reource package name to the new resource package name" do
+      @provider.stub!(:popen4).and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.package_name.should == 'emacs'
+    end
+  
+    it "should raise an exception if a source is supplied but not found" do
+      ::File.stub!(:exists?).and_return(false)
+      lambda { @provider.run_action(:any) }.should raise_error(Chef::Exceptions::Package)
+    end
+  
+    it "should get the source package version from rpm if provided" do
+      @stdout = StringIO.new("emacs 21.4-20.el5")
+      @provider.should_receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' /tmp/emacs-21.4-20.el5.i386.rpm").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.should_receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' emacs").and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.package_name.should == "emacs"
+      @provider.new_resource.version.should == "21.4-20.el5"
+    end
+  
+    it "should return the current version installed if found by rpm" do
+      @stdout = StringIO.new("emacs 21.4-20.el5")
+      @provider.should_receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' /tmp/emacs-21.4-20.el5.i386.rpm").and_return(@status)
+      @provider.should_receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' emacs").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.version.should == "21.4-20.el5"
+    end
+  
+    it "should raise an exception if the source is not set but we are installing" do
+      new_resource = Chef::Resource::Package.new("emacs")
+      provider = Chef::Provider::Package::Rpm.new(new_resource, @run_context)
+      lambda { provider.run_action(:any) }.should raise_error(Chef::Exceptions::Package)
+    end
+  
+    it "should raise an exception if rpm fails to run" do
+      status = mock("Status", :exitstatus => -1)
+      @provider.stub!(:popen4).and_return(status)
+      lambda { @provider.run_action(:any) }.should raise_error(Chef::Exceptions::Package)
+    end
+  end
+  
+  describe "after the current resource is loaded" do
+    before do
+      @current_resource = Chef::Resource::Package.new("emacs")
+      @provider.current_resource = @current_resource
+    end
+
+    describe "when installing or upgrading" do
+      it "should run rpm -i with the package source to install" do
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "rpm  -i /tmp/emacs-21.4-20.el5.i386.rpm"
+        })
+        @provider.install_package("emacs", "21.4-20.el5")
+      end
+  
+      it "should run rpm -U with the package source to upgrade" do
+        @current_resource.version("21.4-19.el5")
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "rpm  -U /tmp/emacs-21.4-20.el5.i386.rpm"
+        })
+        @provider.upgrade_package("emacs", "21.4-20.el5")
+      end
+
+      it "should install from a path when the package is a path and the source is nil" do
+        @new_resource = Chef::Resource::Package.new("/tmp/emacs-21.4-20.el5.i386.rpm")
+        @provider = Chef::Provider::Package::Rpm.new(@new_resource, @run_context)
+        @new_resource.source.should == "/tmp/emacs-21.4-20.el5.i386.rpm"
+        @current_resource = Chef::Resource::Package.new("emacs")
+        @provider.current_resource = @current_resource
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "rpm  -i /tmp/emacs-21.4-20.el5.i386.rpm"
+        })
+        @provider.install_package("/tmp/emacs-21.4-20.el5.i386.rpm", "21.4-20.el5")
+      end
+
+      it "should uprgrade from a path when the package is a path and the source is nil" do
+        @new_resource = Chef::Resource::Package.new("/tmp/emacs-21.4-20.el5.i386.rpm")
+        @provider = Chef::Provider::Package::Rpm.new(@new_resource, @run_context)
+        @new_resource.source.should == "/tmp/emacs-21.4-20.el5.i386.rpm"
+        @current_resource = Chef::Resource::Package.new("emacs")
+        @current_resource.version("21.4-19.el5")
+        @provider.current_resource = @current_resource
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "rpm  -U /tmp/emacs-21.4-20.el5.i386.rpm"
+        })
+        @provider.upgrade_package("/tmp/emacs-21.4-20.el5.i386.rpm", "21.4-20.el5")
+      end
+
+      it "installs with custom options specified in the resource" do
+        @provider.candidate_version = '11'
+        @new_resource.options("--dbpath /var/lib/rpm")
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "rpm --dbpath /var/lib/rpm -i /tmp/emacs-21.4-20.el5.i386.rpm"
+        })
+        @provider.install_package(@new_resource.name, @provider.candidate_version)
+      end
+    end
+
+    describe "when removing the package" do
+      it "should run rpm -e to remove the package" do
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "rpm  -e emacs-21.4-20.el5"
+        })
+        @provider.remove_package("emacs", "21.4-20.el5")
+      end
+    end
+  end
+end
+
diff --git a/spec/unit/provider/package/rubygems_spec.rb b/spec/unit/provider/package/rubygems_spec.rb
new file mode 100644
index 0000000000..be4c3a99c4
--- /dev/null
+++ b/spec/unit/provider/package/rubygems_spec.rb
@@ -0,0 +1,614 @@
+#
+# Author:: David Balatero (dbalatero@gmail.com)
+#
+# Copyright:: Copyright (c) 2009 David Balatero
+# 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 'pp'
+
+module GemspecBackcompatCreator
+  def gemspec(name, version)
+    if Gem::Specification.new.method(:initialize).arity == 0
+      Gem::Specification.new { |s| s.name = name; s.version = version }
+    else
+      Gem::Specification.new(name, version)
+    end
+  end
+end
+
+require 'spec_helper'
+require 'ostruct'
+
+describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
+  include GemspecBackcompatCreator
+
+  before do
+    @gem_env = Chef::Provider::Package::Rubygems::CurrentGemEnvironment.new
+  end
+
+  it "determines the gem paths from the in memory rubygems" do
+    @gem_env.gem_paths.should == Gem.path
+  end
+
+  it "determines the installed versions of gems from Gem.source_index" do
+    gems = [gemspec('rspec-core', Gem::Version.new('1.2.9')), gemspec('rspec-core', Gem::Version.new('1.3.0'))]
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
+      Gem::Specification.should_receive(:find_all_by_name).with('rspec-core', Gem::Dependency.new('rspec-core').requirement).and_return(gems)
+    else
+      Gem.source_index.should_receive(:search).with(Gem::Dependency.new('rspec-core', nil)).and_return(gems)
+    end
+    @gem_env.installed_versions(Gem::Dependency.new('rspec-core', nil)).should == gems
+  end
+
+  it "determines the installed versions of gems from the source index (part2: the unmockening)" do
+    expected = ['rspec-core', Gem::Version.new(RSpec::Core::Version::STRING)]
+    actual = @gem_env.installed_versions(Gem::Dependency.new('rspec-core', nil)).map { |spec| [spec.name, spec.version] }
+    actual.should include(expected)
+  end
+
+  it "yields to a block with an alternate source list set" do
+    sources_in_block = nil
+    normal_sources = Gem.sources
+    begin
+      @gem_env.with_gem_sources("http://gems.example.org") do
+        sources_in_block = Gem.sources
+        raise RuntimeError, "sources should be reset even in case of an error"
+      end
+    rescue RuntimeError
+    end
+    sources_in_block.should == %w{http://gems.example.org}
+    Gem.sources.should == normal_sources
+  end
+
+  it "it doesnt alter the gem sources if none are set" do
+    sources_in_block = nil
+    normal_sources = Gem.sources
+    begin
+      @gem_env.with_gem_sources(nil) do
+        sources_in_block = Gem.sources
+        raise RuntimeError, "sources should be reset even in case of an error"
+      end
+    rescue RuntimeError
+    end
+    sources_in_block.should == normal_sources
+    Gem.sources.should == normal_sources
+  end
+
+  it "finds a matching gem candidate version" do
+    dep = Gem::Dependency.new('rspec', '>= 0')
+    dep_installer = Gem::DependencyInstaller.new
+    @gem_env.stub!(:dependency_installer).and_return(dep_installer)
+    latest = [[gemspec("rspec", Gem::Version.new("1.3.0")), "http://rubygems.org/"]]
+    dep_installer.should_receive(:find_gems_with_sources).with(dep).and_return(latest)
+    @gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0')).should == Gem::Version.new('1.3.0')
+  end
+
+  it "gives the candidate version as nil if none is found" do
+    dep = Gem::Dependency.new('rspec', '>= 0')
+    latest = []
+    dep_installer = Gem::DependencyInstaller.new
+    @gem_env.stub!(:dependency_installer).and_return(dep_installer)
+    dep_installer.should_receive(:find_gems_with_sources).with(dep).and_return(latest)
+    @gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0')).should be_nil
+  end
+
+  it "finds a matching candidate version from a .gem file when the path to the gem is supplied" do
+    location = CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem'
+    @gem_env.candidate_version_from_file(Gem::Dependency.new('chef-integration-test', '>= 0'), location).should == Gem::Version.new('0.1.0')
+    @gem_env.candidate_version_from_file(Gem::Dependency.new('chef-integration-test', '>= 0.2.0'), location).should be_nil
+  end
+
+  it "finds a matching gem from a specific gemserver when explicit sources are given" do
+    dep = Gem::Dependency.new('rspec', '>= 0')
+    latest = [[gemspec("rspec", Gem::Version.new("1.3.0")), "http://rubygems.org/"]]
+
+    @gem_env.should_receive(:with_gem_sources).with('http://gems.example.com').and_yield
+    dep_installer = Gem::DependencyInstaller.new
+    @gem_env.stub!(:dependency_installer).and_return(dep_installer)
+    dep_installer.should_receive(:find_gems_with_sources).with(dep).and_return(latest)
+    @gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>=0'), 'http://gems.example.com').should == Gem::Version.new('1.3.0')
+  end
+
+  it "installs a gem with a hash of options for the dependency installer" do
+    dep_installer = Gem::DependencyInstaller.new
+    @gem_env.should_receive(:dependency_installer).with(:install_dir => '/foo/bar').and_return(dep_installer)
+    @gem_env.should_receive(:with_gem_sources).with('http://gems.example.com').and_yield
+    dep_installer.should_receive(:install).with(Gem::Dependency.new('rspec', '>= 0'))
+    @gem_env.install(Gem::Dependency.new('rspec', '>= 0'), :install_dir => '/foo/bar', :sources => ['http://gems.example.com'])
+  end
+
+  it "builds an uninstaller for a gem with options set to avoid requiring user input" do
+    # default options for uninstaller should be:
+    # :ignore => true, :executables => true
+    Gem::Uninstaller.should_receive(:new).with('rspec', :ignore => true, :executables => true)
+    @gem_env.uninstaller('rspec')
+  end
+
+  it "uninstalls all versions of a gem" do
+    uninstaller = mock('gem uninstaller')
+    uninstaller.should_receive(:uninstall)
+    @gem_env.should_receive(:uninstaller).with('rspec', :all => true).and_return(uninstaller)
+    @gem_env.uninstall('rspec')
+  end
+
+  it "uninstalls a specific version of a gem" do
+    uninstaller = mock('gem uninstaller')
+    uninstaller.should_receive(:uninstall)
+    @gem_env.should_receive(:uninstaller).with('rspec', :version => '1.2.3').and_return(uninstaller)
+    @gem_env.uninstall('rspec', '1.2.3')
+  end
+
+end
+
+describe Chef::Provider::Package::Rubygems::AlternateGemEnvironment do
+  include GemspecBackcompatCreator
+
+  before do
+    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache.clear
+    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache.clear
+    @gem_env = Chef::Provider::Package::Rubygems::AlternateGemEnvironment.new('/usr/weird/bin/gem')
+  end
+
+  it "determines the gem paths from shelling out to gem env" do
+    gem_env_output = ['/path/to/gems', '/another/path/to/gems'].join(File::PATH_SEPARATOR)
+    shell_out_result = OpenStruct.new(:stdout => gem_env_output)
+    @gem_env.should_receive(:shell_out!).with('/usr/weird/bin/gem env gempath').and_return(shell_out_result)
+    @gem_env.gem_paths.should == ['/path/to/gems', '/another/path/to/gems']
+  end
+
+  it "caches the gempaths by gem_binary" do
+    gem_env_output = ['/path/to/gems', '/another/path/to/gems'].join(File::PATH_SEPARATOR)
+    shell_out_result = OpenStruct.new(:stdout => gem_env_output)
+    @gem_env.should_receive(:shell_out!).with('/usr/weird/bin/gem env gempath').and_return(shell_out_result)
+    expected = ['/path/to/gems', '/another/path/to/gems']
+    @gem_env.gem_paths.should == ['/path/to/gems', '/another/path/to/gems']
+    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache['/usr/weird/bin/gem'].should == expected
+  end
+
+  it "uses the cached result for gem paths when available" do
+    gem_env_output = ['/path/to/gems', '/another/path/to/gems'].join(File::PATH_SEPARATOR)
+    shell_out_result = OpenStruct.new(:stdout => gem_env_output)
+    @gem_env.should_not_receive(:shell_out!)
+    expected = ['/path/to/gems', '/another/path/to/gems']
+    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache['/usr/weird/bin/gem']= expected
+    @gem_env.gem_paths.should == ['/path/to/gems', '/another/path/to/gems']
+  end
+
+  it "builds the gems source index from the gem paths" do
+    @gem_env.stub!(:gem_paths).and_return(['/path/to/gems', '/another/path/to/gems'])
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
+      @gem_env.gem_specification
+      Gem::Specification.dirs.should == [ '/path/to/gems/specifications', '/another/path/to/gems/specifications' ]
+    else
+      Gem::SourceIndex.should_receive(:from_gems_in).with('/path/to/gems/specifications', '/another/path/to/gems/specifications')
+      @gem_env.gem_source_index
+    end
+  end
+
+  it "determines the installed versions of gems from the source index" do
+    gems = [gemspec('rspec', Gem::Version.new('1.2.9')), gemspec('rspec', Gem::Version.new('1.3.0'))]
+    rspec_dep = Gem::Dependency.new('rspec', nil)
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
+      @gem_env.stub!(:gem_specification).and_return(Gem::Specification)
+      @gem_env.gem_specification.should_receive(:find_all_by_name).with(rspec_dep.name, rspec_dep.requirement).and_return(gems)
+    else
+      @gem_env.stub!(:gem_source_index).and_return(Gem.source_index)
+      @gem_env.gem_source_index.should_receive(:search).with(rspec_dep).and_return(gems)
+    end
+    @gem_env.installed_versions(Gem::Dependency.new('rspec', nil)).should == gems
+  end
+
+  it "determines the installed versions of gems from the source index (part2: the unmockening)" do
+    $stdout.stub!(:write)
+    path_to_gem = if windows?
+      `where gem`.split[-1]
+    else
+      `which gem`.strip
+    end
+    pending("cant find your gem executable") if path_to_gem.empty?
+    gem_env = Chef::Provider::Package::Rubygems::AlternateGemEnvironment.new(path_to_gem)
+    expected = ['rspec-core', Gem::Version.new(RSpec::Core::Version::STRING)]
+    actual = gem_env.installed_versions(Gem::Dependency.new('rspec-core', nil)).map { |s| [s.name, s.version] }
+    actual.should include(expected)
+  end
+
+  it "detects when the target gem environment is the jruby platform" do
+    gem_env_out=<<-JRUBY_GEM_ENV
+RubyGems Environment:
+  - RUBYGEMS VERSION: 1.3.6
+  - RUBY VERSION: 1.8.7 (2010-05-12 patchlevel 249) [java]
+  - INSTALLATION DIRECTORY: /Users/you/.rvm/gems/jruby-1.5.0
+  - RUBY EXECUTABLE: /Users/you/.rvm/rubies/jruby-1.5.0/bin/jruby
+  - EXECUTABLE DIRECTORY: /Users/you/.rvm/gems/jruby-1.5.0/bin
+  - RUBYGEMS PLATFORMS:
+    - ruby
+    - universal-java-1.6
+  - GEM PATHS:
+     - /Users/you/.rvm/gems/jruby-1.5.0
+     - /Users/you/.rvm/gems/jruby-1.5.0@global
+  - GEM CONFIGURATION:
+     - :update_sources => true
+     - :verbose => true
+     - :benchmark => false
+     - :backtrace => false
+     - :bulk_threshold => 1000
+     - "install" => "--env-shebang"
+     - "update" => "--env-shebang"
+     - "gem" => "--no-rdoc --no-ri"
+     - :sources => ["http://rubygems.org/", "http://gems.github.com/"]
+  - REMOTE SOURCES:
+     - http://rubygems.org/
+     - http://gems.github.com/
+JRUBY_GEM_ENV
+    @gem_env.should_receive(:shell_out!).with('/usr/weird/bin/gem env').and_return(mock('jruby_gem_env', :stdout => gem_env_out))
+    expected = ['ruby', Gem::Platform.new('universal-java-1.6')]
+    @gem_env.gem_platforms.should == expected
+    # it should also cache the result
+    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem'].should == expected
+  end
+
+  it "uses the cached result for gem platforms if available" do
+    @gem_env.should_not_receive(:shell_out!)
+    expected = ['ruby', Gem::Platform.new('universal-java-1.6')]
+    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem']= expected
+    @gem_env.gem_platforms.should == expected
+  end
+
+  it "uses the current gem platforms when the target env is not jruby" do
+    gem_env_out=<<-RBX_GEM_ENV
+RubyGems Environment:
+  - RUBYGEMS VERSION: 1.3.6
+  - RUBY VERSION: 1.8.7 (2010-05-14 patchlevel 174) [x86_64-apple-darwin10.3.0]
+  - INSTALLATION DIRECTORY: /Users/ddeleo/.rvm/gems/rbx-1.0.0-20100514
+  - RUBYGEMS PREFIX: /Users/ddeleo/.rvm/rubies/rbx-1.0.0-20100514
+  - RUBY EXECUTABLE: /Users/ddeleo/.rvm/rubies/rbx-1.0.0-20100514/bin/rbx
+  - EXECUTABLE DIRECTORY: /Users/ddeleo/.rvm/gems/rbx-1.0.0-20100514/bin
+  - RUBYGEMS PLATFORMS:
+    - ruby
+    - x86_64-darwin-10
+    - x86_64-rubinius-1.0
+  - GEM PATHS:
+     - /Users/ddeleo/.rvm/gems/rbx-1.0.0-20100514
+     - /Users/ddeleo/.rvm/gems/rbx-1.0.0-20100514@global
+  - GEM CONFIGURATION:
+     - :update_sources => true
+     - :verbose => true
+     - :benchmark => false
+     - :backtrace => false
+     - :bulk_threshold => 1000
+     - :sources => ["http://rubygems.org/", "http://gems.github.com/"]
+     - "gem" => "--no-rdoc --no-ri"
+  - REMOTE SOURCES:
+     - http://rubygems.org/
+     - http://gems.github.com/
+RBX_GEM_ENV
+    @gem_env.should_receive(:shell_out!).with('/usr/weird/bin/gem env').and_return(mock('rbx_gem_env', :stdout => gem_env_out))
+    @gem_env.gem_platforms.should == Gem.platforms
+    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem'].should == Gem.platforms
+  end
+
+  it "yields to a block while masquerading as a different gems platform" do
+    original_platforms = Gem.platforms
+    platforms_in_block = nil
+    begin
+      @gem_env.with_gem_platforms(['ruby', Gem::Platform.new('sparc64-java-1.7')]) do
+        platforms_in_block = Gem.platforms
+        raise "gem platforms should get set to the correct value even when an error occurs"
+      end
+    rescue RuntimeError
+    end
+    platforms_in_block.should == ['ruby', Gem::Platform.new('sparc64-java-1.7')]
+    Gem.platforms.should == original_platforms
+  end
+
+end
+
+describe Chef::Provider::Package::Rubygems do
+  before(:each) do
+    @node = Chef::Node.new
+    @new_resource = Chef::Resource::GemPackage.new("rspec-core")
+    @spec_version = @new_resource.version RSpec::Core::Version::STRING
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    # We choose detect omnibus via RbConfig::CONFIG['bindir'] in Chef::Provider::Package::Rubygems.new
+    RbConfig::CONFIG.stub!(:[]).with('bindir').and_return("/usr/bin/ruby")
+    @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+  end
+
+  it "triggers a gem configuration load so a later one will not stomp its config values" do
+    # ugly, is there a better way?
+    Gem.instance_variable_get(:@configuration).should_not be_nil
+  end
+
+  it "uses the CurrentGemEnvironment implementation when no gem_binary_path is provided" do
+    @provider.gem_env.should be_a_kind_of(Chef::Provider::Package::Rubygems::CurrentGemEnvironment)
+  end
+
+  it "uses the AlternateGemEnvironment implementation when a gem_binary_path is provided" do
+    @new_resource.gem_binary('/usr/weird/bin/gem')
+    provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+    provider.gem_env.gem_binary_location.should == '/usr/weird/bin/gem'
+  end
+
+  it "searches for a gem binary when running on Omnibus on Unix" do
+    platform_mock :unix do
+      RbConfig::CONFIG.stub!(:[]).with('bindir').and_return("/opt/chef/embedded/bin")
+      ENV.stub!(:[]).with('PATH').and_return("/usr/bin:/usr/sbin:/opt/chef/embedded/bin")
+      File.stub!(:exists?).with('/usr/bin/gem').and_return(false)
+      File.stub!(:exists?).with('/usr/sbin/gem').and_return(true)
+      File.stub!(:exists?).with('/opt/chef/embedded/bin/gem').and_return(true) # should not get here
+      provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+      provider.gem_env.gem_binary_location.should == '/usr/sbin/gem'
+    end
+  end
+
+  it "searches for a gem binary when running on Omnibus on Windows" do
+    platform_mock :windows do
+      RbConfig::CONFIG.stub!(:[]).with('bindir').and_return("d:/opscode/chef/embedded/bin")
+      ENV.stub!(:[]).with('PATH').and_return('C:\windows\system32;C:\windows;C:\Ruby186\bin;d:\opscode\chef\embedded\bin')
+      File.stub!(:exists?).with('C:\\windows\\system32\\gem').and_return(false)
+      File.stub!(:exists?).with('C:\\windows\\gem').and_return(false)
+      File.stub!(:exists?).with('C:\\Ruby186\\bin\\gem').and_return(true)
+      File.stub!(:exists?).with('d:\\opscode\\chef\\bin\\gem').and_return(false) # should not get here
+      File.stub!(:exists?).with('d:\\opscode\\chef\\embedded\\bin\\gem').and_return(false) # should not get here
+      provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+      provider.gem_env.gem_binary_location.should == 'C:\Ruby186\bin\gem'
+    end
+  end
+
+  it "smites you when you try to use a hash of install options with an explicit gem binary" do
+    @new_resource.gem_binary('/foo/bar')
+    @new_resource.options(:fail => :burger)
+    lambda {Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)}.should raise_error(ArgumentError)
+  end
+
+  it "converts the new resource into a gem dependency" do
+    @provider.gem_dependency.should == Gem::Dependency.new('rspec-core', @spec_version)
+    @new_resource.version('~> 1.2.0')
+    @provider.gem_dependency.should == Gem::Dependency.new('rspec-core', '~> 1.2.0')
+  end
+
+  describe "when determining the currently installed version" do
+
+    it "sets the current version to the version specified by the new resource if that version is installed" do
+      @provider.load_current_resource
+      @provider.current_resource.version.should == @spec_version
+    end
+
+    it "sets the current version to the highest installed version if the requested version is not installed" do
+      @new_resource.version('9000.0.2')
+      @provider.load_current_resource
+      @provider.current_resource.version.should == @spec_version
+    end
+
+    it "leaves the current version at nil if the package is not installed" do
+      @new_resource.package_name("no-such-gem-should-exist-with-this-name")
+      @provider.load_current_resource
+      @provider.current_resource.version.should be_nil
+    end
+
+  end
+
+  describe "when determining the candidate version to install" do
+
+    it "does not query for available versions when the current version is the target version" do
+      @provider.current_resource = @new_resource.dup
+      @provider.candidate_version.should be_nil
+    end
+
+    it "determines the candidate version by querying the remote gem servers" do
+      @new_resource.source('http://mygems.example.com')
+      version = Gem::Version.new(@spec_version)
+      @provider.gem_env.should_receive(:candidate_version_from_remote).
+                        with(Gem::Dependency.new('rspec-core', @spec_version), "http://mygems.example.com").
+                        and_return(version)
+      @provider.candidate_version.should == @spec_version
+    end
+
+    it "parses the gem's specification if the requested source is a file" do
+      @new_resource.package_name('chef-integration-test')
+      @new_resource.version('>= 0')
+      @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+      @provider.candidate_version.should == '0.1.0'
+    end
+
+  end
+
+  describe "when installing a gem" do
+    before do
+      @current_resource = Chef::Resource::GemPackage.new('rspec-core')
+      @provider.current_resource = @current_resource
+      @gem_dep = Gem::Dependency.new('rspec-core', @spec_version)
+      @provider.stub!(:load_current_resource)
+    end
+
+    describe "in the current gem environment" do
+      it "installs the gem via the gems api when no explicit options are used" do
+        @provider.gem_env.should_receive(:install).with(@gem_dep, :sources => nil)
+        @provider.action_install.should be_true
+        @provider.converge
+      end
+
+      it "installs the gem via the gems api when a remote source is provided" do
+        @new_resource.source('http://gems.example.org')
+        sources = ['http://gems.example.org']
+        @provider.gem_env.should_receive(:install).with(@gem_dep, :sources => sources)
+        @provider.action_install.should be_true
+        @provider.converge
+      end
+
+      it "installs the gem from file via the gems api when no explicit options are used" do
+        @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+        @provider.gem_env.should_receive(:install).with(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+        @provider.action_install.should be_true
+        @provider.converge
+      end
+
+      it "installs the gem from file via the gems api when the package is a path and the source is nil" do
+        @new_resource = Chef::Resource::GemPackage.new(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+        @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+        @provider.current_resource = @current_resource
+        @new_resource.source.should == CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem'
+        @provider.gem_env.should_receive(:install).with(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+        @provider.action_install.should be_true
+        @provider.converge
+      end
+
+      # this catches 'gem_package "foo"' when "./foo" is a file in the cwd, and instead of installing './foo' it fetches the remote gem
+      it "installs the gem via the gems api, when the package has no file separator characters in it, but a matching file exists in cwd" do
+        ::File.stub!(:exists?).and_return(true)
+        @new_resource.package_name('rspec-core')
+        @provider.gem_env.should_receive(:install).with(@gem_dep, :sources => nil)
+        @provider.action_install.should be_true
+        @provider.converge
+      end
+
+      it "installs the gem by shelling out when options are provided as a String" do
+        @new_resource.options('-i /alt/install/location')
+        expected ="gem install rspec-core -q --no-rdoc --no-ri -v \"#{@spec_version}\" -i /alt/install/location"
+        @provider.should_receive(:shell_out!).with(expected, :env => nil)
+        @provider.action_install.should be_true
+        @provider.converge
+      end
+
+      it "installs the gem via the gems api when options are given as a Hash" do
+        @new_resource.options(:install_dir => '/alt/install/location')
+        @provider.gem_env.should_receive(:install).with(@gem_dep, :sources => nil, :install_dir => '/alt/install/location')
+        @provider.action_install.should be_true
+        @provider.converge
+      end
+
+      describe "at a specific version" do
+        before do
+          @gem_dep = Gem::Dependency.new('rspec-core', @spec_version)
+        end
+
+        it "installs the gem via the gems api" do
+          @provider.gem_env.should_receive(:install).with(@gem_dep, :sources => nil)
+          @provider.action_install.should be_true
+          @provider.converge
+        end
+      end
+      describe "at version specified with comparison operator" do
+        it "skips install if current version satisifies requested version" do
+          @current_resource.stub(:version).and_return("2.3.3")
+          @new_resource.stub(:version).and_return(">=2.3.0")
+
+          @provider.gem_env.should_not_receive(:install)
+          @provider.action_install
+          @provider.converge
+        end
+
+        it "allows user to specify gem version with fuzzy operator" do
+          @current_resource.stub(:version).and_return("2.3.3")
+          @new_resource.stub(:version).and_return("~>2.3.0")
+
+          @provider.gem_env.should_not_receive(:install)
+          @provider.action_install
+          @provider.converge
+        end
+      end
+    end
+
+    describe "in an alternate gem environment" do
+      it "installs the gem by shelling out to gem install" do
+        @new_resource.gem_binary('/usr/weird/bin/gem')
+        @provider.should_receive(:shell_out!).with("/usr/weird/bin/gem install rspec-core -q --no-rdoc --no-ri -v \"#{@spec_version}\"", :env=>nil)
+        @provider.action_install.should be_true
+        @provider.converge
+      end
+
+      it "installs the gem from file by shelling out to gem install" do
+        @new_resource.gem_binary('/usr/weird/bin/gem')
+        @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+        @new_resource.version('>= 0')
+        @provider.should_receive(:shell_out!).with("/usr/weird/bin/gem install #{CHEF_SPEC_DATA}/gems/chef-integration-test-0.1.0.gem -q --no-rdoc --no-ri -v \">= 0\"", :env=>nil)
+        @provider.action_install.should be_true
+        @provider.converge
+      end
+
+      it "installs the gem from file by shelling out to gem install when the package is a path and the source is nil" do
+        @new_resource = Chef::Resource::GemPackage.new(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+        @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+        @provider.current_resource = @current_resource
+        @new_resource.gem_binary('/usr/weird/bin/gem')
+        @new_resource.version('>= 0')
+        @new_resource.source.should == CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem'
+        @provider.should_receive(:shell_out!).with("/usr/weird/bin/gem install #{CHEF_SPEC_DATA}/gems/chef-integration-test-0.1.0.gem -q --no-rdoc --no-ri -v \">= 0\"", :env=>nil)
+        @provider.action_install.should be_true
+        @provider.converge
+      end
+    end
+
+  end
+
+  describe "when uninstalling a gem" do
+    before do
+      @new_resource = Chef::Resource::GemPackage.new("rspec")
+      @current_resource = @new_resource.dup
+      @current_resource.version('1.2.3')
+      @provider.new_resource = @new_resource
+      @provider.current_resource = @current_resource
+    end
+
+    describe "in the current gem environment" do
+      it "uninstalls via the api when no explicit options are used" do
+        # pre-reqs for action_remove to actually remove the package:
+        @provider.new_resource.version.should be_nil
+        @provider.current_resource.version.should_not be_nil
+        # the behavior we're testing:
+        @provider.gem_env.should_receive(:uninstall).with('rspec', nil)
+        @provider.action_remove
+        @provider.converge
+      end
+
+      it "uninstalls via the api when options are given as a Hash" do
+        # pre-reqs for action_remove to actually remove the package:
+        @provider.new_resource.version.should be_nil
+        @provider.current_resource.version.should_not be_nil
+        # the behavior we're testing:
+        @new_resource.options(:install_dir => '/alt/install/location')
+        @provider.gem_env.should_receive(:uninstall).with('rspec', nil, :install_dir => '/alt/install/location')
+        @provider.action_remove
+        @provider.converge
+      end
+
+      it "uninstalls via the gem command when options are given as a String" do
+        @new_resource.options('-i /alt/install/location')
+        @provider.should_receive(:shell_out!).with("gem uninstall rspec -q -x -I -a -i /alt/install/location", :env=>nil)
+        @provider.action_remove
+        @provider.converge
+      end
+
+      it "uninstalls a specific version of a gem when a version is provided" do
+        @new_resource.version('1.2.3')
+        @provider.gem_env.should_receive(:uninstall).with('rspec', '1.2.3')
+        @provider.action_remove
+        @provider.converge
+      end
+    end
+
+    describe "in an alternate gem environment" do
+      it "uninstalls via the gem command" do
+        @new_resource.gem_binary('/usr/weird/bin/gem')
+        @provider.should_receive(:shell_out!).with("/usr/weird/bin/gem uninstall rspec -q -x -I -a", :env=>nil)
+        @provider.action_remove
+        @provider.converge
+      end
+    end
+  end
+end
+
diff --git a/spec/unit/provider/package/smartos_spec.rb b/spec/unit/provider/package/smartos_spec.rb
new file mode 100644
index 0000000000..b4cfe7e409
--- /dev/null
+++ b/spec/unit/provider/package/smartos_spec.rb
@@ -0,0 +1,83 @@
+#
+# Author:: Trevor O (trevoro@joyent.com)
+# Copyright:: Copyright (c) 2012 Opscode
+# 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.join(File.dirname(__FILE__), "..", "..", "..", "spec_helper"))
+require 'ostruct'
+
+describe Chef::Provider::Package::SmartOS, "load_current_resource" do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource     = Chef::Resource::Package.new("varnish")
+    @current_resource = Chef::Resource::Package.new("varnish")
+		
+	
+	  @status = mock("Status", :exitstatus => 0)
+		@provider = Chef::Provider::Package::SmartOS.new(@new_resource, @run_context)
+		Chef::Resource::Package.stub!(:new).and_return(@current_resource)
+		@stdin = StringIO.new
+		@stdout = "varnish-2.1.5nb2\n"
+		@stderr = StringIO.new
+		@pid = 10
+		@shell_out = OpenStruct.new(:stdout => @stdout, :stdin => @stdin, :stderr => @stderr, :status => @status, :exitstatus => 0)
+  end
+
+	describe "when loading current resource" do
+
+    it "should create a current resource with the name of the new_resource" do
+			@provider.should_receive(:shell_out!).and_return(@shell_out)
+			Chef::Resource::Package.should_receive(:new).and_return(@current_resource)
+			@provider.load_current_resource
+    end
+
+		it "should set the current resource package name" do
+			@provider.should_receive(:shell_out!).and_return(@shell_out)
+			@current_resource.should_receive(:package_name).with(@new_resource.package_name)
+			@provider.load_current_resource
+		end
+
+		it "should set the installed version if it is installed" do
+		  @provider.should_receive(:shell_out!).and_return(@shell_out)
+			@provider.load_current_resource
+			@current_resource.version.should == "2.1.5nb2"
+	  end
+
+		it "should set the installed version to nil if it's not installed" do
+			out = OpenStruct.new(:stdout => nil)
+			@provider.should_receive(:shell_out!).and_return(out)
+			@provider.load_current_resource
+			@current_resource.version.should == nil
+		end
+
+
+	end
+
+	describe "when manipulating a resource" do
+	
+		it "run pkgin and install the package" do
+			out = OpenStruct.new(:stdout => nil)
+      @provider.should_receive(:shell_out!).with("pkg_info -E \"varnish*\"", {:env => nil, :returns=>[0,1]}).and_return(@shell_out)
+      @provider.should_receive(:shell_out!).with("pkgin -y install varnish-2.1.5nb2", {:env=>nil}).and_return(out)
+      @provider.load_current_resource
+      @provider.install_package("varnish", "2.1.5nb2")
+		end
+
+	end
+
+end
diff --git a/spec/unit/provider/package/solaris_spec.rb b/spec/unit/provider/package/solaris_spec.rb
new file mode 100644
index 0000000000..dd7cea2aaa
--- /dev/null
+++ b/spec/unit/provider/package/solaris_spec.rb
@@ -0,0 +1,181 @@
+#
+# Author:: Toomas Pelberg (<toomasp@gmx.net>)
+# Copyright:: Copyright (c) 2010 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'
+
+describe Chef::Provider::Package::Solaris do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Package.new("SUNWbash")
+    @new_resource.source("/tmp/bash.pkg")
+
+    @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
+    ::File.stub!(:exists?).and_return(true)
+  end
+
+  describe "assessing the current package status" do
+    before do
+      @pkginfo =<<-PKGINFO
+PKGINST:  SUNWbash
+NAME:  GNU Bourne-Again shell (bash)
+CATEGORY:  system
+ARCH:  sparc
+VERSION:  11.10.0,REV=2005.01.08.05.16
+BASEDIR:  /
+VENDOR:  Sun Microsystems, Inc.
+DESC:  GNU Bourne-Again shell (bash) version 3.0
+PSTAMP:  sfw10-patch20070430084444
+INSTDATE:  Nov 04 2009 01:02
+HOTLINE:  Please contact your local service provider
+PKGINFO
+
+      @status = mock("Status", :exitstatus => 0)
+    end
+
+    it "should create a current resource with the name of new_resource" do
+      @provider.stub!(:popen4).and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.name.should == "SUNWbash"
+    end
+
+    it "should set the current reource package name to the new resource package name" do
+      @provider.stub!(:popen4).and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.package_name.should == "SUNWbash"
+    end
+
+    it "should raise an exception if a source is supplied but not found" do
+      @provider.stub!(:popen4).and_return(@status)
+      ::File.stub!(:exists?).and_return(false)
+      @provider.define_resource_requirements
+      @provider.load_current_resource
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Package)
+    end
+
+
+    it "should get the source package version from pkginfo if provided" do
+      @stdout = StringIO.new(@pkginfo)
+      @stdin, @stderr = StringIO.new, StringIO.new
+      @provider.should_receive(:popen4).with("pkginfo -l -d /tmp/bash.pkg SUNWbash").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.should_receive(:popen4).with("pkginfo -l SUNWbash").and_return(@status)
+      @provider.load_current_resource
+
+      @provider.current_resource.package_name.should == "SUNWbash"
+      @new_resource.version.should == "11.10.0,REV=2005.01.08.05.16"
+    end
+
+    it "should return the current version installed if found by pkginfo" do
+      @stdout = StringIO.new(@pkginfo)
+      @stdin, @stderr = StringIO.new, StringIO.new
+      @provider.should_receive(:popen4).with("pkginfo -l -d /tmp/bash.pkg SUNWbash").and_return(@status)
+      @provider.should_receive(:popen4).with("pkginfo -l SUNWbash").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.version.should == "11.10.0,REV=2005.01.08.05.16"
+    end
+
+    it "should raise an exception if the source is not set but we are installing" do
+      @new_resource = Chef::Resource::Package.new("SUNWbash")
+      @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
+      @provider.stub!(:popen4).and_return(@status)
+      lambda { @provider.run_action(:install) }.should raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should raise an exception if pkginfo fails to run" do
+      @status = mock("Status", :exitstatus => -1)
+      @provider.stub!(:popen4).and_return(@status)
+      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should return a current resource with a nil version if the package is not found" do
+      @stdout = StringIO.new
+      @provider.should_receive(:popen4).with("pkginfo -l -d /tmp/bash.pkg SUNWbash").and_return(@status)
+      @provider.should_receive(:popen4).with("pkginfo -l SUNWbash").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.version.should be_nil
+    end
+  end
+
+  describe "candidate_version" do
+    it "should return the candidate_version variable if already setup" do
+      @provider.candidate_version = "11.10.0,REV=2005.01.08.05.16"
+      @provider.should_not_receive(:popen4)
+      @provider.candidate_version
+    end
+
+    it "should lookup the candidate_version if the variable is not already set" do
+      @status = mock("Status", :exitstatus => 0)
+      @provider.stub!(:popen4).and_return(@status)
+      @provider.should_receive(:popen4)
+      @provider.candidate_version
+    end
+
+    it "should throw and exception if the exitstatus is not 0" do
+      @status = mock("Status", :exitstatus => 1)
+      @provider.stub!(:popen4).and_return(@status)
+      lambda { @provider.candidate_version }.should raise_error(Chef::Exceptions::Package)
+    end
+
+  end
+
+  describe "install and upgrade" do
+    it "should run pkgadd -n -d with the package source to install" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pkgadd -n -d /tmp/bash.pkg all"
+      })
+      @provider.install_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
+    end
+
+    it "should run pkgadd -n -d when the package is a path to install" do
+      @new_resource = Chef::Resource::Package.new("/tmp/bash.pkg")
+      @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
+      @new_resource.source.should == "/tmp/bash.pkg"
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pkgadd -n -d /tmp/bash.pkg all"
+      })
+      @provider.install_package("/tmp/bash.pkg", "11.10.0,REV=2005.01.08.05.16")
+    end
+
+    it "should run pkgadd -n -a /tmp/myadmin -d with the package options -a /tmp/myadmin" do
+      @new_resource.stub!(:options).and_return("-a /tmp/myadmin")
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pkgadd -n -a /tmp/myadmin -d /tmp/bash.pkg all"
+      })
+      @provider.install_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
+    end
+  end
+
+  describe "remove" do
+    it "should run pkgrm -n to remove the package" do
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pkgrm -n SUNWbash"
+      })
+      @provider.remove_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
+    end
+
+    it "should run pkgrm -n -a /tmp/myadmin with options -a /tmp/myadmin" do
+      @new_resource.stub!(:options).and_return("-a /tmp/myadmin")
+      @provider.should_receive(:run_command_with_systems_locale).with({
+        :command => "pkgrm -n -a /tmp/myadmin SUNWbash"
+      })
+      @provider.remove_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
+    end
+
+  end
+end
diff --git a/spec/unit/provider/package/yum_spec.rb b/spec/unit/provider/package/yum_spec.rb
new file mode 100644
index 0000000000..0002ec39f3
--- /dev/null
+++ b/spec/unit/provider/package/yum_spec.rb
@@ -0,0 +1,1795 @@
+#
+# 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 'spec_helper'
+
+describe Chef::Provider::Package::Yum do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Package.new('cups')
+    @status = mock("Status", :exitstatus => 0)
+    @yum_cache = mock(
+      'Chef::Provider::Yum::YumCache',
+      :reload_installed => true,
+      :reset => true,
+      :installed_version => "1.2.4-11.18.el5",
+      :candidate_version => "1.2.4-11.18.el5_2.3",
+      :package_available? => true,
+      :version_available? => true,
+      :allow_multi_install => [ "kernel" ],
+      :package_repository => "base" 
+    )
+    Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+    @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+    @stderr = StringIO.new
+    @pid = mock("PID")
+  end
+
+  describe "when loading the current system state" do
+    it "should create a current resource with the name of the new_resource" do
+      @provider.load_current_resource
+      @provider.current_resource.name.should == "cups"
+    end
+
+    it "should set the current resources package name to the new resources package name" do
+      @provider.load_current_resource
+      @provider.current_resource.package_name.should == "cups"
+    end
+
+    it "should set the installed version to nil on the current resource if no installed package" do
+      @yum_cache.stub!(:installed_version).and_return(nil)
+      @provider.load_current_resource
+      @provider.current_resource.version.should be_nil
+    end
+
+    it "should set the installed version if yum has one" do
+      @provider.load_current_resource
+      @provider.current_resource.version.should == "1.2.4-11.18.el5"
+    end
+
+    it "should set the candidate version if yum info has one" do
+      @provider.load_current_resource
+      @provider.candidate_version.should eql("1.2.4-11.18.el5_2.3")
+    end
+
+    it "should return the current resouce" do
+      @provider.load_current_resource.should eql(@provider.current_resource)
+    end
+
+    describe "when arch in package_name" do
+      it "should set the arch if no existing package_name is found and new_package_name+new_arch is available" do
+        @new_resource = Chef::Resource::YumPackage.new('testing.noarch')
+        @yum_cache = mock(
+          'Chef::Provider::Yum::YumCache'
+        )
+        @yum_cache.stub!(:installed_version) do |package_name, arch|
+          # nothing installed for package_name/new_package_name
+          nil
+        end
+        @yum_cache.stub!(:candidate_version) do |package_name, arch|
+          if package_name == "testing.noarch" || package_name == "testing.more.noarch"
+            nil
+          # candidate for new_package_name
+          elsif package_name == "testing" || package_name == "testing.more"
+            "1.1"
+          end
+        end
+        @yum_cache.stub!(:package_available?).and_return(true)
+        Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+        @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+        @provider.load_current_resource
+        @provider.new_resource.package_name.should == "testing"
+        @provider.new_resource.arch.should == "noarch"
+        @provider.arch.should == "noarch"
+
+        @new_resource = Chef::Resource::YumPackage.new('testing.more.noarch')
+        @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+        @provider.load_current_resource
+        @provider.new_resource.package_name.should == "testing.more"
+        @provider.new_resource.arch.should == "noarch"
+        @provider.arch.should == "noarch"
+      end
+
+      it "should not set the arch when an existing package_name is found" do
+        @new_resource = Chef::Resource::YumPackage.new('testing.beta3')
+        @yum_cache = mock(
+          'Chef::Provider::Yum::YumCache'
+        )
+        @yum_cache.stub!(:installed_version) do |package_name, arch|
+          # installed for package_name
+          if package_name == "testing.beta3" || package_name == "testing.beta3.more"
+            "1.1"
+          elsif package_name == "testing" || package_name == "testing.beta3"
+            nil
+          end
+        end
+        @yum_cache.stub!(:candidate_version) do |package_name, arch|
+          # no candidate for package_name/new_package_name
+          nil
+        end
+        @yum_cache.stub!(:package_available?).and_return(true)
+        Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+        @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+        # annoying side effect of the fun stub'ing above
+        @provider.load_current_resource
+        @provider.new_resource.package_name.should == "testing.beta3"
+        @provider.new_resource.arch.should == nil
+        @provider.arch.should == nil
+
+        @new_resource = Chef::Resource::YumPackage.new('testing.beta3.more')
+        @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+        @provider.load_current_resource
+        @provider.new_resource.package_name.should == "testing.beta3.more"
+        @provider.new_resource.arch.should == nil
+        @provider.arch.should == nil
+      end
+
+      it "should not set the arch when no existing package_name or new_package_name+new_arch is found" do
+        @new_resource = Chef::Resource::YumPackage.new('testing.beta3')
+        @yum_cache = mock(
+          'Chef::Provider::Yum::YumCache'
+        )
+        @yum_cache.stub!(:installed_version) do |package_name, arch|
+          # nothing installed for package_name/new_package_name
+          nil
+        end
+        @yum_cache.stub!(:candidate_version) do |package_name, arch|
+          # no candidate for package_name/new_package_name
+          nil
+        end
+        @yum_cache.stub!(:package_available?).and_return(true)
+        Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+        @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+        @provider.load_current_resource
+        @provider.new_resource.package_name.should == "testing.beta3"
+        @provider.new_resource.arch.should == nil
+        @provider.arch.should == nil
+
+        @new_resource = Chef::Resource::YumPackage.new('testing.beta3.more')
+        @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+        @provider.load_current_resource
+        @provider.new_resource.package_name.should == "testing.beta3.more"
+        @provider.new_resource.arch.should == nil
+        @provider.arch.should == nil
+      end
+
+      it "should ensure it doesn't clobber an existing arch if passed" do
+        @new_resource = Chef::Resource::YumPackage.new('testing.i386')
+        @new_resource.arch("x86_64")
+        @yum_cache = mock(
+          'Chef::Provider::Yum::YumCache'
+        )
+         @yum_cache.stub!(:installed_version) do |package_name, arch|
+           # nothing installed for package_name/new_package_name
+         nil
+        end
+        @yum_cache.stub!(:candidate_version) do |package_name, arch|
+          if package_name == "testing.noarch"
+            nil
+          # candidate for new_package_name
+          elsif package_name == "testing"
+            "1.1"
+          end
+        end.and_return("something")
+        @yum_cache.stub!(:package_available?).and_return(true)
+        Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+        @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+        @provider.load_current_resource
+        @provider.new_resource.package_name.should == "testing.i386"
+        @provider.new_resource.arch.should == "x86_64"
+      end
+    end
+
+    it "should flush the cache if :before is true" do
+      @new_resource.stub!(:flush_cache).and_return({:after => false, :before => true})
+      @yum_cache.should_receive(:reload).once
+      @provider.load_current_resource
+    end
+
+    it "should flush the cache if :before is false" do
+      @new_resource.stub!(:flush_cache).and_return({:after => false, :before => false})
+      @yum_cache.should_not_receive(:reload)
+      @provider.load_current_resource
+    end
+
+    it "should search provides if package name can't be found then set package_name to match" do
+      @yum_cache = mock(
+        'Chef::Provider::Yum::YumCache',
+        :reload_installed => true,
+        :reset => true,
+        :installed_version => "1.2.4-11.18.el5",
+        :candidate_version => "1.2.4-11.18.el5",
+        :package_available? => false,
+        :version_available? => true
+      )
+      Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+      pkg = Chef::Provider::Package::Yum::RPMPackage.new("test-package", "1.2.4-11.18.el5", "x86_64", [])
+      @yum_cache.should_receive(:packages_from_require).and_return([pkg])
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      @provider.load_current_resource
+      @new_resource.package_name.should == "test-package"
+    end
+
+    it "should search provides if package name can't be found, warn about multiple matches, but use the first one" do
+      @yum_cache = mock(
+        'Chef::Provider::Yum::YumCache',
+        :reload_installed => true,
+        :reset => true,
+        :installed_version => "1.2.4-11.18.el5",
+        :candidate_version => "1.2.4-11.18.el5",
+        :package_available? => false,
+        :version_available? => true
+      )
+      Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+      pkg_x = Chef::Provider::Package::Yum::RPMPackage.new("test-package-x", "1.2.4-11.18.el5", "x86_64", [])
+      pkg_y = Chef::Provider::Package::Yum::RPMPackage.new("test-package-y", "1.2.6-11.3.el5", "i386", [])
+      @yum_cache.should_receive(:packages_from_require).and_return([pkg_x, pkg_y])
+      Chef::Log.should_receive(:warn).exactly(1).times.with(%r{matched multiple Provides})
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      @provider.load_current_resource
+      @new_resource.package_name.should == "test-package-x"
+    end
+
+    it "should search provides if no package is available - if no match in installed provides then load the complete set" do
+      @yum_cache = mock(
+        'Chef::Provider::Yum::YumCache',
+        :reload_installed => true,
+        :reset => true,
+        :installed_version => "1.2.4-11.18.el5",
+        :candidate_version => "1.2.4-11.18.el5",
+        :package_available? => false,
+        :version_available? => true
+      )
+      Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+      @yum_cache.should_receive(:packages_from_require).twice.and_return([])
+      @yum_cache.should_receive(:reload_provides)
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      @provider.load_current_resource
+    end
+
+    it "should search provides if no package is available and not load the complete set if action is :remove or :purge" do
+      @yum_cache = mock(
+        'Chef::Provider::Yum::YumCache',
+        :reload_installed => true,
+        :reset => true,
+        :installed_version => "1.2.4-11.18.el5",
+        :candidate_version => "1.2.4-11.18.el5",
+        :package_available? => false,
+        :version_available? => true
+      )
+      Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      @yum_cache.should_receive(:packages_from_require).once.and_return([])
+      @yum_cache.should_not_receive(:reload_provides)
+      @new_resource.action(:remove)
+      @provider.load_current_resource
+      @yum_cache.should_receive(:packages_from_require).once.and_return([])
+      @yum_cache.should_not_receive(:reload_provides)
+      @new_resource.action(:purge)
+      @provider.load_current_resource
+    end
+
+    it "should search provides if no package is available - if no match in provides leave the name intact" do
+      @yum_cache = mock(
+        'Chef::Provider::Yum::YumCache',
+        :reload_provides => true,
+        :reload_installed => true,
+        :reset => true,
+        :installed_version => "1.2.4-11.18.el5",
+        :candidate_version => "1.2.4-11.18.el5",
+        :package_available? => false,
+        :version_available? => true
+      )
+      Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+      @yum_cache.should_receive(:packages_from_require).twice.and_return([])
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      @provider.load_current_resource
+      @new_resource.package_name.should == "cups"
+    end
+  end
+
+  describe "when installing a package" do
+    it "should run yum install with the package name and version" do
+      @provider.load_current_resource
+      Chef::Provider::Package::Yum::RPMUtils.stub!(:rpmvercmp).and_return(-1)
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y install emacs-1.0"
+      )
+      @provider.install_package("emacs", "1.0")
+    end
+
+    it "should run yum localinstall if given a path to an rpm" do
+      @new_resource.stub!(:source).and_return("/tmp/emacs-21.4-20.el5.i386.rpm")
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y localinstall /tmp/emacs-21.4-20.el5.i386.rpm"
+      )
+      @provider.install_package("emacs", "21.4-20.el5")
+    end
+
+    it "should run yum localinstall if given a path to an rpm as the package" do
+      @new_resource = Chef::Resource::Package.new("/tmp/emacs-21.4-20.el5.i386.rpm")
+      ::File.stub!(:exists?).and_return(true)
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      @new_resource.source.should == "/tmp/emacs-21.4-20.el5.i386.rpm"
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y localinstall /tmp/emacs-21.4-20.el5.i386.rpm"
+      )
+      @provider.install_package("/tmp/emacs-21.4-20.el5.i386.rpm", "21.4-20.el5")
+    end
+
+    it "should run yum install with the package name, version and arch" do
+      @provider.load_current_resource
+      @new_resource.stub!(:arch).and_return("i386")
+      Chef::Provider::Package::Yum::RPMUtils.stub!(:rpmvercmp).and_return(-1)
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y install emacs-21.4-20.el5.i386"
+      )
+      @provider.install_package("emacs", "21.4-20.el5")
+    end
+
+    it "installs the package with the options given in the resource" do
+      @provider.load_current_resource
+      @provider.candidate_version = '11'
+      @new_resource.stub!(:options).and_return("--disablerepo epmd")
+      Chef::Provider::Package::Yum::RPMUtils.stub!(:rpmvercmp).and_return(-1)
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y --disablerepo epmd install cups-11"
+      )
+      @provider.install_package(@new_resource.name, @provider.candidate_version)
+    end
+
+    it "should raise an exception if the package is not available" do
+      @yum_cache = mock(
+        'Chef::Provider::Yum::YumCache',
+        :reload_from_cache => true,
+        :reset => true,
+        :installed_version => "1.2.4-11.18.el5",
+        :candidate_version => "1.2.4-11.18.el5_2.3",
+        :package_available? => true,
+        :version_available? => nil
+      )
+      Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      lambda { @provider.install_package("lolcats", "0.99") }.should raise_error(Chef::Exceptions::Package, %r{Version .* not found})
+    end
+
+    it "should raise an exception if candidate version is older than the installed version and allow_downgrade is false" do
+      @new_resource.stub!(:allow_downgrade).and_return(false)
+      @yum_cache = mock(
+        'Chef::Provider::Yum::YumCache',
+        :reload_installed => true,
+        :reset => true,
+        :installed_version => "1.2.4-11.18.el5",
+        :candidate_version => "1.2.4-11.15.el5",
+        :package_available? => true,
+        :version_available? => true,
+        :allow_multi_install => [ "kernel" ]
+      )
+      Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      @provider.load_current_resource
+      lambda { @provider.install_package("cups", "1.2.4-11.15.el5") }.should raise_error(Chef::Exceptions::Package, %r{is newer than candidate package})
+    end
+
+    it "should not raise an exception if candidate version is older than the installed version and the package is list in yum's installonlypkg option" do
+      @yum_cache = mock(
+        'Chef::Provider::Yum::YumCache',
+        :reload_installed => true,
+        :reset => true,
+        :installed_version => "1.2.4-11.18.el5",
+        :candidate_version => "1.2.4-11.15.el5",
+        :package_available? => true,
+        :version_available? => true,
+        :allow_multi_install => [ "cups" ],
+        :package_repository => "base"
+      )
+      Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      @provider.load_current_resource
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y install cups-1.2.4-11.15.el5"
+      )
+      @provider.install_package("cups", "1.2.4-11.15.el5")
+    end
+
+    it "should run yum downgrade if candidate version is older than the installed version and allow_downgrade is true" do
+      @new_resource.stub!(:allow_downgrade).and_return(true)
+      @yum_cache = mock(
+        'Chef::Provider::Yum::YumCache',
+        :reload_installed => true,
+        :reset => true,
+        :installed_version => "1.2.4-11.18.el5",
+        :candidate_version => "1.2.4-11.15.el5",
+        :package_available? => true,
+        :version_available? => true,
+        :allow_multi_install => [],
+        :package_repository => "base"
+      )
+      Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      @provider.load_current_resource
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y downgrade cups-1.2.4-11.15.el5"
+      )
+      @provider.install_package("cups", "1.2.4-11.15.el5")
+    end
+
+    it "should run yum install then flush the cache if :after is true" do
+      @new_resource.stub!(:flush_cache).and_return({:after => true, :before => false})
+      @provider.load_current_resource
+      Chef::Provider::Package::Yum::RPMUtils.stub!(:rpmvercmp).and_return(-1)
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y install emacs-1.0"
+      )
+      @yum_cache.should_receive(:reload).once
+      @provider.install_package("emacs", "1.0")
+    end
+
+    it "should run yum install then not flush the cache if :after is false" do
+      @new_resource.stub!(:flush_cache).and_return({:after => false, :before => false})
+      @provider.load_current_resource
+      Chef::Provider::Package::Yum::RPMUtils.stub!(:rpmvercmp).and_return(-1)
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y install emacs-1.0"
+      )
+      @yum_cache.should_not_receive(:reload)
+      @provider.install_package("emacs", "1.0")
+    end
+  end
+
+  describe "when upgrading a package" do
+    it "should run yum install if the package is installed and a version is given" do
+      @provider.load_current_resource
+      @provider.candidate_version = '11'
+      Chef::Provider::Package::Yum::RPMUtils.stub!(:rpmvercmp).and_return(-1)
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y install cups-11"
+      )
+      @provider.upgrade_package(@new_resource.name, @provider.candidate_version)
+    end
+
+    it "should run yum install if the package is not installed" do
+      @provider.load_current_resource
+      @current_resource = Chef::Resource::Package.new('cups')
+      @provider.candidate_version = '11'
+      Chef::Provider::Package::Yum::RPMUtils.stub!(:rpmvercmp).and_return(-1)
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y install cups-11"
+      )
+      @provider.upgrade_package(@new_resource.name, @provider.candidate_version)
+    end
+
+    it "should raise an exception if candidate version is older than the installed version" do
+      @yum_cache = mock(
+        'Chef::Provider::Yum::YumCache',
+        :reload_installed => true,
+        :reset => true,
+        :installed_version => "1.2.4-11.18.el5",
+        :candidate_version => "1.2.4-11.15.el5",
+        :package_available? => true,
+        :version_available? => true,
+        :allow_multi_install => [ "kernel" ]
+      )
+      Chef::Provider::Package::Yum::YumCache.stub!(:instance).and_return(@yum_cache)
+      @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
+      @provider.load_current_resource
+      lambda { @provider.upgrade_package("cups", "1.2.4-11.15.el5") }.should raise_error(Chef::Exceptions::Package, %r{is newer than candidate package})
+    end
+
+    # Test our little workaround, some crossover into Chef::Provider::Package territory
+    it "should call action_upgrade in the parent if the current resource version is nil" do
+      @yum_cache.stub!(:installed_version).and_return(nil)
+      @provider.load_current_resource
+      @current_resource = Chef::Resource::Package.new('cups')
+      @provider.candidate_version = '11'
+      @provider.should_receive(:upgrade_package).with(
+        "cups",
+        "11"
+      )
+      @provider.action_upgrade
+      @provider.converge
+    end
+
+    it "should call action_upgrade in the parent if the candidate version is nil" do
+      @provider.load_current_resource
+      @current_resource = Chef::Resource::Package.new('cups')
+      @provider.candidate_version = nil 
+      @provider.should_not_receive(:upgrade_package)
+      @provider.action_upgrade
+      @provider.converge
+    end
+
+    it "should call action_upgrade in the parent if the candidate is newer" do
+      @provider.load_current_resource
+      @current_resource = Chef::Resource::Package.new('cups')
+      @provider.candidate_version = '11'
+      @provider.should_receive(:upgrade_package).with(
+        "cups",
+        "11"
+      )
+      @provider.action_upgrade
+      @provider.converge
+    end
+
+    it "should not call action_upgrade in the parent if the candidate is older" do
+      @yum_cache.stub!(:installed_version).and_return("12")
+      @provider.load_current_resource
+      @current_resource = Chef::Resource::Package.new('cups')
+      @provider.candidate_version = '11'
+      @provider.should_not_receive(:upgrade_package)
+      @provider.action_upgrade
+      @provider.converge
+    end
+  end
+
+  describe "when removing a package" do
+    it "should run yum remove with the package name" do
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y remove emacs-1.0"
+      )
+      @provider.remove_package("emacs", "1.0")
+    end
+
+    it "should run yum remove with the package name and arch" do
+      @new_resource.stub!(:arch).and_return("x86_64")
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y remove emacs-1.0.x86_64"
+      )
+      @provider.remove_package("emacs", "1.0")
+    end
+  end
+
+  describe "when purging a package" do
+    it "should run yum remove with the package name" do
+      @provider.should_receive(:yum_command).with(
+        "yum -d0 -e0 -y remove emacs-1.0"
+      )
+      @provider.purge_package("emacs", "1.0")
+    end
+  end
+
+  describe "when running yum" do
+    it "should run yum once if it exits with a return code of 0" do
+      @status = mock("Status", :exitstatus => 0)
+      @provider.stub!(:output_of_command).and_return([@status, "", ""])
+      @provider.should_receive(:output_of_command).once.with(
+        "yum -d0 -e0 -y install emacs-1.0",
+        {}
+      )
+      @provider.yum_command("yum -d0 -e0 -y install emacs-1.0")
+    end
+
+    it "should run yum once if it exits with a return code > 0 and no scriptlet failures" do
+      @status = mock("Status", :exitstatus => 2)
+      @provider.stub!(:output_of_command).and_return([@status, "failure failure", "problem problem"])
+      @provider.should_receive(:output_of_command).once.with(
+        "yum -d0 -e0 -y install emacs-1.0",
+        {}
+      )
+      lambda { @provider.yum_command("yum -d0 -e0 -y install emacs-1.0") }.should raise_error(Chef::Exceptions::Exec)
+    end
+
+    it "should run yum once if it exits with a return code of 1 and %pre scriptlet failures" do
+      @status = mock("Status", :exitstatus => 1)
+      @provider.stub!(:output_of_command).and_return([@status, "error: %pre(demo-1-1.el5.centos.x86_64) scriptlet failed, exit status 2", ""])
+      @provider.should_receive(:output_of_command).once.with(
+        "yum -d0 -e0 -y install emacs-1.0",
+        {}
+      )
+      # will still raise an exception, can't stub out the subsequent call
+      lambda { @provider.yum_command("yum -d0 -e0 -y install emacs-1.0") }.should raise_error(Chef::Exceptions::Exec)
+    end
+
+    it "should run yum twice if it exits with a return code of 1 and %post scriptlet failures" do
+      @status = mock("Status", :exitstatus => 1)
+      @provider.stub!(:output_of_command).and_return([@status, "error: %post(demo-1-1.el5.centos.x86_64) scriptlet failed, exit status 2", ""])
+      @provider.should_receive(:output_of_command).twice.with(
+        "yum -d0 -e0 -y install emacs-1.0",
+        {}
+      )
+      # will still raise an exception, can't stub out the subsequent call
+      lambda { @provider.yum_command("yum -d0 -e0 -y install emacs-1.0") }.should raise_error(Chef::Exceptions::Exec)
+    end
+  end
+end
+
+describe Chef::Provider::Package::Yum::RPMUtils do
+  describe "version_parse" do
+    before do
+      @rpmutils = Chef::Provider::Package::Yum::RPMUtils
+    end
+
+    it "parses known good epoch strings" do
+      [
+        [ "0:3.3", [ 0, "3.3", nil ] ],
+        [ "9:1.7.3", [ 9, "1.7.3", nil ] ],
+        [ "15:20020927", [ 15, "20020927", nil ] ]
+      ].each do |x, y|
+        @rpmutils.version_parse(x).should == y
+      end
+    end
+
+    it "parses strange epoch strings" do
+      [
+        [ ":3.3", [ 0, "3.3", nil ] ],
+        [ "-1:1.7.3", [ nil, nil, "1:1.7.3" ] ],
+        [ "-:20020927", [ nil, nil, ":20020927" ] ]
+      ].each do |x, y|
+        @rpmutils.version_parse(x).should == y
+      end
+    end
+
+    it "parses known good version strings" do
+      [
+        [ "3.3", [ nil, "3.3", nil ] ],
+        [ "1.7.3", [ nil, "1.7.3", nil ] ],
+        [ "20020927", [ nil, "20020927", nil ] ]
+      ].each do |x, y|
+        @rpmutils.version_parse(x).should == y
+      end
+    end
+
+    it "parses strange version strings" do
+      [
+        [ "3..3", [ nil, "3..3", nil ] ],
+        [ "0001.7.3", [ nil, "0001.7.3", nil ] ],
+        [ "20020927,3", [ nil, "20020927,3", nil ] ]
+      ].each do |x, y|
+        @rpmutils.version_parse(x).should == y
+      end
+    end
+
+    it "parses known good version release strings" do
+      [
+        [ "3.3-0.pre3.1.60.el5_5.1", [ nil, "3.3", "0.pre3.1.60.el5_5.1" ] ],
+        [ "1.7.3-1jpp.2.el5", [ nil, "1.7.3", "1jpp.2.el5" ] ],
+        [ "20020927-46.el5", [ nil, "20020927", "46.el5" ] ]
+      ].each do |x, y|
+        @rpmutils.version_parse(x).should == y
+      end
+    end
+
+    it "parses strange version release strings" do
+      [
+        [ "3.3-", [ nil, "3.3", nil ] ],
+        [ "-1jpp.2.el5", [ nil, nil, "1jpp.2.el5" ] ],
+        [ "-0020020927-46.el5", [ nil, "-0020020927", "46.el5" ] ]
+      ].each do |x, y|
+        @rpmutils.version_parse(x).should == y
+      end
+    end
+  end
+
+  describe "rpmvercmp" do
+    before do
+      @rpmutils = Chef::Provider::Package::Yum::RPMUtils
+    end
+
+    it "should validate version compare logic for standard examples" do
+      [
+        # numeric
+        [ "0.0.2", "0.0.1", 1 ],
+        [ "0.2.0", "0.1.0", 1 ],
+        [ "2.0.0", "1.0.0", 1 ],
+        [ "0.0.1", "0.0.1", 0 ],
+        [ "0.0.1", "0.0.2", -1 ],
+        [ "0.1.0", "0.2.0", -1 ],
+        [ "1.0.0", "2.0.0", -1 ],
+        # alpha
+        [ "bb", "aa", 1 ],
+        [ "ab", "aa", 1 ],
+        [ "aa", "aa", 0 ],
+        [ "aa", "bb", -1 ],
+        [ "aa", "ab", -1 ],
+        [ "BB", "AA", 1 ],
+        [ "AA", "AA", 0 ],
+        [ "AA", "BB", -1 ],
+        [ "aa", "AA", 1 ],
+        [ "AA", "aa", -1 ],
+        # alphanumeric
+        [ "0.0.1b", "0.0.1a", 1 ],
+        [ "0.1b.0", "0.1a.0", 1 ],
+        [ "1b.0.0", "1a.0.0", 1 ],
+        [ "0.0.1a", "0.0.1a", 0 ],
+        [ "0.0.1a", "0.0.1b", -1 ],
+        [ "0.1a.0", "0.1b.0", -1 ],
+        [ "1a.0.0", "1b.0.0", -1 ],
+        # alphanumeric against alphanumeric
+        [ "0.0.1", "0.0.a", 1 ],
+        [ "0.1.0", "0.a.0", 1 ],
+        [ "1.0.0", "a.0.0", 1 ],
+        [ "0.0.a", "0.0.a", 0 ],
+        [ "0.0.a", "0.0.1", -1 ],
+        [ "0.a.0", "0.1.0", -1 ],
+        [ "a.0.0", "1.0.0", -1 ],
+        # alphanumeric against numeric
+        [ "0.0.2", "0.0.1a", 1 ],
+        [ "0.0.2a", "0.0.1", 1 ],
+        [ "0.0.1", "0.0.2a", -1 ],
+        [ "0.0.1a", "0.0.2", -1 ],
+        # length
+        [ "0.0.1aa", "0.0.1a", 1 ],
+        [ "0.0.1aa", "0.0.1aa", 0 ],
+        [ "0.0.1a", "0.0.1aa", -1 ],
+     ].each do |x, y, result|
+        @rpmutils.rpmvercmp(x,y).should == result
+      end
+    end
+
+    it "should validate version compare logic for strange examples" do
+      [
+        [ "2,0,0", "1.0.0", 1 ],
+        [ "0.0.1", "0,0.1", 0 ],
+        [ "1.0.0", "2,0,0", -1 ],
+        [ "002.0.0", "001.0.0", 1 ],
+        [ "001..0.1", "001..0.0", 1 ],
+        [ "-001..1", "-001..0", 1 ],
+        [ "1.0.1", nil, 1 ],
+        [ nil, nil, 0 ],
+        [ nil, "1.0.1", -1 ],
+        [ "1.0.1", "", 1 ],
+        [ "", "", 0 ],
+        [ "", "1.0.1", -1 ]
+     ].each do |x, y, result|
+        @rpmutils.rpmvercmp(x,y).should == result
+      end
+    end
+
+    it "tests isalnum good input" do
+      [ 'a', 'z', 'A', 'Z', '0', '9' ].each do |t|
+        @rpmutils.isalnum(t).should == true
+      end
+    end
+
+    it "tests isalnum bad input" do
+      [ '-', '.', '!', '^', ':', '_' ].each do |t|
+        @rpmutils.isalnum(t).should == false
+      end
+    end
+
+    it "tests isalpha good input" do
+      [ 'a', 'z', 'A', 'Z', ].each do |t|
+        @rpmutils.isalpha(t).should == true
+      end
+    end
+
+    it "tests isalpha bad input" do
+      [ '0', '9', '-', '.', '!', '^', ':', '_' ].each do |t|
+        @rpmutils.isalpha(t).should == false
+      end
+    end
+
+    it "tests isdigit good input" do
+      [ '0', '9', ].each do |t|
+        @rpmutils.isdigit(t).should == true
+      end
+    end
+
+    it "tests isdigit bad input" do
+      [ 'A', 'z', '-', '.', '!', '^', ':', '_' ].each do |t|
+        @rpmutils.isdigit(t).should == false
+      end
+    end
+  end
+
+end
+
+describe Chef::Provider::Package::Yum::RPMVersion do
+  describe "new - with parsing" do
+    before do
+      @rpmv = Chef::Provider::Package::Yum::RPMVersion.new("1:1.6.5-9.36.el5")
+    end
+
+    it "should expose evr (name-version-release) available" do
+      @rpmv.e.should == 1
+      @rpmv.v.should == "1.6.5"
+      @rpmv.r.should == "9.36.el5"
+
+      @rpmv.evr.should == "1:1.6.5-9.36.el5"
+    end
+
+    it "should output a version-release string" do
+      @rpmv.to_s.should == "1.6.5-9.36.el5"
+    end
+  end
+
+  describe "new - no parsing" do
+    before do
+      @rpmv = Chef::Provider::Package::Yum::RPMVersion.new("1", "1.6.5", "9.36.el5")
+    end
+
+    it "should expose evr (name-version-release) available" do
+      @rpmv.e.should == 1
+      @rpmv.v.should == "1.6.5"
+      @rpmv.r.should == "9.36.el5"
+
+      @rpmv.evr.should == "1:1.6.5-9.36.el5"
+    end
+
+    it "should output a version-release string" do
+      @rpmv.to_s.should == "1.6.5-9.36.el5"
+    end
+  end
+
+  it "should raise an error unless passed 1 or 3 args" do
+    lambda {
+      Chef::Provider::Package::Yum::RPMVersion.new()
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMVersion.new("1:1.6.5-9.36.el5")
+    }.should_not raise_error
+    lambda {
+      Chef::Provider::Package::Yum::RPMVersion.new("1:1.6.5-9.36.el5", "extra")
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMVersion.new("1", "1.6.5", "9.36.el5")
+    }.should_not raise_error
+    lambda {
+      Chef::Provider::Package::Yum::RPMVersion.new("1", "1.6.5", "9.36.el5", "extra")
+    }.should raise_error(ArgumentError)
+  end
+
+  # thanks version_class_spec.rb!
+  describe "compare" do
+    it "should sort based on complete epoch-version-release data" do
+      [
+        # smaller, larger
+        [ "0:1.6.5-9.36.el5",
+          "1:1.6.5-9.36.el5" ],
+        [ "0:2.3-15.el5",
+          "0:3.3-15.el5" ],
+        [ "0:alpha9.8-27.2",
+          "0:beta9.8-27.2" ],
+        [ "0:0.09-14jpp.3",
+          "0:0.09-15jpp.3" ],
+        [ "0:0.9.0-0.6.20110211.el5",
+          "0:0.9.0-0.6.20120211.el5" ],
+        [ "0:1.9.1-4.el5",
+          "0:1.9.1-5.el5" ],
+        [ "0:1.4.10-7.20090624svn.el5",
+          "0:1.4.10-7.20090625svn.el5" ],
+        [ "0:2.3.4-2.el5",
+          "0:2.3.4-2.el6" ]
+      ].each do |smaller, larger|
+        sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
+        lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
+        sm.should be < lg
+        lg.should be > sm
+        sm.should_not == lg
+      end
+    end
+
+    it "should sort based on partial epoch-version-release data" do
+      [
+        # smaller, larger
+        [ ":1.6.5-9.36.el5",
+          "1:1.6.5-9.36.el5" ],
+        [ "2.3-15.el5",
+          "3.3-15.el5" ],
+        [ "alpha9.8",
+          "beta9.8" ],
+        [ "14jpp",
+          "15jpp" ],
+        [ "0.9.0-0.6",
+          "0.9.0-0.7" ],
+        [ "0:1.9",
+          "3:1.9" ],
+        [ "2.3-2.el5",
+          "2.3-2.el6" ]
+      ].each do |smaller, larger|
+        sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
+        lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
+        sm.should be < lg
+        lg.should be > sm
+        sm.should_not == lg
+      end
+    end
+
+    it "should verify equality of complete epoch-version-release data" do
+      [
+        [ "0:1.6.5-9.36.el5",
+          "0:1.6.5-9.36.el5" ],
+        [ "0:2.3-15.el5",
+          "0:2.3-15.el5" ],
+        [ "0:alpha9.8-27.2",
+          "0:alpha9.8-27.2" ]
+      ].each do |smaller, larger|
+        sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
+        lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
+        sm.should be == lg
+      end
+    end
+
+    it "should verify equality of partial epoch-version-release data" do
+      [
+        [ ":1.6.5-9.36.el5",
+          "0:1.6.5-9.36.el5" ],
+        [ "2.3-15.el5",
+          "2.3-15.el5" ],
+        [ "alpha9.8-3",
+          "alpha9.8-3" ]
+      ].each do |smaller, larger|
+        sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
+        lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
+        sm.should be == lg
+      end
+    end
+  end
+
+  describe "partial compare" do
+    it "should compare based on partial epoch-version-release data" do
+      [
+        # smaller, larger
+        [ "0:1.1.1-1",
+          "1:" ],
+        [ "0:1.1.1-1",
+          "0:1.1.2" ],
+        [ "0:1.1.1-1",
+          "0:1.1.2-1" ],
+        [ "0:",
+          "1:1.1.1-1" ],
+        [ "0:1.1.1",
+          "0:1.1.2-1" ],
+        [ "0:1.1.1-1",
+          "0:1.1.2-1" ],
+      ].each do |smaller, larger|
+        sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
+        lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
+        sm.partial_compare(lg).should be == -1
+        lg.partial_compare(sm).should be == 1
+        sm.partial_compare(lg).should_not be == 0
+      end
+    end
+
+    it "should verify equality based on partial epoch-version-release data" do
+      [
+        [ "0:",
+          "0:1.1.1-1" ],
+        [ "0:1.1.1",
+          "0:1.1.1-1" ],
+        [ "0:1.1.1-1",
+          "0:1.1.1-1" ],
+      ].each do |smaller, larger|
+        sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
+        lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
+        sm.partial_compare(lg).should be == 0
+      end
+    end
+  end
+
+end
+
+describe Chef::Provider::Package::Yum::RPMPackage do
+  describe "new - with parsing" do
+    before do
+      @rpm = Chef::Provider::Package::Yum::RPMPackage.new("testing", "1:1.6.5-9.36.el5", "x86_64", [])
+    end
+
+    it "should expose nevra (name-epoch-version-release-arch) available" do
+      @rpm.name.should == "testing"
+      @rpm.version.e.should == 1
+      @rpm.version.v.should == "1.6.5"
+      @rpm.version.r.should == "9.36.el5"
+      @rpm.arch.should == "x86_64"
+
+      @rpm.nevra.should == "testing-1:1.6.5-9.36.el5.x86_64"
+      @rpm.to_s.should == @rpm.nevra
+    end
+
+    it "should always have at least one provide, itself" do
+      @rpm.provides.size.should == 1
+      @rpm.provides[0].name == "testing"
+      @rpm.provides[0].version.evr == "1:1.6.5-9.36.el5"
+      @rpm.provides[0].flag == :==
+    end
+  end
+
+  describe "new - no parsing" do
+    before do
+      @rpm = Chef::Provider::Package::Yum::RPMPackage.new("testing", "1", "1.6.5", "9.36.el5", "x86_64", [])
+    end
+
+    it "should expose nevra (name-epoch-version-release-arch) available" do
+      @rpm.name.should == "testing"
+      @rpm.version.e.should == 1
+      @rpm.version.v.should == "1.6.5"
+      @rpm.version.r.should == "9.36.el5"
+      @rpm.arch.should == "x86_64"
+
+      @rpm.nevra.should == "testing-1:1.6.5-9.36.el5.x86_64"
+      @rpm.to_s.should == @rpm.nevra
+    end
+
+    it "should always have at least one provide, itself" do
+      @rpm.provides.size.should == 1
+      @rpm.provides[0].name == "testing"
+      @rpm.provides[0].version.evr == "1:1.6.5-9.36.el5"
+      @rpm.provides[0].flag == :==
+    end
+  end
+
+  it "should raise an error unless passed 4 or 6 args" do
+    lambda {
+      Chef::Provider::Package::Yum::RPMPackage.new()
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMPackage.new("testing")
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMPackage.new("testing", "1:1.6.5-9.36.el5")
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMPackage.new("testing", "1:1.6.5-9.36.el5", "x86_64")
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMPackage.new("testing", "1:1.6.5-9.36.el5", "x86_64", [])
+    }.should_not raise_error
+    lambda {
+      Chef::Provider::Package::Yum::RPMPackage.new("testing", "1", "1.6.5", "9.36.el5", "x86_64")
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMPackage.new("testing", "1", "1.6.5", "9.36.el5", "x86_64", [])
+    }.should_not raise_error
+    lambda {
+      Chef::Provider::Package::Yum::RPMPackage.new("testing", "1", "1.6.5", "9.36.el5", "x86_64", [], "extra")
+    }.should raise_error(ArgumentError)
+  end
+
+  describe "<=>" do
+    it "should sort alphabetically based on package name" do
+      [
+        [ "a-test",
+          "b-test" ],
+        [ "B-test",
+          "a-test" ],
+        [ "A-test",
+          "B-test" ],
+        [ "Aa-test",
+          "aA-test" ],
+        [ "1test",
+          "2test" ],
+      ].each do |smaller, larger|
+        sm = Chef::Provider::Package::Yum::RPMPackage.new(smaller, "0:0.0.1-1", "x86_64", [])
+        lg = Chef::Provider::Package::Yum::RPMPackage.new(larger, "0:0.0.1-1", "x86_64", [])
+        sm.should be < lg
+        lg.should be > sm
+        sm.should_not == lg
+      end
+    end
+
+    it "should sort alphabetically based on package arch" do
+      [
+        [ "i386",
+          "x86_64" ],
+        [ "i386",
+          "noarch" ],
+        [ "noarch",
+          "x86_64" ],
+      ].each do |smaller, larger|
+        sm = Chef::Provider::Package::Yum::RPMPackage.new("test-package", "0:0.0.1-1", smaller, [])
+        lg = Chef::Provider::Package::Yum::RPMPackage.new("test-package", "0:0.0.1-1", larger, [])
+        sm.should be < lg
+        lg.should be > sm
+        sm.should_not == lg
+      end
+    end
+  end
+
+end
+
+describe Chef::Provider::Package::Yum::RPMDbPackage do
+  before(:each) do
+    # name, version, arch, installed, available, repoid
+    @rpm_x = Chef::Provider::Package::Yum::RPMDbPackage.new("test-package-b", "0:1.6.5-9.36.el5", "noarch", [], false, true, "base")
+    @rpm_y = Chef::Provider::Package::Yum::RPMDbPackage.new("test-package-b", "0:1.6.5-9.36.el5", "noarch", [], true, true, "extras")
+    @rpm_z = Chef::Provider::Package::Yum::RPMDbPackage.new("test-package-b", "0:1.6.5-9.36.el5", "noarch", [], true, false, "other")
+  end
+
+  describe "initialize" do
+    it "should return a Chef::Provider::Package::Yum::RPMDbPackage object" do
+      @rpm_x.should be_kind_of(Chef::Provider::Package::Yum::RPMDbPackage)
+    end
+  end
+
+  describe "available" do
+    it "should return true" do
+      @rpm_x.available.should be == true
+      @rpm_y.available.should be == true
+      @rpm_z.available.should be == false
+    end
+  end
+
+  describe "installed" do
+    it "should return true" do
+      @rpm_x.installed.should be == false
+      @rpm_y.installed.should be == true
+      @rpm_z.installed.should be == true
+    end
+  end
+
+  describe "repoid" do
+    it "should return the source repository repoid" do
+      @rpm_x.repoid.should be == "base" 
+      @rpm_y.repoid.should be == "extras"
+      @rpm_z.repoid.should be == "other"
+    end
+  end
+end
+
+describe Chef::Provider::Package::Yum::RPMDependency do
+  describe "new - with parsing" do
+    before do
+      @rpmdep = Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :==)
+    end
+
+    it "should expose name, version, flag available" do
+      @rpmdep.name.should == "testing"
+      @rpmdep.version.e.should == 1
+      @rpmdep.version.v.should == "1.6.5"
+      @rpmdep.version.r.should == "9.36.el5"
+      @rpmdep.flag.should == :==
+    end
+  end
+
+  describe "new - no parsing" do
+    before do
+      @rpmdep = Chef::Provider::Package::Yum::RPMDependency.new("testing", "1", "1.6.5", "9.36.el5", :==)
+    end
+
+    it "should expose name, version, flag available" do
+      @rpmdep.name.should == "testing"
+      @rpmdep.version.e.should == 1
+      @rpmdep.version.v.should == "1.6.5"
+      @rpmdep.version.r.should == "9.36.el5"
+      @rpmdep.flag.should == :==
+    end
+  end
+
+  it "should raise an error unless passed 3 or 5 args" do
+    lambda {
+      Chef::Provider::Package::Yum::RPMDependency.new()
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMDependency.new("testing")
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5")
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :==)
+    }.should_not raise_error
+    lambda {
+      Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :==, "extra")
+    }.should raise_error(ArgumentError)
+    lambda {
+      Chef::Provider::Package::Yum::RPMDependency.new("testing", "1", "1.6.5", "9.36.el5", :==)
+    }.should_not raise_error
+    lambda {
+      Chef::Provider::Package::Yum::RPMDependency.new("testing", "1", "1.6.5", "9.36.el5", :==, "extra")
+    }.should raise_error(ArgumentError)
+  end
+
+  describe "parse" do
+    it "should parse a name, flag, version string into a valid RPMDependency object" do
+      @rpmdep = Chef::Provider::Package::Yum::RPMDependency.parse("testing >= 1:1.6.5-9.36.el5")
+
+      @rpmdep.name.should == "testing"
+      @rpmdep.version.e.should == 1
+      @rpmdep.version.v.should == "1.6.5"
+      @rpmdep.version.r.should == "9.36.el5"
+      @rpmdep.flag.should == :>=
+    end
+
+    it "should parse a name into a valid RPMDependency object" do
+      @rpmdep = Chef::Provider::Package::Yum::RPMDependency.parse("testing")
+
+      @rpmdep.name.should == "testing"
+      @rpmdep.version.e.should == nil
+      @rpmdep.version.v.should == nil
+      @rpmdep.version.r.should == nil
+      @rpmdep.flag.should == :==
+    end
+
+    it "should parse an invalid string into the name of a RPMDependency object" do
+      @rpmdep = Chef::Provider::Package::Yum::RPMDependency.parse("testing blah >")
+
+      @rpmdep.name.should == "testing blah >"
+      @rpmdep.version.e.should == nil
+      @rpmdep.version.v.should == nil
+      @rpmdep.version.r.should == nil
+      @rpmdep.flag.should == :==
+    end
+
+    it "should parse various valid flags" do
+      [
+        [ ">", :> ],
+        [ ">=", :>= ],
+        [ "=", :== ],
+        [ "==", :== ],
+        [ "<=", :<= ],
+        [ "<", :< ]
+      ].each do |before, after|
+        @rpmdep = Chef::Provider::Package::Yum::RPMDependency.parse("testing #{before} 1:1.1-1")
+        @rpmdep.flag.should == after
+      end
+    end
+
+    it "should parse various invalid flags and treat them as names" do
+      [
+        [ "<>", :== ],
+        [ "!=", :== ],
+        [ ">>", :== ],
+        [ "<<", :== ],
+        [ "!", :== ],
+        [ "~", :== ]
+      ].each do |before, after|
+        @rpmdep = Chef::Provider::Package::Yum::RPMDependency.parse("testing #{before} 1:1.1-1")
+        @rpmdep.name.should == "testing #{before} 1:1.1-1"
+        @rpmdep.flag.should == after
+      end
+    end
+  end
+
+  describe "satisfy?" do
+    it "should raise an error unless a RPMDependency is passed" do
+      @rpmprovide = Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :==)
+      @rpmrequire = Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :>=)
+      lambda {
+        @rpmprovide.satisfy?("hi")
+      }.should raise_error(ArgumentError)
+      lambda {
+        @rpmprovide.satisfy?(@rpmrequire)
+      }.should_not raise_error
+    end
+
+    it "should validate dependency satisfaction logic for standard examples" do
+      [
+        # names
+        [ "test", "test", true ],
+        [ "test", "foo", false ],
+        # full: epoch:version-relese
+        [ "testing = 1:1.1-1", "testing > 1:1.1-0", true ],
+        [ "testing = 1:1.1-1", "testing >= 1:1.1-0", true ],
+        [ "testing = 1:1.1-1", "testing >= 1:1.1-1", true ],
+        [ "testing = 1:1.1-1", "testing = 1:1.1-1", true ],
+        [ "testing = 1:1.1-1", "testing == 1:1.1-1", true ],
+        [ "testing = 1:1.1-1", "testing <= 1:1.1-1", true ],
+        [ "testing = 1:1.1-1", "testing <= 1:1.1-0", false ],
+        [ "testing = 1:1.1-1", "testing < 1:1.1-0", false ],
+        # partial: epoch:version
+        [ "testing = 1:1.1", "testing > 1:1.0", true ],
+        [ "testing = 1:1.1", "testing >= 1:1.0", true ],
+        [ "testing = 1:1.1", "testing >= 1:1.1", true ],
+        [ "testing = 1:1.1", "testing = 1:1.1", true ],
+        [ "testing = 1:1.1", "testing == 1:1.1", true ],
+        [ "testing = 1:1.1", "testing <= 1:1.1", true ],
+        [ "testing = 1:1.1", "testing <= 1:1.0", false ],
+        [ "testing = 1:1.1", "testing < 1:1.0", false ],
+        # partial: epoch
+        [ "testing = 1:", "testing > 0:", true ],
+        [ "testing = 1:", "testing >= 0:", true ],
+        [ "testing = 1:", "testing >= 1:", true ],
+        [ "testing = 1:", "testing = 1:", true ],
+        [ "testing = 1:", "testing == 1:", true ],
+        [ "testing = 1:", "testing <= 1:", true ],
+        [ "testing = 1:", "testing <= 0:", false ],
+        [ "testing = 1:", "testing < 0:", false ],
+        # mix and match!
+        [ "testing = 1:1.1-1", "testing == 1:1.1", true ],
+        [ "testing = 1:1.1-1", "testing == 1:", true ],
+     ].each do |prov, req, result|
+        @rpmprovide = Chef::Provider::Package::Yum::RPMDependency.parse(prov)
+        @rpmrequire = Chef::Provider::Package::Yum::RPMDependency.parse(req)
+
+        @rpmprovide.satisfy?(@rpmrequire).should == result
+        @rpmrequire.satisfy?(@rpmprovide).should == result
+      end
+    end
+  end
+
+end
+
+# thanks resource_collection_spec.rb!
+describe Chef::Provider::Package::Yum::RPMDb do
+  before(:each) do
+    @rpmdb = Chef::Provider::Package::Yum::RPMDb.new
+    # name, version, arch, installed, available
+    deps_v = [
+      Chef::Provider::Package::Yum::RPMDependency.parse("libz.so.1()(64bit)"),
+      Chef::Provider::Package::Yum::RPMDependency.parse("test-package-a = 0:1.6.5-9.36.el5")
+    ]
+    deps_z = [
+      Chef::Provider::Package::Yum::RPMDependency.parse("libz.so.1()(64bit)"),
+      Chef::Provider::Package::Yum::RPMDependency.parse("config(test) = 0:1.6.5-9.36.el5"),
+      Chef::Provider::Package::Yum::RPMDependency.parse("test-package-c = 0:1.6.5-9.36.el5")
+    ]
+    @rpm_v = Chef::Provider::Package::Yum::RPMDbPackage.new("test-package-a", "0:1.6.5-9.36.el5", "i386", deps_v, true, false, "base")
+    @rpm_w = Chef::Provider::Package::Yum::RPMDbPackage.new("test-package-b", "0:1.6.5-9.36.el5", "i386", [], true, true, "extras")
+    @rpm_x = Chef::Provider::Package::Yum::RPMDbPackage.new("test-package-b", "0:1.6.5-9.36.el5", "x86_64", [], false, true, "extras")
+    @rpm_y = Chef::Provider::Package::Yum::RPMDbPackage.new("test-package-b", "1:1.6.5-9.36.el5", "x86_64", [], true, true, "extras")
+    @rpm_z = Chef::Provider::Package::Yum::RPMDbPackage.new("test-package-c", "0:1.6.5-9.36.el5", "noarch", deps_z, true, true, "base")
+    @rpm_z_mirror = Chef::Provider::Package::Yum::RPMDbPackage.new("test-package-c", "0:1.6.5-9.36.el5", "noarch", deps_z, true, true, "base")
+  end
+
+  describe "initialize" do
+    it "should return a Chef::Provider::Package::Yum::RPMDb object" do
+      @rpmdb.should be_kind_of(Chef::Provider::Package::Yum::RPMDb)
+    end
+  end
+
+  describe "push" do
+    it "should accept an RPMDbPackage object through pushing" do
+      lambda { @rpmdb.push(@rpm_w) }.should_not raise_error
+    end
+
+    it "should accept multiple RPMDbPackage object through pushing" do
+      lambda { @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z) }.should_not raise_error
+    end
+
+    it "should only accept an RPMDbPackage object" do
+      lambda { @rpmdb.push("string") }.should raise_error
+    end
+
+    it "should add the package to the package db" do
+      @rpmdb.push(@rpm_w)
+      @rpmdb["test-package-b"].should_not be == nil
+    end
+
+    it "should add conditionally add the package to the available list" do
+      @rpmdb.available_size.should be == 0
+      @rpmdb.push(@rpm_v, @rpm_w)
+      @rpmdb.available_size.should be == 1
+    end
+
+    it "should add conditionally add the package to the installed list" do
+      @rpmdb.installed_size.should be == 0
+      @rpmdb.push(@rpm_w, @rpm_x)
+      @rpmdb.installed_size.should be == 1
+    end
+
+    it "should have a total of 2 packages in the RPMDb" do
+      @rpmdb.size.should be == 0
+      @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
+      @rpmdb.size.should be == 2
+    end
+
+    it "should keep the Array unique when a duplicate is pushed" do
+      @rpmdb.push(@rpm_z, @rpm_z_mirror)
+      @rpmdb["test-package-c"].size.should be == 1
+    end
+
+    it "should register the package provides in the provides index" do
+      @rpmdb.push(@rpm_v, @rpm_w, @rpm_z)
+      @rpmdb.lookup_provides("test-package-a")[0].should be == @rpm_v
+      @rpmdb.lookup_provides("config(test)")[0].should be == @rpm_z
+      @rpmdb.lookup_provides("libz.so.1()(64bit)")[0].should be == @rpm_v
+      @rpmdb.lookup_provides("libz.so.1()(64bit)")[1].should be == @rpm_z
+    end
+  end
+
+  describe "<<" do
+    it "should accept an RPMPackage object through the << operator" do
+      lambda { @rpmdb << @rpm_w }.should_not raise_error
+    end
+  end
+
+  describe "lookup" do
+    it "should return an Array of RPMPackage objects by index" do
+      @rpmdb << @rpm_w
+      @rpmdb.lookup("test-package-b").should be_kind_of(Array)
+    end
+  end
+
+  describe "[]" do
+    it "should return an Array of RPMPackage objects though the [index] operator" do
+      @rpmdb << @rpm_w
+      @rpmdb["test-package-b"].should be_kind_of(Array)
+    end
+
+    it "should return an Array of 3 RPMPackage objects" do
+      @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
+      @rpmdb["test-package-b"].size.should be == 3
+    end
+
+    it "should return an Array of RPMPackage objects sorted from newest to oldest" do
+      @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
+      @rpmdb["test-package-b"][0].should be == @rpm_y
+      @rpmdb["test-package-b"][1].should be == @rpm_x
+      @rpmdb["test-package-b"][2].should be == @rpm_w
+    end
+  end
+
+  describe "lookup_provides" do
+    it "should return an Array of RPMPackage objects by index" do
+      @rpmdb << @rpm_z
+      x = @rpmdb.lookup_provides("config(test)")
+      x.should be_kind_of(Array)
+      x[0].should be == @rpm_z
+    end
+  end
+
+  describe "clear" do
+    it "should clear the RPMDb" do
+      @rpmdb.should_receive(:clear_available).once
+      @rpmdb.should_receive(:clear_installed).once
+      @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
+      @rpmdb.size.should_not be == 0
+      @rpmdb.lookup_provides("config(test)").should be_kind_of(Array)
+      @rpmdb.clear
+      @rpmdb.lookup_provides("config(test)").should be == nil
+      @rpmdb.size.should be == 0
+    end
+  end
+
+  describe "clear_available" do
+    it "should clear the available list" do
+      @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
+      @rpmdb.available_size.should_not be == 0
+      @rpmdb.clear_available
+      @rpmdb.available_size.should be == 0
+    end
+  end
+
+  describe "available?" do
+    it "should return true if a package is available" do
+      @rpmdb.available?(@rpm_w).should be == false
+      @rpmdb.push(@rpm_v, @rpm_w)
+      @rpmdb.available?(@rpm_v).should be == false
+      @rpmdb.available?(@rpm_w).should be == true
+    end
+  end
+
+  describe "clear_installed" do
+    it "should clear the installed list" do
+      @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
+      @rpmdb.installed_size.should_not be == 0
+      @rpmdb.clear_installed
+      @rpmdb.installed_size.should be == 0
+    end
+  end
+
+  describe "installed?" do
+    it "should return true if a package is installed" do
+      @rpmdb.installed?(@rpm_w).should be == false
+      @rpmdb.push(@rpm_w, @rpm_x)
+      @rpmdb.installed?(@rpm_w).should be == true
+      @rpmdb.installed?(@rpm_x).should be == false
+    end
+  end
+
+  describe "whatprovides" do
+    it "should raise an error unless a RPMDependency is passed" do
+      @rpmprovide = Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :==)
+      @rpmrequire = Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :>=)
+      lambda {
+        @rpmdb.whatprovides("hi")
+      }.should raise_error(ArgumentError)
+      lambda {
+        @rpmdb.whatprovides(@rpmrequire)
+      }.should_not raise_error
+    end
+
+    it "should return an Array of packages statisfying a RPMDependency" do
+      @rpmdb.push(@rpm_v, @rpm_w, @rpm_z)
+
+      @rpmrequire = Chef::Provider::Package::Yum::RPMDependency.parse("test-package-a >= 1.6.5")
+      x = @rpmdb.whatprovides(@rpmrequire)
+      x.should be_kind_of(Array)
+      x[0].should be == @rpm_v
+
+      @rpmrequire = Chef::Provider::Package::Yum::RPMDependency.parse("libz.so.1()(64bit)")
+      x = @rpmdb.whatprovides(@rpmrequire)
+      x.should be_kind_of(Array)
+      x[0].should be == @rpm_v
+      x[1].should be == @rpm_z
+    end
+  end
+
+end
+
+describe Chef::Provider::Package::Yum::YumCache do
+  # allow for the reset of a Singleton
+  # thanks to Ian White (http://blog.ardes.com/2006/12/11/testing-singletons-with-ruby)
+  class << Chef::Provider::Package::Yum::YumCache
+    def reset_instance
+      Singleton.send :__init__, self
+      self
+    end
+  end
+
+  before(:each) do
+    yum_dump_good_output = <<EOF
+[option installonlypkgs] kernel kernel-bigmem kernel-enterprise
+erlang-mochiweb 0 1.4.1 5.el5 x86_64 ['erlang-mochiweb = 1.4.1-5.el5', 'mochiweb = 1.4.1-5.el5'] i installed
+zip 0 2.31 2.el5 x86_64 ['zip = 2.31-2.el5'] r base
+zisofs-tools 0 1.0.6 3.2.2 x86_64 [] a extras
+zlib 0 1.2.3 3 x86_64 ['zlib = 1.2.3-3', 'libz.so.1()(64bit)'] r base
+zlib 0 1.2.3 3 i386 ['zlib = 1.2.3-3', 'libz.so.1'] r base
+zlib-devel 0 1.2.3 3 i386 [] a extras
+zlib-devel 0 1.2.3 3 x86_64 ['zlib-devel = 1.2.3-3'] r base
+znc 0 0.098 1.el5 x86_64 [] a base
+znc-devel 0 0.098 1.el5 i386 [] a extras
+znc-devel 0 0.098 1.el5 x86_64 [] a base
+znc-extra 0 0.098 1.el5 x86_64 [] a base
+znc-modtcl 0 0.098 1.el5 x86_64 [] a base
+znc-test.beta1 0 0.098 1.el5 x86_64 [] a extras
+znc-test.test.beta1 0 0.098 1.el5 x86_64 [] a base
+EOF
+
+    yum_dump_bad_output_separators = <<EOF
+zip 0 2.31 2.el5 x86_64 ['zip = 2.31-2.el5'] r base
+zlib 0 1.2.3 3 x86_64 ['zlib = 1.2.3-3', 'libz.so.1()(64bit)'] i base bad
+zlib-devel 0 1.2.3 3 i386 [] a extras
+bad zlib-devel 0 1.2.3 3 x86_64 ['zlib-devel = 1.2.3-3'] i installed
+znc-modtcl 0 0.098 1.el5 x86_64 [] a base bad
+EOF
+
+    yum_dump_bad_output_type = <<EOF
+zip 0 2.31 2.el5 x86_64 ['zip = 2.31-2.el5'] r base
+zlib 0 1.2.3 3 x86_64 ['zlib = 1.2.3-3', 'libz.so.1()(64bit)'] c base
+zlib-devel 0 1.2.3 3 i386 [] a extras
+zlib-devel 0 1.2.3 3 x86_64 ['zlib-devel = 1.2.3-3'] bad installed
+znc-modtcl 0 0.098 1.el5 x86_64 [] a base
+EOF
+
+    yum_dump_error = <<EOF
+yum-dump Config Error: File contains no section headers.
+file: file://///etc/yum.repos.d/CentOS-Base.repo, line: 12
+'qeqwewe\n'
+EOF
+
+    @status = mock("Status", :exitstatus => 0)
+    @status_bad = mock("Status", :exitstatus => 1)
+    @stdin = mock("STDIN", :nil_object => true)
+    @stdout = mock("STDOUT", :nil_object => true)
+    @stdout_good = yum_dump_good_output.split("\n")
+    @stdout_bad_type = yum_dump_bad_output_type.split("\n")
+    @stdout_bad_separators = yum_dump_bad_output_separators.split("\n")
+    @stderr = mock("STDERR", :nil_object => true)
+    @stderr.stub!(:readlines).and_return(yum_dump_error.split("\n"))
+    @pid = mock("PID", :nil_object => true)
+
+    # new singleton each time
+    Chef::Provider::Package::Yum::YumCache.reset_instance
+    @yc = Chef::Provider::Package::Yum::YumCache.instance
+    # load valid data
+    @yc.stub!(:popen4).and_yield(@pid, @stdin, @stdout_good, @stderr).and_return(@status)
+  end
+
+  describe "initialize" do
+    it "should return a Chef::Provider::Package::Yum::YumCache object" do
+      @yc.should be_kind_of(Chef::Provider::Package::Yum::YumCache)
+    end
+
+    it "should register reload for start of Chef::Client runs" do
+      Chef::Provider::Package::Yum::YumCache.reset_instance
+      Chef::Client.should_receive(:when_run_starts) do |&b|
+        b.should_not be_nil
+      end
+      @yc = Chef::Provider::Package::Yum::YumCache.instance
+    end
+  end
+
+  describe "refresh" do
+    it "should implicitly call yum-dump.py only once by default after being instantiated" do
+      @yc.should_receive(:popen4).once
+      @yc.installed_version("zlib")
+      @yc.reset
+      @yc.installed_version("zlib")
+    end
+
+    it "should run yum-dump.py using the system python when next_refresh is for :all" do
+      @yc.reload
+      @yc.should_receive(:popen4).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides$}, :waitlast=>true)
+      @yc.refresh
+    end
+
+    it "should run yum-dump.py with the installed flag when next_refresh is for :installed" do
+      @yc.reload_installed
+      @yc.should_receive(:popen4).with(%r{^/usr/bin/python .*/yum-dump.py --installed$}, :waitlast=>true)
+      @yc.refresh
+    end
+
+    it "should run yum-dump.py with the all-provides flag when next_refresh is for :provides" do
+      @yc.reload_provides
+      @yc.should_receive(:popen4).with(%r{^/usr/bin/python .*/yum-dump.py --options --all-provides$}, :waitlast=>true)
+      @yc.refresh
+    end
+
+    it "should warn about invalid data with too many separators" do
+      @yc.stub!(:popen4).and_yield(@pid, @stdin, @stdout_bad_separators, @stderr).and_return(@status)
+      Chef::Log.should_receive(:warn).exactly(3).times.with(%r{Problem parsing})
+      @yc.refresh
+    end
+
+    it "should warn about invalid data with an incorrect type" do
+      @yc.stub!(:popen4).and_yield(@pid, @stdin, @stdout_bad_type, @stderr).and_return(@status)
+      Chef::Log.should_receive(:warn).exactly(2).times.with(%r{Problem parsing})
+      @yc.refresh
+    end
+
+    it "should warn about no output from yum-dump.py" do
+      @yc.stub!(:popen4).and_yield(@pid, @stdin, [], @stderr).and_return(@status)
+      Chef::Log.should_receive(:warn).exactly(1).times.with(%r{no output from yum-dump.py})
+      @yc.refresh
+    end
+
+    it "should raise exception yum-dump.py exits with a non zero status" do
+      @yc.stub!(:popen4).and_yield(@pid, @stdin, [], @stderr).and_return(@status_bad)
+      lambda { @yc.refresh}.should raise_error(Chef::Exceptions::Package, %r{CentOS-Base.repo, line: 12})
+    end
+
+    it "should parse type 'i' into an installed state for a package" do
+      @yc.available_version("erlang-mochiweb").should be == nil
+      @yc.installed_version("erlang-mochiweb").should_not be == nil
+    end
+
+    it "should parse type 'a' into an available state for a package" do
+      @yc.available_version("znc").should_not be == nil
+      @yc.installed_version("znc").should be == nil
+    end
+
+    it "should parse type 'r' into an installed and available states for a package" do
+      @yc.available_version("zip").should_not be == nil
+      @yc.installed_version("zip").should_not be == nil
+    end
+
+    it "should parse installonlypkgs from yum-dump.py options output" do
+      @yc.allow_multi_install.should be == %w{kernel kernel-bigmem kernel-enterprise}
+    end
+  end
+
+  describe "installed_version" do
+    it "should take one or two arguments" do
+      lambda { @yc.installed_version("zip") }.should_not raise_error(ArgumentError)
+      lambda { @yc.installed_version("zip", "i386") }.should_not raise_error(ArgumentError)
+      lambda { @yc.installed_version("zip", "i386", "extra") }.should raise_error(ArgumentError)
+    end
+
+    it "should return version-release for matching package regardless of arch" do
+      @yc.installed_version("zip", "x86_64").should be == "2.31-2.el5"
+      @yc.installed_version("zip", nil).should be == "2.31-2.el5"
+    end
+
+    it "should return version-release for matching package and arch" do
+      @yc.installed_version("zip", "x86_64").should be == "2.31-2.el5"
+      @yc.installed_version("zisofs-tools", "i386").should be == nil
+    end
+
+    it "should return nil for an unmatched package" do
+      @yc.installed_version(nil, nil).should be == nil
+      @yc.installed_version("test1", nil).should be == nil
+      @yc.installed_version("test2", "x86_64").should be == nil
+    end
+  end
+
+  describe "available_version" do
+    it "should take one or two arguments" do
+      lambda { @yc.available_version("zisofs-tools") }.should_not raise_error(ArgumentError)
+      lambda { @yc.available_version("zisofs-tools", "i386") }.should_not raise_error(ArgumentError)
+      lambda { @yc.available_version("zisofs-tools", "i386", "extra") }.should raise_error(ArgumentError)
+    end
+
+    it "should return version-release for matching package regardless of arch" do
+      @yc.available_version("zip", "x86_64").should be == "2.31-2.el5"
+      @yc.available_version("zip", nil).should be == "2.31-2.el5"
+    end
+
+    it "should return version-release for matching package and arch" do
+      @yc.available_version("zip", "x86_64").should be == "2.31-2.el5"
+      @yc.available_version("zisofs-tools", "i386").should be == nil
+    end
+
+    it "should return nil for an unmatched package" do
+      @yc.available_version(nil, nil).should be == nil
+      @yc.available_version("test1", nil).should be == nil
+      @yc.available_version("test2", "x86_64").should be == nil
+    end
+  end
+
+  describe "version_available?" do
+    it "should take two or three arguments" do
+      lambda { @yc.version_available?("zisofs-tools") }.should raise_error(ArgumentError)
+      lambda { @yc.version_available?("zisofs-tools", "1.0.6-3.2.2") }.should_not raise_error(ArgumentError)
+      lambda { @yc.version_available?("zisofs-tools", "1.0.6-3.2.2", "x86_64") }.should_not raise_error(ArgumentError)
+    end
+
+    it "should return true if our package-version-arch is available" do
+      @yc.version_available?("zisofs-tools", "1.0.6-3.2.2", "x86_64").should be == true
+    end
+
+    it "should return true if our package-version, no arch, is available" do
+      @yc.version_available?("zisofs-tools", "1.0.6-3.2.2", nil).should be == true
+      @yc.version_available?("zisofs-tools", "1.0.6-3.2.2").should be == true
+    end
+
+    it "should return false if our package-version-arch isn't available" do
+      @yc.version_available?("zisofs-tools", "1.0.6-3.2.2", "pretend").should be == false
+      @yc.version_available?("zisofs-tools", "pretend", "x86_64").should be == false
+      @yc.version_available?("pretend", "1.0.6-3.2.2", "x86_64").should be == false
+    end
+
+    it "should return false if our package-version, no arch, isn't available" do
+      @yc.version_available?("zisofs-tools", "pretend", nil).should be == false
+      @yc.version_available?("zisofs-tools", "pretend").should be == false
+      @yc.version_available?("pretend", "1.0.6-3.2.2").should be == false
+    end
+  end
+
+  describe "package_repository" do
+    it "should take two or three arguments" do
+      lambda { @yc.package_repository("zisofs-tools") }.should raise_error(ArgumentError)
+      lambda { @yc.package_repository("zisofs-tools", "1.0.6-3.2.2") }.should_not raise_error(ArgumentError)
+      lambda { @yc.package_repository("zisofs-tools", "1.0.6-3.2.2", "x86_64") }.should_not raise_error(ArgumentError)
+    end
+
+    it "should return repoid for package-version-arch" do
+      @yc.package_repository("zlib-devel", "1.2.3-3", "i386").should be == "extras"
+      @yc.package_repository("zlib-devel", "1.2.3-3", "x86_64").should be == "base"
+    end
+
+    it "should return repoid for package-version, no arch" do
+      @yc.package_repository("zisofs-tools", "1.0.6-3.2.2", nil).should be == "extras"
+      @yc.package_repository("zisofs-tools", "1.0.6-3.2.2").should be == "extras"
+    end
+
+    it "should return nil when no match for package-version-arch" do
+      @yc.package_repository("zisofs-tools", "1.0.6-3.2.2", "pretend").should be == nil
+      @yc.package_repository("zisofs-tools", "pretend", "x86_64").should be == nil
+      @yc.package_repository("pretend", "1.0.6-3.2.2", "x86_64").should be == nil
+    end
+
+    it "should return nil when no match for package-version, no arch" do
+      @yc.package_repository("zisofs-tools", "pretend", nil).should be == nil 
+      @yc.package_repository("zisofs-tools", "pretend").should be == nil
+      @yc.package_repository("pretend", "1.0.6-3.2.2").should be == nil
+    end
+  end
+
+  describe "reset" do
+    it "should empty the installed and available packages RPMDb" do
+      @yc.available_version("zip", "x86_64").should be == "2.31-2.el5"
+      @yc.installed_version("zip", "x86_64").should be == "2.31-2.el5"
+      @yc.reset
+      @yc.available_version("zip", "x86_64").should be == nil
+      @yc.installed_version("zip", "x86_64").should be == nil
+    end
+  end
+
+  describe "package_available?" do
+    it "should return true a package name is available" do
+      @yc.package_available?("zisofs-tools").should be == true
+      @yc.package_available?("moo").should be == false
+      @yc.package_available?(nil).should be == false
+    end
+
+    it "should return true a package name + arch is available" do
+      @yc.package_available?("zlib-devel.i386").should be == true
+      @yc.package_available?("zisofs-tools.x86_64").should be == true
+      @yc.package_available?("znc-test.beta1.x86_64").should be == true
+      @yc.package_available?("znc-test.beta1").should be == true
+      @yc.package_available?("znc-test.test.beta1").should be == true
+      @yc.package_available?("moo.i386").should be == false
+      @yc.package_available?("zisofs-tools.beta").should be == false
+      @yc.package_available?("znc-test.test").should be == false
+    end
+  end
+
+end
diff --git a/spec/unit/provider/package/zypper_spec.rb b/spec/unit/provider/package/zypper_spec.rb
new file mode 100644
index 0000000000..fab78f4917
--- /dev/null
+++ b/spec/unit/provider/package/zypper_spec.rb
@@ -0,0 +1,159 @@
+#
+# 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 'spec_helper'
+
+describe Chef::Provider::Package::Zypper do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Package.new("cups")
+
+    @current_resource = Chef::Resource::Package.new("cups")
+
+    @status = mock("Status", :exitstatus => 0)
+
+    @provider = Chef::Provider::Package::Zypper.new(@new_resource, @run_context)
+    Chef::Resource::Package.stub!(:new).and_return(@current_resource)
+    @provider.stub!(:popen4).and_return(@status)
+    @stderr = StringIO.new
+    @stdout = StringIO.new
+    @pid = mock("PID")
+    @provider.stub!(:`).and_return("2.0")
+  end
+
+  describe "when loading the current package state" do
+    it "should create a current resource with the name of the new_resource" do
+      Chef::Resource::Package.should_receive(:new).and_return(@current_resource)
+      @provider.load_current_resource
+    end
+
+    it "should set the current resources package name to the new resources package name" do
+      @current_resource.should_receive(:package_name).with(@new_resource.package_name)
+      @provider.load_current_resource
+    end
+
+    it "should run zypper info with the package name" do
+      @provider.should_receive(:popen4).with("zypper info #{@new_resource.package_name}").and_return(@status)
+      @provider.load_current_resource
+    end
+
+    it "should set the installed version to nil on the current resource if zypper info installed version is (none)" do
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @current_resource.should_receive(:version).with(nil).and_return(true)
+      @provider.load_current_resource
+    end
+
+    it "should set the installed version if zypper info has one" do
+      @stdout = StringIO.new("Version: 1.0\nInstalled: Yes\n")
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @current_resource.should_receive(:version).with("1.0").and_return(true)
+      @provider.load_current_resource
+    end
+
+    it "should set the candidate version if zypper info has one" do
+      @stdout = StringIO.new("Version: 1.0\nInstalled: No\nStatus: out-of-date (version 0.9 installed)")
+
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.load_current_resource
+      @provider.candidate_version.should eql("1.0")
+    end
+
+    it "should raise an exception if zypper info fails" do
+      @status.should_receive(:exitstatus).and_return(1)
+      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should not raise an exception if zypper info succeeds" do
+      @status.should_receive(:exitstatus).and_return(0)
+      lambda { @provider.load_current_resource }.should_not raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should return the current resouce" do
+      @provider.load_current_resource.should eql(@current_resource)
+    end
+  end
+
+  describe "install_package" do
+    it "should run zypper install with the package name and version" do
+      @provider.should_receive(:run_command).with({
+          :command => "zypper -n --no-gpg-checks install -l  emacs=1.0",
+        })
+      @provider.install_package("emacs", "1.0")
+    end
+  end
+
+  describe "upgrade_package" do
+    it "should run zypper update with the package name and version" do
+      @provider.should_receive(:run_command).with({
+          :command => "zypper -n --no-gpg-checks install -l emacs=1.0",
+        })
+      @provider.upgrade_package("emacs", "1.0")
+    end
+  end
+
+  describe "remove_package" do
+    it "should run zypper remove with the package name" do
+      @provider.should_receive(:run_command).with({
+          :command => "zypper -n --no-gpg-checks remove  emacs=1.0",
+        })
+      @provider.remove_package("emacs", "1.0")
+    end
+  end
+
+  describe "purge_package" do
+    it "should run remove_package with the name and version" do
+      @provider.should_receive(:remove_package).with("emacs", "1.0")
+      @provider.purge_package("emacs", "1.0")
+    end
+  end
+
+  describe "on an older zypper" do
+    before(:each) do
+      @provider.stub!(:`).and_return("0.11.6")
+    end
+
+    describe "install_package" do
+      it "should run zypper install with the package name and version" do
+        @provider.should_receive(:run_command).with({
+            :command => "zypper install -y emacs"
+          })
+        @provider.install_package("emacs", "1.0")
+      end
+    end
+  
+    describe "upgrade_package" do
+      it "should run zypper update with the package name and version" do
+        @provider.should_receive(:run_command).with({
+            :command => "zypper install -y emacs"
+          })
+        @provider.upgrade_package("emacs", "1.0")
+      end
+    end
+  
+    describe "remove_package" do
+      it "should run zypper remove with the package name" do
+        @provider.should_receive(:run_command).with({
+            :command => "zypper remove -y emacs"
+          })
+        @provider.remove_package("emacs", "1.0")
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/package_spec.rb b/spec/unit/provider/package_spec.rb
new file mode 100644
index 0000000000..4052bc1ffd
--- /dev/null
+++ b/spec/unit/provider/package_spec.rb
@@ -0,0 +1,429 @@
+#
+# 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 'spec_helper'
+
+describe Chef::Provider::Package do
+  before do
+    #Terrible, but we need to implement a pseduo-filesystem for testing
+    #to not have this line. Only affects updating state fields.
+    Chef::Provider::CookbookFile.any_instance.stub(:update_new_file_state)
+
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Package.new('emacs')
+    @current_resource = Chef::Resource::Package.new('emacs')
+    @provider = Chef::Provider::Package.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+
+    @provider.candidate_version = "1.0"
+  end
+
+  describe "when installing a package" do
+    before(:each) do
+      @provider.current_resource = @current_resource
+      @provider.stub!(:install_package).and_return(true)
+    end
+
+    it "should raise a Chef::Exceptions::Package if no version is specified, and no candidate is available" do
+      @provider.candidate_version = nil
+      lambda { @provider.run_action(:install) }.should raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should call preseed_package if a response_file is given" do
+      @new_resource.response_file("foo")
+      @provider.should_receive(:get_preseed_file).with(
+        @new_resource.name,
+        @provider.candidate_version
+      ).and_return("/var/cache/preseed-test")
+
+      @provider.should_receive(:preseed_package).with(
+        "/var/cache/preseed-test"
+      ).and_return(true)
+      @provider.run_action(:install)
+    end
+
+    it "should not call preseed_package if a response_file is not given" do
+      @provider.should_not_receive(:preseed_package)
+      @provider.run_action(:install)
+    end
+
+    it "should install the package at the candidate_version if it is not already installed" do
+      @provider.should_receive(:install_package).with(
+        @new_resource.name,
+        @provider.candidate_version
+      ).and_return(true)
+      @provider.run_action(:install)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should install the package at the version specified if it is not already installed" do
+      @new_resource.version("1.0")
+      @provider.should_receive(:install_package).with(
+        @new_resource.name,
+        @new_resource.version
+      ).and_return(true)
+      @provider.run_action(:install)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should install the package at the version specified if a different version is installed" do
+      @new_resource.version("1.0")
+      @current_resource.stub!(:version).and_return("0.99")
+      @provider.should_receive(:install_package).with(
+        @new_resource.name,
+        @new_resource.version
+      ).and_return(true)
+      @provider.run_action(:install)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should not install the package if it is already installed and no version is specified" do
+      @current_resource.version("1.0")
+      @provider.should_not_receive(:install_package)
+      @provider.run_action(:install)
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    it "should not install the package if it is already installed at the version specified" do
+      @current_resource.version("1.0")
+      @new_resource.version("1.0")
+      @provider.should_not_receive(:install_package)
+      @provider.run_action(:install)
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    it "should call the candidate_version accessor only once if the package is already installed and no version is specified" do
+      @current_resource.version("1.0")
+      @provider.stub!(:candidate_version).and_return("1.0")
+      @provider.run_action(:install)
+    end
+
+    it "should call the candidate_version accessor only once if the package is already installed at the version specified" do
+      @current_resource.version("1.0")
+      @new_resource.version("1.0")
+      @provider.run_action(:install)
+    end
+
+    it "should set the resource to updated if it installs the package" do
+      @provider.run_action(:install)
+      @new_resource.should be_updated
+    end
+
+  end
+
+  describe "when upgrading the package" do
+    before(:each) do
+      @provider.stub!(:upgrade_package).and_return(true)
+    end
+
+    it "should upgrade the package if the current version is not the candidate version" do
+      @provider.should_receive(:upgrade_package).with(
+        @new_resource.name,
+        @provider.candidate_version
+      ).and_return(true)
+      @provider.run_action(:upgrade)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should set the resource to updated if it installs the package" do
+      @provider.run_action(:upgrade)
+      @new_resource.should be_updated
+    end
+
+    it "should not install the package if the current version is the candidate version" do
+      @current_resource.version "1.0"
+      @provider.should_not_receive(:upgrade_package)
+      @provider.run_action(:upgrade)
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    it "should print the word 'uninstalled' if there was no original version" do
+      @current_resource.stub!(:version).and_return(nil)
+      Chef::Log.should_receive(:info).with("package[emacs] upgraded from uninstalled to 1.0")
+      @provider.run_action(:upgrade)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should raise a Chef::Exceptions::Package if current version and candidate are nil" do
+      @current_resource.stub!(:version).and_return(nil)
+      @provider.candidate_version = nil
+      lambda { @provider.run_action(:upgrade) }.should raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should not install the package if candidate version is nil" do
+      @current_resource.version "1.0"
+      @provider.candidate_version = nil
+      @provider.should_not_receive(:upgrade_package)
+      @provider.run_action(:upgrade)
+      @new_resource.should_not be_updated_by_last_action
+    end
+  end
+
+  describe "When removing the package" do
+    before(:each) do
+      @provider.stub!(:remove_package).and_return(true)
+      @current_resource.version '1.4.2'
+    end
+
+    it "should remove the package if it is installed" do
+      @provider.should be_removing_package
+      @provider.should_receive(:remove_package).with('emacs', nil)
+      @provider.run_action(:remove)
+      @new_resource.should be_updated
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should remove the package at a specific version if it is installed at that version" do
+      @new_resource.version "1.4.2"
+      @provider.should be_removing_package
+      @provider.should_receive(:remove_package).with('emacs', '1.4.2')
+      @provider.run_action(:remove)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should not remove the package at a specific version if it is not installed at that version" do
+      @new_resource.version "1.0"
+      @provider.should_not be_removing_package
+      @provider.should_not_receive(:remove_package)
+      @provider.run_action(:remove)
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    it "should not remove the package if it is not installed" do
+      @provider.should_not_receive(:remove_package)
+      @current_resource.stub!(:version).and_return(nil)
+      @provider.run_action(:remove)
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    it "should set the resource to updated if it removes the package" do
+      @provider.run_action(:remove)
+      @new_resource.should be_updated
+    end
+
+  end
+
+  describe "When purging the package" do
+    before(:each) do
+      @provider.stub!(:purge_package).and_return(true)
+      @current_resource.version '1.4.2'
+    end
+
+    it "should purge the package if it is installed" do
+      @provider.should be_removing_package
+      @provider.should_receive(:purge_package).with('emacs', nil)
+      @provider.run_action(:purge)
+      @new_resource.should be_updated
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should purge the package at a specific version if it is installed at that version" do
+      @new_resource.version "1.4.2"
+      @provider.should be_removing_package
+      @provider.should_receive(:purge_package).with('emacs', '1.4.2')
+      @provider.run_action(:purge)
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should not purge the package at a specific version if it is not installed at that version" do
+      @new_resource.version "1.0"
+      @provider.should_not be_removing_package
+      @provider.should_not_receive(:purge_package)
+      @provider.run_action(:purge)
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    it "should not purge the package if it is not installed" do
+      @current_resource.instance_variable_set(:@version, nil)
+      @provider.should_not be_removing_package
+
+      @provider.should_not_receive(:purge_package)
+      @provider.run_action(:purge)
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    it "should set the resource to updated if it purges the package" do
+      @provider.run_action(:purge)
+      @new_resource.should be_updated
+    end
+
+  end
+
+  describe "when reconfiguring the package" do
+    before(:each) do
+      @provider.stub!(:reconfig_package).and_return(true)
+    end
+
+    it "should info log, reconfigure the package and update the resource" do
+      @current_resource.stub!(:version).and_return('1.0')
+      @new_resource.stub!(:response_file).and_return(true)
+      @provider.should_receive(:get_preseed_file).and_return('/var/cache/preseed-test')
+      @provider.stub!(:preseed_package).and_return(true)
+      @provider.stub!(:reconfig_package).and_return(true)
+      Chef::Log.should_receive(:info).with("package[emacs] reconfigured")
+      @provider.should_receive(:reconfig_package)
+      @provider.run_action(:reconfig)
+      @new_resource.should be_updated
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "should debug log and not reconfigure the package if the package is not installed" do
+      @current_resource.stub!(:version).and_return(nil)
+      Chef::Log.should_receive(:debug).with("package[emacs] is NOT installed - nothing to do")
+      @provider.should_not_receive(:reconfig_package)
+      @provider.run_action(:reconfig)
+      @new_resource.should_not be_updated_by_last_action
+    end 
+
+    it "should debug log and not reconfigure the package if no response_file is given" do
+      @current_resource.stub!(:version).and_return('1.0')
+      @new_resource.stub!(:response_file).and_return(nil)
+      Chef::Log.should_receive(:debug).with("package[emacs] no response_file provided - nothing to do")
+      @provider.should_not_receive(:reconfig_package)
+      @provider.run_action(:reconfig)
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    it "should debug log and not reconfigure the package if the response_file has not changed" do
+      @current_resource.stub!(:version).and_return('1.0')
+      @new_resource.stub!(:response_file).and_return(true)
+      @provider.should_receive(:get_preseed_file).and_return(false)
+      @provider.stub!(:preseed_package).and_return(false)
+      Chef::Log.should_receive(:debug).with("package[emacs] preseeding has not changed - nothing to do")
+      @provider.should_not_receive(:reconfig_package)
+      @provider.run_action(:reconfig)
+      @new_resource.should_not be_updated_by_last_action
+    end
+  end
+
+  describe "when running commands to be implemented by subclasses" do
+    it "should raises UnsupportedAction for install" do
+      lambda { @provider.install_package('emacs', '1.4.2') }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    end
+
+    it "should raises UnsupportedAction for upgrade" do
+      lambda { @provider.upgrade_package('emacs', '1.4.2') }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    end
+
+    it "should raises UnsupportedAction for remove" do
+      lambda { @provider.remove_package('emacs', '1.4.2') }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    end
+
+    it "should raises UnsupportedAction for purge" do
+      lambda { @provider.purge_package('emacs', '1.4.2') }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    end
+
+    it "should raise UnsupportedAction for preseed_package" do
+      preseed_file = "/tmp/sun-jdk-package-preseed-file.seed"
+      lambda { @provider.preseed_package(preseed_file) }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    end
+
+    it "should raise UnsupportedAction for reconfig" do
+      lambda { @provider.reconfig_package('emacs', '1.4.2') }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    end
+  end
+
+  describe "when given a response file" do
+    before(:each) do
+      @cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
+      Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, @cookbook_repo) }
+
+      @node = Chef::Node.new
+      cl = Chef::CookbookLoader.new(@cookbook_repo)
+      cl.load_cookbooks
+      @cookbook_collection = Chef::CookbookCollection.new(cl)
+      @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+
+      @node.automatic_attrs[:platform] = 'PLATFORM: just testing'
+      @node.automatic_attrs[:platform_version] = 'PLATFORM VERSION: just testing'
+
+      @new_resource.response_file('java.response')
+      @new_resource.cookbook_name = 'java'
+    end
+
+    describe "creating the cookbook file resource to fetch the response file" do
+      before do
+        Chef::FileCache.should_receive(:create_cache_path).with('preseed/java').and_return("/tmp/preseed/java")
+      end
+      it "sets the preseed resource's runcontext to its own run context" do
+        Chef::FileCache.rspec_reset
+        Chef::FileCache.stub!(:create_cache_path).and_return("/tmp/preseed/java")
+        @provider.preseed_resource('java', '6').run_context.should_not be_nil
+        @provider.preseed_resource('java', '6').run_context.should equal(@provider.run_context)
+      end
+
+      it "should set the cookbook name of the remote file to the new resources cookbook name" do
+        @provider.preseed_resource('java', '6').cookbook_name.should == 'java'
+      end
+
+      it "should set remote files source to the new resources response file" do
+        @provider.preseed_resource('java', '6').source.should == 'java.response'
+      end
+
+      it "should never back up the cached response file" do
+        @provider.preseed_resource('java', '6').backup.should be_false
+      end
+
+      it "sets the install path of the resource to $file_cache/$cookbook/$pkg_name-$pkg_version.seed" do
+        @provider.preseed_resource('java', '6').path.should == '/tmp/preseed/java/java-6.seed'
+      end
+    end
+
+    describe "when installing the preseed file to the cache location" do
+      before do
+        @node.automatic_attrs[:platform] = :just_testing
+        @node.automatic_attrs[:platform_version] = :just_testing
+
+        @response_file_destination = Dir.tmpdir + '/preseed--java--java-6.seed'
+
+        @response_file_resource = Chef::Resource::CookbookFile.new(@response_file_destination, @run_context)
+        @response_file_resource.cookbook_name = 'java'
+        @response_file_resource.backup(false)
+        @response_file_resource.source('java.response')
+
+
+        @provider.should_receive(:preseed_resource).with('java', '6').and_return(@response_file_resource)
+      end
+
+      after do
+        FileUtils.rm(@response_file_destination) if ::File.exist?(@response_file_destination)
+      end
+
+      it "creates the preseed file in the cache" do
+        @response_file_resource.should_receive(:run_action).with(:create)
+        @provider.get_preseed_file("java", "6")
+      end
+
+      it "returns the path to the response file if the response file was updated" do
+        @provider.get_preseed_file("java", "6").should == @response_file_destination
+      end
+
+      it "should return false if the response file has not been updated" do
+        @response_file_resource.updated_by_last_action(false)
+        @response_file_resource.should_not be_updated_by_last_action
+        # don't let the response_file_resource set updated to true
+        @response_file_resource.should_receive(:run_action).with(:create)
+        @provider.get_preseed_file("java", "6").should be(false)
+      end
+
+    end
+
+  end
+end
diff --git a/spec/unit/provider/remote_directory_spec.rb b/spec/unit/provider/remote_directory_spec.rb
new file mode 100644
index 0000000000..19a17c269f
--- /dev/null
+++ b/spec/unit/provider/remote_directory_spec.rb
@@ -0,0 +1,204 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2010 Daniel DeLeo
+# 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 'digest/md5'
+require 'tmpdir'
+require 'chef/mixin/file_class'
+
+class Chef::CFCCheck
+  include Chef::Mixin::FileClass
+end
+
+describe Chef::Provider::RemoteDirectory do
+  before do
+    Chef::FileAccessControl.any_instance.stub(:set_all)
+    #Terrible, but we need to implement a pseduo-filesystem for testing
+    #to not have this line. Only affects updating state fields.
+    Chef::Provider::CookbookFile.any_instance.stub(:update_new_file_state)
+
+    @resource = Chef::Resource::RemoteDirectory.new("/tmp/tafty")
+    # in CHEF_SPEC_DATA/cookbooks/openldap/files/default/remotedir
+    @resource.source "remotedir"
+    @resource.cookbook('openldap')
+
+    @cookbook_repo = ::File.expand_path(::File.join(CHEF_SPEC_DATA, "cookbooks"))
+    Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, @cookbook_repo) }
+
+    @node = Chef::Node.new
+    cl = Chef::CookbookLoader.new(@cookbook_repo)
+    cl.load_cookbooks
+    @cookbook_collection = Chef::CookbookCollection.new(cl)
+
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+
+    @provider = Chef::Provider::RemoteDirectory.new(@resource, @run_context)
+    @provider.current_resource = @resource.clone
+  end
+
+  describe "when access control is configured on the resource" do
+    before do
+      @resource.mode  "0750"
+      @resource.group "wheel"
+      @resource.owner "root"
+
+      @resource.files_mode  "0640"
+      @resource.files_group "staff"
+      @resource.files_owner "toor"
+      @resource.files_backup 23
+
+      @resource.source "remotedir_root"
+    end
+
+    it "configures access control on intermediate directorys" do
+      directory_resource = @provider.send(:resource_for_directory, "/tmp/intermediate_dir")
+      directory_resource.path.should  == "/tmp/intermediate_dir"
+      directory_resource.mode.should  == "0750"
+      directory_resource.group.should == "wheel"
+      directory_resource.owner.should == "root"
+      directory_resource.recursive.should be_true
+    end
+
+    it "configures access control on files in the directory" do
+      @resource.cookbook "berlin_style_tasty_cupcakes"
+      cookbook_file = @provider.send(:cookbook_file_resource,
+                                    "/target/destination/path.txt",
+                                    "relative/source/path.txt")
+      cookbook_file.cookbook_name.should  == "berlin_style_tasty_cupcakes"
+      cookbook_file.source.should         == "remotedir_root/relative/source/path.txt"
+      cookbook_file.mode.should           == "0640"
+      cookbook_file.group.should          == "staff"
+      cookbook_file.owner.should          == "toor"
+      cookbook_file.backup.should         == 23
+    end
+  end
+
+  describe "when creating the remote directory" do
+    before do
+      @node.automatic_attrs[:platform] = :just_testing
+      @node.automatic_attrs[:platform_version] = :just_testing
+
+      @destination_dir = Dir.mktmpdir << "/remote_directory_test"
+      @resource.path(@destination_dir)
+    end
+
+    after {FileUtils.rm_rf(@destination_dir)}
+
+    it "transfers the directory with all contents" do
+      @provider.run_action(:create)
+      ::File.exist?(@destination_dir + '/remote_dir_file1.txt').should be_true
+      ::File.exist?(@destination_dir + '/remote_dir_file2.txt').should be_true
+      ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file1.txt').should be_true
+      ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file2.txt').should be_true
+      ::File.exist?(@destination_dir + '/remotesubdir/.a_dotfile').should be_true
+      ::File.exist?(@destination_dir + '/.a_dotdir/.a_dotfile_in_a_dotdir').should be_true
+    end
+
+    describe "only if it is missing" do
+      it "should not overwrite existing files" do
+        @resource.overwrite(true)
+        @provider.run_action(:create)
+
+        File.open(@destination_dir + '/remote_dir_file1.txt', 'a') {|f| f.puts "blah blah blah" }
+        File.open(@destination_dir + '/remotesubdir/remote_subdir_file1.txt', 'a') {|f| f.puts "blah blah blah" }
+        file1md5 = Digest::MD5.hexdigest(File.read(@destination_dir + '/remote_dir_file1.txt'))
+        subdirfile1md5 = Digest::MD5.hexdigest(File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))
+
+        @provider.run_action(:create_if_missing)
+
+        file1md5.eql?(Digest::MD5.hexdigest(File.read(@destination_dir + '/remote_dir_file1.txt'))).should be_true
+        subdirfile1md5.eql?(Digest::MD5.hexdigest(File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))).should be_true
+      end
+    end
+
+    describe "with purging enabled" do
+      before {@resource.purge(true)}
+
+      it "removes existing files if purge is true" do
+        @provider.run_action(:create)
+        FileUtils.touch(@destination_dir + '/marked_for_death.txt')
+        FileUtils.touch(@destination_dir + '/remotesubdir/marked_for_death_again.txt')
+        @provider.run_action(:create)
+
+        ::File.exist?(@destination_dir + '/remote_dir_file1.txt').should be_true
+        ::File.exist?(@destination_dir + '/remote_dir_file2.txt').should be_true
+        ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file1.txt').should be_true
+        ::File.exist?(@destination_dir + '/remotesubdir/remote_subdir_file2.txt').should be_true
+
+        ::File.exist?(@destination_dir + '/marked_for_death.txt').should be_false
+        ::File.exist?(@destination_dir + '/remotesubdir/marked_for_death_again.txt').should be_false
+      end
+
+      it "removes files in subdirectories before files above" do
+        @provider.run_action(:create)
+        FileUtils.mkdir_p(@destination_dir + '/a/multiply/nested/directory/')
+        FileUtils.touch(@destination_dir + '/a/foo.txt')
+        FileUtils.touch(@destination_dir + '/a/multiply/bar.txt')
+        FileUtils.touch(@destination_dir + '/a/multiply/nested/baz.txt')
+        FileUtils.touch(@destination_dir + '/a/multiply/nested/directory/qux.txt')
+        @provider.run_action(:create)
+        ::File.exist?(@destination_dir + '/a/foo.txt').should be_false
+        ::File.exist?(@destination_dir + '/a/multiply/bar.txt').should be_false
+        ::File.exist?(@destination_dir + '/a/multiply/nested/baz.txt').should be_false
+        ::File.exist?(@destination_dir + '/a/multiply/nested/directory/qux.txt').should be_false
+      end
+
+      it "removes directory symlinks properly" do
+        symlinked_dir_path = @destination_dir + '/symlinked_dir'
+        @provider.action = :create
+        @provider.run_action
+
+        @fclass = Chef::CFCCheck.new
+
+        Dir.mktmpdir do |tmp_dir|
+          begin
+            @fclass.file_class.symlink(tmp_dir.dup, symlinked_dir_path)
+            ::File.exist?(symlinked_dir_path).should be_true
+
+            @provider.run_action
+
+            ::File.exist?(symlinked_dir_path).should be_false
+            ::File.exist?(tmp_dir).should be_true
+          rescue Chef::Exceptions::Win32APIError => e
+            pending "This must be run as an Administrator to create symlinks"
+          end
+        end
+      end
+    end
+
+    describe "with overwrite disabled" do
+      before {@resource.purge(false)}
+      before {@resource.overwrite(false)}
+
+      it "leaves modifications alone" do
+        @provider.run_action(:create)
+        ::File.open(@destination_dir + '/remote_dir_file1.txt', 'a') {|f| f.puts "blah blah blah" }
+        ::File.open(@destination_dir + '/remotesubdir/remote_subdir_file1.txt', 'a') {|f| f.puts "blah blah blah" }
+        file1md5 = Digest::MD5.hexdigest(::File.read(@destination_dir + '/remote_dir_file1.txt'))
+        subdirfile1md5 = Digest::MD5.hexdigest(::File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))
+        @provider.stub!(:update_new_file_state)
+        @provider.run_action(:create)
+        file1md5.eql?(Digest::MD5.hexdigest(::File.read(@destination_dir + '/remote_dir_file1.txt'))).should be_true
+        subdirfile1md5.eql?(Digest::MD5.hexdigest(::File.read(@destination_dir + '/remotesubdir/remote_subdir_file1.txt'))).should be_true
+      end
+    end
+
+  end
+end
+
diff --git a/spec/unit/provider/remote_file_spec.rb b/spec/unit/provider/remote_file_spec.rb
new file mode 100644
index 0000000000..78d7e77121
--- /dev/null
+++ b/spec/unit/provider/remote_file_spec.rb
@@ -0,0 +1,324 @@
+#
+# 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 'spec_helper'
+
+describe Chef::Provider::RemoteFile, "action_create" do
+  before(:each) do
+    @resource = Chef::Resource::RemoteFile.new("seattle")
+    @resource.path(File.expand_path(File.join(CHEF_SPEC_DATA, "seattle.txt")))
+    @resource.source("http://foo")
+    @node = Chef::Node.new
+    @node.name "latte"
+
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @provider = Chef::Provider::RemoteFile.new(@resource, @run_context)
+    #To prevent the current_resource.checksum from being overridden.
+    @provider.stub!(:load_current_resource)
+  end
+
+  describe "when checking if the file is at the target version" do
+    it "considers the current file to be at the target version if it exists and matches the user-provided checksum" do
+      @provider.current_resource = @resource.dup
+      @resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      @provider.current_resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      @provider.current_resource_matches_target_checksum?.should be_true
+    end
+  end
+
+  describe "when fetching the file from the remote" do
+    before(:each) do
+      @tempfile = Tempfile.new("chef-rspec-remote_file_spec-line#{__LINE__}--")
+
+      @rest = mock(Chef::REST, { })
+      Chef::REST.stub!(:new).and_return(@rest)
+      @rest.stub!(:streaming_request).and_return(@tempfile)
+      @rest.stub!(:create_url) { |url| url } 
+      @resource.cookbook_name = "monkey"
+
+      @provider.stub!(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      @provider.current_resource = @resource.clone
+      @provider.current_resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      File.stub!(:exists?).and_return(true)
+      FileUtils.stub!(:cp).and_return(true)
+      Chef::Platform.stub!(:find_platform_and_version).and_return([ :mac_os_x, "10.5.1" ])
+    end
+
+    after do
+      @tempfile.close!
+    end
+
+    before do
+      @resource.source("http://opscode.com/seattle.txt")
+    end
+
+    describe "and the target location's enclosing directory does not exist" do
+      before do
+        @resource.path("/tmp/this/path/does/not/exist/file.txt")
+      end
+
+      it "raises a specific error describing the problem" do
+        lambda {@provider.run_action(:create)}.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+      end
+    end
+
+    shared_examples_for "source specified with multiple URIs" do
+      it "should try to download the next URI when the first one fails" do
+        @rest.should_receive(:streaming_request).with("http://foo", {}).once.and_raise(SocketError)
+        @rest.should_receive(:streaming_request).with("http://bar", {}).once.and_return(@tempfile)
+        @provider.run_action(:create)
+      end
+
+      it "should raise an exception when all the URIs fail" do
+        @rest.should_receive(:streaming_request).with("http://foo", {}).once.and_raise(SocketError)
+        @rest.should_receive(:streaming_request).with("http://bar", {}).once.and_raise(SocketError)
+        lambda { @provider.run_action(:create) }.should raise_error(SocketError)
+      end
+
+      it "should download from only one URI when the first one works" do
+        @rest.should_receive(:streaming_request).once.and_return(@tempfile)
+        @provider.run_action(:create)
+      end
+
+    end
+
+    describe "and the source specifies multiple URIs using multiple arguments" do
+      it_should_behave_like "source specified with multiple URIs"
+
+      before(:each) do
+        @resource.source("http://foo", "http://bar")
+      end
+    end
+
+    describe "and the source specifies multiple URIs using an array" do
+      it_should_behave_like "source specified with multiple URIs"
+
+      before(:each) do
+        @resource.source([ "http://foo", "http://bar" ])
+      end
+    end
+
+    describe "and the resource specifies a checksum" do
+
+      describe "and the existing file matches the checksum exactly" do
+        before do
+          @resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+        end
+
+        it "does not download the file" do
+          @rest.should_not_receive(:fetch).with("http://opscode.com/seattle.txt").and_return(@tempfile)
+          @provider.run_action(:create)
+        end
+
+        it "does not update the resource" do
+          @provider.run_action(:create)
+          @provider.new_resource.should_not be_updated
+        end
+
+      end
+
+      describe "and the existing file matches the given partial checksum" do
+        before do
+          @resource.checksum("0fd012fd")
+        end
+
+        it "should not download the file if the checksum is a partial match from the beginning" do
+          @rest.should_not_receive(:fetch).with("http://opscode.com/seattle.txt").and_return(@tempfile)
+          @provider.run_action(:create)
+        end
+
+        it "does not update the resource" do
+          @provider.run_action(:create)
+          @provider.new_resource.should_not be_updated
+        end
+
+      end
+
+      describe "and the existing file doesn't match the given checksum" do
+        it "downloads the file" do
+          @resource.checksum("this hash doesn't match")
+          @rest.should_receive(:streaming_request).with("http://opscode.com/seattle.txt", {}).and_return(@tempfile)
+          @provider.stub!(:update_new_file_state)
+          @provider.run_action(:create)
+        end
+
+        it "does not consider the checksum a match if the matching string is offset" do
+          # i.e., the existing file is      "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa"
+          @resource.checksum("fd012fd")
+          @rest.should_receive(:streaming_request).with("http://opscode.com/seattle.txt", {}).and_return(@tempfile)
+          @provider.stub!(:update_new_file_state)
+          @provider.run_action(:create)
+        end
+      end
+
+    end
+
+    describe "and the resource doesn't specify a checksum" do
+      it "should download the file from the remote URL" do
+        @resource.checksum(nil)
+        @rest.should_receive(:streaming_request).with("http://opscode.com/seattle.txt", {}).and_return(@tempfile)
+        @provider.run_action(:create)
+      end
+    end
+
+    # CHEF-3140
+    # Some servers return tarballs as content type tar and encoding gzip, which
+    # is totally wrong. When this happens and gzip isn't disabled, Chef::REST
+    # will decompress the file for you, which is not at all what you expected
+    # to happen (you end up with an uncomressed tar archive instead of the
+    # gzipped tar archive you expected). To work around this behavior, we
+    # detect when users are fetching gzipped files and turn off gzip in
+    # Chef::REST.
+
+    context "and the target file is a tarball" do
+      before do
+        @resource.path(File.expand_path(File.join(CHEF_SPEC_DATA, "seattle.tar.gz")))
+        Chef::REST.should_receive(:new).with("http://opscode.com/seattle.txt", nil, nil, :disable_gzip => true).and_return(@rest)
+      end
+
+      it "disables gzip in the http client" do
+        @provider.action_create
+      end
+
+    end
+
+    context "and the source appears to be a tarball" do
+      before do
+        @resource.source("http://example.com/tarball.tgz")
+        Chef::REST.should_receive(:new).with("http://example.com/tarball.tgz", nil, nil, :disable_gzip => true).and_return(@rest)
+      end
+
+      it "disables gzip in the http client" do
+        @provider.action_create
+      end
+    end
+
+    it "should raise an exception if it's any other kind of retriable response than 304" do
+      r = Net::HTTPMovedPermanently.new("one", "two", "three")
+      e = Net::HTTPRetriableError.new("301", r)
+      @rest.stub!(:streaming_request).and_raise(e)
+      lambda { @provider.run_action(:create) }.should raise_error(Net::HTTPRetriableError)
+    end
+
+    it "should raise an exception if anything else happens" do
+      r = Net::HTTPBadRequest.new("one", "two", "three")
+      e = Net::HTTPServerException.new("fake exception", r)
+      @rest.stub!(:streaming_request).and_raise(e)
+      lambda { @provider.run_action(:create) }.should raise_error(Net::HTTPServerException)
+    end
+
+    it "should checksum the raw file" do
+      @provider.should_receive(:checksum).with(@tempfile.path).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      @provider.run_action(:create)
+    end
+
+    describe "when the target file does not exist" do
+      before do
+        ::File.stub!(:exists?).with(@resource.path).and_return(false)
+        @provider.stub!(:get_from_server).and_return(@tempfile)
+      end
+
+      it "should copy the raw file to the new resource" do
+        FileUtils.should_receive(:cp).with(@tempfile.path, @resource.path).and_return(true)
+        @provider.stub!(:update_new_file_state)
+        @provider.run_action(:create)
+      end
+
+      it "should set the new resource to updated" do
+        @provider.stub!(:update_new_file_state)
+        @provider.run_action(:create)
+        @resource.should be_updated
+      end
+
+      describe "and create_if_missing is invoked" do
+        it "should invoke action_create" do
+          @provider.should_receive(:action_create)
+          @provider.run_action(:create_if_missing)
+        end
+      end
+    end
+
+    describe "when the target file already exists" do
+      before do
+        ::File.stub!(:exists?).with(@resource.path).and_return(true)
+        @provider.stub!(:diff_current).and_return([
+         "--- /tmp/foo  2012-08-30 21:28:17.632782551 +0000",
+         "+++ /tmp/bar 2012-08-30 21:28:20.816975437 +0000",
+         "@@ -1 +1 @@",
+         "-foo bar",
+         "+bar foo"
+        ])
+        @provider.stub!(:get_from_server).and_return(@tempfile)
+      end
+
+      describe "and create_if_missing is invoked" do
+        it "should take no action" do
+          @provider.should_not_receive(:action_create) 
+          @provider.run_action(:create_if_missing)
+        end
+      end
+
+      describe "and the file downloaded from the remote is identical to the current" do
+        it "shouldn't backup the original file" do
+          @provider.should_not_receive(:backup).with(@resource.path)
+          @provider.run_action(:create)
+        end
+
+        it "doesn't mark the resource as updated" do
+          @provider.run_action(:create)
+          @provider.new_resource.should_not be_updated
+        end
+      end
+
+      describe "and the checksum doesn't match" do
+        before do
+          sha2_256 = "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa-NO_MATCHY"
+          @provider.current_resource.checksum(sha2_256)
+        end
+
+        it "should backup the original file" do
+          @provider.stub!(:update_new_file_state)
+          @provider.should_receive(:backup).with(@resource.path).and_return(true)
+          @provider.run_action(:create)
+        end
+
+        it "should copy the raw file to the new resource" do
+          @provider.stub!(:update_new_file_state)
+          FileUtils.should_receive(:cp).with(@tempfile.path, @resource.path).and_return(true)
+          @provider.run_action(:create)
+        end
+
+        it "should set the new resource to updated" do
+          @provider.stub!(:update_new_file_state)
+          @provider.run_action(:create)
+          @resource.should be_updated
+        end
+      end
+
+      it "should set permissions" do
+        @provider.should_receive(:set_all_access_controls).and_return(true)
+        @provider.run_action(:create)
+      end
+
+
+    end
+
+  end
+end
diff --git a/spec/unit/provider/route_spec.rb b/spec/unit/provider/route_spec.rb
new file mode 100644
index 0000000000..3c5db0b7a1
--- /dev/null
+++ b/spec/unit/provider/route_spec.rb
@@ -0,0 +1,230 @@
+#
+# Author:: Bryan McLellan (btm@loftninjas.org)
+# Copyright:: Copyright (c) 2009 Bryan McLellan
+# 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 Chef::Provider::Route do
+  before do
+    @node = Chef::Node.new
+    @cookbook_collection = Chef::CookbookCollection.new([])
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+
+    @new_resource = Chef::Resource::Route.new('10.0.0.10')
+    @new_resource.gateway "10.0.0.9"
+    @current_resource = Chef::Resource::Route.new('10.0.0.10')
+    @current_resource.gateway "10.0.0.9"
+
+    @provider = Chef::Provider::Route.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+
+  describe Chef::Provider::Route, "hex2ip" do
+    it "should return nil if ip address is invalid" do
+      @provider.hex2ip('foo').should be_nil # does not even look like an ip
+      @provider.hex2ip('ABCDEFGH').should be_nil # 8 chars, but invalid
+    end
+
+    it "should return quad-dotted notation for a valid IP" do
+      @provider.hex2ip('01234567').should == '103.69.35.1'
+      @provider.hex2ip('0064a8c0').should == '192.168.100.0'
+      @provider.hex2ip('00FFFFFF').should == '255.255.255.0'
+    end
+  end
+
+
+  describe Chef::Provider::Route, "load_current_resource" do
+    context "on linux" do
+      before do
+        @node.automatic_attrs[:os] = 'linux'
+        routing_table = "Iface	Destination	Gateway 	Flags	RefCnt	Use	Metric	Mask		MTU	Window	IRTT\n" +
+                        "eth0	0064A8C0	0984A8C0	0003	0	0	0	00FFFFFF	0	0	0\n"
+        route_file = StringIO.new(routing_table)
+        File.stub!(:open).with("/proc/net/route", "r").and_return(route_file)
+      end
+
+      it "should set is_running to false when a route is not detected" do
+        resource = Chef::Resource::Route.new('10.10.10.0/24')
+        resource.stub!(:gateway).and_return("10.0.0.1")
+        resource.stub!(:device).and_return("eth0")
+        provider = Chef::Provider::Route.new(resource, @run_context)
+
+        provider.load_current_resource
+        provider.is_running.should be_false
+      end
+
+      it "should detect existing routes and set is_running attribute correctly" do
+        resource = Chef::Resource::Route.new('192.168.100.0/24')
+        resource.stub!(:gateway).and_return("192.168.132.9")
+        resource.stub!(:device).and_return("eth0")
+        provider = Chef::Provider::Route.new(resource, @run_context)
+
+        provider.load_current_resource
+        provider.is_running.should be_true
+      end
+
+      it "should use gateway value when matching routes" do
+        resource = Chef::Resource::Route.new('192.168.100.0/24')
+        resource.stub!(:gateway).and_return("10.10.10.10")
+        resource.stub!(:device).and_return("eth0")
+        provider = Chef::Provider::Route.new(resource, @run_context)
+
+        provider.load_current_resource
+        provider.is_running.should be_false
+      end
+    end
+  end
+
+  describe Chef::Provider::Route, "action_add" do
+    it "should add the route if it does not exist" do
+      @provider.stub!(:run_command).and_return(true)
+      @current_resource.stub!(:gateway).and_return(nil)
+      @provider.should_receive(:generate_command).once.with(:add)
+      @provider.should_receive(:generate_config)
+      @provider.run_action(:add)
+      @new_resource.should be_updated
+    end
+
+    it "should not add the route if it exists" do
+      @provider.stub!(:run_command).and_return(true)
+      @provider.stub!(:is_running).and_return(true)
+      @provider.should_not_receive(:generate_command).with(:add)
+      @provider.should_receive(:generate_config)
+      @provider.run_action(:add)
+      @new_resource.should_not be_updated
+    end
+  end
+
+  describe Chef::Provider::Route, "action_delete" do
+    it "should delete the route if it exists" do
+      @provider.stub!(:run_command).and_return(true)
+      @provider.should_receive(:generate_command).once.with(:delete)
+      @provider.stub!(:is_running).and_return(true)
+      @provider.run_action(:delete)
+      @new_resource.should be_updated
+    end
+
+    it "should not delete the route if it does not exist" do
+      @current_resource.stub!(:gateway).and_return(nil)
+      @provider.stub!(:run_command).and_return(true)
+      @provider.should_not_receive(:generate_command).with(:add)
+      @provider.run_action(:delete)
+      @new_resource.should_not be_updated
+    end
+  end
+
+  describe Chef::Provider::Route, "generate_command for action_add" do
+    it "should include a netmask when a one is specified" do
+      @new_resource.stub!(:netmask).and_return('255.255.0.0')
+      @provider.generate_command(:add).should match(/\/\d{1,2}\s/)
+    end
+
+    it "should not include a netmask when a one is specified" do
+      @new_resource.stub!(:netmask).and_return(nil)
+      @provider.generate_command(:add).should_not match(/\/\d{1,2}\s/)
+    end
+
+    it "should include ' via $gateway ' when a gateway is specified" do
+      @provider.generate_command(:add).should match(/\svia\s#{@new_resource.gateway}\s/)
+    end
+
+    it "should not include ' via $gateway ' when a gateway is not specified" do
+      @new_resource.stub!(:gateway).and_return(nil)
+      @provider.generate_command(:add).should_not match(/\svia\s#{@new_resource.gateway}\s/)
+    end
+  end
+
+  describe Chef::Provider::Route, "generate_command for action_delete" do
+    it "should include a netmask when a one is specified" do
+      @new_resource.stub!(:netmask).and_return('255.255.0.0')
+      @provider.generate_command(:delete).should match(/\/\d{1,2}\s/)
+    end
+
+    it "should not include a netmask when a one is specified" do
+      @new_resource.stub!(:netmask).and_return(nil)
+      @provider.generate_command(:delete).should_not match(/\/\d{1,2}\s/)
+    end
+
+    it "should include ' via $gateway ' when a gateway is specified" do
+      @provider.generate_command(:delete).should match(/\svia\s#{@new_resource.gateway}\s/)
+    end
+
+    it "should not include ' via $gateway ' when a gateway is not specified" do
+      @new_resource.stub!(:gateway).and_return(nil)
+      @provider.generate_command(:delete).should_not match(/\svia\s#{@new_resource.gateway}\s/)
+    end
+  end
+
+  describe Chef::Provider::Route, "config_file_contents for action_add" do
+    it "should include a netmask when a one is specified" do
+      @new_resource.stub!(:netmask).and_return('255.255.0.0')
+      @provider.config_file_contents(:add, { :target => @new_resource.target, :netmask => @new_resource.netmask}).should match(/\/\d{1,2}.*\n$/)
+    end
+
+    it "should not include a netmask when a one is specified" do
+      @provider.config_file_contents(:add, { :target => @new_resource.target}).should_not match(/\/\d{1,2}.*\n$/)
+    end
+
+    it "should include ' via $gateway ' when a gateway is specified" do
+      @provider.config_file_contents(:add, { :target => @new_resource.target, :gateway => @new_resource.gateway}).should match(/\svia\s#{@new_resource.gateway}\n/)
+    end
+
+    it "should not include ' via $gateway ' when a gateway is not specified" do
+      @provider.generate_command(:add).should_not match(/\svia\s#{@new_resource.gateway}\n/)
+    end
+  end
+
+  describe Chef::Provider::Route, "config_file_contents for action_delete" do
+    it "should return an empty string" do
+      @provider.config_file_contents(:delete).should match(/^$/)
+    end
+  end
+
+  describe Chef::Provider::Route, "generate_config method" do
+    %w[ centos redhat fedora ].each do |platform|
+      it "should write a route file on #{platform} platform" do
+        @node.automatic_attrs[:platform] = platform
+
+        route_file = StringIO.new
+        File.should_receive(:new).with("/etc/sysconfig/network-scripts/route-eth0", "w").and_return(route_file)
+        #Chef::Log.should_receive(:debug).with("route[10.0.0.10] writing route.eth0\n10.0.0.10 via 10.0.0.9\n")
+        @run_context.resource_collection << @new_resource
+
+        @provider.generate_config
+        @provider.converge
+      end
+    end
+
+    it "should put all routes for a device in a route config file" do
+      @node.automatic_attrs[:platform] = 'centos'
+
+      route_file = StringIO.new
+      File.should_receive(:new).and_return(route_file)
+      @run_context.resource_collection << Chef::Resource::Route.new('192.168.1.0/24 via 192.168.0.1')
+      @run_context.resource_collection << Chef::Resource::Route.new('192.168.2.0/24 via 192.168.0.1')
+      @run_context.resource_collection << Chef::Resource::Route.new('192.168.3.0/24 via 192.168.0.1')
+
+      @provider.generate_config
+      @provider.converge
+      route_file.string.split("\n").should have(3).items
+      route_file.string.should match(/^192.168.1.0\/24 via 192.168.0.1$/)
+      route_file.string.should match(/^192.168.2.0\/24 via 192.168.0.1$/)
+      route_file.string.should match(/^192.168.3.0\/24 via 192.168.0.1$/)
+    end
+  end
+end
diff --git a/spec/unit/provider/ruby_block_spec.rb b/spec/unit/provider/ruby_block_spec.rb
new file mode 100644
index 0000000000..7fc58c9c70
--- /dev/null
+++ b/spec/unit/provider/ruby_block_spec.rb
@@ -0,0 +1,46 @@
+#
+# Author:: AJ Christensen (<aj@opscode.com>)
+# Copyright:: Copyright (c) 2009 Opscode
+# 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 Chef::Provider::RubyBlock, "initialize" do
+  before(:each) do
+    $evil_global_evil_laugh = :wahwah
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::RubyBlock.new("bloc party")
+    @new_resource.block { $evil_global_evil_laugh = :mwahahaha}
+    @provider = Chef::Provider::RubyBlock.new(@new_resource, @run_context)
+  end
+
+  it "should call the block and flag the resource as updated" do
+    @provider.run_action(:run)
+    $evil_global_evil_laugh.should == :mwahahaha
+    @new_resource.should be_updated
+  end
+
+  it "accepts `create' as an alias for `run'" do
+    # SEE ALSO: CHEF-3500
+    # "create" used to be the default action, it was renamed.
+    @provider.run_action(:create)
+    $evil_global_evil_laugh.should == :mwahahaha
+    @new_resource.should be_updated
+  end
+end
+
diff --git a/spec/unit/provider/script_spec.rb b/spec/unit/provider/script_spec.rb
new file mode 100644
index 0000000000..5111a94578
--- /dev/null
+++ b/spec/unit/provider/script_spec.rb
@@ -0,0 +1,96 @@
+#
+# Author:: Adam Jacob (adam@opscode.com)
+# Copyright:: Copyright (c) 2009 Opscode
+# 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 Chef::Provider::Script, "action_run" do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Script.new('run some perl code')
+    @new_resource.code "$| = 1; print 'i like beans'"
+    @new_resource.interpreter 'perl'
+
+    @provider = Chef::Provider::Script.new(@new_resource, @run_context)
+
+    @script_file = StringIO.new
+    @script_file.stub!(:path).and_return('/tmp/the_script_file')
+
+    @provider.stub!(:shell_out!).and_return(true)
+  end
+
+  it "creates a temporary file to store the script" do
+    @provider.script_file.should be_an_instance_of(Tempfile)
+  end
+
+  it "unlinks the tempfile when finished" do
+    tempfile_path = @provider.script_file.path
+    @provider.unlink_script_file
+    File.exist?(tempfile_path).should be_false
+  end
+
+  it "sets the owner and group for the script file" do
+    @new_resource.user 'toor'
+    @new_resource.group 'wheel'
+    @provider.stub!(:script_file).and_return(@script_file)
+    FileUtils.should_receive(:chown).with('toor', 'wheel', "/tmp/the_script_file")
+    @provider.set_owner_and_group
+  end
+
+  context "with the script file set to the correct owner and group" do
+    before do
+      @provider.stub!(:set_owner_and_group)
+      @provider.stub!(:script_file).and_return(@script_file)
+    end
+    describe "when writing the script to the file" do
+      it "should put the contents of the script in the temp file" do
+        @provider.action_run
+        @script_file.rewind
+        @script_file.string.should == "$| = 1; print 'i like beans'\n"
+      end
+
+      it "closes before executing the script and unlinks it when finished" do
+        @provider.action_run
+        @script_file.should be_closed
+      end
+
+    end
+
+    describe "when running the script" do
+      it 'should set the command to "interpreter"  "tempfile"' do
+        @provider.action_run
+        @new_resource.command.should == '"perl"  "/tmp/the_script_file"'
+      end
+
+      describe "with flags set on the resource" do
+        before do
+          @new_resource.flags '-f'
+        end
+
+        it "should set the command to 'interpreter flags tempfile'" do
+          @provider.action_run
+          @new_resource.command.should == '"perl" -f "/tmp/the_script_file"'
+        end
+
+      end
+
+    end
+  end
+
+end
diff --git a/spec/unit/provider/service/arch_service_spec.rb b/spec/unit/provider/service/arch_service_spec.rb
new file mode 100644
index 0000000000..a7afa28da1
--- /dev/null
+++ b/spec/unit/provider/service/arch_service_spec.rb
@@ -0,0 +1,330 @@
+#
+# Author:: Jan Zimmek (<jan.zimmek@web.de>)
+# Author:: AJ Christensen (<aj@hjksolutions.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 'spec_helper'
+require 'ostruct'
+
+
+# most of this code has been ripped from init_service_spec.rb
+# and is only slightly modified to match "arch" needs.
+
+describe Chef::Provider::Service::Arch, "load_current_resource" do
+  before(:each) do
+    @node = Chef::Node.new
+    @node.automatic_attrs[:command] = {:ps => "ps -ef"}
+
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new("chef")
+    @new_resource.pattern("chef")
+    @new_resource.supports({:status => false})
+
+
+    @provider = Chef::Provider::Service::Arch.new(@new_resource, @run_context)
+
+    ::File.stub!(:exists?).with("/etc/rc.conf").and_return(true)
+    ::File.stub!(:read).with("/etc/rc.conf").and_return("DAEMONS=(network apache sshd)")
+  end
+
+  describe "when first created" do
+    it "should set the current resources service name to the new resources service name" do
+      @provider.stub(:shell_out).and_return(OpenStruct.new(:exitstatus => 0, :stdout => ""))
+      @provider.load_current_resource
+      @provider.current_resource.service_name.should == 'chef'
+    end
+  end
+
+
+  describe "when the service supports status" do
+    before do
+      @new_resource.supports({:status => true})
+    end
+
+    it "should run '/etc/rc.d/service_name status'" do
+      @provider.should_receive(:shell_out).with("/etc/rc.d/chef status").and_return(OpenStruct.new(:exitstatus => 0))
+      @provider.load_current_resource
+    end
+  
+    it "should set running to true if the the status command returns 0" do
+      @provider.stub!(:shell_out).with("/etc/rc.d/chef status").and_return(OpenStruct.new(:exitstatus => 0))
+      @provider.load_current_resource
+      @provider.current_resource.running.should be_true
+    end
+
+    it "should set running to false if the status command returns anything except 0" do
+      @provider.stub!(:shell_out).with("/etc/rc.d/chef status").and_return(OpenStruct.new(:exitstatus => 1))
+      @provider.load_current_resource
+      @provider.current_resource.running.should be_false
+    end
+
+    it "should set running to false if the status command raises" do
+      @provider.stub!(:shell_out).with("/etc/rc.d/chef status").and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      @provider.load_current_resource
+      @provider.current_resource.running.should be_false
+    end
+
+  end
+
+
+  describe "when a status command has been specified" do
+    before do
+      @new_resource.status_command("/etc/rc.d/chefhasmonkeypants status")
+    end
+
+    it "should run the services status command if one has been specified" do
+      @provider.should_receive(:shell_out).with("/etc/rc.d/chefhasmonkeypants status").and_return(OpenStruct.new(:exitstatus => 0))
+      @provider.load_current_resource
+    end
+    
+  end
+
+  it "should raise error if the node has a nil ps attribute and no other means to get status" do
+    @node.automatic_attrs[:command] = {:ps => nil}
+    @provider.define_resource_requirements
+    @provider.action = :start
+    lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+  end
+
+  it "should raise error if the node has an empty ps attribute and no other means to get status" do
+    @node.automatic_attrs[:command] = {:ps => ""}
+    @provider.define_resource_requirements
+    @provider.action = :start
+    lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+  end
+
+
+  it "should fail if file /etc/rc.conf does not exist" do
+    ::File.stub!(:exists?).with("/etc/rc.conf").and_return(false)
+    lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Service)
+  end
+
+  it "should fail if file /etc/rc.conf does not contain DAEMONS array" do
+    ::File.stub!(:read).with("/etc/rc.conf").and_return("")
+    lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Service)
+  end
+
+  describe "when discovering service status with ps" do
+    before do
+      @stdout = StringIO.new(<<-DEFAULT_PS)
+aj        7842  5057  0 21:26 pts/2    00:00:06 vi init.rb
+aj        7903  5016  0 21:26 pts/5    00:00:00 /bin/bash
+aj        8119  6041  0 21:34 pts/3    00:00:03 vi init_service_spec.rb
+DEFAULT_PS
+      @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+      @provider.stub!(:shell_out!).and_return(@status)
+      
+      @node.automatic_attrs[:command] = {:ps => "ps -ef"}
+    end
+
+    it "determines the service is running when it appears in ps" do
+      @stdout = StringIO.new(<<-RUNNING_PS)
+aj        7842  5057  0 21:26 pts/2    00:00:06 chef
+aj        7842  5057  0 21:26 pts/2    00:00:06 poos
+RUNNING_PS
+      @status.stub!(:stdout).and_return(@stdout)
+      @provider.load_current_resource 
+      @provider.current_resource.running.should be_true
+    end
+
+    it "determines the service is not running when it does not appear in ps" do
+      @provider.stub!(:shell_out!).and_return(@status)
+      @provider.load_current_resource
+      @provider.current_resource.running.should be_false
+    end
+
+    it "should raise an exception if ps fails" do
+      @provider.stub!(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      @provider.load_current_resource
+      @provider.action = :start
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+  end
+
+  it "should return existing entries in DAEMONS array" do
+    ::File.stub!(:read).with("/etc/rc.conf").and_return("DAEMONS=(network !apache ssh)")
+    @provider.daemons.should == ['network', '!apache', 'ssh']
+  end
+  
+  context "when the current service status is known" do
+    before do
+      @current_resource = Chef::Resource::Service.new("chef")
+      @provider.current_resource = @current_resource
+    end
+    
+    describe Chef::Provider::Service::Arch, "enable_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:start_command).and_return(false)
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+
+      it "should add chef to DAEMONS array" do
+        ::File.stub!(:read).with("/etc/rc.conf").and_return("DAEMONS=(network)")
+        @provider.should_receive(:update_daemons).with(['network', 'chef'])
+        @provider.enable_service()
+      end
+    end
+
+    describe Chef::Provider::Service::Arch, "disable_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:start_command).and_return(false)
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+
+      it "should remove chef from DAEMONS array" do
+        ::File.stub!(:read).with("/etc/rc.conf").and_return("DAEMONS=(network chef)")
+        @provider.should_receive(:update_daemons).with(['network', '!chef'])
+        @provider.disable_service()
+      end
+    end
+
+
+    describe Chef::Provider::Service::Arch, "start_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:start_command).and_return(false)
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+  
+      it "should call the start command if one is specified" do
+        @new_resource.stub!(:start_command).and_return("/etc/rc.d/chef startyousillysally")
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/chef startyousillysally")
+        @provider.start_service()
+      end
+
+      it "should call '/etc/rc.d/service_name start' if no start command is specified" do
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} start")
+        @provider.start_service()
+      end 
+    end
+
+    describe Chef::Provider::Service::Arch, "stop_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:stop_command).and_return(false)
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+
+      it "should call the stop command if one is specified" do
+        @new_resource.stub!(:stop_command).and_return("/etc/rc.d/chef itoldyoutostop")
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/chef itoldyoutostop")
+        @provider.stop_service()
+      end
+
+      it "should call '/etc/rc.d/service_name stop' if no stop command is specified" do
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} stop")
+        @provider.stop_service()
+      end
+    end
+
+    describe Chef::Provider::Service::Arch, "restart_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:restart_command).and_return(false)
+      #   @new_resource.stub!(:supports).and_return({:restart => false})
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+
+      it "should call 'restart' on the service_name if the resource supports it" do
+        @new_resource.stub!(:supports).and_return({:restart => true})
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} restart")
+        @provider.restart_service()
+      end
+
+      it "should call the restart_command if one has been specified" do
+        @new_resource.stub!(:restart_command).and_return("/etc/rc.d/chef restartinafire")
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} restartinafire")
+        @provider.restart_service()
+      end
+
+      it "should just call stop, then start when the resource doesn't support restart and no restart_command is specified" do
+        @provider.should_receive(:stop_service)
+        @provider.should_receive(:sleep).with(1)
+        @provider.should_receive(:start_service)
+        @provider.restart_service()
+      end
+    end
+
+    describe Chef::Provider::Service::Arch, "reload_service" do
+      # before(:each) do
+      #   @new_resource = mock("Chef::Resource::Service",
+      #     :null_object => true,
+      #     :name => "chef",
+      #     :service_name => "chef",
+      #     :running => false
+      #   )
+      #   @new_resource.stub!(:reload_command).and_return(false)
+      #   @new_resource.stub!(:supports).and_return({:reload => false})
+      # 
+      #   @provider = Chef::Provider::Service::Arch.new(@node, @new_resource)
+      #   Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      # end
+
+      it "should call 'reload' on the service if it supports it" do
+        @new_resource.stub!(:supports).and_return({:reload => true})
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} reload")
+        @provider.reload_service()
+      end
+
+      it "should should run the user specified reload command if one is specified and the service doesn't support reload" do
+        @new_resource.stub!(:reload_command).and_return("/etc/rc.d/chef lollerpants")
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/#{@new_resource.service_name} lollerpants")
+        @provider.reload_service()
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/service/debian_service_spec.rb b/spec/unit/provider/service/debian_service_spec.rb
new file mode 100644
index 0000000000..bea9360561
--- /dev/null
+++ b/spec/unit/provider/service/debian_service_spec.rb
@@ -0,0 +1,254 @@
+#
+# Author:: AJ Christensen (<aj@hjksolutions.com>)
+# Copyright:: Copyright (c) 2008 HJK Solutions, LLC
+# 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 Chef::Provider::Service::Debian, "load_current_resource" do
+  before(:each) do
+    @node = Chef::Node.new
+    @node.automatic_attrs[:command] = {:ps => 'fuuuu'}
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new("chef")
+
+    @current_resource = Chef::Resource::Service.new("chef")
+
+    @provider = Chef::Provider::Service::Debian.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+
+    @pid, @stdin, @stdout, @stderr = nil, nil, nil, nil
+
+  end
+
+  it "ensures /usr/sbin/update-rc.d is available" do
+    File.should_receive(:exists?).with("/usr/sbin/update-rc.d").and_return(false)
+    @provider.define_resource_requirements
+    lambda { @provider.process_resource_requirements } .should raise_error(Chef::Exceptions::Service)
+  end
+
+  describe "when update-rc.d shows the init script linked to rc*.d/" do
+    before do
+      @provider.stub!(:assert_update_rcd_available)
+
+      result=<<-UPDATE_RC_D_SUCCESS
+Removing any system startup links for /etc/init.d/chef ...
+  /etc/rc0.d/K20chef
+  /etc/rc1.d/K20chef
+  /etc/rc2.d/S20chef
+  /etc/rc3.d/S20chef
+  /etc/rc4.d/S20chef
+  /etc/rc5.d/S20chef
+  /etc/rc6.d/K20chef
+  UPDATE_RC_D_SUCCESS
+      @stdout = StringIO.new(result)
+      @stderr = StringIO.new
+      @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+      @provider.stub!(:shell_out!).and_return(@status)
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+    end
+
+    it "says the service is enabled" do
+      @provider.service_currently_enabled?(@provider.get_priority).should be_true
+    end
+
+    it "stores the 'enabled' state" do
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      @provider.load_current_resource.should equal(@current_resource)
+      @current_resource.enabled.should be_true
+    end
+  end
+
+  {"Debian/Lenny and older" => {
+      "linked" => {
+        "stdout" => " Removing any system startup links for /etc/init.d/chef ...
+   /etc/rc0.d/K20chef
+   /etc/rc1.d/K20chef
+   /etc/rc2.d/S20chef
+   /etc/rc3.d/S20chef
+   /etc/rc4.d/S20chef
+   /etc/rc5.d/S20chef
+   /etc/rc6.d/K20chef",
+        "stderr" => ""
+      },
+      "not linked" => {
+        "stdout" => " Removing any system startup links for /etc/init.d/chef ...",
+        "stderr" => ""
+      },
+    },
+    "Debian/Squeeze and earlier" => {
+      "linked" => {
+        "stdout" => "update-rc.d: using dependency based boot sequencing",
+        "stderr" => "insserv: remove service /etc/init.d/../rc0.d/K20chef-client
+insserv: remove service /etc/init.d/../rc1.d/K20chef-client
+insserv: remove service /etc/init.d/../rc2.d/S20chef-client
+insserv: remove service /etc/init.d/../rc3.d/S20chef-client
+insserv: remove service /etc/init.d/../rc4.d/S20chef-client
+insserv: remove service /etc/init.d/../rc5.d/S20chef-client
+insserv: remove service /etc/init.d/../rc6.d/K20chef-client
+insserv: dryrun, not creating .depend.boot, .depend.start, and .depend.stop"
+      },
+      "not linked" => {
+        "stdout" => "update-rc.d: using dependency based boot sequencing",
+        "stderr" => ""
+      }
+    }
+  }.each do |model, streams|
+    describe "when update-rc.d shows the init script linked to rc*.d/" do
+      before do
+        @provider.stub!(:assert_update_rcd_available)
+
+        @stdout = StringIO.new(streams["linked"]["stdout"])
+        @stderr = StringIO.new(streams["linked"]["stderr"])
+        @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+        @provider.stub!(:shell_out!).and_return(@status)
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      end
+
+      it "says the service is enabled" do
+        @provider.service_currently_enabled?(@provider.get_priority).should be_true
+      end
+
+      it "stores the 'enabled' state" do
+        Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+        @provider.load_current_resource.should equal(@current_resource)
+        @current_resource.enabled.should be_true
+      end
+
+      it "stores the start/stop priorities of the service" do
+        @provider.load_current_resource
+        expected_priorities = {"6"=>[:stop, "20"],
+          "0"=>[:stop, "20"],
+          "1"=>[:stop, "20"],
+          "2"=>[:start, "20"],
+          "3"=>[:start, "20"],
+          "4"=>[:start, "20"],
+          "5"=>[:start, "20"]}
+        @provider.current_resource.priority.should == expected_priorities
+      end
+    end
+
+    describe "when using squeeze/earlier and update-rc.d shows the init script isn't linked to rc*.d" do
+      before do
+        @provider.stub!(:assert_update_rcd_available)
+        @stdout = StringIO.new(streams["not linked"]["stdout"])
+        @stderr = StringIO.new(streams["not linked"]["stderr"])
+        @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+        @provider.stub!(:shell_out!).and_return(@status)
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      end
+
+      it "says the service is disabled" do
+        @provider.service_currently_enabled?(@provider.get_priority).should be_false
+      end
+
+      it "stores the 'disabled' state" do
+        Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+        @provider.load_current_resource.should equal(@current_resource)
+        @current_resource.enabled.should be_false
+      end
+    end
+  end
+
+  describe "when update-rc.d shows the init script isn't linked to rc*.d" do
+    before do
+      @provider.stub!(:assert_update_rcd_available)
+      @status = mock("Status", :exitstatus => 0)
+      @stdout = StringIO.new(" Removing any system startup links for /etc/init.d/chef ...")
+      @stderr = StringIO.new
+      @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+      @provider.stub!(:shell_out!).and_return(@status)
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+    end
+
+    it "says the service is disabled" do
+      @provider.service_currently_enabled?(@provider.get_priority).should be_false
+    end
+
+    it "stores the 'disabled' state" do
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      @provider.load_current_resource.should equal(@current_resource)
+      @current_resource.enabled.should be_false
+    end
+  end
+
+  describe "when update-rc.d fails" do
+    before do
+      @status = mock("Status", :exitstatus => -1)
+      @provider.stub!(:popen4).and_return(@status)
+    end
+
+    it "raises an error" do
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+  end
+
+  describe "when enabling a service without priority" do
+    it "should call update-rc.d 'service_name' defaults" do
+      @provider.should_receive(:run_command).with({:command => "/usr/sbin/update-rc.d -f #{@new_resource.service_name} remove"})
+      @provider.should_receive(:run_command).with({:command => "/usr/sbin/update-rc.d #{@new_resource.service_name} defaults"})
+      @provider.enable_service()
+    end
+  end
+
+  describe "when enabling a service with simple priority" do
+    before do
+      @new_resource.priority(75)
+    end
+
+    it "should call update-rc.d 'service_name' defaults" do
+      @provider.should_receive(:run_command).with({:command => "/usr/sbin/update-rc.d -f #{@new_resource.service_name} remove"})
+      @provider.should_receive(:run_command).with({:command => "/usr/sbin/update-rc.d #{@new_resource.service_name} defaults 75 25"})
+      @provider.enable_service()
+    end
+  end
+
+  describe "when enabling a service with complex priorities" do
+    before do
+      @new_resource.priority(2 => [:start, 20], 3 => [:stop, 55])
+    end
+
+    it "should call update-rc.d 'service_name' defaults" do
+      @provider.should_receive(:run_command).with({:command => "/usr/sbin/update-rc.d -f #{@new_resource.service_name} remove"})
+      @provider.should_receive(:run_command).with({:command => "/usr/sbin/update-rc.d #{@new_resource.service_name} start 20 2 . stop 55 3 . "})
+      @provider.enable_service()
+    end
+  end
+
+  describe "when disabling a service without a priority" do
+
+    it "should call update-rc.d -f 'service_name' remove + stop with a default priority" do
+      @provider.should_receive(:run_command).with({:command => "/usr/sbin/update-rc.d -f #{@new_resource.service_name} remove"})
+      @provider.should_receive(:run_command).with({:command => "/usr/sbin/update-rc.d -f #{@new_resource.service_name} stop 80 2 3 4 5 ."})
+      @provider.disable_service()
+    end
+  end
+
+  describe "when disabling a service with simple priority" do
+    before do
+      @new_resource.priority(75)
+    end
+
+    it "should call update-rc.d -f 'service_name' remove + stop with a specified priority" do
+      @provider.should_receive(:run_command).with({:command => "/usr/sbin/update-rc.d -f #{@new_resource.service_name} remove"})
+      @provider.should_receive(:run_command).with({:command => "/usr/sbin/update-rc.d -f #{@new_resource.service_name} stop #{100 - @new_resource.priority} 2 3 4 5 ."})
+      @provider.disable_service()
+    end
+  end
+end
diff --git a/spec/unit/provider/service/freebsd_service_spec.rb b/spec/unit/provider/service/freebsd_service_spec.rb
new file mode 100644
index 0000000000..6dd06bde2c
--- /dev/null
+++ b/spec/unit/provider/service/freebsd_service_spec.rb
@@ -0,0 +1,379 @@
+#
+# Author:: Bryan McLellan (btm@loftninjas.org)
+# Copyright:: Copyright (c) 2009 Bryan McLellan
+# 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 Chef::Provider::Service::Freebsd do
+  before do
+    @node = Chef::Node.new
+    @node.automatic_attrs[:command] = {:ps => "ps -ax"}
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new("apache22")
+    @new_resource.pattern("httpd")
+    @new_resource.supports({:status => false})
+
+    @current_resource = Chef::Resource::Service.new("apache22")
+
+    @provider = Chef::Provider::Service::Freebsd.new(@new_resource,@run_context)
+    @provider.action = :start
+    @init_command = "/usr/local/etc/rc.d/apache22"
+    Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+  end
+
+  describe "load_current_resource" do
+    before(:each) do
+      @stdout = StringIO.new(<<-PS_SAMPLE)
+413  ??  Ss     0:02.51 /usr/sbin/syslogd -s
+539  ??  Is     0:00.14 /usr/sbin/sshd
+545  ??  Ss     0:17.53 sendmail: accepting connections (sendmail)
+PS_SAMPLE
+      @status = mock(:stdout => @stdout, :exitstatus => 0)
+      @provider.stub!(:shell_out!).with(@node[:command][:ps]).and_return(@status)
+
+      ::File.stub!(:exists?).and_return(false)
+      ::File.stub!(:exists?).with("/usr/local/etc/rc.d/#{@new_resource.service_name}").and_return(true)
+      @lines = mock("lines")
+      @lines.stub!(:each).and_yield("sshd_enable=\"YES\"").
+                          and_yield("#{@new_resource.name}_enable=\"YES\"")
+      ::File.stub!(:open).and_return(@lines)
+
+      @rc_with_name = StringIO.new(<<-RC_SAMPLE)
+name="apache22"
+rcvar=`set_rcvar`
+RC_SAMPLE
+      ::File.stub!(:open).with("/usr/local/etc/rc.d/#{@new_resource.service_name}").and_return(@rc_with_name)
+      @provider.stub(:service_enable_variable_name).and_return nil
+
+    end
+
+    it "should create a current resource with the name of the new resource" do
+      Chef::Resource::Service.should_receive(:new).and_return(@current_resource)
+      @provider.load_current_resource
+    end
+
+    it "should set the current resources service name to the new resources service name" do
+      @provider.load_current_resource
+      @current_resource.service_name.should == @new_resource.service_name
+    end
+
+    it "should not raise an exception if the rcscript have a name variable" do
+      @provider.load_current_resource
+      lambda { @provider.service_enable_variable_name }.should_not raise_error(Chef::Exceptions::Service)
+    end
+
+    describe "when the service supports status" do
+      before do
+        @new_resource.supports({:status => true})
+      end
+
+      it "should run '/etc/init.d/service_name status'" do
+        @provider.should_receive(:shell_out).with("/usr/local/etc/rc.d/#{@current_resource.service_name} status").and_return(@status)
+        @provider.load_current_resource
+      end
+
+      it "should set running to true if the the status command returns 0" do
+        @provider.should_receive(:shell_out).with("/usr/local/etc/rc.d/#{@current_resource.service_name} status").and_return(@status)
+        @current_resource.should_receive(:running).with(true)
+        @provider.load_current_resource
+      end
+
+      it "should set running to false if the status command returns anything except 0" do
+        @provider.should_receive(:shell_out).with("/usr/local/etc/rc.d/#{@current_resource.service_name} status").and_raise(Mixlib::ShellOut::ShellCommandFailed)
+        @current_resource.should_receive(:running).with(false)
+        @provider.load_current_resource
+       # @provider.current_resource.running.should be_false
+      end
+    end
+
+    describe "when a status command has been specified" do
+      before do
+        @new_resource.status_command("/bin/chefhasmonkeypants status")
+      end
+
+      it "should run the services status command if one has been specified" do
+        @provider.should_receive(:shell_out).with("/bin/chefhasmonkeypants status").and_return(@status)
+        @provider.load_current_resource
+      end
+
+    end
+
+    it "should raise error if the node has a nil ps attribute and no other means to get status" do
+      @node.automatic_attrs[:command] = {:ps => nil}
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+
+    it "should raise error if the node has an empty ps attribute and no other means to get status" do
+      @node.automatic_attrs[:command] = {:ps => ""}
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+    
+    describe "when executing assertions" do
+      it "should verify that /etc/rc.conf exists" do
+        ::File.should_receive(:exists?).with("/etc/rc.conf")
+        @provider.stub!(:service_enable_variable_name).and_return("#{@current_resource.service_name}_enable")
+        @provider.load_current_resource
+      end
+
+      context "and the init script is not found" do
+        [ "start", "reload", "restart", "enable" ].each do |action|
+          it "should raise an exception when the action is #{action}" do
+            ::File.stub!(:exists?).and_return(false)
+            @provider.load_current_resource
+            @provider.define_resource_requirements 
+            @provider.instance_variable_get("@rcd_script_found").should be_false
+            @provider.action = action
+            lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+          end
+        end
+
+        [ "stop", "disable" ].each do |action|
+          it "should not raise an error when the action is #{action}" do
+            @provider.action = action
+            lambda { @provider.process_resource_requirements }.should_not raise_error
+          end
+        end
+      end
+
+      it "update state when current resource enabled state could not be determined" do
+        ::File.should_receive(:exists?).with("/etc/rc.conf").and_return false
+        @provider.load_current_resource
+        @provider.instance_variable_get("@enabled_state_found").should be_false
+      end 
+
+      it "update state when current resource enabled state could be determined" do
+        ::File.stub!(:exist?).with("/usr/local/etc/rc.d/#{@new_resource.service_name}").and_return(true)
+        ::File.should_receive(:exists?).with("/etc/rc.conf").and_return  true
+        @provider.load_current_resource
+        @provider.instance_variable_get("@enabled_state_found").should be_false
+        @provider.instance_variable_get("@rcd_script_found").should be_true
+        @provider.define_resource_requirements 
+        lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service,
+          "Could not find the service name in /usr/local/etc/rc.d/#{@current_resource.service_name} and rcvar")
+      end 
+
+      it "should throw an exception if service line is missing from rc.d script" do
+          pending "not implemented" do
+            false.should be_true
+          end
+      end
+
+    end
+
+    describe "when we have a 'ps' attribute" do
+      before do
+        @node.automatic_attrs[:command] = {:ps => "ps -ax"}
+      end
+
+      it "should shell_out! the node's ps command" do
+        @provider.should_receive(:shell_out!).with(@node[:command][:ps]).and_return(@status)
+        @provider.load_current_resource
+      end
+
+      it "should read stdout of the ps command" do
+        @provider.stub!(:shell_out!).and_return(@status)
+        @stdout.should_receive(:each_line).and_return(true)
+        @provider.load_current_resource
+      end
+
+      it "should set running to true if the regex matches the output" do
+        @stdout.stub!(:each_line).and_yield("555  ??  Ss     0:05.16 /usr/sbin/cron -s").
+                                  and_yield(" 9881  ??  Ss     0:06.67 /usr/local/sbin/httpd -DNOHTTPACCEPT")
+        @provider.load_current_resource 
+        @current_resource.running.should be_true
+      end
+
+      it "should set running to false if the regex doesn't match" do
+        @provider.stub!(:shell_out!).and_return(@status)
+        @provider.load_current_resource
+        @current_resource.running.should be_false
+      end
+
+      it "should raise an exception if ps fails" do
+        @provider.stub!(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+        @provider.load_current_resource
+        @provider.define_resource_requirements
+        lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+      end
+    end
+
+    it "should return the current resource" do
+      @provider.load_current_resource.should eql(@current_resource)
+    end
+
+    describe "when starting the service" do
+      it "should call the start command if one is specified" do
+        @new_resource.start_command("/etc/rc.d/chef startyousillysally")
+        @provider.should_receive(:shell_out!).with("/etc/rc.d/chef startyousillysally")
+        @provider.load_current_resource
+        @provider.start_service()
+      end
+
+      it "should call '/usr/local/etc/rc.d/service_name faststart' if no start command is specified" do
+        @provider.should_receive(:shell_out!).with("/usr/local/etc/rc.d/#{@new_resource.service_name} faststart")
+        @provider.load_current_resource
+        @provider.start_service()
+      end
+    end
+
+    describe Chef::Provider::Service::Init, "stop_service" do
+      it "should call the stop command if one is specified" do
+        @new_resource.stop_command("/etc/init.d/chef itoldyoutostop")
+        @provider.should_receive(:shell_out!).with("/etc/init.d/chef itoldyoutostop")
+        @provider.load_current_resource
+        @provider.stop_service()
+      end
+
+      it "should call '/usr/local/etc/rc.d/service_name faststop' if no stop command is specified" do
+        @provider.should_receive(:shell_out!).with("/usr/local/etc/rc.d/#{@new_resource.service_name} faststop")
+        @provider.load_current_resource
+        @provider.stop_service()
+      end
+    end
+
+    describe "when restarting a service" do
+      it "should call 'restart' on the service_name if the resource supports it" do
+        @new_resource.supports({:restart => true})
+        @provider.should_receive(:shell_out!).with("/usr/local/etc/rc.d/#{@new_resource.service_name} fastrestart")
+        @provider.load_current_resource
+        @provider.restart_service()
+      end
+
+      it "should call the restart_command if one has been specified" do
+        @new_resource.restart_command("/etc/init.d/chef restartinafire")
+        @provider.should_receive(:shell_out!).with("/etc/init.d/chef restartinafire")
+        @provider.load_current_resource
+        @provider.restart_service()
+      end
+    end
+
+    describe "when the rcscript does not have a name variable" do
+      before do
+        @rc_without_name = StringIO.new(<<-RC_SAMPLE)
+rcvar=`set_rcvar`
+RC_SAMPLE
+        ::File.stub!(:open).with("/usr/local/etc/rc.d/#{@current_resource.service_name}").and_return(@rc_with_noname)
+        @provider.current_resource = @current_resource
+      end
+
+      describe "when rcvar returns foobar_enable" do
+        before do
+          @rcvar_stdout = <<RCVAR_SAMPLE
+# apache22
+#
+# #{@current_resource.service_name}_enable="YES"
+#   (default: "")
+RCVAR_SAMPLE
+          @status = mock(:stdout => @rcvar_stdout, :exitstatus => 0)
+          @provider.stub!(:shell_out!).with("/usr/local/etc/rc.d/#{@current_resource.service_name} rcvar").and_return(@status)
+        end
+
+        it "should get the service name from rcvar if the rcscript does not have a name variable" do
+          @provider.load_current_resource
+          @provider.unstub!(:service_enable_variable_name)
+          @provider.service_enable_variable_name.should == "#{@current_resource.service_name}_enable"
+        end
+
+        it "should not raise an exception if the rcscript does not have a name variable" do
+          @provider.load_current_resource
+          lambda { @provider.service_enable_variable_name }.should_not raise_error(Chef::Exceptions::Service)
+        end
+      end
+
+      describe "when rcvar does not return foobar_enable" do
+        before do
+          @rcvar_stdout = <<RCVAR_SAMPLE
+# service_with_noname
+#
+RCVAR_SAMPLE
+          @status = mock(:stdout => @rcvar_stdout, :exitstatus => 0)
+          @provider.stub!(:shell_out!).with("/usr/local/etc/rc.d/#{@current_resource.service_name} rcvar").and_return(@status)
+        end
+
+        [ "start", "reload", "restart", "enable" ].each do |action|
+          it "should raise an exception when the action is #{action}" do
+            @provider.action = action
+            @provider.load_current_resource
+            @provider.define_resource_requirements
+            lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+          end
+        end
+
+        [ "stop", "disable" ].each do |action|
+          it "should not raise an error when the action is #{action}" do
+            ::File.stub!(:exist?).with("/usr/local/etc/rc.d/#{@new_resource.service_name}").and_return(true)
+            @provider.action = action
+            @provider.load_current_resource
+            @provider.define_resource_requirements
+            lambda { @provider.process_resource_requirements }.should_not raise_error(Chef::Exceptions::Service)
+          end
+        end
+      end
+    end
+  end
+
+  describe Chef::Provider::Service::Freebsd, "enable_service" do
+    before do
+      @provider.current_resource = @current_resource
+      @provider.stub!(:service_enable_variable_name).and_return("#{@current_resource.service_name}_enable")
+    end
+
+    it "should enable the service if it is not enabled" do
+      @current_resource.stub!(:enabled).and_return(false)
+      @provider.should_receive(:read_rc_conf).and_return([ "foo", "#{@current_resource.service_name}_enable=\"NO\"", "bar" ])
+      @provider.should_receive(:write_rc_conf).with(["foo", "bar", "#{@current_resource.service_name}_enable=\"YES\""])
+      @provider.enable_service()
+    end
+
+    it "should enable the service if it is not enabled and not already specified in the rc.conf file" do
+      @current_resource.stub!(:enabled).and_return(false)
+      @provider.should_receive(:read_rc_conf).and_return([ "foo", "bar" ])
+      @provider.should_receive(:write_rc_conf).with(["foo", "bar", "#{@current_resource.service_name}_enable=\"YES\""])
+      @provider.enable_service()
+    end
+
+    it "should not enable the service if it is already enabled" do
+      @current_resource.stub!(:enabled).and_return(true)
+      @provider.should_not_receive(:write_rc_conf)
+      @provider.enable_service
+    end
+  end
+
+  describe Chef::Provider::Service::Freebsd, "disable_service" do
+    before do
+      @provider.current_resource = @current_resource
+      @provider.stub!(:service_enable_variable_name).and_return("#{@current_resource.service_name}_enable")
+    end
+
+    it "should should disable the service if it is not disabled" do
+      @current_resource.stub!(:enabled).and_return(true)
+      @provider.should_receive(:read_rc_conf).and_return([ "foo", "#{@current_resource.service_name}_enable=\"YES\"", "bar" ])
+      @provider.should_receive(:write_rc_conf).with(["foo", "bar", "#{@current_resource.service_name}_enable=\"NO\""])
+      @provider.disable_service()
+    end
+
+    it "should not disable the service if it is already disabled" do
+      @current_resource.stub!(:enabled).and_return(false)
+      @provider.should_not_receive(:write_rc_conf)
+      @provider.disable_service()
+    end
+  end
+end
diff --git a/spec/unit/provider/service/gentoo_service_spec.rb b/spec/unit/provider/service/gentoo_service_spec.rb
new file mode 100644
index 0000000000..8d4ada043b
--- /dev/null
+++ b/spec/unit/provider/service/gentoo_service_spec.rb
@@ -0,0 +1,144 @@
+#
+# Author:: Lee Jensen (<ljensen@engineyard.com>)
+# Author:: AJ Christensen (<aj@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 'spec_helper'
+
+describe Chef::Provider::Service::Gentoo do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    
+    @new_resource     = Chef::Resource::Service.new("chef")
+    @current_resource = Chef::Resource::Service.new("chef")
+    
+    @provider = Chef::Provider::Service::Gentoo.new(@new_resource, @run_context)
+    Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+    @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+    @provider.stub!(:shell_out).and_return(@status)
+    File.stub!(:exists?).with("/etc/init.d/chef").and_return(true)
+    File.stub!(:exists?).with("/sbin/rc-update").and_return(true)
+    File.stub!(:exists?).with("/etc/runlevels/default/chef").and_return(false)
+    File.stub!(:readable?).with("/etc/runlevels/default/chef").and_return(false)
+  end
+ # new test: found_enabled state
+  #
+  describe "load_current_resource" do  
+    it "should raise Chef::Exceptions::Service if /sbin/rc-update does not exist" do
+      File.should_receive(:exists?).with("/sbin/rc-update").and_return(false)
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+
+    it "should track when service file is not found in /etc/runlevels" do
+      @provider.load_current_resource
+      @provider.instance_variable_get("@found_script").should be_false
+    end
+
+    it "should track when service file is found in /etc/runlevels/**/" do
+      Dir.stub!(:glob).with("/etc/runlevels/**/chef").and_return(["/etc/runlevels/default/chef"])
+      @provider.load_current_resource
+      @provider.instance_variable_get("@found_script").should be_true
+    end
+
+    describe "when detecting the service enable state" do
+      describe "and the glob returns a default service script file" do
+        before do
+          Dir.stub!(:glob).with("/etc/runlevels/**/chef").and_return(["/etc/runlevels/default/chef"])
+        end
+
+        describe "and the file exists and is readable" do
+          before do
+            File.stub!(:exists?).with("/etc/runlevels/default/chef").and_return(true)
+            File.stub!(:readable?).with("/etc/runlevels/default/chef").and_return(true)
+          end
+          it "should set enabled to true" do
+            @provider.load_current_resource
+            @current_resource.enabled.should be_true
+          end
+        end
+
+        describe "and the file exists but is not readable" do
+          before do
+            File.stub!(:exists?).with("/etc/runlevels/default/chef").and_return(true)
+            File.stub!(:readable?).with("/etc/runlevels/default/chef").and_return(false)
+          end
+          
+          it "should set enabled to false" do
+            @provider.load_current_resource
+            @current_resource.enabled.should be_false
+          end
+        end
+
+        describe "and the file does not exist" do
+          before do
+            File.stub!(:exists?).with("/etc/runlevels/default/chef").and_return(false)
+            File.stub!(:readable?).with("/etc/runlevels/default/chef").and_return("foobarbaz")
+          end
+
+          it "should set enabled to false" do
+            @provider.load_current_resource
+            @current_resource.enabled.should be_false
+          end
+
+        end
+      end
+
+  end
+ 
+    it "should return the current_resource" do
+      @provider.load_current_resource.should == @current_resource
+    end  
+
+    it "should support the status command automatically" do
+      @provider.load_current_resource
+      @new_resource.supports[:status].should be_true
+    end
+
+    it "should support the restart command automatically" do
+      @provider.load_current_resource
+      @new_resource.supports[:restart].should be_true
+    end
+
+    it "should not support the reload command automatically" do
+      @provider.load_current_resource
+      @new_resource.supports[:reload].should_not be_true
+    end
+
+  end
+  
+  describe "action_methods" do
+    before(:each) { @provider.stub!(:load_current_resource).and_return(@current_resource) }
+
+    describe Chef::Provider::Service::Gentoo, "enable_service" do
+      it "should call rc-update add *service* default" do
+        @provider.should_receive(:run_command).with({:command => "/sbin/rc-update add chef default"})
+        @provider.enable_service()
+      end
+    end
+
+    describe Chef::Provider::Service::Gentoo, "disable_service" do
+      it "should call rc-update del *service* default" do
+        @provider.should_receive(:run_command).with({:command => "/sbin/rc-update del chef default"})
+        @provider.disable_service()
+      end
+    end
+  end
+
+end
diff --git a/spec/unit/provider/service/init_service_spec.rb b/spec/unit/provider/service/init_service_spec.rb
new file mode 100644
index 0000000000..77b22c8cf4
--- /dev/null
+++ b/spec/unit/provider/service/init_service_spec.rb
@@ -0,0 +1,212 @@
+#
+# Author:: AJ Christensen (<aj@hjksolutions.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 'spec_helper'
+
+describe Chef::Provider::Service::Init, "load_current_resource" do
+  before(:each) do
+    @node = Chef::Node.new
+    @node.automatic_attrs[:command] = {:ps => "ps -ef"}
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new("chef")
+
+    @current_resource = Chef::Resource::Service.new("chef")
+
+    @provider = Chef::Provider::Service::Init.new(@new_resource, @run_context)
+    Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+
+    @stdout = StringIO.new(<<-PS)
+aj        7842  5057  0 21:26 pts/2    00:00:06 vi init.rb
+aj        7903  5016  0 21:26 pts/5    00:00:00 /bin/bash
+aj        8119  6041  0 21:34 pts/3    00:00:03 vi init_service_spec.rb
+PS
+    @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+    @provider.stub!(:shell_out!).and_return(@status)
+  end
+  
+  it "should create a current resource with the name of the new resource" do
+    @provider.load_current_resource
+    @provider.current_resource.should equal(@current_resource)
+  end
+
+  it "should set the current resources service name to the new resources service name" do
+    @provider.load_current_resource
+    @current_resource.service_name.should == 'chef'
+  end
+
+  describe "when the service supports status" do
+    before do
+      @new_resource.supports({:status => true})
+    end
+
+    it "should run '/etc/init.d/service_name status'" do
+      @provider.should_receive(:shell_out).with("/etc/init.d/#{@current_resource.service_name} status").and_return(@status)
+      @provider.load_current_resource
+    end
+  
+    it "should set running to true if the the status command returns 0" do
+      @provider.stub!(:shell_out).with("/etc/init.d/#{@current_resource.service_name} status").and_return(@status)
+      @provider.load_current_resource
+      @current_resource.running.should be_true
+    end
+
+    it "should set running to false if the status command returns anything except 0" do
+      @status.stub!(:exitstatus).and_return(1)
+      @provider.stub!(:shell_out).with("/etc/init.d/#{@current_resource.service_name} status").and_return(@status)
+      @provider.load_current_resource
+      @current_resource.running.should be_false
+    end
+
+    it "should set running to false if the status command raises" do
+      @provider.stub!(:shell_out).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      @provider.load_current_resource
+      @current_resource.running.should be_false
+    end
+  end
+
+  describe "when a status command has been specified" do
+    before do
+      @new_resource.stub!(:status_command).and_return("/etc/init.d/chefhasmonkeypants status")
+    end
+
+    it "should run the services status command if one has been specified" do
+      @provider.should_receive(:shell_out).with("/etc/init.d/chefhasmonkeypants status").and_return(@status)
+      @provider.load_current_resource
+    end
+    
+  end
+  
+  describe "when the node has not specified a ps command" do
+    
+    it "should raise an error if the node has a nil ps attribute" do
+      @node.automatic_attrs[:command] = {:ps => nil}
+      @provider.load_current_resource
+      @provider.action = :start
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+
+    it "should raise an error if the node has an empty ps attribute" do
+      @node.automatic_attrs[:command] = {:ps => ""}
+      @provider.load_current_resource
+      @provider.action = :start
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+    
+  end
+
+
+  describe "when we have a 'ps' attribute" do
+    it "should shell_out! the node's ps command" do
+      @provider.should_receive(:shell_out!).and_return(@status)
+      @provider.load_current_resource
+    end
+
+    it "should set running to true if the regex matches the output" do
+      @stdout = StringIO.new(<<-RUNNING_PS)
+aj        7842  5057  0 21:26 pts/2    00:00:06 chef
+aj        7842  5057  0 21:26 pts/2    00:00:06 poos
+RUNNING_PS
+      @status.stub!(:stdout).and_return(@stdout)
+      @provider.load_current_resource 
+      @current_resource.running.should be_true
+    end
+
+    it "should set running to false if the regex doesn't match" do
+      @provider.stub!(:shell_out!).and_return(@status)
+      @provider.load_current_resource
+      @current_resource.running.should be_false
+    end
+
+    it "should raise an exception if ps fails" do
+      @provider.stub!(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      @provider.load_current_resource
+      @provider.action = :start
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+  end
+
+  it "should return the current resource" do
+    @provider.load_current_resource.should eql(@current_resource)
+  end
+
+  describe "when starting the service" do
+    it "should call the start command if one is specified" do
+      @new_resource.start_command("/etc/init.d/chef startyousillysally")
+      @provider.should_receive(:shell_out!).with("/etc/init.d/chef startyousillysally")
+      @provider.start_service()
+    end
+
+    it "should call '/etc/init.d/service_name start' if no start command is specified" do
+      @provider.should_receive(:shell_out!).with("/etc/init.d/#{@new_resource.service_name} start")
+      @provider.start_service()
+    end 
+  end
+
+  describe Chef::Provider::Service::Init, "stop_service" do
+    it "should call the stop command if one is specified" do
+      @new_resource.stop_command("/etc/init.d/chef itoldyoutostop")
+      @provider.should_receive(:shell_out!).with("/etc/init.d/chef itoldyoutostop")
+      @provider.stop_service()
+    end
+
+    it "should call '/etc/init.d/service_name stop' if no stop command is specified" do
+      @provider.should_receive(:shell_out!).with("/etc/init.d/#{@new_resource.service_name} stop")
+      @provider.stop_service()
+    end
+  end
+
+  describe "when restarting a service" do
+    it "should call 'restart' on the service_name if the resource supports it" do
+      @new_resource.supports({:restart => true})
+      @provider.should_receive(:shell_out!).with("/etc/init.d/#{@new_resource.service_name} restart")
+      @provider.restart_service()
+    end
+
+    it "should call the restart_command if one has been specified" do
+      @new_resource.restart_command("/etc/init.d/chef restartinafire")
+      @provider.should_receive(:shell_out!).with("/etc/init.d/#{@new_resource.service_name} restartinafire")
+      @provider.restart_service()
+    end
+
+    it "should just call stop, then start when the resource doesn't support restart and no restart_command is specified" do
+      @provider.should_receive(:stop_service)
+      @provider.should_receive(:sleep).with(1)
+      @provider.should_receive(:start_service)
+      @provider.restart_service()
+    end
+  end
+
+  describe "when reloading a service" do
+    it "should call 'reload' on the service if it supports it" do
+      @new_resource.supports({:reload => true})
+      @provider.should_receive(:shell_out!).with("/etc/init.d/chef reload")
+      @provider.reload_service()
+    end
+
+    it "should should run the user specified reload command if one is specified and the service doesn't support reload" do
+      @new_resource.reload_command("/etc/init.d/chef lollerpants")
+      @provider.should_receive(:shell_out!).with("/etc/init.d/chef lollerpants")
+      @provider.reload_service()
+    end
+  end
+end
diff --git a/spec/unit/provider/service/insserv_service_spec.rb b/spec/unit/provider/service/insserv_service_spec.rb
new file mode 100644
index 0000000000..c823d511b5
--- /dev/null
+++ b/spec/unit/provider/service/insserv_service_spec.rb
@@ -0,0 +1,76 @@
+#
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# Copyright:: Copyright (c) 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.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::Service::Insserv do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @node.automatic_attrs[:command] = {:ps => "ps -ax"}
+
+    @new_resource = Chef::Resource::Service.new("initgrediant")
+    @current_resource = Chef::Resource::Service.new("initgrediant")
+
+    @provider = Chef::Provider::Service::Insserv.new(@new_resource, @run_context)
+    @status = mock("Process::Status mock", :exitstatus => 0, :stdout => "")
+    @provider.stub!(:shell_out!).and_return(@status)
+  end
+
+  describe "load_current_resource" do
+    describe "when startup links exist" do
+      before do 
+        Dir.stub!(:glob).with("/etc/rc**/S*initgrediant").and_return(["/etc/rc5.d/S18initgrediant", "/etc/rc2.d/S18initgrediant", "/etc/rc4.d/S18initgrediant", "/etc/rc3.d/S18initgrediant"])
+      end
+
+      it "sets the current enabled status to true" do
+        @provider.load_current_resource
+        @provider.current_resource.enabled.should be_true
+      end
+    end
+
+    describe "when startup links do not exist" do
+      before do 
+        Dir.stub!(:glob).with("/etc/rc**/S*initgrediant").and_return([])
+      end
+
+      it "sets the current enabled status to false" do
+        @provider.load_current_resource
+        @provider.current_resource.enabled.should be_false
+      end
+    end
+
+  end
+
+  describe "enable_service" do
+    it "should call insserv and create the default links" do
+      @provider.should_receive(:run_command).with({:command=>"/sbin/insserv -r -f #{@new_resource.service_name}"})
+      @provider.should_receive(:run_command).with({:command=>"/sbin/insserv -d -f #{@new_resource.service_name}"})
+      @provider.enable_service
+    end
+  end
+  
+  describe "disable_service" do
+    it "should call insserv and remove the links" do
+      @provider.should_receive(:run_command).with({:command=>"/sbin/insserv -r -f #{@new_resource.service_name}"})
+      @provider.disable_service
+    end
+  end
+end
+
diff --git a/spec/unit/provider/service/invokercd_service_spec.rb b/spec/unit/provider/service/invokercd_service_spec.rb
new file mode 100644
index 0000000000..ace2ad24e3
--- /dev/null
+++ b/spec/unit/provider/service/invokercd_service_spec.rb
@@ -0,0 +1,212 @@
+#
+# Author:: AJ Christensen (<aj@hjksolutions.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 'spec_helper'
+
+describe Chef::Provider::Service::Invokercd, "load_current_resource" do
+  before(:each) do
+    @node = Chef::Node.new
+    @node.automatic_attrs[:command] = {:ps => "ps -ef"}
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new("chef")
+
+    @current_resource = Chef::Resource::Service.new("chef")
+
+    @provider = Chef::Provider::Service::Invokercd.new(@new_resource, @run_context)
+    Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+
+    @stdout = StringIO.new(<<-PS)
+aj        7842  5057  0 21:26 pts/2    00:00:06 vi init.rb
+aj        7903  5016  0 21:26 pts/5    00:00:00 /bin/bash
+aj        8119  6041  0 21:34 pts/3    00:00:03 vi init_service_spec.rb
+PS
+    @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+    @provider.stub!(:shell_out!).and_return(@status)
+  end
+  
+  it "should create a current resource with the name of the new resource" do
+    @provider.load_current_resource
+    @provider.current_resource.should equal(@current_resource)
+  end
+
+  it "should set the current resources service name to the new resources service name" do
+    @provider.load_current_resource
+    @current_resource.service_name.should == 'chef'
+  end
+
+  describe "when the service supports status" do
+    before do
+      @new_resource.supports({:status => true})
+    end
+
+    it "should run '/usr/sbin/invoke-rc.d service_name status'" do
+      @provider.should_receive(:shell_out).with("/usr/sbin/invoke-rc.d #{@current_resource.service_name} status").and_return(@status)
+      @provider.load_current_resource
+    end
+  
+    it "should set running to true if the the status command returns 0" do
+      @provider.stub!(:shell_out).with("/usr/sbin/invoke-rc.d #{@current_resource.service_name} status").and_return(@status)
+      @provider.load_current_resource
+      @current_resource.running.should be_true
+    end
+
+    it "should set running to false if the status command returns anything except 0" do
+      @status.stub!(:exitstatus).and_return(1)
+      @provider.stub!(:shell_out).with("/usr/sbin/invoke-rc.d #{@current_resource.service_name} status").and_return(@status)
+      @provider.load_current_resource
+      @current_resource.running.should be_false
+    end
+
+    it "should set running to false if the status command raises" do
+      @provider.stub!(:shell_out).with("/usr/sbin/invoke-rc.d #{@current_resource.service_name} status").and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      @provider.load_current_resource
+      @current_resource.running.should be_false
+    end
+  end
+
+  describe "when a status command has been specified" do
+    before do
+      @new_resource.stub!(:status_command).and_return("/usr/sbin/invoke-rc.d chefhasmonkeypants status")
+    end
+
+    it "should run the services status command if one has been specified" do
+      @provider.should_receive(:shell_out).with("/usr/sbin/invoke-rc.d chefhasmonkeypants status").and_return(@status)
+      @provider.load_current_resource
+    end
+    
+  end
+  
+  describe "when the node has not specified a ps command" do
+    it "should raise error if the node has a nil ps attribute and no other means to get status" do
+      @node.automatic_attrs[:command] = {:ps => nil}
+      @provider.action = :start
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+
+    it "should raise error if the node has an empty ps attribute and no other means to get status" do
+      @node.automatic_attrs[:command] = {:ps => ""}
+      @provider.action = :start
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+    
+  end
+
+
+  describe "when we have a 'ps' attribute" do
+    it "should shell_out! the node's ps command" do
+      @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+      @provider.should_receive(:shell_out!).with(@node[:command][:ps]).and_return(@status)
+      @provider.load_current_resource
+    end
+
+    it "should set running to true if the regex matches the output" do
+      @stdout = StringIO.new(<<-RUNNING_PS)
+aj        7842  5057  0 21:26 pts/2    00:00:06 chef
+aj        7842  5057  0 21:26 pts/2    00:00:06 poos
+RUNNING_PS
+      @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+      @provider.should_receive(:shell_out!).and_return(@status)
+      @provider.load_current_resource 
+      @current_resource.running.should be_true
+    end
+
+    it "should set running to false if the regex doesn't match" do
+      @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+      @provider.should_receive(:shell_out!).and_return(@status)
+      @provider.load_current_resource
+      @current_resource.running.should be_false
+    end
+
+    it "should raise an exception if ps fails" do
+      @provider.stub!(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      @provider.action = :start
+      @provider.load_current_resource
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+  end
+
+  it "should return the current resource" do
+    @provider.load_current_resource.should eql(@current_resource)
+  end
+
+  describe "when starting the service" do
+    it "should call the start command if one is specified" do
+      @new_resource.start_command("/usr/sbin/invoke-rc.d chef startyousillysally")
+      @provider.should_receive(:shell_out!).with("/usr/sbin/invoke-rc.d chef startyousillysally")
+      @provider.start_service()
+    end
+
+    it "should call '/usr/sbin/invoke-rc.d service_name start' if no start command is specified" do
+      @provider.should_receive(:shell_out!).with("/usr/sbin/invoke-rc.d #{@new_resource.service_name} start")
+      @provider.start_service()
+    end 
+  end
+
+  describe Chef::Provider::Service::Invokercd, "stop_service" do
+    it "should call the stop command if one is specified" do
+      @new_resource.stop_command("/usr/sbin/invoke-rc.d chef itoldyoutostop")
+      @provider.should_receive(:shell_out!).with("/usr/sbin/invoke-rc.d chef itoldyoutostop")
+      @provider.stop_service()
+    end
+
+    it "should call '/usr/sbin/invoke-rc.d service_name stop' if no stop command is specified" do
+      @provider.should_receive(:shell_out!).with("/usr/sbin/invoke-rc.d #{@new_resource.service_name} stop")
+      @provider.stop_service()
+    end
+  end
+
+  describe "when restarting a service" do
+    it "should call 'restart' on the service_name if the resource supports it" do
+      @new_resource.supports({:restart => true})
+      @provider.should_receive(:shell_out!).with("/usr/sbin/invoke-rc.d #{@new_resource.service_name} restart")
+      @provider.restart_service()
+    end
+
+    it "should call the restart_command if one has been specified" do
+      @new_resource.restart_command("/usr/sbin/invoke-rc.d chef restartinafire")
+      @provider.should_receive(:shell_out!).with("/usr/sbin/invoke-rc.d #{@new_resource.service_name} restartinafire")
+      @provider.restart_service()
+    end
+
+    it "should just call stop, then start when the resource doesn't support restart and no restart_command is specified" do
+      @provider.should_receive(:stop_service)
+      @provider.should_receive(:sleep).with(1)
+      @provider.should_receive(:start_service)
+      @provider.restart_service()
+    end
+  end
+
+  describe "when reloading a service" do
+    it "should call 'reload' on the service if it supports it" do
+      @new_resource.supports({:reload => true})
+      @provider.should_receive(:shell_out!).with("/usr/sbin/invoke-rc.d chef reload")
+      @provider.reload_service()
+    end
+
+    it "should should run the user specified reload command if one is specified and the service doesn't support reload" do
+      @new_resource.reload_command("/usr/sbin/invoke-rc.d chef lollerpants")
+      @provider.should_receive(:shell_out!).with("/usr/sbin/invoke-rc.d chef lollerpants")
+      @provider.reload_service()
+    end
+  end
+end
diff --git a/spec/unit/provider/service/macosx_spec.rb b/spec/unit/provider/service/macosx_spec.rb
new file mode 100644
index 0000000000..9c3ec340a2
--- /dev/null
+++ b/spec/unit/provider/service/macosx_spec.rb
@@ -0,0 +1,229 @@
+#
+# Author:: Igor Afonov <afonov@gmail.com>
+# Copyright:: Copyright (c) 2011 Igor Afonov
+# 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 Chef::Provider::Service::Macosx do
+  let(:node) { Chef::Node.new }
+  let(:events) {Chef::EventDispatch::Dispatcher.new}
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:provider) { described_class.new(new_resource, run_context) }
+  let(:stdout) { StringIO.new }
+
+  before do
+    Dir.stub!(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist"], [])
+    provider.stub!(:shell_out!).
+             with("launchctl list", {:group => 1001, :user => 101}).
+             and_return(mock("ouput", :stdout => stdout))
+
+    File.stub!(:stat).and_return(mock("stat", :gid => 1001, :uid => 101))
+  end
+
+  ["redis-server", "io.redis.redis-server"].each do |service_name|
+    context "when service name is given as #{service_name}" do
+      let(:new_resource) { Chef::Resource::Service.new(service_name) }
+      let!(:current_resource) { Chef::Resource::Service.new(service_name) }
+
+      describe "#load_current_resource" do
+        context "when launchctl returns pid in service list" do
+          let(:stdout) { StringIO.new <<-SVC_LIST }
+12761 - 0x100114220.old.machinit.thing
+7777  - io.redis.redis-server
+- - com.lol.stopped-thing
+SVC_LIST
+
+          before do
+            provider.load_current_resource
+          end
+
+          it "sets resource running state to true" do
+            provider.current_resource.running.should be_true
+          end
+
+          it "sets resouce enabled state to true" do
+            provider.current_resource.enabled.should be_true
+          end
+        end
+
+        describe "running unsupported actions" do
+          before do
+            Dir.stub!(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist"], [])
+          end
+          it "should throw an exception when enable action is attempted" do
+            lambda {provider.run_action(:enable)}.should raise_error(Chef::Exceptions::UnsupportedAction)
+          end
+          it "should throw an exception when reload action is attempted" do
+            lambda {provider.run_action(:reload)}.should raise_error(Chef::Exceptions::UnsupportedAction)
+          end
+          it "should throw an exception when disable action is attempted" do
+            lambda {provider.run_action(:disable)}.should raise_error(Chef::Exceptions::UnsupportedAction)
+          end
+        end
+        context "when launchctl returns empty service pid" do
+          let(:stdout) { StringIO.new <<-SVC_LIST }
+12761 - 0x100114220.old.machinit.thing
+- - io.redis.redis-server
+- - com.lol.stopped-thing
+SVC_LIST
+
+          before do
+            provider.load_current_resource
+          end
+
+          it "sets resource running state to false" do
+            provider.current_resource.running.should be_false
+          end
+
+          it "sets resouce enabled state to true" do
+            provider.current_resource.enabled.should be_true
+          end
+        end
+
+        context "when launchctl doesn't return service entry at all" do
+          let(:stdout) { StringIO.new <<-SVC_LIST }
+12761 - 0x100114220.old.machinit.thing
+- - com.lol.stopped-thing
+SVC_LIST
+
+          it "sets service running state to false" do
+            provider.load_current_resource
+            provider.current_resource.running.should be_false
+          end
+
+          context "and plist for service is not available" do
+            before do
+              Dir.stub!(:glob).and_return([])
+              provider.load_current_resource
+            end
+
+            it "sets resouce enabled state to false" do
+              provider.current_resource.enabled.should be_false
+            end
+          end
+
+          context "and plist for service is available" do
+            before do
+              Dir.stub!(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist"], [])
+              provider.load_current_resource
+            end
+
+            it "sets resouce enabled state to true" do
+              provider.current_resource.enabled.should be_true
+            end
+          end
+
+          describe "and several plists match service name" do
+            it "throws exception" do
+              Dir.stub!(:glob).and_return(["/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist",
+                                           "/Users/wtf/something.plist"])
+              provider.load_current_resource
+              provider.define_resource_requirements
+              lambda { provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+            end
+          end
+        end
+      end
+      describe "#start_service" do
+        before do
+          Chef::Resource::Service.stub!(:new).and_return(current_resource)
+          provider.load_current_resource
+          current_resource.stub!(:running).and_return(false)
+        end
+
+        it "calls the start command if one is specified and service is not running" do
+          new_resource.stub!(:start_command).and_return("cowsay dirty")
+
+          provider.should_receive(:shell_out!).with("cowsay dirty")
+          provider.start_service
+        end
+
+        it "shows warning message if service is already running" do
+          current_resource.stub!(:running).and_return(true)
+          Chef::Log.should_receive(:debug).with("service[#{service_name}] already running, not starting")
+
+          provider.start_service
+        end
+
+        it "starts service via launchctl if service found" do
+          provider.should_receive(:shell_out!).
+                   with("launchctl load -w '/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist'",
+                         :group => 1001, :user => 101).
+                   and_return(0)
+
+          provider.start_service
+        end
+      end
+
+      describe "#stop_service" do
+        before do
+          Chef::Resource::Service.stub!(:new).and_return(current_resource)
+
+          provider.load_current_resource
+          current_resource.stub!(:running).and_return(true)
+        end
+
+        it "calls the stop command if one is specified and service is running" do
+          new_resource.stub!(:stop_command).and_return("kill -9 123")
+
+          provider.should_receive(:shell_out!).with("kill -9 123")
+          provider.stop_service
+        end
+
+        it "shows warning message if service is not running" do
+          current_resource.stub!(:running).and_return(false)
+          Chef::Log.should_receive(:debug).with("service[#{service_name}] not running, not stopping")
+
+          provider.stop_service
+        end
+
+        it "stops the service via launchctl if service found" do
+          provider.should_receive(:shell_out!).
+                   with("launchctl unload '/Users/igor/Library/LaunchAgents/io.redis.redis-server.plist'",
+                        :group => 1001, :user => 101).
+                   and_return(0)
+
+          provider.stop_service
+        end
+      end
+
+      describe "#restart_service" do
+        before do
+          Chef::Resource::Service.stub!(:new).and_return(current_resource)
+
+          provider.load_current_resource
+          current_resource.stub!(:running).and_return(true)
+          provider.stub!(:sleep)
+        end
+
+        it "issues a command if given" do
+          new_resource.stub!(:restart_command).and_return("reload that thing")
+
+          provider.should_receive(:shell_out!).with("reload that thing")
+          provider.restart_service
+        end
+
+        it "stops and then starts service" do
+          provider.should_receive(:stop_service)
+          provider.should_receive(:start_service);
+
+          provider.restart_service
+        end
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/service/redhat_spec.rb b/spec/unit/provider/service/redhat_spec.rb
new file mode 100644
index 0000000000..dd874a4f05
--- /dev/null
+++ b/spec/unit/provider/service/redhat_spec.rb
@@ -0,0 +1,156 @@
+#
+# Author:: AJ Christensen (<aj@hjksolutions.com>)
+# Copyright:: Copyright (c) 2008 HJK Solutions, LLC
+# 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.join(File.dirname(__FILE__), "..", "..", "..", "spec_helper"))
+require 'ostruct'
+
+shared_examples_for "define_resource_requirements_common" do
+  it "should raise an error if /sbin/chkconfig does not exist" do
+    File.stub!(:exists?).with("/sbin/chkconfig").and_return(false)
+    @provider.stub!(:shell_out).with("/sbin/service chef status").and_raise(Errno::ENOENT)
+    @provider.stub!(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_raise(Errno::ENOENT)
+    @provider.load_current_resource
+    @provider.define_resource_requirements
+    lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+  end
+
+  it "should not raise an error if the service exists but is not added to any runlevels" do
+    status = mock("Status", :exitstatus => 0, :stdout => "" , :stderr => "")
+    @provider.should_receive(:shell_out).with("/sbin/service chef status").and_return(status)
+    chkconfig = mock("Chkconfig", :exitstatus => 0, :stdout => "", :stderr => "service chef supports chkconfig, but is not referenced in any runlevel (run 'chkconfig --add chef')")
+    @provider.should_receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+    @provider.load_current_resource
+    @provider.define_resource_requirements
+    lambda { @provider.process_resource_requirements }.should_not raise_error
+  end
+end
+
+describe "Chef::Provider::Service::Redhat" do
+
+  before(:each) do
+    @node = Chef::Node.new
+    @node.automatic_attrs[:command] = {:ps => 'foo'}
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+ 
+    @new_resource = Chef::Resource::Service.new("chef")
+
+    @current_resource = Chef::Resource::Service.new("chef")
+
+    @provider = Chef::Provider::Service::Redhat.new(@new_resource, @run_context)
+    @provider.action = :start
+    Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+    File.stub!(:exists?).with("/sbin/chkconfig").and_return(true)
+  end
+
+  describe "while not in why run mode" do
+    before(:each) do
+      Chef::Config[:why_run] = false
+    end
+
+    describe "load current resource" do
+      it "sets the current enabled status to true if the service is enabled for any run level" do
+        status = mock("Status", :exitstatus => 0, :stdout => "" , :stderr => "")
+        @provider.should_receive(:shell_out).with("/sbin/service chef status").and_return(status)
+        chkconfig = mock("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", :stderr => "")
+        @provider.should_receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        @provider.instance_variable_get("@service_missing").should be_false
+        @provider.load_current_resource
+        @current_resource.enabled.should be_true
+      end
+  
+      it "sets the current enabled status to false if the regex does not match" do
+        status = mock("Status", :exitstatus => 0, :stdout => "" , :stderr => "")
+        @provider.should_receive(:shell_out).with("/sbin/service chef status").and_return(status)
+        chkconfig = mock("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:off   6:off", :stderr => "")
+        @provider.should_receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        @provider.instance_variable_get("@service_missing").should be_false
+        @provider.load_current_resource.should eql(@current_resource)
+        @current_resource.enabled.should be_false
+      end
+    end
+  
+    describe "define resource requirements" do
+      it_should_behave_like "define_resource_requirements_common"
+    
+      context "when the service does not exist" do
+        before do
+          status = mock("Status", :exitstatus => 1, :stdout => "", :stderr => "chef: unrecognized service")
+          @provider.should_receive(:shell_out).with("/sbin/service chef status").and_return(status)
+          chkconfig = mock("Chkconfig", :existatus=> 1, :stdout => "", :stderr => "error reading information on service chef: No such file or directory")
+          @provider.should_receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+          @provider.load_current_resource
+          @provider.define_resource_requirements
+        end
+
+        [ "start", "reload", "restart", "enable" ].each do |action|
+          it "should raise an error when the action is #{action}" do
+            @provider.action = action
+            lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+          end
+        end
+
+        [ "stop", "disable" ].each do |action|
+          it "should not raise an error when the action is #{action}" do
+            @provider.action = action
+            lambda { @provider.process_resource_requirements }.should_not raise_error
+          end
+        end
+      end
+    end
+  end
+
+  describe "while in why run mode" do
+    before(:each) do
+      Chef::Config[:why_run] = true
+    end
+
+    after do
+      Chef::Config[:why_run] = false
+    end
+
+    describe "define resource requirements" do
+      it_should_behave_like "define_resource_requirements_common"
+
+      it "should not raise an error if the service does not exist" do
+        status = mock("Status", :exitstatus => 1, :stdout => "", :stderr => "chef: unrecognized service")
+        @provider.should_receive(:shell_out).with("/sbin/service chef status").and_return(status)
+        chkconfig = mock("Chkconfig", :existatus=> 1, :stdout => "", :stderr => "error reading information on service chef: No such file or directory")
+        @provider.should_receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
+        @provider.load_current_resource
+        @provider.define_resource_requirements
+        lambda { @provider.process_resource_requirements }.should_not raise_error
+      end
+    end
+  end
+
+  describe "enable_service" do
+    it "should call chkconfig to add 'service_name'" do
+      @provider.should_receive(:shell_out!).with("/sbin/chkconfig #{@new_resource.service_name} on")
+      @provider.enable_service
+    end
+  end
+
+  describe "disable_service" do
+    it "should call chkconfig to del 'service_name'" do
+      @provider.should_receive(:shell_out!).with("/sbin/chkconfig #{@new_resource.service_name} off")
+      @provider.disable_service
+    end
+  end
+
+end
diff --git a/spec/unit/provider/service/simple_service_spec.rb b/spec/unit/provider/service/simple_service_spec.rb
new file mode 100644
index 0000000000..cc0173e246
--- /dev/null
+++ b/spec/unit/provider/service/simple_service_spec.rb
@@ -0,0 +1,171 @@
+#
+# Author:: Mathieu Sauve-Frankel <msf@kisoku.net>
+# Copyright:: Copyright (c) 2009, Mathieu Sauve Frankel
+# 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 Chef::Provider::Service::Simple, "load_current_resource" do
+  before(:each) do
+    @node = Chef::Node.new
+    @node.automatic_attrs[:command] = {:ps => "ps -ef"}
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new("chef")
+    @current_resource = Chef::Resource::Service.new("chef")
+
+    @provider = Chef::Provider::Service::Simple.new(@new_resource, @run_context)
+    Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+
+    @stdout = StringIO.new(<<-NOMOCKINGSTRINGSPLZ)
+aj        7842  5057  0 21:26 pts/2    00:00:06 vi init.rb
+aj        7903  5016  0 21:26 pts/5    00:00:00 /bin/bash
+aj        8119  6041  0 21:34 pts/3    00:00:03 vi simple_service_spec.rb
+NOMOCKINGSTRINGSPLZ
+    @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+    @provider.stub!(:shell_out!).and_return(@status)
+  end
+  
+  it "should create a current resource with the name of the new resource" do
+    Chef::Resource::Service.should_receive(:new).and_return(@current_resource)
+    @provider.load_current_resource
+  end
+
+  it "should set the current resources service name to the new resources service name" do
+    @current_resource.should_receive(:service_name).with(@new_resource.service_name)
+    @provider.load_current_resource
+  end
+
+  it "should raise error if the node has a nil ps attribute and no other means to get status" do
+    @node.automatic_attrs[:command] = {:ps => nil}
+    @provider.define_resource_requirements
+    lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+  end
+
+  it "should raise error if the node has an empty ps attribute and no other means to get status" do
+    @node.automatic_attrs[:command] = {:ps => ""}
+    @provider.define_resource_requirements
+    lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+  end
+
+  describe "when we have a 'ps' attribute" do
+    it "should shell_out! the node's ps command" do
+      @provider.should_receive(:shell_out!).with(@node[:command][:ps]).and_return(@status)
+      @provider.load_current_resource
+    end
+
+    it "should read stdout of the ps command" do
+      @provider.stub!(:shell_out!).and_return(@status)
+      @stdout.should_receive(:each_line).and_return(true)
+      @provider.load_current_resource
+    end
+
+    it "should set running to true if the regex matches the output" do
+      @stdout = StringIO.new(<<-NOMOCKINGSTRINGSPLZ)
+aj        7842  5057  0 21:26 pts/2    00:00:06 chef
+aj        7842  5057  0 21:26 pts/2    00:00:06 poos
+NOMOCKINGSTRINGSPLZ
+      @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
+      @provider.stub!(:shell_out!).and_return(@status)
+      @provider.load_current_resource 
+      @current_resource.running.should be_true
+    end
+
+    it "should set running to false if the regex doesn't match" do
+      @provider.stub!(:shell_out!).and_return(@status)
+      @provider.load_current_resource
+      @current_resource.running.should be_false
+    end
+
+    it "should raise an exception if ps fails" do
+      @provider.stub!(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      @provider.action = :start
+      @provider.load_current_resource
+      @provider.define_resource_requirements
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+  end
+
+  it "should return the current resource" do
+    @provider.load_current_resource.should eql(@current_resource)
+  end
+
+
+
+  describe "when starting the service" do
+    it "should call the start command if one is specified" do
+      @new_resource.stub!(:start_command).and_return("#{@new_resource.start_command}")
+      @provider.should_receive(:shell_out!).with("#{@new_resource.start_command}")
+      @provider.start_service()
+    end
+
+    it "should raise an exception if no start command is specified" do
+      @provider.define_resource_requirements
+      @provider.action = :start
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end 
+  end
+
+  describe "when stopping a service" do
+    it "should call the stop command if one is specified" do
+      @new_resource.stop_command("/etc/init.d/themadness stop")
+      @provider.should_receive(:shell_out!).with("/etc/init.d/themadness stop")
+      @provider.stop_service()
+    end
+
+    it "should raise an exception if no stop command is specified" do
+      @provider.define_resource_requirements
+      @provider.action = :stop
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+    end
+  end
+
+  describe Chef::Provider::Service::Simple, "restart_service" do
+    it "should call the restart command if one has been specified" do
+      @new_resource.restart_command("/etc/init.d/foo restart")
+      @provider.should_receive(:shell_out!).with("/etc/init.d/foo restart")
+      @provider.restart_service()
+    end
+
+    it "should raise an exception if the resource doesn't support restart, no restart command is provided, and no stop command is provided" do
+      @provider.define_resource_requirements
+      @provider.action = :restart
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service) 
+    end
+
+    it "should just call stop, then start when the resource doesn't support restart and no restart_command is specified" do
+      @provider.should_receive(:stop_service)
+      @provider.should_receive(:sleep).with(1)
+      @provider.should_receive(:start_service)
+      @provider.restart_service()
+    end
+  end
+
+  describe Chef::Provider::Service::Simple, "reload_service" do
+    it "should raise an exception if reload is requested but no command is specified" do
+      @provider.define_resource_requirements
+      @provider.action = :reload
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    end
+
+    it "should should run the user specified reload command if one is specified" do
+      @new_resource.reload_command("kill -9 1")
+      @provider.should_receive(:shell_out!).with("kill -9 1")
+      @provider.reload_service()
+    end
+  end
+end
diff --git a/spec/unit/provider/service/solaris_smf_service_spec.rb b/spec/unit/provider/service/solaris_smf_service_spec.rb
new file mode 100644
index 0000000000..3ea2902755
--- /dev/null
+++ b/spec/unit/provider/service/solaris_smf_service_spec.rb
@@ -0,0 +1,140 @@
+#
+# Author:: Toomas Pelberg (<toomasp@gmx.net>)
+# Copyright:: Copyright (c) 2010 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'
+
+describe Chef::Provider::Service::Solaris do
+  before(:each) do
+    @node =Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new('chef')
+
+    @current_resource = Chef::Resource::Service.new('chef')
+
+    @provider = Chef::Provider::Service::Solaris.new(@new_resource, @run_context)
+    Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+
+    @stdin = StringIO.new
+    @stdout = StringIO.new
+    @stderr = StringIO.new
+    @pid = 2342
+    @stdout_string = "state disabled"
+    @stdout.stub!(:gets).and_return(@stdout_string)
+  end
+
+  it "should raise an error if /bin/svcs does not exist" do
+    File.should_receive(:exists?).with("/bin/svcs").and_return(false)
+    lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Service)
+  end 
+
+  describe "on a host with /bin/svcs" do
+
+    before do
+      File.stub!(:exists?).with('/bin/svcs').and_return(true)
+    end
+
+    describe "when discovering the current service state" do
+      it "should create a current resource with the name of the new resource" do
+        @provider.stub!(:popen4).with("/bin/svcs -l chef").and_return(@status)
+        Chef::Resource::Service.should_receive(:new).and_return(@current_resource)
+        @provider.load_current_resource
+      end
+
+
+      it "should return the current resource" do
+        @provider.stub!(:popen4).with("/bin/svcs -l chef").and_return(@status)
+        @provider.load_current_resource.should eql(@current_resource)
+      end 
+
+      it "should popen4 '/bin/svcs -l service_name'" do
+        @provider.should_receive(:popen4).with("/bin/svcs -l chef").and_return(@status)
+        @provider.load_current_resource
+      end
+
+      it "should mark service as not running" do
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @current_resource.should_receive(:running).with(false)
+        @provider.load_current_resource
+      end
+
+      it "should mark service as running" do
+        @stdout.stub!(:each).and_yield("state online")
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @current_resource.should_receive(:running).with(true)
+        @provider.load_current_resource
+      end
+    end
+
+    describe "when enabling the service" do
+      before(:each) do
+        #@provider = Chef::Provider::Service::Solaris.new(@node, @new_resource)
+        @provider.current_resource = @current_resource
+        @current_resource.enabled(true)
+      end
+
+      it "should call svcadm enable chef" do
+        @provider.should_receive(:run_command).with({:command => "/usr/sbin/svcadm enable chef"})
+        @provider.should_receive(:service_status).and_return(@current_resource)
+        @provider.enable_service.should be_true
+      end
+
+      it "should call svcadm enable chef for start_service" do
+        @provider.should_receive(:run_command).with({:command => "/usr/sbin/svcadm enable chef"})
+        @provider.should_receive(:service_status).and_return(@current_resource)
+        @provider.start_service.should be_true
+      end
+
+    end
+
+
+    describe "when disabling the service" do
+      before(:each) do
+        @provider.current_resource = @current_resource
+        @current_resource.enabled(false)
+      end
+
+      it "should call svcadm disable chef" do
+        @provider.should_receive(:run_command).with({:command => "/usr/sbin/svcadm disable chef"})
+        @provider.should_receive(:service_status).and_return(@current_resource)
+        @provider.disable_service.should be_false
+      end
+
+      it "should call svcadm disable chef for stop_service" do
+        @provider.should_receive(:run_command).with({:command => "/usr/sbin/svcadm disable chef"})
+        @provider.should_receive(:service_status).and_return(@current_resource)
+        @provider.stop_service.should be_false
+      end
+
+    end
+
+    describe "when reloading the service" do
+      before(:each) do
+        @status = mock("Process::Status", :exitstatus => 0)
+        @provider.current_resource = @current_resource
+      end
+
+      it "should call svcadm refresh chef" do
+        @provider.should_receive(:run_command).with({:command => "/usr/sbin/svcadm refresh chef"}).and_return(@status)
+        @provider.reload_service.should be_true
+      end
+
+    end
+  end
+end
diff --git a/spec/unit/provider/service/systemd_service_spec.rb b/spec/unit/provider/service/systemd_service_spec.rb
new file mode 100644
index 0000000000..dbdedecd40
--- /dev/null
+++ b/spec/unit/provider/service/systemd_service_spec.rb
@@ -0,0 +1,239 @@
+#
+# Author:: Stephen Haynes (<sh@nomitor.com>)
+# Copyright:: Copyright (c) 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.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::Service::Systemd do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Service.new('rsyslog.service')
+    @provider = Chef::Provider::Service::Systemd.new(@new_resource, @run_context)
+  end
+
+  describe "load_current_resource" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog.service')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+
+      @provider.stub!(:is_active?).and_return(false)
+      @provider.stub!(:is_enabled?).and_return(false)
+    end
+
+    it "should create a current resource with the name of the new resource" do
+      Chef::Resource::Service.should_receive(:new).and_return(@current_resource)
+      @provider.load_current_resource
+    end
+
+    it "should set the current resources service name to the new resources service name" do
+      @current_resource.should_receive(:service_name).with(@new_resource.service_name)
+      @provider.load_current_resource
+    end
+
+    it "should check if the service is running" do
+      @provider.should_receive(:is_active?)
+      @provider.load_current_resource
+    end
+
+    it "should set running to true if the service is running" do
+      @provider.stub!(:is_active?).and_return(true)
+      @current_resource.should_receive(:running).with(true)
+      @provider.load_current_resource
+    end
+
+    it "should set running to false if the service is not running" do
+      @provider.stub!(:is_active?).and_return(false)
+      @current_resource.should_receive(:running).with(false)
+      @provider.load_current_resource
+    end
+
+    describe "when a status command has been specified" do
+      before do
+        @new_resource.stub!(:status_command).and_return("/bin/chefhasmonkeypants status")
+      end
+
+      it "should run the services status command if one has been specified" do
+        @provider.stub!(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
+        @current_resource.should_receive(:running).with(true)
+        @provider.load_current_resource
+      end
+
+      it "should run the services status command if one has been specified and properly set status check state" do
+        @provider.stub!(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
+        @provider.load_current_resource
+        @provider.instance_variable_get("@status_check_success").should be_true
+      end
+      
+      it "should set running to false if it catches a Chef::Exceptions::Exec when using a status command" do
+        @provider.stub!(:run_command_with_systems_locale).and_raise(Chef::Exceptions::Exec)
+        @current_resource.should_receive(:running).with(false)
+        @provider.load_current_resource
+      end
+    
+      it "should update state to indicate status check failed when an exception is thrown using a status command" do
+        @provider.stub!(:run_command_with_systems_locale).and_raise(Chef::Exceptions::Exec)
+        @provider.load_current_resource
+        @provider.instance_variable_get("@status_check_success").should be_false
+      end
+    end 
+
+    it "should check if the service is enabled" do
+      @provider.should_receive(:is_enabled?)
+      @provider.load_current_resource
+    end
+
+    it "should set enabled to true if the service is enabled" do
+      @provider.stub!(:is_enabled?).and_return(true)
+      @current_resource.should_receive(:enabled).with(true)
+      @provider.load_current_resource
+    end
+
+    it "should set enabled to false if the service is not enabled" do
+      @provider.stub!(:is_enabled?).and_return(false)
+      @current_resource.should_receive(:enabled).with(false)
+      @provider.load_current_resource
+    end
+
+    it "should return the current resource" do
+      @provider.load_current_resource.should eql(@current_resource)
+    end
+  end
+
+  describe "start and stop service" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog.service')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      @provider.current_resource = @current_resource
+    end
+
+    it "should call the start command if one is specified" do
+      @new_resource.stub!(:start_command).and_return("/sbin/rsyslog startyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog startyousillysally")
+      @provider.start_service
+    end
+
+    it "should call '/bin/systemctl start service_name' if no start command is specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl start #{@new_resource.service_name}"}).and_return(0)
+      @provider.start_service
+    end
+
+    it "should not call '/bin/systemctl start service_name' if it is already running" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl start #{@new_resource.service_name}"}).and_return(0)
+      @provider.start_service
+    end
+
+    it "should call the restart command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog restartyousillysally")
+      @provider.restart_service
+    end
+
+    it "should call '/bin/systemctl restart service_name' if no restart command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl restart #{@new_resource.service_name}"}).and_return(0)
+      @provider.restart_service
+    end
+
+    it "should call the reload command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog reloadyousillysally")
+      @provider.reload_service
+    end
+
+    it "should call '/bin/systemctl reload service_name' if no reload command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl reload #{@new_resource.service_name}"}).and_return(0)
+      @provider.reload_service
+    end
+
+    it "should call the stop command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog stopyousillysally")
+      @provider.stop_service
+    end
+
+    it "should call '/bin/systemctl stop service_name' if no stop command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl stop #{@new_resource.service_name}"}).and_return(0)
+      @provider.stop_service
+    end
+
+    it "should not call '/bin/systemctl stop service_name' if it is already stopped" do
+      @current_resource.stub!(:running).and_return(false)
+      @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl stop #{@new_resource.service_name}"}).and_return(0)
+      @provider.stop_service
+    end
+  end
+
+  describe "enable and disable service" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog.service')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      @provider.current_resource = @current_resource
+    end
+
+    it "should call '/bin/systemctl enable service_name' to enable the service" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl enable #{@new_resource.service_name}"}).and_return(0)
+      @provider.enable_service
+    end
+
+    it "should call '/bin/systemctl disable service_name' to disable the service" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/bin/systemctl disable #{@new_resource.service_name}"}).and_return(0)
+      @provider.disable_service
+    end
+  end
+
+  describe "is_active?" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog.service')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+    end
+
+    it "should return true if '/bin/systemctl is-active service_name' returns 0" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => '/bin/systemctl is-active rsyslog.service', :ignore_failure => true}).and_return(0)
+      @provider.is_active?.should be_true
+    end
+
+    it "should return false if '/bin/systemctl is-active service_name' returns anything except 0" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => '/bin/systemctl is-active rsyslog.service', :ignore_failure => true}).and_return(1)
+      @provider.is_active?.should be_false
+    end
+  end
+
+  describe "is_enabled?" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog.service')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+    end
+
+    it "should return true if '/bin/systemctl is-enabled service_name' returns 0" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => '/bin/systemctl is-enabled rsyslog.service', :ignore_failure => true}).and_return(0)
+      @provider.is_enabled?.should be_true
+    end
+
+    it "should return false if '/bin/systemctl is-enabled service_name' returns anything except 0" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => '/bin/systemctl is-enabled rsyslog.service', :ignore_failure => true}).and_return(1)
+      @provider.is_enabled?.should be_false
+    end
+  end
+end
diff --git a/spec/unit/provider/service/upstart_service_spec.rb b/spec/unit/provider/service/upstart_service_spec.rb
new file mode 100644
index 0000000000..2fc49c7aa2
--- /dev/null
+++ b/spec/unit/provider/service/upstart_service_spec.rb
@@ -0,0 +1,314 @@
+#
+# Author:: Bryan McLellan (btm@loftninjas.org)
+# Copyright:: Copyright (c) 2010 Bryan McLellan
+# 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 Chef::Provider::Service::Upstart do
+  before(:each) do
+    @node =Chef::Node.new
+    @node.name('upstarter')
+    @node.automatic_attrs[:platform] = 'ubuntu'
+    @node.automatic_attrs[:platform_version] = '9.10'
+
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::Service.new("rsyslog")
+    @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+  end
+
+  describe "when first created" do
+    before do
+      @platform = nil
+    end
+
+    it "should return /etc/event.d as the upstart job directory when running on Ubuntu 9.04" do
+      @node.automatic_attrs[:platform_version] = '9.04'
+      #Chef::Platform.stub!(:find_platform_and_version).and_return([ "ubuntu", "9.04" ])
+      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+      @provider.instance_variable_get(:@upstart_job_dir).should == "/etc/event.d"
+      @provider.instance_variable_get(:@upstart_conf_suffix).should == ""
+    end
+
+    it "should return /etc/init as the upstart job directory when running on Ubuntu 9.10" do
+      @node.automatic_attrs[:platform_version] = '9.10'
+      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+      @provider.instance_variable_get(:@upstart_job_dir).should == "/etc/init"
+      @provider.instance_variable_get(:@upstart_conf_suffix).should == ".conf"
+    end
+
+    it "should return /etc/init as the upstart job directory by default" do
+      @node.automatic_attrs[:platform_version] = '9000'
+      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+      @provider.instance_variable_get(:@upstart_job_dir).should == "/etc/init"
+      @provider.instance_variable_get(:@upstart_conf_suffix).should == ".conf"
+    end
+  end
+
+  describe "load_current_resource" do
+    before(:each) do
+      @node.automatic_attrs[:command] = {:ps => "ps -ax"}
+
+      @current_resource = Chef::Resource::Service.new("rsyslog")
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+
+      @status = mock("Status", :exitstatus => 0)
+      @provider.stub!(:popen4).and_return(@status)
+      @stdin = StringIO.new
+      @stdout = StringIO.new
+      @stderr = StringIO.new
+      @pid = mock("PID")
+      
+      ::File.stub!(:exists?).and_return(true)
+      ::File.stub!(:open).and_return(true)
+    end
+
+    it "should create a current resource with the name of the new resource" do
+      Chef::Resource::Service.should_receive(:new).and_return(@current_resource)
+      @provider.load_current_resource
+    end
+
+    it "should set the current resources service name to the new resources service name" do
+      @current_resource.should_receive(:service_name).with(@new_resource.service_name)
+      @provider.load_current_resource
+    end
+
+    it "should run '/sbin/status rsyslog'" do
+      @provider.should_receive(:popen4).with("/sbin/status rsyslog").and_return(@status)
+      @provider.load_current_resource
+    end
+
+    describe "when the status command uses the new format" do
+      before do
+      end
+
+      it "should set running to true if the the status command returns 0" do
+        @stdout = StringIO.new("rsyslog start/running")
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        @current_resource.running.should be_true
+      end
+
+      it "should set running to false if the status command returns anything except 0" do
+        @stdout = StringIO.new("rsyslog stop/waiting")
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        @current_resource.running.should be_false
+      end
+    end
+
+    describe "when the status command uses the old format" do
+      it "should set running to true if the the status command returns 0" do
+        @stdout = StringIO.new("rsyslog (start) running, process 32225")
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        @current_resource.running.should be_true
+      end
+
+      it "should set running to false if the status command returns anything except 0" do
+        @stdout = StringIO.new("rsyslog (stop) waiting")
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        @current_resource.running.should be_false
+      end
+    end
+
+    it "should set running to false if it catches a Chef::Exceptions::Exec" do
+      @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+      @current_resource.should_receive(:running).with(false)
+      @provider.load_current_resource
+    end
+
+    it "should set enabled to true when it finds 'starts on'" do
+      @lines = mock("start on filesystem", :gets => "start on filesystem")
+      ::File.stub!(:open).and_yield(@lines)
+      @current_resource.should_receive(:running).with(false)
+      @provider.load_current_resource
+    end
+
+    it "should set enabled to false when it finds '#starts on'" do
+      @lines = mock("start on filesystem", :gets => "#start on filesystem")
+      ::File.stub!(:open).and_yield(@lines)
+      @current_resource.should_receive(:running).with(false)
+      @provider.load_current_resource
+    end
+
+    it "should assume disable when no job configuration file is found" do
+      ::File.stub!(:exists?).and_return(false)
+      @current_resource.should_receive(:running).with(false)
+      @provider.load_current_resource
+    end
+
+
+    it "should track state when the upstart configuration file fails to load" do
+      File.should_receive(:exists?).and_return false
+      @provider.load_current_resource
+      @provider.instance_variable_get("@config_file_found").should == false
+    end
+
+    describe "when a status command has been specified" do
+      before do
+        @new_resource.stub!(:status_command).and_return("/bin/chefhasmonkeypants status")
+      end
+
+      it "should run the services status command if one has been specified" do
+        @provider.stub!(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
+        @current_resource.should_receive(:running).with(true)
+        @provider.load_current_resource
+      end
+
+      it "should track state when the user-provided status command fails" do 
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+        @provider.load_current_resource
+        @provider.instance_variable_get("@command_success").should == false
+      end
+
+      it "should set running to false if it catches a Chef::Exceptions::Exec when using a status command" do
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+        @current_resource.should_receive(:running).with(false)
+        @provider.load_current_resource
+      end
+    end
+
+    it "should track state when we fail to obtain service status via upstart_state" do
+      @provider.should_receive(:upstart_state).and_raise Chef::Exceptions::Exec
+      @provider.load_current_resource
+      @provider.instance_variable_get("@command_success").should == false
+    end
+    
+    it "should return the current resource" do
+      @provider.load_current_resource.should eql(@current_resource)
+    end
+
+
+  end
+
+  describe "enable and disable service" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog')
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      @provider.current_resource = @current_resource
+      Chef::Util::FileEdit.stub!(:new)
+    end
+
+    it "should enable the service if it is not enabled" do
+      @file = Object.new
+      Chef::Util::FileEdit.stub!(:new).and_return(@file)
+      @current_resource.stub!(:enabled).and_return(false)
+      @file.should_receive(:search_file_replace)
+      @file.should_receive(:write_file)
+      @provider.enable_service()
+    end
+
+    it "should disable the service if it is enabled" do
+      @file = Object.new
+      Chef::Util::FileEdit.stub!(:new).and_return(@file)
+      @current_resource.stub!(:enabled).and_return(true)
+      @file.should_receive(:search_file_replace)
+      @file.should_receive(:write_file)
+      @provider.disable_service()
+    end
+
+  end
+
+  describe "start and stop service" do
+    before(:each) do
+      @current_resource = Chef::Resource::Service.new('rsyslog')
+
+      Chef::Resource::Service.stub!(:new).and_return(@current_resource)
+      @provider.current_resource = @current_resource
+    end
+
+    it "should call the start command if one is specified" do
+      @new_resource.stub!(:start_command).and_return("/sbin/rsyslog startyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog startyousillysally")
+      @provider.start_service()
+    end
+
+    it "should call '/sbin/start service_name' if no start command is specified" do
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"}).and_return(0)
+      @provider.start_service()
+    end
+
+    it "should not call '/sbin/start service_name' if it is already running" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"}).and_return(0)
+      @provider.start_service()
+    end
+
+    it "should pass parameters to the start command if they are provided" do
+      @new_resource = Chef::Resource::Service.new("rsyslog")
+      @new_resource.parameters({ "OSD_ID" => "2" })
+      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
+      @provider.current_resource = @current_resource
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/start rsyslog OSD_ID=2"}).and_return(0)
+      @provider.start_service()
+    end
+
+    it "should call the restart command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog restartyousillysally")
+      @provider.restart_service()
+    end
+
+    it "should call '/sbin/restart service_name' if no restart command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/restart #{@new_resource.service_name}"}).and_return(0)
+      @provider.restart_service()
+    end
+
+    it "should call '/sbin/start service_name' if restart_service is called for a stopped service" do
+      @current_resource.stub!(:running).and_return(false)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"}).and_return(0)
+      @provider.restart_service()
+    end
+
+    it "should call the reload command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog reloadyousillysally")
+      @provider.reload_service()
+    end
+
+    it "should call '/sbin/reload service_name' if no reload command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/reload #{@new_resource.service_name}"}).and_return(0)
+      @provider.reload_service()
+    end
+
+    it "should call the stop command if one is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @new_resource.stub!(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
+      @provider.should_receive(:shell_out!).with("/sbin/rsyslog stopyousillysally")
+      @provider.stop_service()
+    end
+
+    it "should call '/sbin/stop service_name' if no stop command is specified" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/stop #{@new_resource.service_name}"}).and_return(0)
+      @provider.stop_service()
+    end
+
+    it "should not call '/sbin/stop service_name' if it is already stopped" do
+      @current_resource.stub!(:running).and_return(false)
+      @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/sbin/stop #{@new_resource.service_name}"}).and_return(0)
+      @provider.stop_service()
+    end
+  end
+end
diff --git a/spec/unit/provider/service/windows_spec.rb b/spec/unit/provider/service/windows_spec.rb
new file mode 100644
index 0000000000..a68e798d36
--- /dev/null
+++ b/spec/unit/provider/service/windows_spec.rb
@@ -0,0 +1,235 @@
+#
+# Author:: Nuo Yan <nuo@opscode.com>
+# Author:: Seth Chisamore <schisamo@opscode.com>
+# Copyright:: Copyright (c) 2010-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.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::Service::Windows, "load_current_resource" do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Service.new("chef")
+    @provider = Chef::Provider::Service::Windows.new(@new_resource, @run_context)
+    Object.send(:remove_const, 'Win32') if defined?(Win32)
+    Win32 = Module.new
+    Win32::Service = Class.new
+    Win32::Service::AUTO_START = 0x00000002
+    Win32::Service::DISABLED = 0x00000004
+    Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
+      mock("StatusStruct", :current_state => "running"))
+    Win32::Service.stub!(:config_info).with(@new_resource.service_name).and_return(
+      mock("ConfigStruct", :start_type => "auto start"))
+    Win32::Service.stub!(:exists?).and_return(true)
+  end
+
+  it "should set the current resources service name to the new resources service name" do
+    @provider.load_current_resource
+    @provider.current_resource.service_name.should == 'chef'
+  end
+
+  it "should return the current resource" do
+    @provider.load_current_resource.should equal(@provider.current_resource)
+  end
+
+  it "should set the current resources status" do
+    @provider.load_current_resource
+    @provider.current_resource.running.should be_true
+  end
+
+  it "should set the current resources start type" do
+    @provider.load_current_resource
+    @provider.current_resource.enabled.should be_true
+  end
+
+  describe Chef::Provider::Service::Windows, "start_service" do
+    before(:each) do
+      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
+        mock("StatusStruct", :current_state => "stopped"),
+        mock("StatusStruct", :current_state => "running"))
+    end
+
+    it "should call the start command if one is specified" do
+      @new_resource.start_command "sc start chef"
+      @provider.should_receive(:shell_out!).with("#{@new_resource.start_command}").and_return("Starting custom service")
+      @provider.start_service
+      @new_resource.updated_by_last_action?.should be_true
+    end
+
+    it "should use the built-in command if no start command is specified" do
+      Win32::Service.should_receive(:start).with(@new_resource.service_name)
+      @provider.start_service
+      @new_resource.updated_by_last_action?.should be_true
+    end
+
+    it "should do nothing if the service does not exist" do
+      Win32::Service.stub!(:exists?).with(@new_resource.service_name).and_return(false)
+      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      @provider.start_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+    it "should do nothing if the service is running" do
+      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
+        mock("StatusStruct", :current_state => "running"))
+      @provider.load_current_resource
+      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      @provider.start_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+  end
+
+  describe Chef::Provider::Service::Windows, "stop_service" do
+    
+    before(:each) do
+      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
+        mock("StatusStruct", :current_state => "running"),
+        mock("StatusStruct", :current_state => "stopped"))
+    end
+
+    it "should call the stop command if one is specified" do
+      @new_resource.stop_command "sc stop chef"
+      @provider.should_receive(:shell_out!).with("#{@new_resource.stop_command}").and_return("Stopping custom service")
+      @provider.stop_service
+      @new_resource.updated_by_last_action?.should be_true
+    end
+
+    it "should use the built-in command if no stop command is specified" do
+      Win32::Service.should_receive(:stop).with(@new_resource.service_name)
+      @provider.stop_service
+      @new_resource.updated_by_last_action?.should be_true
+    end
+
+    it "should do nothing if the service does not exist" do
+      Win32::Service.stub!(:exists?).with(@new_resource.service_name).and_return(false)
+      Win32::Service.should_not_receive(:stop).with(@new_resource.service_name)
+      @provider.stop_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+    it "should do nothing if the service is stopped" do
+      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
+        mock("StatusStruct", :current_state => "stopped"))
+      @provider.load_current_resource
+      Win32::Service.should_not_receive(:stop).with(@new_resource.service_name)
+      @provider.stop_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+  end
+
+  describe Chef::Provider::Service::Windows, "restart_service" do
+
+    it "should call the restart command if one is specified" do
+      @new_resource.restart_command "sc restart"
+      @provider.should_receive(:shell_out!).with("#{@new_resource.restart_command}")
+      @provider.restart_service
+      @new_resource.updated_by_last_action?.should be_true
+    end
+
+    it "should stop then start the service if it is running" do
+      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
+        mock("StatusStruct", :current_state => "running"), 
+        mock("StatusStruct", :current_state => "stopped"), 
+        mock("StatusStruct", :current_state => "stopped"), 
+        mock("StatusStruct", :current_state => "running"))
+      Win32::Service.should_receive(:stop).with(@new_resource.service_name)
+      Win32::Service.should_receive(:start).with(@new_resource.service_name)
+      @provider.restart_service
+      @new_resource.updated_by_last_action?.should be_true
+    end
+
+    it "should just start the service if it is stopped" do
+      Win32::Service.stub!(:status).with(@new_resource.service_name).and_return(
+        mock("StatusStruct", :current_state => "stopped"), 
+        mock("StatusStruct", :current_state => "stopped"), 
+        mock("StatusStruct", :current_state => "running"))
+      Win32::Service.should_receive(:start).with(@new_resource.service_name)
+      @provider.restart_service
+      @new_resource.updated_by_last_action?.should be_true
+    end
+
+    it "should do nothing if the service does not exist" do
+      Win32::Service.stub!(:exists?).with(@new_resource.service_name).and_return(false)
+      Win32::Service.should_not_receive(:stop).with(@new_resource.service_name)
+      Win32::Service.should_not_receive(:start).with(@new_resource.service_name)
+      @provider.restart_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+  end
+
+  describe Chef::Provider::Service::Windows, "enable_service" do
+
+    before(:each) do
+      Win32::Service.stub!(:config_info).with(@new_resource.service_name).and_return(
+        mock("ConfigStruct", :start_type => "disabled"))
+    end
+
+    it "should enable service" do
+      Win32::Service.should_receive(:configure).with(:service_name => @new_resource.service_name, :start_type => Win32::Service::AUTO_START)
+      @provider.enable_service
+      @new_resource.updated_by_last_action?.should be_true
+    end
+
+    it "should do nothing if the service does not exist" do
+      Win32::Service.stub!(:exists?).with(@new_resource.service_name).and_return(false)
+      Win32::Service.should_not_receive(:configure)
+      @provider.enable_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+    it "should do nothing if the service is enabled" do
+      Win32::Service.stub!(:config_info).with(@new_resource.service_name).and_return(
+        mock("ConfigStruct", :start_type => "auto start"))
+      Win32::Service.should_not_receive(:configure)
+      @provider.enable_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+  end
+  
+  describe Chef::Provider::Service::Windows, "disable_service" do
+
+    before(:each) do
+      Win32::Service.stub!(:config_info).with(@new_resource.service_name).and_return(
+        mock("ConfigStruct", :start_type => "auto start"))
+    end
+
+    it "should disable service" do
+      Win32::Service.should_receive(:configure).with(:service_name => @new_resource.service_name, :start_type => Win32::Service::DISABLED)
+      @provider.disable_service
+      @new_resource.updated_by_last_action?.should be_true
+    end
+
+    it "should do nothing if the service does not exist" do
+      Win32::Service.stub!(:exists?).with(@new_resource.service_name).and_return(false)
+      Win32::Service.should_not_receive(:configure)
+      @provider.disable_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+    it "should do nothing if the service is disabled" do
+      Win32::Service.stub!(:config_info).with(@new_resource.service_name).and_return(
+        mock("ConfigStruct", :start_type => "disabled"))
+      @provider.load_current_resource
+      Win32::Service.should_not_receive(:configure)
+      @provider.disable_service
+      @new_resource.updated_by_last_action?.should be_false
+    end
+
+  end
+end
diff --git a/spec/unit/provider/service_spec.rb b/spec/unit/provider/service_spec.rb
new file mode 100644
index 0000000000..d25d7cf735
--- /dev/null
+++ b/spec/unit/provider/service_spec.rb
@@ -0,0 +1,169 @@
+#
+# Author:: AJ Christensen (<aj@hjksolutions.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 'spec_helper'
+
+describe Chef::Provider::Service do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Service.new("chef")
+    @current_resource = Chef::Resource::Service.new("chef")
+
+    @provider = Chef::Provider::Service.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+    @provider.stub!(:load_current_resource)
+  end
+
+  describe "when enabling the service" do
+    it "should enable the service if disabled and set the resource as updated" do
+      @current_resource.enabled(false)
+      @provider.should_receive(:enable_service).and_return(true)
+      @provider.action_enable
+      @provider.converge
+      @provider.new_resource.should be_updated
+    end
+
+    it "should not enable the service if already enabled" do
+      @current_resource.enabled(true)
+      @provider.should_not_receive(:enable_service)
+      @provider.action_enable
+      @provider.converge
+      @provider.new_resource.should_not be_updated
+    end
+  end
+
+
+  describe "when disabling the service" do
+    it "should disable the service if enabled and set the resource as updated" do
+      @current_resource.stub!(:enabled).and_return(true)
+      @provider.should_receive(:disable_service).and_return(true)
+      @provider.run_action(:disable)
+      @provider.new_resource.should be_updated
+    end
+
+    it "should not disable the service if already disabled" do
+      @current_resource.stub!(:enabled).and_return(false)
+      @provider.should_not_receive(:disable_service).and_return(true)
+      @provider.run_action(:disable)
+      @provider.new_resource.should_not be_updated
+    end
+  end
+
+  describe "action_start" do
+    it "should start the service if it isn't running and set the resource as updated" do
+      @current_resource.running(false)
+      @provider.should_receive(:start_service).with.and_return(true)
+      @provider.run_action(:start)
+      @provider.new_resource.should be_updated
+    end
+
+    it "should not start the service if already running" do
+      @current_resource.running(true)
+      @provider.should_not_receive(:start_service)
+      @provider.run_action(:start)
+      @provider.new_resource.should_not be_updated
+    end
+  end
+
+  describe "action_stop" do
+    it "should stop the service if it is running and set the resource as updated" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:stop_service).and_return(true)
+      @provider.run_action(:stop)
+      @provider.new_resource.should be_updated
+    end
+
+    it "should not stop the service if it's already stopped" do
+      @current_resource.stub!(:running).and_return(false)
+      @provider.should_not_receive(:stop_service).and_return(true)
+      @provider.run_action(:stop)
+      @provider.new_resource.should_not be_updated
+    end
+  end
+
+  describe "action_restart" do
+    before do
+      @current_resource.supports(:restart => true)
+    end
+
+    it "should restart the service if it's supported and set the resource as updated" do
+      @provider.should_receive(:restart_service).and_return(true)
+      @provider.run_action(:restart)
+      @provider.new_resource.should be_updated
+    end
+
+    it "should restart the service even if it isn't running and set the resource as updated" do
+      @current_resource.stub!(:running).and_return(false)
+      @provider.should_receive(:restart_service).and_return(true)
+      @provider.run_action(:restart)
+      @provider.new_resource.should be_updated
+    end
+  end
+
+  describe "action_reload" do
+    before do
+      @new_resource.supports(:reload => true)
+    end
+
+    it "should raise an exception if reload isn't supported" do
+      @new_resource.supports(:reload => false)
+      @new_resource.stub!(:reload_command).and_return(false)
+      lambda { @provider.run_action(:reload) }.should raise_error(Chef::Exceptions::UnsupportedAction)
+    end
+
+    it "should reload the service if it is running and set the resource as updated" do
+      @current_resource.stub!(:running).and_return(true)
+      @provider.should_receive(:reload_service).and_return(true)
+      @provider.run_action(:reload)
+      @provider.new_resource.should be_updated
+    end
+
+    it "should not reload the service if it's stopped" do
+      @current_resource.stub!(:running).and_return(false)
+      @provider.should_not_receive(:reload_service).and_return(true)
+      @provider.run_action(:stop)
+      @provider.new_resource.should_not be_updated
+    end
+  end
+
+  it "delegates enable_service to subclasses" do
+    lambda { @provider.enable_service }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+
+  it "delegates disable_service to subclasses" do
+    lambda { @provider.disable_service }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+
+  it "delegates start_service to subclasses" do
+    lambda { @provider.start_service }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+
+  it "delegates stop_service to subclasses" do
+    lambda { @provider.stop_service }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+
+  it "delegates restart_service to subclasses" do
+    lambda { @provider.restart_service }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+
+  it "delegates reload_service to subclasses" do
+    lambda { @provider.reload_service }.should raise_error(Chef::Exceptions::UnsupportedAction)
+  end
+end
diff --git a/spec/unit/provider/subversion_spec.rb b/spec/unit/provider/subversion_spec.rb
new file mode 100644
index 0000000000..e441428d6c
--- /dev/null
+++ b/spec/unit/provider/subversion_spec.rb
@@ -0,0 +1,281 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.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 'spec_helper'
+
+describe Chef::Provider::Subversion do
+
+  before do
+    @resource = Chef::Resource::Subversion.new("my app")
+    @resource.repository "http://svn.example.org/trunk/"
+    @resource.destination "/my/deploy/dir"
+    @resource.revision "12345"
+    @resource.svn_arguments(false)
+    @resource.svn_info_args(false)
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @provider = Chef::Provider::Subversion.new(@resource, @run_context)
+  end
+
+  it "converts resource attributes to options for run_command and popen4" do
+    @provider.run_options.should == {}
+    @resource.user 'deployninja'
+    @provider.run_options.should == {:user => "deployninja"}
+  end
+
+  context "determining the revision of the currently deployed code" do
+
+    before do
+      @stdout = mock("stdout")
+      @stderr = mock("stderr")
+      @exitstatus = mock("exitstatus")
+    end
+
+    it "sets the revision to nil if there isn't any deployed code yet" do
+      ::File.should_receive(:exist?).with("/my/deploy/dir/.svn").and_return(false)
+      @provider.find_current_revision.should be_nil
+    end
+
+    it "determines the current revision if there's a checkout with svn data available" do
+      example_svn_info =  "Path: .\n" +
+                          "URL: http://svn.example.org/trunk/myapp\n" +
+                          "Repository Root: http://svn.example.org\n" +
+                          "Repository UUID: d62ff500-7bbc-012c-85f1-0026b0e37c24\n" +
+                          "Revision: 11739\nNode Kind: directory\n" +
+                          "Schedule: normal\n" +
+                          "Last Changed Author: codeninja\n" +
+                          "Last Changed Rev: 11410\n" + # Last Changed Rev is preferred to Revision
+                          "Last Changed Date: 2009-03-25 06:09:56 -0600 (Wed, 25 Mar 2009)\n\n"
+      ::File.should_receive(:exist?).with("/my/deploy/dir/.svn").and_return(true)
+      ::File.should_receive(:directory?).with("/my/deploy/dir").and_return(true)
+      ::Dir.should_receive(:chdir).with("/my/deploy/dir").and_yield
+      @stdout.stub!(:string).and_return(example_svn_info)
+      @stderr.stub!(:string).and_return("")
+      @exitstatus.stub!(:exitstatus).and_return(0)
+      expected_command = ["svn info", {:cwd=>"/my/deploy/dir"}]
+      @provider.should_receive(:popen4).with(*expected_command).
+                                        and_yield("no-pid", "no-stdin", @stdout,@stderr).
+                                        and_return(@exitstatus)
+      @provider.find_current_revision.should eql("11410")
+    end
+
+    it "gives nil as the current revision if the deploy dir isn't a SVN working copy" do
+      example_svn_info = "svn: '/tmp/deploydir' is not a working copy\n"
+      ::File.should_receive(:exist?).with("/my/deploy/dir/.svn").and_return(true)
+      ::File.should_receive(:directory?).with("/my/deploy/dir").and_return(true)
+      ::Dir.should_receive(:chdir).with("/my/deploy/dir").and_yield
+      @stdout.stub!(:string).and_return(example_svn_info)
+      @stderr.stub!(:string).and_return("")
+      @exitstatus.stub!(:exitstatus).and_return(1)
+      @provider.should_receive(:popen4).and_yield("no-pid", "no-stdin", @stdout,@stderr).
+                                        and_return(@exitstatus)
+      @provider.find_current_revision.should be_nil
+    end
+
+    it "finds the current revision when loading the current resource state" do
+      # note: the test is kinda janky, but it provides regression coverage for CHEF-2092
+      @resource.instance_variable_set(:@action, :sync)
+      @provider.should_receive(:find_current_revision).and_return("12345")
+      @provider.load_current_resource
+      @provider.current_resource.revision.should == "12345"
+    end
+  end
+
+  it "creates the current_resource object and sets its revision to the current deployment's revision as long as we're not exporting" do
+    @provider.stub!(:find_current_revision).and_return("11410")
+    @provider.new_resource.instance_variable_set :@action, [:checkout]
+    @provider.load_current_resource
+    @provider.current_resource.name.should eql(@resource.name)
+    @provider.current_resource.revision.should eql("11410")
+  end
+
+  context "resolving revisions to an integer" do
+
+    before do
+      @stdout = mock("stdout")
+      @stderr = mock("stderr")
+      @resource.svn_info_args "--no-auth-cache"
+    end
+
+    it "returns the revision number as is if it's already an integer" do
+      @provider.revision_int.should eql("12345")
+    end
+
+    it "queries the server and resolves the revision if it's not an integer (i.e. 'HEAD')" do
+      example_svn_info =  "Path: .\n" +
+                          "URL: http://svn.example.org/trunk/myapp\n" +
+                          "Repository Root: http://svn.example.org\n" +
+                          "Repository UUID: d62ff500-7bbc-012c-85f1-0026b0e37c24\n" +
+                          "Revision: 11739\nNode Kind: directory\n" +
+                          "Schedule: normal\n" +
+                          "Last Changed Author: codeninja\n" +
+                          "Last Changed Rev: 11410\n" + # Last Changed Rev is preferred to Revision
+                          "Last Changed Date: 2009-03-25 06:09:56 -0600 (Wed, 25 Mar 2009)\n\n"
+      exitstatus = mock("exitstatus")
+      exitstatus.stub!(:exitstatus).and_return(0)
+      @resource.revision "HEAD"
+      @stdout.stub!(:string).and_return(example_svn_info)
+      @stderr.stub!(:string).and_return("")
+      expected_command = ["svn info http://svn.example.org/trunk/ --no-auth-cache  -rHEAD", {:cwd=>Dir.tmpdir}]
+      @provider.should_receive(:popen4).with(*expected_command).
+                                        and_yield("no-pid","no-stdin",@stdout,@stderr).
+                                        and_return(exitstatus)
+      @provider.revision_int.should eql("11410")
+    end
+
+    it "returns a helpful message if data from `svn info` can't be parsed" do
+      example_svn_info =  "some random text from an error message\n"
+      exitstatus = mock("exitstatus")
+      exitstatus.stub!(:exitstatus).and_return(0)
+      @resource.revision "HEAD"
+      @stdout.stub!(:string).and_return(example_svn_info)
+      @stderr.stub!(:string).and_return("")
+      @provider.should_receive(:popen4).and_yield("no-pid","no-stdin",@stdout,@stderr).
+                                        and_return(exitstatus)
+      lambda {@provider.revision_int}.should raise_error(RuntimeError, "Could not parse `svn info` data: some random text from an error message")
+
+    end
+
+    it "responds to :revision_slug as an alias for revision_sha" do
+      @provider.should respond_to(:revision_slug)
+    end
+
+  end
+
+  it "generates a checkout command with default options" do
+    @provider.checkout_command.should eql("svn checkout -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir")
+  end
+
+  it "generates a checkout command with authentication" do
+    @resource.svn_username "deployNinja"
+    @resource.svn_password "vanish!"
+    @provider.checkout_command.should eql("svn checkout -q --username deployNinja --password vanish!  " +
+                                          "-r12345 http://svn.example.org/trunk/ /my/deploy/dir")
+  end
+
+  it "generates a checkout command with arbitrary options" do
+    @resource.svn_arguments "--no-auth-cache"
+    @provider.checkout_command.should eql("svn checkout --no-auth-cache -q  -r12345 "+
+                                          "http://svn.example.org/trunk/ /my/deploy/dir")
+  end
+
+  it "generates a sync command with default options" do
+    @provider.sync_command.should eql("svn update -q  -r12345 /my/deploy/dir")
+  end
+
+  it "generates an export command with default options" do
+    @provider.export_command.should eql("svn export --force -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir")
+  end
+
+  it "doesn't try to find the current revision when loading the resource if running an export" do
+    @provider.new_resource.instance_variable_set :@action, [:export]
+    @provider.should_not_receive(:find_current_revision)
+    @provider.load_current_resource
+  end
+
+  it "doesn't try to find the current revision when loading the resource if running a force export" do
+    @provider.new_resource.instance_variable_set :@action, [:force_export]
+    @provider.should_not_receive(:find_current_revision)
+    @provider.load_current_resource
+  end
+
+  it "runs an export with the --force option" do
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    expected_cmd = "svn export --force -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
+    @provider.should_receive(:run_command).with(:command => expected_cmd)
+    @provider.run_action(:force_export)
+    @resource.should be_updated
+  end
+
+  it "runs the checkout command for action_checkout" do
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    expected_cmd = "svn checkout -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
+    @provider.should_receive(:run_command).with(:command => expected_cmd)
+    @provider.run_action(:checkout)
+    @resource.should be_updated
+  end
+
+  it "raises an error if the svn checkout command would fail because the enclosing directory doesn't exist" do
+    lambda {@provider.run_action(:sync)}.should raise_error(Chef::Exceptions::MissingParentDirectory)
+  end
+
+  it "should not checkout if the destination exists or is a non empty directory" do
+    ::File.stub!(:exist?).with("/my/deploy/dir/.svn").and_return(false)
+    ::File.stub!(:exist?).with("/my/deploy/dir").and_return(true)
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::Dir.stub!(:entries).with("/my/deploy/dir").and_return(['.','..','foo','bar'])
+    @provider.should_not_receive(:checkout_command)
+    @provider.run_action(:checkout)
+    @resource.should_not be_updated
+  end
+
+  it "runs commands with the user and group specified in the resource" do
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    @resource.user "whois"
+    @resource.group "thisis"
+    expected_cmd = "svn checkout -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
+    @provider.should_receive(:run_command).with(:command => expected_cmd, :user => "whois", :group => "thisis")
+    @provider.run_action(:checkout)
+    @resource.should be_updated
+  end
+
+  it "does a checkout for action_sync if there's no deploy dir" do
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::File.should_receive(:exist?).with("/my/deploy/dir/.svn").twice.and_return(false)
+    @provider.should_receive(:action_checkout)
+    @provider.run_action(:sync)
+  end
+
+  it "does a checkout for action_sync if the deploy dir exists but is empty" do
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::File.should_receive(:exist?).with("/my/deploy/dir/.svn").twice.and_return(false)
+    @provider.should_receive(:action_checkout)
+    @provider.run_action(:sync) 
+  end
+
+  it "runs the sync_command on action_sync if the deploy dir exists and isn't empty" do
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::File.should_receive(:exist?).with("/my/deploy/dir/.svn").and_return(true)
+    @provider.stub!(:find_current_revision).and_return("11410")
+    @provider.stub!(:current_revision_matches_target_revision?).and_return(false)
+    expected_cmd = "svn update -q  -r12345 /my/deploy/dir"
+    @provider.should_receive(:run_command).with(:command => expected_cmd)
+    @provider.run_action(:sync)
+    @resource.should be_updated
+  end
+
+  it "does not fetch any updates if the remote revision matches the current revision" do
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::File.should_receive(:exist?).with("/my/deploy/dir/.svn").and_return(true)
+    @provider.stub!(:find_current_revision).and_return('12345')
+    @provider.stub!(:current_revision_matches_target_revision?).and_return(true)
+    @provider.run_action(:sync)
+    @resource.should_not be_updated
+  end
+
+  it "runs the export_command on action_export" do
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    expected_cmd = "svn export --force -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
+    @provider.should_receive(:run_command).with(:command => expected_cmd)
+    @provider.run_action(:export)
+    @resource.should be_updated
+  end
+
+end
diff --git a/spec/unit/provider/template_spec.rb b/spec/unit/provider/template_spec.rb
new file mode 100644
index 0000000000..6747876d61
--- /dev/null
+++ b/spec/unit/provider/template_spec.rb
@@ -0,0 +1,198 @@
+#
+# 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 'stringio'
+require 'spec_helper'
+require 'etc'
+require 'ostruct'
+
+describe Chef::Provider::Template do
+  before(:each) do
+    @cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
+    Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, @cookbook_repo) }
+
+    @node = Chef::Node.new
+    cl = Chef::CookbookLoader.new(@cookbook_repo)
+    cl.load_cookbooks
+    @cookbook_collection = Chef::CookbookCollection.new(cl)
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+
+    @rendered_file_location = Dir.tmpdir + '/openldap_stuff.conf'
+
+    @resource = Chef::Resource::Template.new(@rendered_file_location)
+    @resource.cookbook_name = 'openldap'
+
+    @provider = Chef::Provider::Template.new(@resource, @run_context)
+    @current_resource = @resource.dup
+    @provider.current_resource = @current_resource
+    @access_controls = mock("access controls")
+    @provider.stub!(:access_controls).and_return(@access_controls)
+    passwd_struct = if windows?
+                      Struct::Passwd.new("root", "x", 0, 0, "/root", "/bin/bash")
+                    else
+                      Struct::Passwd.new("root", "x", 0, 0, "root", "/root", "/bin/bash")
+                    end
+    group_struct = OpenStruct.new(:name => "root", :passwd => "x", :gid => 0)
+    Etc.stub!(:getpwuid).and_return(passwd_struct)
+    Etc.stub!(:getgrgid).and_return(group_struct)
+  end
+
+  describe "when creating the template" do
+
+    before do 
+
+    end
+    after do
+      FileUtils.rm(@rendered_file_location) if ::File.exist?(@rendered_file_location)
+    end
+
+    it "finds the template file in the coobook cache if it isn't local" do
+      @provider.template_location.should == CHEF_SPEC_DATA + '/cookbooks/openldap/templates/default/openldap_stuff.conf.erb'
+    end
+
+    it "finds the template file locally if it is local" do
+      @resource.local(true)
+      @resource.source('/tmp/its_on_disk.erb')
+      @provider.template_location.should == '/tmp/its_on_disk.erb'
+    end
+
+    it "stops executing when the local template source can't be found" do 
+      @access_controls.stub!(:requires_changes?).and_return(false)
+      @resource.source "invalid.erb" 
+      @resource.local true
+      lambda { @provider.run_action(:create) } .should raise_error Chef::Mixin::WhyRun::ResourceRequirements::Assertion::AssertionFailure
+    end
+
+    it "should use the cookbook name if defined in the template resource" do
+      @resource.cookbook_name = 'apache2'
+      @resource.cookbook('openldap')
+      @resource.source "test.erb"
+      @provider.template_location.should == CHEF_SPEC_DATA + '/cookbooks/openldap/templates/default/test.erb'
+    end
+
+    describe "when the target file does not exist" do
+      it "creates the template with the rendered content" do
+        @access_controls.stub!(:requires_changes?).and_return(true)
+        @access_controls.should_receive(:set_all!)
+        @node.normal[:slappiness] = "a warm gun"
+        @provider.should_receive(:backup)
+        @provider.run_action(:create)
+        IO.read(@rendered_file_location).should == "slappiness is a warm gun"
+        @resource.should be_updated_by_last_action
+      end
+
+      it "should set the file access control as specified in the resource" do
+        @access_controls.stub!(:requires_changes?).and_return(false)
+        @access_controls.should_receive(:set_all!)
+        @resource.owner("adam")
+        @resource.group("wheel")
+        @resource.mode(00644)
+        @provider.run_action(:create)
+        @resource.should be_updated_by_last_action
+      end
+
+      it "creates the template with the rendered content for the create if missing action" do
+        @access_controls.stub!(:requires_changes?).and_return(true)
+        @access_controls.should_receive(:set_all!)
+        @node.normal[:slappiness] = "happiness"
+        @provider.should_receive(:backup)
+        @provider.run_action(:create_if_missing)
+        IO.read(@rendered_file_location).should == "slappiness is happiness"
+        @resource.should be_updated_by_last_action
+      end
+    end
+
+    describe "when the target file has the wrong content" do
+      before do
+        File.open(@rendered_file_location, "w+") { |f| f.print "blargh" }
+      end
+
+      it "overwrites the file with the updated content when the create action is run" do
+        @node.normal[:slappiness] = "a warm gun"
+        @access_controls.stub!(:requires_changes?).and_return(false)
+        @access_controls.should_receive(:set_all!)
+        @provider.should_receive(:backup)
+        @provider.run_action(:create)
+        IO.read(@rendered_file_location).should == "slappiness is a warm gun"
+        @resource.should be_updated_by_last_action
+      end
+
+      it "should set the file access control as specified in the resource" do
+        @access_controls.stub!(:requires_changes?).and_return(true)
+        @access_controls.should_receive(:set_all!)
+        @resource.owner("adam")
+        @resource.group("wheel")
+        @resource.mode(00644)
+        @provider.should_receive(:backup)
+        @provider.run_action(:create)
+        @resource.should be_updated_by_last_action
+      end
+
+      it "doesn't overwrite the file when the create if missing action is run" do
+        @access_controls.stub!(:requires_changes?).and_return(false)
+        @access_controls.should_not_receive(:set_all!)
+        @node.normal[:slappiness] = "a warm gun"
+        @provider.should_not_receive(:backup)
+        @provider.run_action(:create_if_missing)
+        IO.read(@rendered_file_location).should == "blargh"
+        @resource.should_not be_updated_by_last_action
+      end
+    end
+
+    describe "when the target has the correct content" do
+      before do
+        Chef::ChecksumCache.instance.reset!
+        File.open(@rendered_file_location, "w") { |f| f.print "slappiness is a warm gun" }
+        @current_resource.checksum('4ff94a87794ed9aefe88e734df5a66fc8727a179e9496cbd88e3b5ec762a5ee9')
+        @access_controls = mock("access controls")
+        @provider.stub!(:access_controls).and_return(@access_controls)
+      end
+
+      it "does not backup the original or overwrite it" do
+        @node.normal[:slappiness] = "a warm gun"
+        @access_controls.stub!(:requires_changes?).and_return(false)
+        @provider.should_not_receive(:backup)
+        FileUtils.should_not_receive(:mv)
+        @provider.run_action(:create)
+        @resource.should_not be_updated_by_last_action
+      end
+
+      it "does not backup the original or overwrite it on create if missing" do
+        @node.normal[:slappiness] = "a warm gun"
+        @access_controls.stub!(:requires_changes?).and_return(false)
+        @provider.should_not_receive(:backup)
+        FileUtils.should_not_receive(:mv)
+        @provider.run_action(:create)
+        @resource.should_not be_updated_by_last_action
+      end
+
+      it "sets the file access controls if they have diverged" do
+        @provider.stub!(:backup).and_return(true)
+        @access_controls.stub!(:requires_changes?).and_return(true)
+        @access_controls.should_receive(:set_all!)
+        @resource.owner("adam")
+        @resource.group("wheel")
+        @resource.mode(00644)
+        @provider.should_receive(:backup)
+        @provider.run_action(:create)
+        @resource.should be_updated_by_last_action
+      end
+    end
+
+  end
+end
diff --git a/spec/unit/provider/user/dscl_spec.rb b/spec/unit/provider/user/dscl_spec.rb
new file mode 100644
index 0000000000..3894cd61b4
--- /dev/null
+++ b/spec/unit/provider/user/dscl_spec.rb
@@ -0,0 +1,480 @@
+#
+# Author:: Dreamcat4 (<dreamcat4@gmail.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.
+#
+
+ShellCmdResult = Struct.new(:stdout, :stderr, :exitstatus)
+
+require 'spec_helper'
+require 'ostruct'
+
+describe Chef::Provider::User::Dscl do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::User.new("toor")
+    @provider = Chef::Provider::User::Dscl.new(@new_resource, @run_context)
+  end
+  
+  describe "when shelling out to dscl" do
+    it "should run dscl with the supplied cmd /Path args" do
+      shell_return = ShellCmdResult.new('stdout', 'err', 0)
+      @provider.should_receive(:shell_out).with("dscl . -cmd /Path args").and_return(shell_return)
+      @provider.safe_dscl("cmd /Path args").should == 'stdout'
+    end
+
+    it "returns an empty string from delete commands" do
+      shell_return = ShellCmdResult.new('out', 'err', 23)
+      @provider.should_receive(:shell_out).with("dscl . -delete /Path args").and_return(shell_return)
+      @provider.safe_dscl("delete /Path args").should == ""
+    end
+
+    it "should raise an exception for any other command" do
+      shell_return = ShellCmdResult.new('out', 'err', 23)
+      @provider.should_receive(:shell_out).with('dscl . -cmd /Path arguments').and_return(shell_return)
+      lambda { @provider.safe_dscl("cmd /Path arguments") }.should raise_error(Chef::Exceptions::DsclCommandFailed)
+    end
+
+    it "raises an exception when dscl reports 'no such key'" do
+      shell_return = ShellCmdResult.new("No such key: ", 'err', 23)
+      @provider.should_receive(:shell_out).with('dscl . -cmd /Path args').and_return(shell_return)
+      lambda { @provider.safe_dscl("cmd /Path args") }.should raise_error(Chef::Exceptions::DsclCommandFailed)
+    end
+
+    it "raises an exception when dscl reports 'eDSRecordNotFound'" do
+      shell_return = ShellCmdResult.new("<dscl_cmd> DS Error: -14136 (eDSRecordNotFound)", 'err', -14136)
+      @provider.should_receive(:shell_out).with('dscl . -cmd /Path args').and_return(shell_return)
+      lambda { @provider.safe_dscl("cmd /Path args") }.should raise_error(Chef::Exceptions::DsclCommandFailed)
+    end
+  end
+
+  describe "get_free_uid" do
+    before do
+      @provider.stub!(:safe_dscl).and_return("\nwheel      200\nstaff      201\n")
+    end
+  
+    it "should run safe_dscl with list /Users uid" do
+      @provider.should_receive(:safe_dscl).with("list /Users uid")
+      @provider.get_free_uid
+    end
+
+    it "should return the first unused uid number on or above 200" do
+      @provider.get_free_uid.should == 202
+    end
+  
+    it "should raise an exception when the search limit is exhausted" do
+      search_limit = 1
+      lambda { @provider.get_free_uid(search_limit) }.should raise_error(RuntimeError)
+    end
+  end
+
+  describe "uid_used?" do
+    before do
+      @provider.stub!(:safe_dscl).and_return("\naj      500\n")
+    end
+
+    it "should run safe_dscl with list /Users uid" do
+      @provider.should_receive(:safe_dscl).with("list /Users uid")
+      @provider.uid_used?(500)
+    end
+  
+    it "should return true for a used uid number" do
+      @provider.uid_used?(500).should be_true
+    end
+
+    it "should return false for an unused uid number" do
+      @provider.uid_used?(501).should be_false
+    end
+
+    it "should return false if not given any valid uid number" do
+      @provider.uid_used?(nil).should be_false
+    end
+  end
+
+  describe "when determining the uid to set" do
+    it "raises RequestedUIDUnavailable if the requested uid is already in use" do
+      @provider.stub!(:uid_used?).and_return(true)
+      @provider.should_receive(:get_free_uid).and_return(501)
+      lambda { @provider.set_uid }.should raise_error(Chef::Exceptions::RequestedUIDUnavailable)
+    end
+  
+    it "finds a valid, unused uid when none is specified" do
+      @provider.should_receive(:safe_dscl).with("list /Users uid").and_return('')
+      @provider.should_receive(:safe_dscl).with("create /Users/toor UniqueID 501")
+      @provider.should_receive(:get_free_uid).and_return(501)
+      @provider.set_uid
+      @new_resource.uid.should == 501
+    end
+  
+    it "sets the uid specified in the resource" do
+      @new_resource.uid(1000)
+      @provider.should_receive(:safe_dscl).with("create /Users/toor UniqueID 1000").and_return(true)
+      @provider.should_receive(:safe_dscl).with("list /Users uid").and_return('')
+      @provider.set_uid
+    end
+  end
+
+  describe "when modifying the home directory" do
+    before do
+      @new_resource.supports({ :manage_home => true })
+      @new_resource.home('/Users/toor')
+      
+      @current_resource = @new_resource.dup
+      @provider.current_resource = @current_resource
+    end
+
+    it "deletes the home directory when resource#home is nil" do
+      @new_resource.instance_variable_set(:@home, nil)
+      @provider.should_receive(:safe_dscl).with("delete /Users/toor NFSHomeDirectory").and_return(true)
+      @provider.modify_home
+    end
+  
+
+    it "raises InvalidHomeDirectory when the resource's home directory doesn't look right" do
+      @new_resource.home('epic-fail')
+      lambda { @provider.modify_home }.should raise_error(Chef::Exceptions::InvalidHomeDirectory)
+    end
+
+    it "moves the users home to the new location if it exists and the target location is different" do
+      @new_resource.supports(:manage_home => true)
+      
+      current_home = CHEF_SPEC_DATA + '/old_home_dir'
+      current_home_files = [current_home + '/my-dot-emacs', current_home + '/my-dot-vim']
+      @current_resource.home(current_home)
+      @new_resource.gid(23)
+      ::File.stub!(:exists?).with('/old/home/toor').and_return(true)
+      ::File.stub!(:exists?).with('/Users/toor').and_return(true)
+    
+      FileUtils.should_receive(:mkdir_p).with('/Users/toor').and_return(true)
+      FileUtils.should_receive(:rmdir).with(current_home)
+      ::Dir.should_receive(:glob).with("#{CHEF_SPEC_DATA}/old_home_dir/*",::File::FNM_DOTMATCH).and_return(current_home_files)
+      FileUtils.should_receive(:mv).with(current_home_files, "/Users/toor", :force => true)
+      FileUtils.should_receive(:chown_R).with('toor','23','/Users/toor')
+      
+      @provider.should_receive(:safe_dscl).with("create /Users/toor NFSHomeDirectory '/Users/toor'")
+      @provider.modify_home
+    end
+
+    it "should raise an exception when the systems user template dir (skel) cannot be found" do
+      ::File.stub!(:exists?).and_return(false,false,false)
+      lambda { @provider.modify_home }.should raise_error(Chef::Exceptions::User)
+    end
+
+    it "should run ditto to copy any missing files from skel to the new home dir" do
+      ::File.should_receive(:exists?).with("/System/Library/User\ Template/English.lproj").and_return(true)
+      FileUtils.should_receive(:chown_R).with('toor', '', '/Users/toor')
+      @provider.should_receive(:shell_out!).with("ditto '/System/Library/User Template/English.lproj' '/Users/toor'")
+      @provider.ditto_home
+    end
+
+    it "creates the user's NFSHomeDirectory and home directory" do
+      @provider.should_receive(:safe_dscl).with("create /Users/toor NFSHomeDirectory '/Users/toor'").and_return(true)
+      @provider.should_receive(:ditto_home)
+      @provider.modify_home
+    end
+  end
+
+  describe "osx_shadow_hash?" do
+    it "should return true when the string is a shadow hash" do
+      @provider.osx_shadow_hash?("0"*8*155).should eql(true)
+    end
+
+    it "should return false otherwise" do
+      @provider.osx_shadow_hash?("any other string").should eql(false)
+    end
+  end
+
+  describe "when detecting the format of a password" do
+    it "detects a OS X salted sha1" do
+      @provider.osx_salted_sha1?("0"*48).should eql(true)
+      @provider.osx_salted_sha1?("any other string").should eql(false)
+    end
+  end
+
+  describe "guid" do
+    it "should run safe_dscl with read /Users/user GeneratedUID to get the users GUID" do
+      expected_uuid = "b398449e-cee0-45e0-80f8-b0b5b1bfdeaa"
+      @provider.should_receive(:safe_dscl).with("read /Users/toor GeneratedUID").and_return(expected_uuid + "\n")
+      @provider.guid.should == expected_uuid
+    end
+  end
+
+  describe "shadow_hash_set?" do
+
+    it "should run safe_dscl with read /Users/user to see if the AuthenticationAuthority key exists" do
+      @provider.should_receive(:safe_dscl).with("read /Users/toor")
+      @provider.shadow_hash_set?
+    end
+
+    describe "when the user account has an AuthenticationAuthority key" do
+      it "uses the shadow hash when there is a ShadowHash field in the AuthenticationAuthority key" do
+        @provider.should_receive(:safe_dscl).with("read /Users/toor").and_return("\nAuthenticationAuthority: ;ShadowHash;\n")
+        @provider.shadow_hash_set?.should be_true
+      end
+
+      it "does not use the shadow hash when there is no ShadowHash field in the AuthenticationAuthority key" do
+        @provider.should_receive(:safe_dscl).with("read /Users/toor").and_return("\nAuthenticationAuthority: \n")
+        @provider.shadow_hash_set?.should be_false
+      end
+
+    end
+
+    describe "with no AuthenticationAuthority key in the user account" do
+      it "does not use the shadow hash" do
+        @provider.should_receive(:safe_dscl).with("read /Users/toor").and_return("")
+        @provider.shadow_hash_set?.should eql(false)
+      end
+    end
+  end
+
+  describe "when setting or modifying the user password" do
+    before do
+      @new_resource.password("password")
+      @output = StringIO.new
+    end
+
+    describe "when using a salted sha1 for the password" do
+      before do
+        @new_resource.password("F"*48)
+      end
+    
+      it "should write a shadow hash file with the expected salted sha1" do
+        uuid = "B398449E-CEE0-45E0-80F8-B0B5B1BFDEAA"
+        File.should_receive(:open).with('/var/db/shadow/hash/B398449E-CEE0-45E0-80F8-B0B5B1BFDEAA', "w", 384).and_yield(@output)
+        @provider.should_receive(:safe_dscl).with("read /Users/toor GeneratedUID").and_return(uuid)
+        @provider.should_receive(:safe_dscl).with("read /Users/toor").and_return("\nAuthenticationAuthority: ;ShadowHash;\n")
+        expected_salted_sha1 = @new_resource.password
+        expected_shadow_hash = "00000000"*155
+        expected_shadow_hash[168] = expected_salted_sha1
+        @provider.modify_password
+        @output.string.strip.should == expected_shadow_hash
+      end    
+    end
+
+    describe "when given a shadow hash file for the password" do
+      it "should write the shadow hash file directly to /var/db/shadow/hash/GUID" do
+        shadow_hash = '0123456789ABCDE0123456789ABCDEF' * 40
+        raise 'oops' unless shadow_hash.size == 1240
+        @new_resource.password shadow_hash
+        uuid = "B398449E-CEE0-45E0-80F8-B0B5B1BFDEAA"
+        File.should_receive(:open).with('/var/db/shadow/hash/B398449E-CEE0-45E0-80F8-B0B5B1BFDEAA', "w", 384).and_yield(@output)
+        @provider.should_receive(:safe_dscl).with("read /Users/toor GeneratedUID").and_return(uuid)
+        @provider.should_receive(:safe_dscl).with("read /Users/toor").and_return("\nAuthenticationAuthority: ;ShadowHash;\n")
+        @provider.modify_password
+        @output.string.strip.should == shadow_hash
+      end
+    end
+
+    describe "when given a string for the password" do
+      it "should output a salted sha1 and shadow hash file from the specified password" do
+        uuid = "B398449E-CEE0-45E0-80F8-B0B5B1BFDEAA"
+        File.should_receive(:open).with('/var/db/shadow/hash/B398449E-CEE0-45E0-80F8-B0B5B1BFDEAA', "w", 384).and_yield(@output)
+        @new_resource.password("password")
+        OpenSSL::Random.stub!(:random_bytes).and_return("\377\377\377\377\377\377\377\377")
+        expected_salted_sha1 = "F"*8+"SHA1-"*8
+        expected_shadow_hash = "00000000"*155
+        expected_shadow_hash[168] = expected_salted_sha1
+        @provider.should_receive(:safe_dscl).with("read /Users/toor GeneratedUID").and_return(uuid)
+        @provider.should_receive(:safe_dscl).with("read /Users/toor").and_return("\nAuthenticationAuthority: ;ShadowHash;\n")
+        @provider.modify_password
+        @output.string.strip.should match(/^0{168}(FFFFFFFF1C1AA7935D4E1190AFEC92343F31F7671FBF126D)0{1071}$/)
+      end    
+    end
+
+    it "should write the output directly to the shadow hash file at /var/db/shadow/hash/GUID" do
+      shadow_file = StringIO.new
+      uuid = "B398449E-CEE0-45E0-80F8-B0B5B1BFDEAA"
+      File.should_receive(:open).with("/var/db/shadow/hash/B398449E-CEE0-45E0-80F8-B0B5B1BFDEAA",'w',0600).and_yield(shadow_file)
+      @provider.should_receive(:safe_dscl).with("read /Users/toor GeneratedUID").and_return(uuid)
+      @provider.should_receive(:safe_dscl).with("read /Users/toor").and_return("\nAuthenticationAuthority: ;ShadowHash;\n")
+      @provider.modify_password
+      shadow_file.string.should match(/^0{168}[0-9A-F]{48}0{1071}$/)
+    end
+
+    it "should run safe_dscl append /Users/user AuthenticationAuthority ;ShadowHash; when no shadow hash set" do
+      shadow_file = StringIO.new
+      uuid = "B398449E-CEE0-45E0-80F8-B0B5B1BFDEAA"
+      File.should_receive(:open).with("/var/db/shadow/hash/B398449E-CEE0-45E0-80F8-B0B5B1BFDEAA",'w',0600).and_yield(shadow_file)
+      @provider.should_receive(:safe_dscl).with("read /Users/toor GeneratedUID").and_return(uuid)
+      @provider.should_receive(:safe_dscl).with("read /Users/toor").and_return("\nAuthenticationAuthority:\n")
+      @provider.should_receive(:safe_dscl).with("append /Users/toor AuthenticationAuthority ';ShadowHash;'")
+      @provider.modify_password
+      shadow_file.string.should match(/^0{168}[0-9A-F]{48}0{1071}$/)
+    end
+  end
+
+  describe "load_current_resource" do
+    it "should raise an error if the required binary /usr/bin/dscl doesn't exist" do
+      ::File.should_receive(:exists?).with("/usr/bin/dscl").and_return(false)
+      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::User)
+    end
+
+    it "shouldn't raise an error if /usr/bin/dscl exists" do
+      ::File.stub!(:exists?).and_return(true)
+      lambda { @provider.load_current_resource }.should_not raise_error(Chef::Exceptions::User)
+    end
+  end
+
+  describe "when the user does not yet exist and chef is creating it" do
+    context "with a numeric gid" do
+      before do
+        @new_resource.comment "#mockssuck"
+        @new_resource.gid 1001
+      end
+
+      it "creates the user, comment field, sets uid, gid, configures the home directory, sets the shell, and sets the password" do
+        @provider.should_receive :dscl_create_user
+        @provider.should_receive :dscl_create_comment
+        @provider.should_receive :set_uid
+        @provider.should_receive :dscl_set_gid
+        @provider.should_receive :modify_home
+        @provider.should_receive :dscl_set_shell
+        @provider.should_receive :modify_password
+        @provider.create_user
+      end
+
+      it "creates the user and sets the comment field" do
+        @provider.should_receive(:safe_dscl).with("create /Users/toor").and_return(true)
+        @provider.dscl_create_user
+      end
+
+      it "sets the comment field" do
+        @provider.should_receive(:safe_dscl).with("create /Users/toor RealName '#mockssuck'").and_return(true)
+        @provider.dscl_create_comment
+      end
+
+      it "should run safe_dscl with create /Users/user PrimaryGroupID to set the users primary group" do
+        @provider.should_receive(:safe_dscl).with("create /Users/toor PrimaryGroupID '1001'").and_return(true)
+        @provider.dscl_set_gid
+      end
+
+      it "should run safe_dscl with create /Users/user UserShell to set the users login shell" do
+        @provider.should_receive(:safe_dscl).with("create /Users/toor UserShell '/usr/bin/false'").and_return(true)
+        @provider.dscl_set_shell
+      end
+    end
+
+    context "with a non-numeric gid" do
+      before do
+        @new_resource.comment "#mockssuck"
+        @new_resource.gid "newgroup"
+      end
+
+      it "should map the group name to a numeric ID when the group exists" do
+        @provider.should_receive(:safe_dscl).with("read /Groups/newgroup PrimaryGroupID").ordered.and_return("PrimaryGroupID: 1001\n")
+        @provider.should_receive(:safe_dscl).with("create /Users/toor PrimaryGroupID '1001'").ordered.and_return(true)
+        @provider.dscl_set_gid
+      end
+
+      it "should raise an exception when the group does not exist" do
+        shell_return = ShellCmdResult.new("<dscl_cmd> DS Error: -14136 (eDSRecordNotFound)", 'err', -14136)
+        @provider.should_receive(:shell_out).with('dscl . -read /Groups/newgroup PrimaryGroupID').and_return(shell_return)
+        lambda { @provider.dscl_set_gid }.should raise_error(Chef::Exceptions::GroupIDNotFound)
+      end
+    end
+  end
+
+  describe "when the user exists and chef is managing it" do
+    before do
+      @current_resource = @new_resource.dup
+      @provider.current_resource = @current_resource
+      
+      # These are all different from @current_resource
+      @new_resource.username "mud"
+      @new_resource.uid 2342
+      @new_resource.gid 2342
+      @new_resource.home '/Users/death'
+      @new_resource.password 'goaway'
+    end
+    
+    it "sets the user, comment field, uid, gid, moves the home directory, sets the shell, and sets the password" do
+      @provider.should_receive :dscl_create_user
+      @provider.should_receive :dscl_create_comment
+      @provider.should_receive :set_uid
+      @provider.should_receive :dscl_set_gid
+      @provider.should_receive :modify_home
+      @provider.should_receive :dscl_set_shell
+      @provider.should_receive :modify_password
+      @provider.create_user
+    end
+  end
+
+  describe "when changing the gid" do
+    before do
+      @current_resource = @new_resource.dup
+      @provider.current_resource = @current_resource
+      
+      # This is different from @current_resource
+      @new_resource.gid 2342
+    end
+    
+    it "sets the gid" do
+      @provider.should_receive :dscl_set_gid
+      @provider.manage_user
+    end
+  end
+
+  describe "when the user exists and chef is removing it" do
+    it "removes the user's home directory when the resource is configured to manage home" do
+      @new_resource.supports({ :manage_home => true })
+      @provider.should_receive(:safe_dscl).with("read /Users/toor").and_return("NFSHomeDirectory: /Users/fuuuuuuuuuuuuu")
+      @provider.should_receive(:safe_dscl).with("delete /Users/toor")
+      FileUtils.should_receive(:rm_rf).with("/Users/fuuuuuuuuuuuuu")
+      @provider.remove_user
+    end
+    
+    it "removes the user from any group memberships" do
+      Etc.stub(:group).and_yield(OpenStruct.new(:name => 'ragefisters', :mem => 'toor'))
+      @provider.should_receive(:safe_dscl).with("delete /Users/toor")
+      @provider.should_receive(:safe_dscl).with("delete /Groups/ragefisters GroupMembership 'toor'")
+      @provider.remove_user
+    end
+  end
+
+  describe "when discovering if a user is locked" do
+
+    it "determines the user is not locked when dscl shows an AuthenticationAuthority without a DisabledUser field" do
+      @provider.should_receive(:safe_dscl).with("read /Users/toor")
+      @provider.should_not be_locked
+    end
+
+    it "determines the user is locked when dscl shows an AuthenticationAuthority with a DisabledUser field" do
+      @provider.should_receive(:safe_dscl).with('read /Users/toor').and_return("\nAuthenticationAuthority: ;DisabledUser;\n")
+      @provider.should be_locked
+    end
+
+    it "determines the user is not locked when dscl shows no AuthenticationAuthority" do
+      @provider.should_receive(:safe_dscl).with('read /Users/toor').and_return("\n")
+      @provider.should_not be_locked
+    end
+  end
+
+  describe "when locking the user" do
+    it "should run safe_dscl with append /Users/user AuthenticationAuthority ;DisabledUser; to lock the user account" do
+      @provider.should_receive(:safe_dscl).with("append /Users/toor AuthenticationAuthority ';DisabledUser;'")
+      @provider.lock_user
+    end
+  end
+
+  describe "when unlocking the user" do
+    it "removes DisabledUser from the authentication string" do
+      @provider.should_receive(:safe_dscl).with("read /Users/toor AuthenticationAuthority").and_return("\nAuthenticationAuthority: ;ShadowHash; ;DisabledUser;\n")
+      @provider.should_receive(:safe_dscl).with("create /Users/toor AuthenticationAuthority ';ShadowHash;'")
+      @provider.unlock_user
+    end
+  end
+end
diff --git a/spec/unit/provider/user/pw_spec.rb b/spec/unit/provider/user/pw_spec.rb
new file mode 100644
index 0000000000..b7503ea15f
--- /dev/null
+++ b/spec/unit/provider/user/pw_spec.rb
@@ -0,0 +1,235 @@
+#
+# Author:: Stephen Haynes (<sh@nomitor.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 'spec_helper'
+
+describe Chef::Provider::User::Pw do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    
+    @new_resource = Chef::Resource::User.new("adam")
+    @new_resource.comment   "Adam Jacob"
+    @new_resource.uid       1000
+    @new_resource.gid       1000
+    @new_resource.home      "/home/adam"
+    @new_resource.shell     "/usr/bin/zsh"
+    @new_resource.password  "abracadabra"
+    
+    @new_resource.supports :manage_home => true
+
+    @current_resource = Chef::Resource::User.new("adam")
+    @current_resource.comment  "Adam Jacob"
+    @current_resource.uid      1000
+    @current_resource.gid      1000
+    @current_resource.home     "/home/adam"
+    @current_resource.shell    "/usr/bin/zsh"
+    @current_resource.password "abracadabra"
+
+    @provider = Chef::Provider::User::Pw.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+
+  describe "setting options to the pw command" do
+    field_list = {
+      'comment' => "-c",
+      'home' => "-d",
+      'gid' => "-g",
+      'uid' => "-u",
+      'shell' => "-s"
+    }
+    field_list.each do |attribute, option|
+      it "should check for differences in #{attribute} between the new and current resources" do
+        @current_resource.should_receive(attribute)
+        @new_resource.should_receive(attribute)
+        @provider.set_options
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not null" do
+        @new_resource.stub!(attribute).and_return("hola")
+        @provider.set_options.should eql(" #{@new_resource.username} #{option} '#{@new_resource.send(attribute)}' -m")
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not null, without homedir management" do
+        @new_resource.stub!(:supports).and_return({:manage_home => false})
+        @new_resource.stub!(attribute).and_return("hola")
+        @provider.set_options.should eql(" #{@new_resource.username} #{option} '#{@new_resource.send(attribute)}'")
+      end
+    end
+
+    it "should combine all the possible options" do
+      match_string = " adam"
+      field_list.sort{ |a,b| a[0] <=> b[0] }.each do |attribute, option|
+        @new_resource.stub!(attribute).and_return("hola")
+        match_string << " #{option} 'hola'"
+      end
+      match_string << " -m"
+      @provider.set_options.should eql(match_string)
+    end
+  end
+
+  describe "create_user" do
+    before(:each) do
+      @provider.stub!(:run_command).and_return(true)
+      @provider.stub!(:modify_password).and_return(true)
+    end
+
+    it "should run pw useradd with the return of set_options" do
+      @provider.should_receive(:run_command).with({ :command => "pw useradd adam -m" }).and_return(true)
+      @provider.create_user
+    end
+
+    it "should modify the password" do
+      @provider.should_receive(:modify_password).and_return(true)
+      @provider.create_user
+    end
+  end
+
+  describe "manage_user" do
+    before(:each) do
+      @provider.stub!(:run_command).and_return(true)
+      @provider.stub!(:modify_password).and_return(true)
+    end
+
+    it "should run pw usermod with the return of set_options" do
+      @provider.should_receive(:run_command).with({ :command => "pw usermod adam -m" }).and_return(true)
+      @provider.manage_user
+    end
+
+    it "should modify the password" do
+      @provider.should_receive(:modify_password).and_return(true)
+      @provider.create_user
+    end
+  end
+
+  describe "remove_user" do
+    it "should run pw userdel with the new resources user name" do
+      @new_resource.supports :manage_home => false
+      @provider.should_receive(:run_command).with({ :command => "pw userdel #{@new_resource.username}" }).and_return(true)
+      @provider.remove_user
+    end
+
+    it "should run pw userdel with the new resources user name and -r if manage_home is true" do
+      @provider.should_receive(:run_command).with({ :command => "pw userdel #{@new_resource.username} -r"}).and_return(true)
+      @provider.remove_user
+    end
+  end
+
+  describe "determining if the user is locked" do
+    it "should return true if user is locked" do
+      @current_resource.stub!(:password).and_return("*LOCKED*abracadabra")
+      @provider.check_lock.should eql(true)
+    end
+
+    it "should return false if user is not locked" do
+      @current_resource.stub!(:password).and_return("abracadabra")
+      @provider.check_lock.should eql(false)
+    end
+  end
+
+  describe "when locking the user" do
+    it "should run pw lock with the new resources username" do
+      @provider.should_receive(:run_command).with({ :command => "pw lock #{@new_resource.username}"})
+      @provider.lock_user
+    end
+  end
+
+  describe "when unlocking the user" do
+    it "should run pw unlock with the new resources username" do
+      @provider.should_receive(:run_command).with({ :command => "pw unlock #{@new_resource.username}"})
+      @provider.unlock_user
+    end
+  end
+
+  describe "when modifying the password" do
+    before(:each) do
+      @status = mock("Status", :exitstatus => 0)
+      @provider.stub!(:popen4).and_return(@status)
+      @pid, @stdin, @stdout, @stderr = nil, nil, nil, nil
+    end
+
+    it "should check for differences in password between the new and current resources" do
+      @current_resource.should_receive(:password)
+      @new_resource.should_receive(:password)
+      @provider.modify_password
+    end
+
+    describe "and the passwords are identical" do
+      before(:each) do
+        @new_resource.stub!(:password).and_return("abracadabra")
+        @current_resource.stub!(:password).and_return("abracadabra")
+      end
+
+      it "logs an appropriate message" do
+        Chef::Log.should_receive(:debug).with("user[adam] no change needed to password")
+        @provider.modify_password
+      end
+    end
+
+    describe "and the passwords are different" do
+      before(:each) do
+        @new_resource.stub!(:password).and_return("abracadabra")
+        @current_resource.stub!(:password).and_return("sesame")
+      end
+
+      it "should log an appropriate message" do
+        Chef::Log.should_receive(:debug).with("user[adam] updating password")
+        @provider.modify_password
+      end
+
+      it "should run pw usermod with the username and the option -H 0" do
+        @provider.should_receive(:popen4).with("pw usermod adam -H 0", :waitlast => true).and_return(@status)
+        @provider.modify_password
+      end
+
+      it "should send the new password to the stdin of pw usermod" do
+        @stdin = StringIO.new
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.modify_password
+        @stdin.string.should == "abracadabra\n"
+      end
+
+      it "should raise an exception if pw usermod fails" do
+        @status.should_receive(:exitstatus).and_return(1)
+        lambda { @provider.modify_password }.should raise_error(Chef::Exceptions::User)
+      end
+
+      it "should not raise an exception if pw usermod succeeds" do
+        @status.should_receive(:exitstatus).and_return(0)
+        lambda { @provider.modify_password }.should_not raise_error(Chef::Exceptions::User)
+      end
+    end
+  end
+
+  describe "when loading the current state" do
+    before do
+      @provider.new_resource = Chef::Resource::User.new("adam")
+    end
+
+    it "should raise an error if the required binary /usr/sbin/pw doesn't exist" do
+      File.should_receive(:exists?).with("/usr/sbin/pw").and_return(false)
+      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::User)
+    end
+
+    it "shouldn't raise an error if /usr/sbin/pw exists" do
+      File.stub!(:exists?).and_return(true)
+      lambda { @provider.load_current_resource }.should_not raise_error(Chef::Exceptions::User)
+    end
+  end
+end
diff --git a/spec/unit/provider/user/useradd_spec.rb b/spec/unit/provider/user/useradd_spec.rb
new file mode 100644
index 0000000000..ea6caf6e0a
--- /dev/null
+++ b/spec/unit/provider/user/useradd_spec.rb
@@ -0,0 +1,386 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2010 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'
+
+describe Chef::Provider::User::Useradd do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::User.new("adam", @run_context)
+    @new_resource.comment "Adam Jacob"
+    @new_resource.uid 1000
+    @new_resource.gid 1000
+    @new_resource.home "/home/adam"
+    @new_resource.shell "/usr/bin/zsh"
+    @new_resource.password "abracadabra"
+    @new_resource.system false
+    @new_resource.manage_home false
+    @new_resource.non_unique false
+    @current_resource = Chef::Resource::User.new("adam", @run_context)
+    @current_resource.comment "Adam Jacob"
+    @current_resource.uid 1000
+    @current_resource.gid 1000
+    @current_resource.home "/home/adam"
+    @current_resource.shell "/usr/bin/zsh"
+    @current_resource.password "abracadabra"
+    @current_resource.system false
+    @current_resource.manage_home false
+    @current_resource.non_unique false
+    @current_resource.supports({:manage_home => false, :non_unique => false})
+    @provider = Chef::Provider::User::Useradd.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+
+  describe "when setting option" do
+    field_list = {
+      'comment' => "-c",
+      'gid' => "-g",
+      'uid' => "-u",
+      'shell' => "-s",
+      'password' => "-p"
+    }
+
+    field_list.each do |attribute, option|
+      it "should check for differences in #{attribute} between the new and current resources" do
+        @current_resource.should_receive(attribute)
+        @new_resource.should_receive(attribute)
+        @provider.universal_options
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not nil" do
+        @new_resource.stub!(attribute).and_return("hola")
+        @provider.universal_options.should eql(" #{option} 'hola'")
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not nil, without homedir management" do
+        @new_resource.stub!(:supports).and_return({:manage_home => false,
+                                                    :non_unique => false})
+        @new_resource.stub!(attribute).and_return("hola")
+        @provider.universal_options.should eql(" #{option} 'hola'")
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not nil, without homedir management (using real attributes)" do
+        @new_resource.stub!(:manage_home).and_return(false)
+        @new_resource.stub!(:non_unique).and_return(false)
+        @new_resource.stub!(attribute).and_return("hola")
+        @provider.universal_options.should eql(" #{option} 'hola'")
+      end
+    end
+
+    it "should combine all the possible options" do
+      match_string = ""
+      field_list.sort{ |a,b| a[0] <=> b[0] }.each do |attribute, option|
+        @new_resource.stub!(attribute).and_return("hola")
+        match_string << " #{option} 'hola'"
+      end
+      @provider.universal_options.should eql(match_string)
+    end
+
+    describe "when we want to create a system user" do
+      before do
+        @new_resource.manage_home(true)
+        @new_resource.non_unique(false)
+      end
+
+      it "should set useradd -r" do
+        @new_resource.system(true)
+        @provider.useradd_options.should == " -r"
+      end
+    end
+
+    describe "when the resource has a different home directory and supports home directory management" do
+      before do
+        @new_resource.stub!(:home).and_return("/wowaweea")
+        @new_resource.stub!(:supports).and_return({:manage_home => true,
+                                                   :non_unique => false})
+      end
+
+      it "should set -m -d /homedir" do
+        @provider.universal_options.should == " -m -d '/wowaweea'"
+        @provider.useradd_options.should == ""
+      end
+    end
+
+    describe "when the resource has a different home directory and supports home directory management (using real attributes)" do
+      before do
+        @new_resource.stub!(:home).and_return("/wowaweea")
+        @new_resource.stub!(:manage_home).and_return(true)
+        @new_resource.stub!(:non_unique).and_return(false)
+      end
+
+      it "should set -m -d /homedir" do
+        @provider.universal_options.should eql(" -m -d '/wowaweea'")
+        @provider.useradd_options.should == ""
+      end
+    end
+
+    describe "when the resource supports non_unique ids" do
+      before do
+        @new_resource.stub!(:supports).and_return({:manage_home => false,
+                                                  :non_unique => true})
+      end
+
+      it "should set -m -o" do
+        @provider.universal_options.should eql(" -o")
+      end
+    end
+
+    describe "when the resource supports non_unique ids (using real attributes)" do
+      before do
+        @new_resource.stub!(:manage_home).and_return(false)
+        @new_resource.stub!(:non_unique).and_return(true)
+      end
+
+      it "should set -m -o" do
+        @provider.universal_options.should eql(" -o")
+      end
+    end
+  end
+
+  describe "when creating a user" do
+    before(:each) do
+      @current_resource = Chef::Resource::User.new(@new_resource.name, @run_context)
+      @current_resource.username(@new_resource.username)
+      @provider.current_resource = @current_resource
+      @provider.new_resource.manage_home true
+      @provider.new_resource.home "/Users/mud"
+      @provider.new_resource.gid '23'
+    end
+
+    it "runs useradd with the computed command options" do
+      command = "useradd -c 'Adam Jacob' -g '23' -p 'abracadabra' -s '/usr/bin/zsh' -u '1000' -m -d '/Users/mud' adam"
+      @provider.should_receive(:run_command).with({ :command => command }).and_return(true)
+      @provider.create_user
+    end
+
+    describe "and home is not specified for new system user resource" do
+
+      before do
+        @provider.new_resource.system true
+        # there is no public API to set attribute's value to nil 
+        @provider.new_resource.instance_variable_set("@home", nil)
+      end
+
+      it "should not include -m or -d in the command options" do
+        command = "useradd -c 'Adam Jacob' -g '23' -p 'abracadabra' -s '/usr/bin/zsh' -u '1000' -r adam"
+        @provider.should_receive(:run_command).with({ :command => command }).and_return(true)
+        @provider.create_user
+      end
+
+    end
+
+  end
+
+  describe "when managing a user" do
+    before(:each) do
+      @provider.new_resource.manage_home true
+      @provider.new_resource.home "/Users/mud"
+      @provider.new_resource.gid '23'
+    end
+
+    # CHEF-3423, -m must come before the username
+    it "runs usermod with the computed command options" do
+      @provider.should_receive(:run_command).with({ :command => "usermod -g '23' -m -d '/Users/mud' adam" }).and_return(true)
+      @provider.manage_user
+    end
+
+    it "does not set the -r option to usermod" do
+      @new_resource.system(true)
+      @provider.should_receive(:run_command).with({ :command => "usermod -g '23' -m -d '/Users/mud' adam" }).and_return(true)
+      @provider.manage_user
+    end
+
+    it "CHEF-3429: does not set -m if we aren't changing the home directory" do
+      @provider.should_receive(:updating_home?).and_return(false)
+      @provider.should_receive(:run_command).with({ :command => "usermod -g '23' adam" }).and_return(true)
+      @provider.manage_user
+    end
+  end
+
+  describe "when removing a user" do
+
+    it "should run userdel with the new resources user name" do
+      @provider.should_receive(:run_command).with({ :command => "userdel #{@new_resource.username}" }).and_return(true)
+      @provider.remove_user
+    end
+
+    it "should run userdel with the new resources user name and -r if manage_home is true" do
+      @new_resource.stub!(:supports).and_return({ :manage_home => true,
+                                                  :non_unique => false})
+      @provider.should_receive(:run_command).with({ :command => "userdel -r #{@new_resource.username}"}).and_return(true)
+      @provider.remove_user
+    end
+
+    it "should run userdel with the new resources user name if non_unique is true" do
+      @new_resource.stub!(:supports).and_return({ :manage_home => false,
+                                                  :non_unique => true})
+      @provider.should_receive(:run_command).with({ :command => "userdel #{@new_resource.username}"}).and_return(true)
+      @provider.remove_user
+    end
+  end
+
+  describe "when checking the lock" do
+    before(:each) do
+      # @node = Chef::Node.new
+      # @new_resource = mock("Chef::Resource::User",
+      #   :nil_object => true,
+      #   :username => "adam"
+      # )
+      @status = mock("Status", :exitstatus => 0)
+      #@provider = Chef::Provider::User::Useradd.new(@node, @new_resource)
+      @provider.stub!(:popen4).and_return(@status)
+      @stdin = mock("STDIN", :nil_object => true)
+      @stdout = mock("STDOUT", :nil_object => true)
+      @stdout.stub!(:gets).and_return("root P 09/02/2008 0 99999 7 -1")
+      @stderr = mock("STDERR", :nil_object => true)
+      @pid = mock("PID", :nil_object => true)
+    end
+
+    it "should call passwd -S to check the lock status" do
+      @provider.should_receive(:popen4).with("passwd -S #{@new_resource.username}").and_return(@status)
+      @provider.check_lock
+    end
+
+    it "should get the first line of passwd -S STDOUT" do
+      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @stdout.should_receive(:gets).and_return("root P 09/02/2008 0 99999 7 -1")
+      @provider.check_lock
+    end
+
+    it "should return false if status begins with P" do
+      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.check_lock.should eql(false)
+    end
+
+    it "should return false if status begins with N" do
+      @stdout.stub!(:gets).and_return("root N")
+      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.check_lock.should eql(false)
+    end
+
+    it "should return true if status begins with L" do
+      @stdout.stub!(:gets).and_return("root L")
+      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.check_lock.should eql(true)
+    end
+
+    it "should raise a Chef::Exceptions::User if passwd -S fails on anything other than redhat/centos" do
+      @node.automatic_attrs[:platform] = 'ubuntu'
+      @status.should_receive(:exitstatus).and_return(1)
+      lambda { @provider.check_lock }.should raise_error(Chef::Exceptions::User)
+    end
+
+    ['redhat', 'centos'].each do |os|
+      it "should not raise a Chef::Exceptions::User if passwd -S exits with 1 on #{os} and the passwd package is version 0.73-1" do
+        @node.automatic_attrs[:platform] = os
+        @stdout.stub!(:gets).and_return("passwd-0.73-1\n")
+        @status.should_receive(:exitstatus).twice.and_return(1)
+        @provider.should_receive(:popen4).with("passwd -S #{@new_resource.username}")
+        @provider.should_receive(:popen4).with("rpm -q passwd").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        lambda { @provider.check_lock }.should_not raise_error(Chef::Exceptions::User)
+      end
+
+      it "should raise a Chef::Exceptions::User if passwd -S exits with 1 on #{os} and the passwd package is not version 0.73-1" do
+        @node.automatic_attrs[:platform] = os
+        @stdout.stub!(:gets).and_return("passwd-0.73-2\n")
+        @status.should_receive(:exitstatus).twice.and_return(1)
+        @provider.should_receive(:popen4).with("passwd -S #{@new_resource.username}")
+        @provider.should_receive(:popen4).with("rpm -q passwd").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        lambda { @provider.check_lock }.should raise_error(Chef::Exceptions::User)
+      end
+
+      it "should raise a Chef::Exceptions::User if passwd -S exits with something other than 0 or 1 on #{os}" do
+        @node.automatic_attrs[:platform] = os
+        @status.should_receive(:exitstatus).twice.and_return(2)
+        lambda { @provider.check_lock }.should raise_error(Chef::Exceptions::User)
+      end
+    end
+  end
+
+  describe "when locking the user" do
+    it "should run usermod -L with the new resources username" do
+      @provider.should_receive(:run_command).with({ :command => "usermod -L #{@new_resource.username}"})
+      @provider.lock_user
+    end
+  end
+
+  describe "when unlocking the user" do
+    it "should run usermod -L with the new resources username" do
+      @provider.should_receive(:run_command).with({ :command => "usermod -U #{@new_resource.username}"})
+      @provider.unlock_user
+    end
+  end
+
+  describe "when checking if home needs updating" do
+    [
+     {
+       "action" => "should return false if home matches",
+       "current_resource_home" => [ "/home/laurent" ],
+       "new_resource_home" => [ "/home/laurent" ],
+       "expected_result" => false
+     },
+     {
+       "action" => "should return true if home doesn't match",
+       "current_resource_home" => [ "/home/laurent" ],
+       "new_resource_home" => [ "/something/else" ],
+       "expected_result" => true
+     },
+     {
+       "action" => "should return false if home only differs by trailing slash",
+       "current_resource_home" => [ "/home/laurent" ],
+       "new_resource_home" => [ "/home/laurent/", "/home/laurent" ],
+       "expected_result" => false
+     },
+     {
+       "action" => "should return false if home is an equivalent path",
+       "current_resource_home" => [ "/home/laurent" ],
+       "new_resource_home" => [ "/home/./laurent", "/home/laurent" ],
+       "expected_result" => false
+     },
+    ].each do |home_check|
+      it home_check["action"] do
+        @provider.current_resource.home home_check["current_resource_home"].first
+        @current_home_mock = mock("Pathname")
+        @provider.new_resource.home home_check["new_resource_home"].first
+        @new_home_mock = mock("Pathname")
+
+        Pathname.should_receive(:new).with(@current_resource.home).and_return(@current_home_mock)
+        @current_home_mock.should_receive(:cleanpath).and_return(home_check["current_resource_home"].last)
+        Pathname.should_receive(:new).with(@new_resource.home).and_return(@new_home_mock)
+        @new_home_mock.should_receive(:cleanpath).and_return(home_check["new_resource_home"].last)
+
+        @provider.updating_home?.should == home_check["expected_result"]
+      end
+    end
+    it "should return true if the current home does not exist but a home is specified by the new resource" do
+      @new_resource = Chef::Resource::User.new("adam", @run_context)
+      @current_resource = Chef::Resource::User.new("adam", @run_context)
+      @provider = Chef::Provider::User::Useradd.new(@new_resource, @run_context)
+      @provider.current_resource = @current_resource
+      @current_resource.home nil
+      @new_resource.home "/home/kitten"
+
+      @provider.updating_home?.should == true
+    end
+  end
+end
diff --git a/spec/unit/provider/user/windows_spec.rb b/spec/unit/provider/user/windows_spec.rb
new file mode 100644
index 0000000000..6ede11b28c
--- /dev/null
+++ b/spec/unit/provider/user/windows_spec.rb
@@ -0,0 +1,178 @@
+#
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Copyright:: Copyright (c) 2010 VMware, 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'
+
+class Chef
+  class Util
+    class Windows
+      class NetUser
+      end
+    end
+  end
+end
+
+describe Chef::Provider::User::Windows do
+  before(:each) do
+    @node = Chef::Node.new
+    @new_resource = Chef::Resource::User.new("monkey")
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @current_resource = Chef::Resource::User.new("monkey")
+
+    @net_user = mock("Chef::Util::Windows::NetUser")
+    Chef::Util::Windows::NetUser.stub!(:new).and_return(@net_user)
+
+    @provider = Chef::Provider::User::Windows.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+  
+  describe "when comparing the user's current attributes to the desired attributes" do
+    before do
+      @new_resource.comment   "Adam Jacob"
+      @new_resource.uid       1000
+      @new_resource.gid       1000
+      @new_resource.home      "/home/adam"
+      @new_resource.shell     "/usr/bin/zsh"
+      @new_resource.password  "abracadabra"
+
+      @provider.current_resource = @new_resource.clone
+    end
+    describe "and the attributes match" do
+      it "doesn't set the comment field to be updated" do
+        @provider.set_options.should_not have_key(:full_name)
+      end
+
+      it "doesn't set the home directory to be updated" do
+        @provider.set_options.should_not have_key(:home_dir)
+      end
+
+      it "doesn't set the group id to be updated" do
+        @provider.set_options.should_not have_key(:primary_group_id)
+      end
+
+      it "doesn't set the user id to be updated" do
+        @provider.set_options.should_not have_key(:user_id)
+      end
+
+      it "doesn't set the shell to be updated" do
+        @provider.set_options.should_not have_key(:script_path)
+      end
+
+      it "doesn't set the password to be updated" do
+        @provider.set_options.should_not have_key(:password)
+      end
+
+    end
+    
+    describe "and the attributes do not match" do
+      before do
+        @current_resource = Chef::Resource::User.new("adam")
+        @current_resource.comment   "Adam Jacob-foo"
+        @current_resource.uid       1111
+        @current_resource.gid       1111
+        @current_resource.home      "/home/adam-foo"
+        @current_resource.shell     "/usr/bin/tcsh"
+        @current_resource.password  "foobarbaz"
+        @provider.current_resource = @current_resource
+      end
+
+      it "marks the full_name field to be updated" do
+        @provider.set_options[:full_name].should == "Adam Jacob"
+      end
+
+      it "marks the home_dir attribute to be updated" do
+        @provider.set_options[:home_dir].should == '/home/adam'
+      end
+
+      it "marks the primary_group_id attribute to be updated" do
+        @provider.set_options[:primary_group_id].should == 1000
+      end
+
+      it "marks the user_id attribute to be updated" do
+        @provider.set_options[:user_id].should == 1000
+      end
+
+      it "marks the script_path attribute to be updated" do
+        @provider.set_options[:script_path].should == '/usr/bin/zsh'
+      end
+
+      it "marks the password attribute to be updated" do
+        @provider.set_options[:password].should == 'abracadabra'
+      end
+    end
+  end
+
+  describe "when creating the user" do
+    it "should call @net_user.add with the return of set_options" do
+      @provider.stub!(:set_options).and_return(:name=> "monkey")
+      @net_user.should_receive(:add).with(:name=> "monkey")
+      @provider.create_user
+    end
+  end
+
+  describe "manage_user" do
+    before(:each) do
+      @provider.stub!(:set_options).and_return(:name=> "monkey")
+    end
+  
+    it "should call @net_user.update with the return of set_options" do
+      @net_user.should_receive(:update).with(:name=> "monkey")
+      @provider.manage_user
+    end
+  end
+
+  describe "when removing the user" do
+    it "should call @net_user.delete" do
+      @net_user.should_receive(:delete)
+      @provider.remove_user
+    end
+  end
+
+  describe "when checking if the user is locked" do
+    before(:each) do
+      @current_resource.password "abracadabra"
+    end
+
+    it "should return true if user is locked" do
+      @net_user.stub!(:check_enabled).and_return(true)
+      @provider.check_lock.should eql(true)
+    end
+
+    it "should return false if user is not locked" do
+      @net_user.stub!(:check_enabled).and_return(false)
+      @provider.check_lock.should eql(false)
+    end
+  end
+
+  describe "locking the user" do
+    it "should call @net_user.disable_account" do
+      @net_user.stub!(:check_enabled).and_return(true)
+      @net_user.should_receive(:disable_account)
+      @provider.lock_user
+    end
+  end
+
+  describe "unlocking the user" do
+    it "should call @net_user.enable_account" do
+      @net_user.stub!(:check_enabled).and_return(false)
+      @net_user.should_receive(:enable_account)
+      @provider.unlock_user
+    end
+  end
+end
diff --git a/spec/unit/provider/user_spec.rb b/spec/unit/provider/user_spec.rb
new file mode 100644
index 0000000000..4066ffd7fe
--- /dev/null
+++ b/spec/unit/provider/user_spec.rb
@@ -0,0 +1,477 @@
+#
+# 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 'spec_helper'
+
+EtcPwnamIsh = Struct.new(:name, :passwd, :uid, :gid, :gecos, :dir, :shell, :change, :uclass, :expire)
+EtcGrnamIsh = Struct.new(:name, :passwd, :gid, :mem)
+
+describe Chef::Provider::User do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::User.new("adam")
+    @new_resource.comment "Adam Jacob"
+    @new_resource.uid 1000
+    @new_resource.gid 1000
+    @new_resource.home "/home/adam"
+    @new_resource.shell "/usr/bin/zsh"
+
+    @current_resource = Chef::Resource::User.new("adam")
+    @current_resource.comment "Adam Jacob"
+    @current_resource.uid 1000
+    @current_resource.gid 1000
+    @current_resource.home "/home/adam"
+    @current_resource.shell "/usr/bin/zsh"
+
+    @provider = Chef::Provider::User.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+
+  describe "when first created" do
+    it "assume the user exists by default" do
+      @provider.user_exists.should eql(true)
+    end
+
+    it "does not know the locked state" do
+      @provider.locked.should eql(nil)
+    end
+  end
+
+  describe "executing load_current_resource" do
+    before(:each) do
+      @node = Chef::Node.new
+      #@new_resource = mock("Chef::Resource::User", 
+      #  :null_object => true,
+      #  :username => "adam",
+      #  :comment => "Adam Jacob",
+      #  :uid => 1000,
+      #  :gid => 1000,
+      #  :home => "/home/adam",
+      #  :shell => "/usr/bin/zsh",
+      #  :password => nil,
+      #  :updated => nil
+      #)
+      Chef::Resource::User.stub!(:new).and_return(@current_resource)
+      @pw_user = EtcPwnamIsh.new
+      @pw_user.name = "adam"
+      @pw_user.gid = 1000
+      @pw_user.uid = 1000
+      @pw_user.gecos = "Adam Jacob"
+      @pw_user.dir = "/home/adam"
+      @pw_user.shell = "/usr/bin/zsh"
+      @pw_user.passwd = "*"
+      Etc.stub!(:getpwnam).and_return(@pw_user)
+    end
+
+    it "should create a current resource with the same name as the new resource" do
+      @provider.load_current_resource
+      @provider.current_resource.name.should == 'adam'
+    end
+
+    it "should set the username of the current resource to the username of the new resource" do
+      @provider.load_current_resource
+      @current_resource.username.should == @new_resource.username
+    end
+
+    it "should look up the user in /etc/passwd with getpwnam" do
+      Etc.should_receive(:getpwnam).with(@new_resource.username).and_return(@pw_user)
+      @provider.load_current_resource
+    end
+
+    it "should set user_exists to false if the user is not found with getpwnam" do
+      Etc.should_receive(:getpwnam).and_raise(ArgumentError)
+      @provider.load_current_resource
+      @provider.user_exists.should eql(false)
+    end
+
+    # The mapping between the Chef::Resource::User and Getpwnam struct
+    user_attrib_map = {
+      :uid => :uid,
+      :gid => :gid,
+      :comment => :gecos,
+      :home => :dir,
+      :shell => :shell
+    }
+    user_attrib_map.each do |user_attrib, getpwnam_attrib|
+      it "should set the current resources #{user_attrib} based on getpwnam #{getpwnam_attrib}" do
+        @current_resource.should_receive(user_attrib).with(@pw_user.send(getpwnam_attrib))
+        @provider.load_current_resource
+      end
+    end
+
+    it "should attempt to convert the group gid if one has been supplied" do
+      @provider.should_receive(:convert_group_name)
+      @provider.load_current_resource
+    end
+
+    it "shouldn't try and convert the group gid if none has been supplied" do
+      @new_resource.stub!(:gid).and_return(nil)
+      @provider.should_not_receive(:convert_group_name)
+      @provider.load_current_resource
+    end
+
+    it "should return the current resource" do
+      @provider.load_current_resource.should eql(@current_resource)
+    end
+
+    describe "and running assertions" do
+      def self.shadow_lib_unavail?
+        begin
+          require 'rubygems'
+          require 'shadow'
+        rescue LoadError => e
+          pending "ruby-shadow gem not installed for dynamic load test"
+          true
+        else
+          false
+        end
+      end
+
+      before (:each) do
+        user = @pw_user.dup
+        user.name = "root"
+        user.passwd = "x"
+        @new_resource.password "some new password"
+        Etc.stub!(:getpwnam).and_return(user)
+      end
+      
+      unless shadow_lib_unavail?
+        context "and we have the ruby-shadow gem" do
+          pending "and we are not root (rerun this again as root)", :requires_unprivileged_user => true 
+  
+          context "and we are root", :requires_root => true do
+            it "should pass assertions when ruby-shadow can be loaded" do
+              @provider.action = 'create'
+              original_method = @provider.method(:require)
+              @provider.should_receive(:require) { |*args| original_method.call(*args) }
+              passwd_info = Struct::PasswdEntry.new(:sp_namp => "adm ", :sp_pwdp => "$1$T0N0Q.lc$nyG6pFI3Dpqa5cxUz/57j0", :sp_lstchg => 14861, :sp_min => 0, :sp_max => 99999, 
+                                                    :sp_warn => 7, :sp_inact => -1, :sp_expire => -1, :sp_flag => -1)
+              Shadow::Passwd.should_receive(:getspnam).with("adam").and_return(passwd_info)
+              @provider.load_current_resource
+              @provider.define_resource_requirements
+              @provider.process_resource_requirements
+            end
+          end
+        end
+      end
+
+      it "should fail assertions when ruby-shadow cannot be loaded" do
+        @provider.should_receive(:require).with("shadow") { raise LoadError }
+        @provider.load_current_resource
+        @provider.define_resource_requirements
+        lambda {@provider.process_resource_requirements}.should raise_error Chef::Exceptions::MissingLibrary 
+      end
+
+    end
+  end
+
+  describe "compare_user" do
+    before(:each) do
+      # @node = Chef::Node.new
+      # @new_resource = mock("Chef::Resource::User", 
+      #   :null_object => true,
+      #   :username => "adam",
+      #   :comment => "Adam Jacob",
+      #   :uid => 1000,
+      #   :gid => 1000,
+      #   :home => "/home/adam",
+      #   :shell => "/usr/bin/zsh",
+      #   :password => nil,
+      #   :updated => nil
+      # )
+      # @current_resource = mock("Chef::Resource::User", 
+      #   :null_object => true,
+      #   :username => "adam",
+      #   :comment => "Adam Jacob",
+      #   :uid => 1000,
+      #   :gid => 1000,
+      #   :home => "/home/adam",
+      #   :shell => "/usr/bin/zsh",
+      #   :password => nil,
+      #   :updated => nil
+      # )
+      # @provider = Chef::Provider::User.new(@node, @new_resource)
+      # @provider.current_resource = @current_resource
+    end
+
+    %w{uid gid comment home shell password}.each do |attribute|
+      it "should return true if #{attribute} doesn't match" do
+        @new_resource.should_receive(attribute).exactly(2).times.and_return(true)
+        @current_resource.should_receive(attribute).once.and_return(false)
+        @provider.compare_user.should eql(true)
+      end
+    end
+
+    it "should return false if the objects are identical" do
+      @provider.compare_user.should eql(false)
+    end  
+  end
+
+  describe "action_create" do
+    before(:each) do
+      @provider.stub!(:load_current_resource)
+      # @current_resource = mock("Chef::Resource::User", 
+      #   :null_object => true,
+      #   :username => "adam",
+      #   :comment => "Adam Jacob",
+      #   :uid => 1000,
+      #   :gid => 1000,
+      #   :home => "/home/adam",
+      #   :shell => "/usr/bin/zsh",
+      #   :password => nil,
+      #   :updated => nil
+      # )
+      # @provider = Chef::Provider::User.new(@node, @new_resource)
+      # @provider.current_resource = @current_resource
+      # @provider.user_exists = false
+      # @provider.stub!(:create_user).and_return(true)
+      # @provider.stub!(:manage_user).and_return(true)
+    end
+
+    it "should call create_user if the user does not exist" do
+      @provider.user_exists = false
+      @provider.should_receive(:create_user).and_return(true)
+      @provider.action_create
+      @provider.converge
+      @new_resource.should be_updated
+    end
+
+    it "should call manage_user if the user exists and has mismatched attributes" do
+      @provider.user_exists = true
+      @provider.stub!(:compare_user).and_return(true)
+      @provider.should_receive(:manage_user).and_return(true)
+      @provider.action_create
+      @provider.converge
+    end
+
+    it "should set the the new_resources updated flag when it creates the user if we call manage_user" do
+      @provider.user_exists = true
+      @provider.stub!(:compare_user).and_return(true)
+      @provider.stub!(:manage_user).and_return(true)
+      @provider.action_create
+      @provider.converge
+      @new_resource.should be_updated
+    end
+  end
+
+  describe "action_remove" do
+    before(:each) do
+      @provider.stub!(:load_current_resource)
+    end
+
+    it "should not call remove_user if the user does not exist" do
+      @provider.user_exists = false
+      @provider.should_not_receive(:remove_user) 
+      @provider.action_remove
+      @provider.converge
+    end
+
+    it "should call remove_user if the user exists" do
+      @provider.user_exists = true
+      @provider.should_receive(:remove_user)
+      @provider.action_remove
+      @provider.converge
+    end
+
+    it "should set the new_resources updated flag to true if the user is removed" do
+      @provider.user_exists = true
+      @provider.should_receive(:remove_user)
+      @provider.action_remove
+      @provider.converge
+      @new_resource.should be_updated
+    end
+  end
+
+  describe "action_manage" do
+    before(:each) do
+      @provider.stub!(:load_current_resource)
+      # @node = Chef::Node.new
+      # @new_resource = mock("Chef::Resource::User", 
+      #   :null_object => true
+      # )
+      # @current_resource = mock("Chef::Resource::User", 
+      #   :null_object => true
+      # )
+      # @provider = Chef::Provider::User.new(@node, @new_resource)
+      # @provider.current_resource = @current_resource
+      # @provider.user_exists = true
+      # @provider.stub!(:manage_user).and_return(true)
+    end
+
+    it "should run manage_user if the user exists and has mismatched attributes" do
+      @provider.should_receive(:compare_user).and_return(true)
+      @provider.should_receive(:manage_user).and_return(true)
+      @provider.action_manage
+      @provider.converge
+    end
+
+    it "should set the new resources updated flag to true if manage_user is called" do
+      @provider.stub!(:compare_user).and_return(true)
+      @provider.stub!(:manage_user).and_return(true)
+      @provider.action_manage
+      @provider.converge
+      @new_resource.should be_updated
+    end
+
+    it "should not run manage_user if the user does not exist" do
+      @provider.user_exists = false
+      @provider.should_not_receive(:manage_user)
+      @provider.action_manage
+      @provider.converge
+    end
+
+    it "should not run manage_user if the user exists but has no differing attributes" do
+      @provider.should_receive(:compare_user).and_return(false)
+      @provider.should_not_receive(:manage_user)
+      @provider.action_manage
+      @provider.converge
+    end
+  end
+
+  describe "action_modify" do
+    before(:each) do
+      @provider.stub!(:load_current_resource)
+      # @node = Chef::Node.new
+      # @new_resource = mock("Chef::Resource::User", 
+      #   :null_object => true
+      # )
+      # @current_resource = mock("Chef::Resource::User", 
+      #   :null_object => true
+      # )
+      # @provider = Chef::Provider::User.new(@node, @new_resource)
+      # @provider.current_resource = @current_resource
+      # @provider.user_exists = true
+      # @provider.stub!(:manage_user).and_return(true)
+    end
+
+    it "should run manage_user if the user exists and has mismatched attributes" do
+      @provider.should_receive(:compare_user).and_return(true)
+      @provider.should_receive(:manage_user).and_return(true)
+      @provider.action_modify
+      @provider.converge
+    end
+
+    it "should set the new resources updated flag to true if manage_user is called" do
+      @provider.stub!(:compare_user).and_return(true)
+      @provider.stub!(:manage_user).and_return(true)
+      @provider.action_modify
+      @provider.converge
+      @new_resource.should be_updated
+    end
+
+    it "should not run manage_user if the user exists but has no differing attributes" do
+      @provider.should_receive(:compare_user).and_return(false)
+      @provider.should_not_receive(:manage_user)
+      @provider.action_modify
+      @provider.converge
+    end
+
+    it "should raise a Chef::Exceptions::User if the user doesn't exist" do
+      @provider.user_exists = false
+      lambda { @provider.action = :modify; @provider.run_action }.should raise_error(Chef::Exceptions::User)
+    end
+  end
+
+
+  describe "action_lock" do
+    before(:each) do
+      @provider.stub!(:load_current_resource)
+    end
+    it "should lock the user if it exists and is unlocked" do
+      @provider.stub!(:check_lock).and_return(false)
+      @provider.should_receive(:lock_user).and_return(true)
+      @provider.action_lock
+      @provider.converge
+    end
+
+    it "should set the new resources updated flag to true if lock_user is called" do
+      @provider.stub!(:check_lock).and_return(false)
+      @provider.should_receive(:lock_user)
+      @provider.action_lock
+      @provider.converge
+      @new_resource.should be_updated
+    end
+
+    it "should raise a Chef::Exceptions::User if we try and lock a user that does not exist" do
+      @provider.user_exists = false
+      @provider.action = :lock
+
+      lambda { @provider.run_action }.should raise_error(Chef::Exceptions::User)
+    end
+  end
+
+  describe "action_unlock" do
+    before(:each) do
+      @provider.stub!(:load_current_resource)
+      # @node = Chef::Node.new
+      # @new_resource = mock("Chef::Resource::User", 
+      #   :null_object => true
+      # )
+      # @current_resource = mock("Chef::Resource::User", 
+      #   :null_object => true
+      # )
+      # @provider = Chef::Provider::User.new(@node, @new_resource)
+      # @provider.current_resource = @current_resource
+      # @provider.user_exists = true
+      # @provider.stub!(:check_lock).and_return(true)
+      # @provider.stub!(:unlock_user).and_return(true)
+    end
+
+    it "should unlock the user if it exists and is locked" do
+      @provider.stub!(:check_lock).and_return(true)
+      @provider.should_receive(:unlock_user).and_return(true)
+      @provider.action_unlock
+      @provider.converge
+      @new_resource.should be_updated
+    end
+
+    it "should raise a Chef::Exceptions::User if we try and unlock a user that does not exist" do
+      @provider.user_exists = false
+      @provider.action = :unlock
+      lambda { @provider.run_action }.should raise_error(Chef::Exceptions::User)
+    end
+  end
+
+  describe "convert_group_name" do
+    before do
+      @new_resource.gid('999')
+      @group = EtcGrnamIsh.new('wheel', '*', 999, [])
+    end
+
+    it "should lookup the group name locally" do
+      Etc.should_receive(:getgrnam).with("999").and_return(@group)
+      @provider.convert_group_name.should == 999
+    end
+
+    it "should raise an error if we can't translate the group name during resource assertions" do
+      Etc.should_receive(:getgrnam).and_raise(ArgumentError)
+      @provider.define_resource_requirements
+      @provider.convert_group_name
+      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::User)
+    end
+
+    it "should set the new resources gid to the integerized version if available" do
+      Etc.should_receive(:getgrnam).with("999").and_return(@group)
+      @provider.convert_group_name
+      @new_resource.gid.should == 999
+    end
+  end
+end