chef 11.16.4 → 11.18.0

data/spec/unit/knife/cookbook_site_share_spec.rb

@@ -108,16 +108,16 @@ describe Chef::Knife::CookbookSiteShare do
       File.stub(:open).and_return(true)
     end
 
-    it 'should post the cookbook to "http://cookbooks.opscode.com"' do
-      response_text = {:uri => 'http://cookbooks.opscode.com/cookbooks/cookbook_name'}.to_json
+    it 'should post the cookbook to "https://supermarket.getchef.com"' do
+      response_text = {:uri => 'https://supermarket.getchef.com/cookbooks/cookbook_name'}.to_json
       @upload_response.stub(:body).and_return(response_text)
       @upload_response.stub(:code).and_return(201)
-      Chef::CookbookSiteStreamingUploader.should_receive(:post).with(/cookbooks\.opscode\.com/, anything(), anything(), anything())
+      Chef::CookbookSiteStreamingUploader.should_receive(:post).with(/supermarket\.getchef\.com/, anything(), anything(), anything())
       @knife.run
     end
 
     it 'should alert the user when a version already exists' do
-      response_text = {:error_messages => ['Version already exists']}.to_json
+      response_text = Chef::JSONCompat.to_json({:error_messages => ['Version already exists']})
       @upload_response.stub(:body).and_return(response_text)
       @upload_response.stub(:code).and_return(409)
       lambda { @knife.run }.should raise_error(SystemExit)
@@ -125,7 +125,7 @@ describe Chef::Knife::CookbookSiteShare do
     end
 
     it 'should pass any errors on to the user' do
-      response_text = {:error_messages => ["You're holding it wrong"]}.to_json
+      response_text = Chef::JSONCompat.to_json({:error_messages => ["You're holding it wrong"]})
       @upload_response.stub(:body).and_return(response_text)
       @upload_response.stub(:code).and_return(403)
       lambda { @knife.run }.should raise_error(SystemExit)
@@ -133,7 +133,7 @@ describe Chef::Knife::CookbookSiteShare do
     end
 
     it 'should print the body if no errors are exposed on failure' do
