chef 16.2.44-universal-mingw32 → 16.4.35-universal-mingw32

data/spec/unit/resource/windows_feature_powershell_spec.rb

@@ -22,6 +22,7 @@ describe Chef::Resource::WindowsFeaturePowershell do
   let(:events) { Chef::EventDispatch::Dispatcher.new }
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
   let(:resource) { Chef::Resource::WindowsFeaturePowershell.new(%w{SNMP DHCP}, run_context) }
+  let(:provider) { resource.provider_for_action(:install) }
 
   it "sets resource name as :windows_feature_powershell" do
     expect(resource.resource_name).to eql(:windows_feature_powershell)
@@ -35,10 +36,6 @@ describe Chef::Resource::WindowsFeaturePowershell do
     expect(resource.feature_name).to eql(%w{snmp dhcp})
   end
 
-  it "sets the default action as :install" do
-    expect(resource.action).to eql([:install])
-  end
-
   it "supports :delete, :install, :remove actions" do
     expect { resource.action :delete }.not_to raise_error
     expect { resource.action :install }.not_to raise_error
@@ -54,4 +51,33 @@ describe Chef::Resource::WindowsFeaturePowershell do
     resource.feature_name "SNMP"
     expect(resource.feature_name).to eql(["snmp"])
   end
+
+  it "install a single feature" do
+    resource.feature_name "snmp"
+    expect { resource.action :install }.not_to raise_error
+  end
+
+  it "install multi feature" do
+    resource.feature_name "SNMP, DHCP"
+    expect { resource.action :install }.not_to raise_error
+  end
+
+  it "does not attempt to install features that have been removed" do
+    node.default["powershell_features_cache"] ||= {}
+    node.default["powershell_features_cache"]["disabled"] = ["dhcp"]
+    node.default["powershell_features_cache"]["removed"] = ["snmp"]
+    resource.feature_name "dhcp, snmp"
+
+    expect(provider.features_to_install).to eq(["dhcp"])
+  end
+
+  it "attempts to install features that have been removed when source is set" do
+    node.default["powershell_features_cache"] ||= {}
+    node.default["powershell_features_cache"]["disabled"] = ["dhcp"]
+    node.default["powershell_features_cache"]["removed"] = ["snmp"]
+    resource.feature_name "dhcp, snmp"
+    resource.source 'D:\\sources\\sxs'
+
+    expect(provider.features_to_install).to eq(%w{dhcp snmp})
+  end
 end

data/spec/unit/resource/windows_firewall_profile_spec.rb