-      response_text = {:system_error => "Your call was dropped", :reason => "There's a map for that"}.to_json
+      response_text = Chef::JSONCompat.to_json({:system_error => "Your call was dropped", :reason => "There's a map for that"})
       @upload_response.stub(:body).and_return(response_text)
       @upload_response.stub(:code).and_return(500)
       @knife.ui.should_receive(:error).with(/#{Regexp.escape(response_text)}/)#.ordered

data/spec/unit/knife/core/bootstrap_context_spec.rb

@@ -116,13 +116,13 @@ EXPECTED
   describe "when JSON attributes are given" do
     let(:config) { {:first_boot_attributes => {:baz => :quux}} }
     it "adds the attributes to first_boot" do
-      bootstrap_context.first_boot.to_json.should eq({:baz => :quux, :run_list => run_list}.to_json)
+      Chef::JSONCompat.to_json(bootstrap_context.first_boot).should eq(Chef::JSONCompat.to_json({:baz => :quux, :run_list => run_list}))
     end
   end
 
   describe "when JSON attributes are NOT given" do
     it "sets first_boot equal to run_list" do
-      bootstrap_context.first_boot.to_json.should eq({:run_list => run_list}.to_json)
+      Chef::JSONCompat.to_json(bootstrap_context.first_boot).should eq(Chef::JSONCompat.to_json({:run_list => run_list}))
     end
   end
 

data/spec/unit/knife/core/subcommand_loader_spec.rb

@@ -73,7 +73,72 @@ describe Chef::Knife::SubcommandLoader do
     @loader.site_subcommands.should include(expected_command)
   end
 
-  describe "finding 3rd party plugins" do 
+  # https://github.com/opscode/chef-dk/issues/227
+  #
+  # `knife` in ChefDK isn't from a gem install, it's directly run from a clone
+  # of the source, but there can be one or more versions of chef also installed
+  # as a gem. If the gem install contains a command that doesn't exist in the
+  # source tree of the "primary" chef install, it can be loaded and cause an
+  # error. We also want to ensure that we only load builtin commands from the
+  # "primary" chef install.
+  context "when a different version of chef is also installed as a gem" do
+
+    let(:all_found_commands) do
+      [
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/bootstrap.rb",
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_bulk_delete.rb",
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_create.rb",
+        # We use the fake version 1.0.0 because that version doesn't exist,
+        # which ensures it won't ever equal "chef-#{Chef::VERSION}"
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/bootstrap.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/client_bulk_delete.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/client_create.rb",
+        # This command is "extra" compared to what's in the embedded/apps/chef install:
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/data_bag_secret_options.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-vault-2.2.4/lib/chef/knife/decrypt.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/knife-spork-1.4.1/lib/chef/knife/spork-bump.rb",
+        # These are fake commands that have names designed to test that the
+        # regex is strict enough
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-foo-#{Chef::VERSION}/lib/chef/knife/chef-foo.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/foo-chef-#{Chef::VERSION}/lib/chef/knife/foo-chef.rb",
+        # In a real scenario, we'd use rubygems APIs to only select the most
+        # recent gem, but for this test we want to check that we're doing the
+        # right thing both when the plugin version matches and does not match
+        # the current chef version. Looking at
+        # `SubcommandLoader::MATCHES_THIS_CHEF_GEM` and
+        # `SubcommandLoader::MATCHES_CHEF_GEM` should make it clear why we want
+        # to test these two cases.
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-bar-1.0.0/lib/chef/knife/chef-bar.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/bar-chef-1.0.0/lib/chef/knife/bar-chef.rb"
+      ]
+    end
+
+    let(:expected_valid_commands) do
+      [
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/bootstrap.rb",
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_bulk_delete.rb",
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_create.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-vault-2.2.4/lib/chef/knife/decrypt.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/knife-spork-1.4.1/lib/chef/knife/spork-bump.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-foo-#{Chef::VERSION}/lib/chef/knife/chef-foo.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/foo-chef-#{Chef::VERSION}/lib/chef/knife/foo-chef.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-bar-1.0.0/lib/chef/knife/chef-bar.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/bar-chef-1.0.0/lib/chef/knife/bar-chef.rb"
+      ]
+    end
+
+    before do
+      expect(@loader).to receive(:find_files_latest_gems).with("chef/knife/*.rb").and_return(all_found_commands)
+      expect(@loader).to receive(:find_subcommands_via_dirglob).and_return({})
+    end
+
+    it "ignores commands from the non-matching gem install" do
+      expect(@loader.find_subcommands_via_rubygems.values).to eq(expected_valid_commands)
+    end
+
+  end
+
+  describe "finding 3rd party plugins" do
     let(:env_home) { "/home/alice" }
     let(:manifest_path) { env_home + "/.chef/plugin_manifest.json" }
 

data/spec/unit/knife/data_bag_from_file_spec.rb

@@ -21,7 +21,6 @@ require 'spec_helper'
 require 'chef/data_bag_item'
 require 'chef/encrypted_data_bag_item'
 require 'tempfile'
-require 'json'
 
 Chef::Knife::DataBagFromFile.load_deps
 
@@ -46,7 +45,7 @@ describe Chef::Knife::DataBagFromFile do
         "greeting" => "hello",
         "nested" => { "a1" => [1, 2, 3], "a2" => { "b1" => true }}
     }
-    @db_file.write(@plain_data.to_json)
+    @db_file.write(Chef::JSONCompat.to_json(@plain_data))
     @db_file.flush
     @knife.instance_variable_set(:@name_args, ['bag_name', @db_file.path])
   end

data/spec/unit/node_spec.rb

@@ -762,6 +762,10 @@ describe Chef::Node do
       end
       serialized_node.run_list.should == node.run_list
     end
+
+    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+      let(:subject) { node.from_file(File.expand_path("nodes/test.example.com.rb", CHEF_SPEC_DATA)) }
+    end
   end
 
   describe "to_s" do

data/spec/unit/provider/dsc_script_spec.rb

@@ -22,123 +22,152 @@ require 'chef/util/dsc/resource_info'
 require 'spec_helper'
 
 describe Chef::Provider::DscScript do
-  let (:node) {
-    node = Chef::Node.new
-    node.automatic[:languages][:powershell][:version] = '4.0'
-    node
-  }
-  let (:events) { Chef::EventDispatch::Dispatcher.new }
-  let (:run_context) { Chef::RunContext.new(node, {}, events) }
-  let (:resource) { Chef::Resource::DscScript.new("script", run_context) }
-  let (:provider) do
-    Chef::Provider::DscScript.new(resource, run_context)
-  end
-
-  describe '#load_current_resource' do
-    it "describes the resource as converged if there were 0 DSC resources" do
-      allow(provider).to receive(:run_configuration).with(:test).and_return([])
-      provider.load_current_resource
-      provider.instance_variable_get('@resource_converged').should be_true
+  context 'when DSC is available' do
+    let (:node) {
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = '4.0'
+      node
+    }
+    let (:events) { Chef::EventDispatch::Dispatcher.new }
+    let (:run_context) { Chef::RunContext.new(node, {}, events) }
+    let (:resource) { Chef::Resource::DscScript.new("script", run_context) }
+    let (:provider) do
+      Chef::Provider::DscScript.new(resource, run_context)
     end
 
-    it "describes the resource as not converged if there is 1 DSC resources that is converged" do
-      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
-      allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
-      provider.load_current_resource
-      provider.instance_variable_get('@resource_converged').should be_true
+    describe '#load_current_resource' do
+      it "describes the resource as converged if there were 0 DSC resources" do
+        allow(provider).to receive(:run_configuration).with(:test).and_return([])
+        provider.load_current_resource
+        provider.instance_variable_get('@resource_converged').should be_true
+      end
+
+      it "describes the resource as not converged if there is 1 DSC resources that is converged" do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
+        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
+        provider.load_current_resource
+        provider.instance_variable_get('@resource_converged').should be_true
+      end
+
+      it "describes the resource as not converged if there is 1 DSC resources that is not converged" do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
+        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
+        provider.load_current_resource
+        provider.instance_variable_get('@resource_converged').should be_false
+      end
+
+      it "describes the resource as not converged if there are any DSC resources that are not converged" do
+        dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
+        dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
+
+        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
+        provider.load_current_resource
+        provider.instance_variable_get('@resource_converged').should be_false
+      end
+
+      it "describes the resource as converged if all DSC resources that are converged" do
+        dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
+        dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
+
+        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
+        provider.load_current_resource
+        provider.instance_variable_get('@resource_converged').should be_true
+      end
     end
 
-    it "describes the resource as not converged if there is 1 DSC resources that is not converged" do
-      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
-      allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
-      provider.load_current_resource
-      provider.instance_variable_get('@resource_converged').should be_false
+    describe '#generate_configuration_document' do
+      # I think integration tests should cover these cases
+
+      it 'uses configuration_document_from_script_path when a dsc script file is given' do
+        allow(provider).to receive(:load_current_resource)
+        resource.command("path_to_script")
+        generator = double('Chef::Util::DSC::ConfigurationGenerator')
+        generator.should_receive(:configuration_document_from_script_path)
+        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
+        provider.send(:generate_configuration_document, 'tmp', nil)
+      end
+
+      it 'uses configuration_document_from_script_code when a the dsc resource is given' do
+        allow(provider).to receive(:load_current_resource)
+        resource.code("ImADSCResource{}")
+        generator = double('Chef::Util::DSC::ConfigurationGenerator')
+        generator.should_receive(:configuration_document_from_script_code)
+        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
+        provider.send(:generate_configuration_document, 'tmp', nil)
+      end
+
+      it 'should noop if neither code or command are provided' do
+        allow(provider).to receive(:load_current_resource)
+        generator = double('Chef::Util::DSC::ConfigurationGenerator')
+        generator.should_receive(:configuration_document_from_script_code).with('', anything(), anything())
+        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
+        provider.send(:generate_configuration_document, 'tmp', nil)
+      end
     end
 
-    it "describes the resource as not converged if there are any DSC resources that are not converged" do
-      dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
-      dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
-
-      allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
-      provider.load_current_resource
-      provider.instance_variable_get('@resource_converged').should be_false
+    describe 'action_run' do
+      it 'should converge the script if it is not converged' do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
+        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
+        allow(provider).to receive(:run_configuration).with(:set)
+
+        provider.run_action(:run)
+        resource.should be_updated
+      end
+
+      it 'should not converge if the script is already converged' do
+        allow(provider).to receive(:run_configuration).with(:test).and_return([])
+        
+        provider.run_action(:run)
+        resource.should_not be_updated
+      end
     end
 
-    it "describes the resource as converged if all DSC resources that are converged" do
-      dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
-      dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
-
-      allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
-      provider.load_current_resource
-      provider.instance_variable_get('@resource_converged').should be_true
+    describe '#generate_description' do
+      it 'removes the resource name from the beginning of any log line from the LCM' do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', true, ['resourcename doing something', 'lastline'])
+        provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
+        provider.send(:generate_description)[1].should match(/converge DSC resource resourcename by doing something/)
+      end
+
+      it 'ignores the last line' do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', true, ['resourcename doing something', 'lastline'])
+        provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
+        provider.send(:generate_description)[1].should_not match(/lastline/)
+      end
+
+      it 'reports a dsc resource has not been changed if the LCM reported no change was required' do
+        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', false, ['resourcename does nothing', 'lastline'])
+        provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
+        provider.send(:generate_description)[1].should match(/converge DSC resource resourcename by doing nothing/)
+      end
     end
   end
 