@@ -0,0 +1,77 @@
+#
+# Copyright:: Copyright (c) Chef Software 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::Resource::WindowsFirewallProfile do
+  let(:resource) { Chef::Resource::WindowsFirewallProfile.new("fakey_fakerton") }
+
+  it "sets resource name as :windows_firewall_profile" do
+    expect(resource.resource_name).to eql(:windows_firewall_profile)
+  end
+
+  %w{ Domain Private Public }.each do |this_profile|
+    it "The profile accepts values for the \"#{this_profile}\" Profile" do
+      expect { resource.profile this_profile }.not_to raise_error
+    end
+  end
+
+  it "the profile property does not accept bad profile names" do
+    expect { resource.profile "Special" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "the resource's default_inbound_action property only strings Block, Allow, or NotConfigured" do
+    expect { resource.default_inbound_action "AllowSome" }.to raise_error(ArgumentError)
+    expect { resource.default_inbound_action "Block" }.not_to raise_error
+  end
+  it "the resource's default_outbound_action property only accepts strings Block, Allow, or NotConfigured" do
+    expect { resource.default_outbound_action "BlockMost" }.to raise_error(ArgumentError)
+    expect { resource.default_outbound_action "Allow" }.not_to raise_error
+  end
+  it "the resource's allow_inbound_rules property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_inbound_rules "Yes" }.to raise_error(ArgumentError)
+    expect { resource.allow_inbound_rules true }.not_to raise_error
+  end
+  it "the resource's allow_local_firewall_rules property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_local_firewall_rules "No" }.to raise_error(ArgumentError)
+    expect { resource.allow_local_firewall_rules false }.not_to raise_error
+  end
+  it "the resource's allow_local_ipsec_rules property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_local_ipsec_rules "Yes" }.to raise_error(ArgumentError)
+    expect { resource.allow_local_ipsec_rules true }.not_to raise_error
+  end
+  it "the resource's allow_user_apps property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_user_apps "No" }.to raise_error(ArgumentError)
+    expect { resource.allow_user_apps false }.not_to raise_error
+  end
+  it "the resource's allow_user_ports property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_user_ports "Nope" }.to raise_error(ArgumentError)
+    expect { resource.allow_user_ports "NotConfigured" }.not_to raise_error
+  end
+  it "the resource's allow_unicast_response property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_unicast_response "True" }.to raise_error(ArgumentError)
+    expect { resource.allow_unicast_response true }.not_to raise_error
+  end
+  it "the resource's display_notification property only accepts strings true, false, or NotConfigured" do
+    expect { resource.display_notification "False" }.to raise_error(ArgumentError)
+    expect { resource.display_notification false }.not_to raise_error
+  end
+
+  it "sets the default action as :configure" do
+    expect(resource.action).to eql([:enable])
+  end
+end

data/spec/unit/resource/windows_package_spec.rb

@@ -58,6 +58,7 @@ describe Chef::Resource::WindowsPackage, "initialize" do
     expect { resource.installer_type :msi }.not_to raise_error
     expect { resource.installer_type :nsis }.not_to raise_error
     expect { resource.installer_type :wise }.not_to raise_error
+    expect { resource.installer_type :something_else_entirely }.to raise_error(Chef::Exceptions::ValidationFailed)
     expect { resource.installer_type "msi" }.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 

data/spec/unit/resource_reporter_spec.rb

@@ -19,7 +19,7 @@
 # limitations under the License.
 #
 
-require_relative "../spec_helper"
+require "spec_helper"
 require "chef/resource_reporter"
 require "socket"
 

data/spec/unit/resource_spec.rb

@@ -1255,19 +1255,36 @@ describe Chef::Resource do
       expect(block_value).to eq(original_umask)
     end
 
-    it "changes the umask in the block to the set value" do
-      resource.umask = "0123"
+    if windows?
+      it "is a no-op on Windows" do
+        resource.umask = "0123"
 
-      block_value = nil
+        block_value = nil
 
-      resource.with_umask do
-        block_value = ::File.umask
+        resource.with_umask do
+          block_value = ::File.umask
+        end
+
+        # Format the returned value so a potential error message is easier to understand.
+        actual_value = block_value.to_s(8).rjust(4, "0")
+
+        expect(actual_value).to eq("0000")
       end
+    else
+      it "changes the umask in the block to the set value" do
+        resource.umask = "0123"
+
+        block_value = nil
 
-      # Format the returned value so a potential error message is easier to understand.
-      actual_value = block_value.to_s(8).rjust(4, "0")
+        resource.with_umask do
+          block_value = ::File.umask
+        end
 
-      expect(actual_value).to eq("0123")
+        # Format the returned value so a potential error message is easier to understand.
+        actual_value = block_value.to_s(8).rjust(4, "0")
+
+        expect(actual_value).to eq("0123")
+      end
     end
 
     it "resets the umask afterwards" do

data/spec/unit/role_spec.rb

@@ -259,7 +259,7 @@ describe Chef::Role do
     it "should return a Chef::Role object from JSON" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes", "#{Chef::Config[:role_path]}/memes/lolcat.json"])
       file_path = File.join(Chef::Config[:role_path], "memes/lolcat.json")
-      expect(File).to receive(:exists?).with(file_path).exactly(1).times.and_return(true)
+      expect(File).to receive(:exist?).with(file_path).exactly(1).times.and_return(true)
       expect(IO).to receive(:read).with(file_path).and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
@@ -268,7 +268,7 @@ describe Chef::Role do
     it "should return a Chef::Role object from a Ruby DSL" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes", "#{Chef::Config[:role_path]}/memes/lolcat.rb"])
       rb_path = File.join(Chef::Config[:role_path], "memes/lolcat.rb")
-      expect(File).to receive(:exists?).with(rb_path).exactly(1).times.and_return(true)
+      expect(File).to receive(:exist?).with(rb_path).exactly(1).times.and_return(true)
       expect(File).to receive(:readable?).with(rb_path).exactly(1).times.and_return(true)
       expect(File).to receive(:file?).with(rb_path).exactly(1).times.and_return(true)
       expect(IO).to receive(:read).with(rb_path).and_return(ROLE_DSL)
@@ -280,8 +280,8 @@ describe Chef::Role do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes", "#{Chef::Config[:role_path]}/memes/lolcat.json", "#{Chef::Config[:role_path]}/memes/lolcat.rb"])
       js_path = File.join(Chef::Config[:role_path], "memes/lolcat.json")
       rb_path = File.join(Chef::Config[:role_path], "memes/lolcat.rb")
-      expect(File).to receive(:exists?).with(js_path).exactly(1).times.and_return(true)
-      expect(File).not_to receive(:exists?).with(rb_path)
+      expect(File).to receive(:exist?).with(js_path).exactly(1).times.and_return(true)
+      expect(File).not_to receive(:exist?).with(rb_path)
       expect(IO).to receive(:read).with(js_path).and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
@@ -289,19 +289,19 @@ describe Chef::Role do
 
     it "should raise an exception if the file does not exist" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/meme.rb"])
-      expect(File).not_to receive(:exists?)
+      expect(File).not_to receive(:exist?)
       expect { @role.class.from_disk("lolcat") }.to raise_error(Chef::Exceptions::RoleNotFound)
     end
 
     it "should raise an exception if two files exist with the same name" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes/lolcat.rb", "#{Chef::Config[:role_path]}/lolcat.rb"])
-      expect(File).not_to receive(:exists?)
+      expect(File).not_to receive(:exist?)
       expect { @role.class.from_disk("lolcat") }.to raise_error(Chef::Exceptions::DuplicateRole)
     end
 
     it "should not raise an exception if two files exist with a similar name" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes/lolcat.rb", "#{Chef::Config[:role_path]}/super_lolcat.rb"])
-      expect(File).to receive(:exists?).with("#{Chef::Config[:role_path]}/memes/lolcat.rb").and_return(true)
+      expect(File).to receive(:exist?).with("#{Chef::Config[:role_path]}/memes/lolcat.rb").and_return(true)
       allow_any_instance_of(Chef::Role).to receive(:from_file).with("#{Chef::Config[:role_path]}/memes/lolcat.rb")
       expect { @role.class.from_disk("lolcat") }.not_to raise_error
     end
@@ -310,50 +310,52 @@ describe Chef::Role do
   describe "when loading from disk and role_path is an array" do
 
     before(:each) do
-      Chef::Config[:role_path] = ["/path1", "/path/path2"]
+      Chef::Config[:role_path] = ["/path1", "/path1/path2"]
     end
 
+    let(:root) { windows? ? "C:/path1" : "/path1" }
+
     it "should return a Chef::Role object from JSON" do
-      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return(["/path1/lolcat.json"])
-      expect(File).to receive(:exists?).with("/path1/lolcat.json").exactly(1).times.and_return(true)
-      expect(IO).to receive(:read).with("/path1/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
+      expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return(["#{root}/lolcat.json"])
+      expect(File).to receive(:exist?).with("#{root}/lolcat.json").exactly(1).times.and_return(true)
+      expect(IO).to receive(:read).with("#{root}/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should return a Chef::Role object from JSON when role is in the second path" do
-      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return([])
-      expect(Dir).to receive(:glob).with(File.join("/path/path2", "**", "**")).exactly(1).times.and_return(["/path/path2/lolcat.json"])
-      expect(File).to receive(:exists?).with("/path/path2/lolcat.json").exactly(1).times.and_return(true)
-      expect(IO).to receive(:read).with("/path/path2/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
+      expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join("#{root}/path2", "**", "**")).exactly(1).times.and_return(["#{root}/path2/lolcat.json"])
+      expect(File).to receive(:exist?).with("#{root}/path2/lolcat.json").exactly(1).times.and_return(true)
+      expect(IO).to receive(:read).with("#{root}/path2/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should return a Chef::Role object from a Ruby DSL" do
-      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return(["/path1/lolcat.rb"])
-      expect(File).to receive(:exists?).with("/path1/lolcat.rb").exactly(1).times.and_return(true)
-      expect(File).to receive(:readable?).with("/path1/lolcat.rb").and_return(true)
-      expect(File).to receive(:file?).with("/path1/lolcat.rb").and_return(true)
-      expect(IO).to receive(:read).with("/path1/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
+      expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return(["#{root}/lolcat.rb"])
+      expect(File).to receive(:exist?).with("#{root}/lolcat.rb").exactly(1).times.and_return(true)
+      expect(File).to receive(:readable?).with("#{root}/lolcat.rb").and_return(true)
+      expect(File).to receive(:file?).with("#{root}/lolcat.rb").and_return(true)
+      expect(IO).to receive(:read).with("#{root}/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should return a Chef::Role object from a Ruby DSL when role is in the second path" do
-      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return([])
-      expect(Dir).to receive(:glob).with(File.join("/path/path2", "**", "**")).exactly(1).times.and_return(["/path/path2/lolcat.rb"])
-      expect(File).to receive(:exists?).with("/path/path2/lolcat.rb").exactly(1).times.and_return(true)
-      expect(File).to receive(:readable?).with("/path/path2/lolcat.rb").and_return(true)
-      expect(File).to receive(:file?).with("/path/path2/lolcat.rb").and_return(true)
-      expect(IO).to receive(:read).with("/path/path2/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
+      expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join("#{root}/path2", "**", "**")).exactly(1).times.and_return(["#{root}/path2/lolcat.rb"])
+      expect(File).to receive(:exist?).with("#{root}/path2/lolcat.rb").exactly(1).times.and_return(true)
+      expect(File).to receive(:readable?).with("#{root}/path2/lolcat.rb").and_return(true)
+      expect(File).to receive(:file?).with("#{root}/path2/lolcat.rb").and_return(true)
+      expect(IO).to receive(:read).with("#{root}/path2/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should raise an exception if the file does not exist" do
-      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return([])
-      expect(Dir).to receive(:glob).with(File.join("/path/path2", "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join("#{root}/path2", "**", "**")).exactly(1).times.and_return([])
       expect { @role.class.from_disk("lolcat") }.to raise_error(Chef::Exceptions::RoleNotFound)
     end
 

data/spec/unit/run_context/cookbook_compiler_spec.rb

@@ -175,7 +175,7 @@ describe Chef::RunContext::CookbookCompiler do
     describe "event dispatch" do
       let(:recipe) { "dependency1::default" }
       let(:recipe_path) do
-        File.expand_path("../../../data/run_context/cookbooks/dependency1/recipes/default.rb", __FILE__)
+        File.expand_path("../../data/run_context/cookbooks/dependency1/recipes/default.rb", __dir__)
       end
       before do
         node.run_list(recipe)

data/spec/unit/run_lock_spec.rb

@@ -15,7 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative "../spec_helper"
+require "spec_helper"
 require "chef/client"
 
 describe Chef::RunLock do

data/spec/unit/scan_access_control_spec.rb

@@ -15,7 +15,7 @@
 # limitations under the License.
 #
 
-require_relative "../spec_helper"
+require "spec_helper"
 require "chef/scan_access_control"
 
 describe Chef::ScanAccessControl do

data/spec/unit/server_api_spec.rb

@@ -59,20 +59,22 @@ describe Chef::ServerAPI do
   end
 
   context "versioned apis" do
-    class VersionedClassV0
-      extend Chef::Mixin::VersionedAPI
-      minimum_api_version 0
-    end
-
-    class VersionedClassV2
-      extend Chef::Mixin::VersionedAPI
-      minimum_api_version 2
-    end
-
-    class VersionedClassVersions
-      extend Chef::Mixin::VersionedAPIFactory
-      add_versioned_api_class VersionedClassV0
-      add_versioned_api_class VersionedClassV2
+    let(:version_class) do
+      Class.new do
+        extend Chef::Mixin::VersionedAPIFactory
+
+        version_class_v0 = Class.new do
+          extend Chef::Mixin::VersionedAPI
+          minimum_api_version 0
+        end
+        add_versioned_api_class version_class_v0
+
+        version_class_v2 = Class.new do
+          extend Chef::Mixin::VersionedAPI
+          minimum_api_version 2
+        end
+        add_versioned_api_class version_class_v2
+      end
     end
 
     before do
@@ -80,7 +82,7 @@ describe Chef::ServerAPI do
     end
 
     let(:versioned_client) do
-      Chef::ServerAPI.new(url, version_class: VersionedClassVersions)
+      Chef::ServerAPI.new(url, version_class: version_class)
     end
 
     it "on protocol negotiation it posts the same message body without doubly-encoding the json string" do
@@ -114,11 +116,36 @@ describe Chef::ServerAPI do
 
     it "500 on a get retries and gets correctly " do
       WebMock.disable_net_connect!
-      get_body = { bar: "baz" }
       headers = { "Accept" => "application/json", "Accept-Encoding" => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3", "Host" => "chef.example.com:4000", "X-Chef-Version" => Chef::VERSION, "X-Ops-Sign" => "algorithm=sha1;version=1.1;", "X-Ops-Userid" => "silent-bob" }
       stub_request(:get, "http://chef.example.com:4000/foo").with(headers: headers).to_return(status: [500, "Internal Server Error"])
       stub_request(:get, "http://chef.example.com:4000/foo").with(headers: headers).to_return(status: 200, body: "", headers: {})
       client.get("foo")
     end
+
+    it "406 on a post does protocol negotiation" do
+      WebMock.disable_net_connect!
+      post_body = { bar: "baz" }
+      body_406 = '{"error":"invalid-x-ops-server-api-version","message":"Specified version 2 not supported","min_version":0,"max_version":1}'
+      stub_request(:post, "http://chef.example.com:4000/foo").with(body: post_body.to_json, headers: { "X-Ops-Server-Api-Version" => "2" }).to_return(status: [406, "Not Acceptable"], body: body_406 )
+      stub_request(:post, "http://chef.example.com:4000/foo").with(body: post_body.to_json, headers: { "X-Ops-Server-Api-Version" => "0" }).to_return(status: 200, body: "", headers: {})
+      client.post("foo", post_body)
+    end
+
+    it "406 on a put does protocol negotiation" do
+      WebMock.disable_net_connect!
+      put_body = { bar: "baz" }
+      body_406 = '{"error":"invalid-x-ops-server-api-version","message":"Specified version 2 not supported","min_version":0,"max_version":1}'
+      stub_request(:put, "http://chef.example.com:4000/foo").with(body: put_body.to_json, headers: { "X-Ops-Server-Api-Version" => "2" }).to_return(status: [406, "Not Acceptable"], body: body_406 )
+      stub_request(:put, "http://chef.example.com:4000/foo").with(body: put_body.to_json, headers: { "X-Ops-Server-Api-Version" => "0" }).to_return(status: 200, body: "", headers: {})
+      client.put("foo", put_body)
+    end
+
+    it "406 on a get does protocol negotiation" do
+      WebMock.disable_net_connect!
+      body_406 = '{"error":"invalid-x-ops-server-api-version","message":"Specified version 2 not supported","min_version":0,"max_version":1}'
+      stub_request(:get, "http://chef.example.com:4000/foo").with(headers: { "X-Ops-Server-Api-Version" => "2" }).to_return(status: [406, "Not Acceptable"], body: body_406 )
+      stub_request(:get, "http://chef.example.com:4000/foo").with(headers: { "X-Ops-Server-Api-Version" => "0" }).to_return(status: 200, body: "", headers: {})
+      client.get("foo")
+    end
   end
 end

data/spec/unit/util/backup_spec.rb

@@ -21,7 +21,7 @@ require "tmpdir"
 
 describe Chef::Util::Backup do
 
-  let (:tempfile) do
+  let(:tempfile) do
     Tempfile.new("chef-util-backup-spec-test")
   end
 

data/spec/unit/util/diff_spec.rb

@@ -61,10 +61,6 @@ shared_examples_for "a diff util" do
       Chef::Config[:diff_disabled] = true
     end
 
-    after do
-      Chef::Config[:diff_disabled] = false
-    end
-
     it "calling for_output should return the error message" do
       expect(differ.for_output).to eql( [ "(diff output suppressed by config)" ] )
     end
@@ -300,14 +296,9 @@ shared_examples_for "a diff util" do
 
   describe "when testing the diff_filesize_threshold" do
     before do
-      @diff_filesize_threshold_saved = Chef::Config[:diff_filesize_threshold]
       Chef::Config[:diff_filesize_threshold] = 10
     end
 
-    after do
-      Chef::Config[:diff_filesize_threshold] = @diff_filesize_threshold_saved
-    end
-
     describe "when the old_file goes over the threshold" do
       before do
         old_tempfile.write("But thats what you get when Wu-Tang raised you")
@@ -359,14 +350,9 @@ shared_examples_for "a diff util" do
     describe "when the diff output is too long" do
 
       before do
-        @diff_output_threshold_saved = Chef::Config[:diff_output_threshold]
         Chef::Config[:diff_output_threshold] = 10
       end
 
-      after do
-        Chef::Config[:diff_output_threshold] = @diff_output_threshold_saved
-      end
-
       it "calling for_output should return the error message" do
         expect(differ.for_output).to eql(["(long diff of over 10 characters, diff output suppressed)"])
       end
@@ -546,7 +532,7 @@ shared_examples_for "a diff util" do
 
 end
 
-describe Chef::Util::Diff, uses_diff: true do
+describe Chef::Util::Diff do
   let!(:old_file) { old_tempfile.path }
   let!(:new_file) { new_tempfile.path }