-  describe '#generate_configuration_document' do
-    # I think integration tests should cover these cases
-
-    it 'uses configuration_document_from_script_path when a dsc script file is given' do
-      allow(provider).to receive(:load_current_resource)
-      resource.command("path_to_script")
-      generator = double('Chef::Util::DSC::ConfigurationGenerator')
-      generator.should_receive(:configuration_document_from_script_path)
-      allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
-      provider.send(:generate_configuration_document, 'tmp', nil)
-    end
-
-    it 'uses configuration_document_from_script_code when a the dsc resource is given' do
-      allow(provider).to receive(:load_current_resource)
-      resource.code("ImADSCResource{}")
-      generator = double('Chef::Util::DSC::ConfigurationGenerator')
-      generator.should_receive(:configuration_document_from_script_code)
-      allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
-      provider.send(:generate_configuration_document, 'tmp', nil)
-    end
-
-    it 'should noop if neither code or command are provided' do
-      allow(provider).to receive(:load_current_resource)
-      generator = double('Chef::Util::DSC::ConfigurationGenerator')
-      generator.should_receive(:configuration_document_from_script_code).with('', anything(), anything())
-      allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
-      provider.send(:generate_configuration_document, 'tmp', nil)
-    end
-  end
-
-  describe 'action_run' do
-    it 'should converge the script if it is not converged' do
-      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
-      allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
-      allow(provider).to receive(:run_configuration).with(:set)
-
-      provider.run_action(:run)
-      resource.should be_updated
-    end
-
-    it 'should not converge if the script is already converged' do
-      allow(provider).to receive(:run_configuration).with(:test).and_return([])
-      
-      provider.run_action(:run)
-      resource.should_not be_updated
-    end
-  end
-
-  describe '#generate_description' do
-    it 'removes the resource name from the beginning of any log line from the LCM' do
-      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', true, ['resourcename doing something', 'lastline'])
-      provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
-      provider.send(:generate_description)[1].should match(/converge DSC resource resourcename by doing something/)
-    end
-
-    it 'ignores the last line' do
-      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', true, ['resourcename doing something', 'lastline'])
-      provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
-      provider.send(:generate_description)[1].should_not match(/lastline/)
-    end
+  context 'when Dsc is not available' do
+    let (:node) { Chef::Node.new }
+    let (:events) { Chef::EventDispatch::Dispatcher.new }
+    let (:run_context) { Chef::RunContext.new(node, {}, events) }
+    let (:resource) { Chef::Resource::DscScript.new('script', run_context) }
+    let (:provider) { Chef::Provider::DscScript.new(resource, run_context) }
+
+    describe 'action_run' do
+      ['1.0', '2.0', '3.0'].each do |version|
+        it "raises an exception for powershell version '#{version}'" do
+          node.automatic[:languages][:powershell][:version] = version
+
+          expect {
+            provider.run_action(:run)
+          }.to raise_error(Chef::Exceptions::NoProviderAvailable)
+        end
+      end
+
+      it 'raises an exception if Powershell is not present' do
+        expect {
+          provider.run_action(:run)
+        }.to raise_error(Chef::Exceptions::NoProviderAvailable)
+      end
 
-    it 'reports a dsc resource has not been changed if the LCM reported no change was required' do
-      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', false, ['resourcename does nothing', 'lastline'])
-      provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
-      provider.send(:generate_description)[1].should match(/converge DSC resource resourcename by doing nothing/)
     end
   end
 end

data/spec/unit/provider/env/windows_spec.rb

@@ -53,7 +53,7 @@ describe Chef::Provider::Env::Windows, :windows_only do
       end
 
       it "should update the ruby ENV object when it updates the value" do
-        provider.should_receive(:compare_value).and_return(true)
+        provider.should_receive(:requires_modify_or_create?).and_return(true)
         new_resource.value("foobar")
         provider.action_modify
         expect(ENV['CHEF_WINDOWS_ENV_TEST']).to eql('foobar')
@@ -92,7 +92,7 @@ describe Chef::Provider::Env::Windows, :windows_only do
       end
 
       it "replaces Windows system variables" do
-        provider.should_receive(:compare_value).and_return(true)
+        provider.should_receive(:requires_modify_or_create?).and_return(true)
         provider.should_receive(:expand_path).with(system_root).and_return(system_root_value)
         provider.action_modify
         expect(ENV['PATH']).to eql(system_root_value)

data/spec/unit/provider/env_spec.rb

@@ -88,20 +88,20 @@ describe Chef::Provider::Env do
 
     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.should_receive(:requires_modify_or_create?).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.stub(:requires_modify_or_create?).and_return(true)
       @provider.should_receive(:modify_env).and_return(true)
       @provider.action_create
     end
 
     it "should set 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(:requires_modify_or_create?).and_return(true)
       @provider.stub(:modify_env).and_return(true)
       @provider.action_create
       @new_resource.should be_updated
@@ -147,20 +147,20 @@ describe Chef::Provider::Env do
     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(:requires_modify_or_create?).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(:requires_modify_or_create?).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_receive(:requires_modify_or_create?).and_return(false)
       @provider.should_not_receive(:modify_env)
       @provider.action_modify
     end
@@ -198,9 +198,31 @@ describe Chef::Provider::Env do
       @provider.delete_element.should eql(true)
       @new_resource.should be_updated
     end
+
+    context "when new_resource's value contains the delimiter"  do
+      it "should return false if all the elements are deleted" do
+        # This indicates that the entire key needs to be deleted
+        @new_resource.value("C:/foo/bin;C:/bar/bin")
+        @provider.delete_element.should eql(false)
+        @new_resource.should_not be_updated  # This will be updated in action_delete
+      end
+
+      it "should return true if any, but not all, of the elements are deleted" do
+        @new_resource.value("C:/foo/bin;C:/notbaz/bin")
+        @provider.should_receive(:create_env)
+        @provider.delete_element.should eql(true)
+        @new_resource.should be_updated
+      end
+
+      it "should return true if none of the elements are deleted" do
+        @new_resource.value("C:/notfoo/bin;C:/notbaz/bin")
+        @provider.delete_element.should eql(true)
+        @new_resource.should_not be_updated
+      end
+    end
   end
 
-  describe "compare_value" do
+  describe "requires_modify_or_create?" do
     before(:each) do
       @new_resource.value("C:/bar")
       @current_resource = @new_resource.clone
@@ -208,25 +230,68 @@ describe Chef::Provider::Env do
     end
 
     it "should return false if the values are equal" do
-      @provider.compare_value.should be_false
+      @provider.requires_modify_or_create?.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
+      @provider.requires_modify_or_create?.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
+      @provider.requires_modify_or_create?.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
+      @provider.requires_modify_or_create?.should be_true
+    end
+
+    context "when new_resource's value contains the delimiter"  do
+      it "should return false if all the current values are contained" do
+        @new_resource.value("C:/biz;C:/baz")
+        @new_resource.delim(";")
+        @current_resource.value("C:/biz;C:/foo/bin;C:/baz")
+        @provider.requires_modify_or_create?.should be_false
+      end
+
+      it "should return true if any of the new values are not contained" do
+        @new_resource.value("C:/biz;C:/baz;C:/bin")
+        @new_resource.delim(";")
+        @current_resource.value("C:/biz;C:/foo/bin;C:/baz")
+        @provider.requires_modify_or_create?.should be_true
+      end
+    end
+  end
+
+  describe "modify_env" do
+    before(:each) do
+      @provider.stub(:create_env).and_return(true)
+      @new_resource.delim ";"
+
+      @current_resource = Chef::Resource::Env.new("FOO")
+      @current_resource.value "C:/foo/bin"
+      @provider.current_resource = @current_resource
+    end
+
+    it "should not modify the variable passed to the resource" do
+      new_value = "C:/bar/bin"
+      passed_value = new_value.dup
+      @new_resource.value(passed_value)
+      @provider.modify_env
+      passed_value.should == new_value
+    end
+
+    it "should only add values not already contained when a delimiter is provided" do
+      @new_resource.value("C:/foo;C:/bar;C:/baz")
+      @new_resource.delim(";")
+      @current_resource.value("C:/foo/bar;C:/bar;C:/baz")
+      @provider.modify_env
+      @new_resource.value.should eq("C:/foo;C:/foo/bar;C:/bar;C:/baz")
     end
   end
 end