chef 18.2.7 → 18.3.0

data/lib/chef/resource/windows_security_policy.rb

@@ -118,13 +118,13 @@ class Chef
             file.write("[Unicode]\r\nUnicode=yes\r\n[System Access]\r\n#{policy_line}\r\n[Version]\r\nsignature=\"$CHICAGO$\"\r\nRevision=1\r\n")
             file.close
             file_path = file.path.tr("/", "\\")
-            cmd = "C:\\Windows\\System32\\secedit /configure /db C:\\windows\\security\\new.sdb /cfg #{file_path} /areas SECURITYPOLICY"
+            cmd = "C:\\Windows\\System32\\secedit /configure /db C:\\windows\\security\\new.sdb /cfg \"#{file_path}\" /areas SECURITYPOLICY"
           else
             policy_line = "#{security_option} = #{security_value}"
             file.write("[Unicode]\r\nUnicode=yes\r\n[System Access]\r\n#{policy_line}\r\n[Version]\r\nsignature=\"$CHICAGO$\"\r\nRevision=1\r\n")
             file.close
             file_path = file.path.tr("/", "\\")
-            cmd = "C:\\Windows\\System32\\secedit /configure /db C:\\windows\\security\\new.sdb /cfg #{file_path} /areas SECURITYPOLICY"
+            cmd = "C:\\Windows\\System32\\secedit /configure /db C:\\windows\\security\\new.sdb /cfg \"#{file_path}\" /areas SECURITYPOLICY"
           end
           shell_out!(cmd)
           file.unlink

data/lib/chef/resource.rb

@@ -1508,7 +1508,17 @@ class Chef
         dirname = ::File.dirname(partial)
         basename = ::File.basename(partial, ".rb")
         basename = basename[1..] if basename.start_with?("_")
-        class_eval IO.read(::File.expand_path("#{dirname}/_#{basename}.rb", ::File.dirname(caller_locations.first.path)))
+
+        # Support recursive `use`
+        callers = caller_locations
+        used_from = if callers.first.label == "use"
+                      callers.detect { |caller| caller.label == "class_from_file" }.path
+                    else
+                      callers.first.path
+                    end
+
+        fullpath = ::File.expand_path("#{dirname}/_#{basename}.rb", ::File.dirname(used_from))
+        class_eval IO.read(fullpath)
       end
     end
 

data/lib/chef/version.rb

@@ -23,7 +23,7 @@ require_relative "version_string"
 
 class Chef
   CHEF_ROOT = File.expand_path("..", __dir__)
-  VERSION = Chef::VersionString.new("18.2.7")
+  VERSION = Chef::VersionString.new("18.3.0")
 end
 
 #

data/lib/chef/win32/security.rb

@@ -721,7 +721,13 @@ class Chef
         unless LogonUserW(username, domain, password, logon_type, logon_provider, token)
           Chef::ReservedNames::Win32::Error.raise!
         end
-        Token.new(Handle.new(token.read_pointer))
+
+        # originally this was .read_pointer, but that is interpreted as a non-primitive
+        # class (FFI::Pointer) and causes an ArgumentError (Invalid Memory Object) when
+        # compared to GetCurrentProcess(), which returns a HANDLE (void *). Since a
+        # HANDLE is not a pointer to allocated memory that Ruby C extensions can understand,
+        # the Invalid Memory Object error is raised.
+        Token.new(Handle.new(token.read_ulong))
       end
 
       def self.test_and_raise_lsa_nt_status(result)

data/spec/functional/resource/chocolatey_package_spec.rb

@@ -22,8 +22,16 @@ describe Chef::Resource::ChocolateyPackage, :windows_only, :choco_installed do
   include Chef::Mixin::ShellOut
 
   let(:package_name) { "test-A" }
-  let(:package_list) { proc { shell_out!("choco list -lo -r #{Array(package_name).join(" ")}").stdout.chomp } }
   let(:package_source) { File.join(CHEF_SPEC_ASSETS, "chocolatey_feed") }
+  let(:package_list) do
+    if Chef::Provider::Package::Chocolatey.query_command == "list"
+      # using result of query_command because that indicates which "search" command to use
+      # which coincides with the package list output
+      proc { shell_out!("choco search -lo #{Array(package_name).join(" ")}").stdout.chomp }
+    else
+      proc { shell_out!("choco list #{Array(package_name).join(" ")}").stdout.chomp }
+    end
+  end
 
   let(:run_context) do
     Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
@@ -54,12 +62,16 @@ describe Chef::Resource::ChocolateyPackage, :windows_only, :choco_installed do
     ENV["Path"] = ENV.delete("Path")
   end
 
+  after(:each) do
+    described_class.instance_variable_set(:@get_choco_version, nil)
+  end
+
   context "installing a package" do
     after { remove_package }
 
     it "installs the latest version" do
       subject.run_action(:install)
-      expect(package_list.call).to eq("#{package_name}|2.0")
+      expect(package_list.call).to match(/^#{package_name}|2.0.0$/)
     end
 
     it "does not install if already installed" do
@@ -69,19 +81,19 @@ describe Chef::Resource::ChocolateyPackage, :windows_only, :choco_installed do
     end
 
     it "installs version given" do
-      subject.version "1.0"
+      subject.version "1.0.0"
       subject.run_action(:install)
-      expect(package_list.call).to eq("#{package_name}|1.0")
+      expect(package_list.call).to match(/^#{package_name}|1.0.0$/)
     end
 
     it "installs new version if one is already installed" do
-      subject.version "1.0"
+      subject.version "1.0.0"
       subject.run_action(:install)
-      expect(package_list.call).to eq("#{package_name}|1.0")
+      expect(package_list.call).to match(/^#{package_name}|1.0.0$/)
 
-      subject.version "2.0"
+      subject.version "2.0.0"
       subject.run_action(:install)
-      expect(package_list.call).to eq("#{package_name}|2.0")
+      expect(package_list.call).to match(/^#{package_name}|2.0.0$/)
     end
 
     context "installing multiple packages" do
@@ -89,7 +101,7 @@ describe Chef::Resource::ChocolateyPackage, :windows_only, :choco_installed do
 
       it "installs both packages" do
         subject.run_action(:install)
-        expect(package_list.call).to eq("test-A|2.0\r\ntest-B|1.0")
+        expect(package_list.call).to match(/^test-A|2.0.0\r\ntest-B|1.0.0$/)
       end
     end
 
@@ -101,13 +113,13 @@ describe Chef::Resource::ChocolateyPackage, :windows_only, :choco_installed do
     it "installs with an option as a string" do
       subject.options "--force --confirm"
       subject.run_action(:install)
-      expect(package_list.call).to eq("#{package_name}|2.0")
+      expect(package_list.call).to match(/^#{package_name}|2.0.0$/)
     end
 
     it "installs with multiple options as a string" do
       subject.options "--force --confirm"
       subject.run_action(:install)
-      expect(package_list.call).to eq("#{package_name}|2.0")
+      expect(package_list.call).to match(/^#{package_name}|2.0.0$/)
     end
 
     context "when multiple options passed as string" do
@@ -137,7 +149,7 @@ describe Chef::Resource::ChocolateyPackage, :windows_only, :choco_installed do
     it "installs with multiple options as an array" do
       subject.options [ "--force", "--confirm" ]
       subject.run_action(:install)
-      expect(package_list.call).to eq("#{package_name}|2.0")
+      expect(package_list.call).to match(/^#{package_name}|2.0.0$/)
     end
   end
 
@@ -145,24 +157,24 @@ describe Chef::Resource::ChocolateyPackage, :windows_only, :choco_installed do
     after { remove_package }
 
     it "upgrades to a specific version" do
-      subject.version "1.0"
+      subject.version "1.0.0"
       subject.run_action(:install)
-      expect(package_list.call).to eq("#{package_name}|1.0")
+      expect(package_list.call).to match(/^#{package_name}|1.0.0$/)
 
-      subject.version "1.5"
+      subject.version "1.5.0"
       subject.run_action(:upgrade)
-      expect(package_list.call).to eq("#{package_name}|1.5")
+      expect(package_list.call).to match(/^#{package_name}|1.5.0$/)
     end
 
     it "upgrades to the latest version if no version given" do
-      subject.version "1.0"
+      subject.version "1.0.0"
       subject.run_action(:install)
-      expect(package_list.call).to eq("#{package_name}|1.0")
+      expect(package_list.call).to match(/^#{package_name}|1.0.0$/)
 
       subject2 = Chef::Resource::ChocolateyPackage.new("test-A", run_context)
       subject2.source package_source
       subject2.run_action(:upgrade)
-      expect(package_list.call).to eq("#{package_name}|2.0")
+      expect(package_list.call).to match(/^#{package_name}|2.0.0$/)
     end
   end
 
@@ -170,7 +182,7 @@ describe Chef::Resource::ChocolateyPackage, :windows_only, :choco_installed do
     it "removes an installed package" do
       subject.run_action(:install)
       remove_package
-      expect(package_list.call).to eq("")
+      expect(package_list.call).to match(/0 packages installed/)
     end
   end
 

data/spec/functional/resource/execute_spec.rb

@@ -62,7 +62,7 @@ describe Chef::Resource::Execute do
   end
 
   describe "when parent resource sets :cwd" do
-    let(:guard) { %{ruby -e 'exit 1 unless File.exists?("./nested.json")'} }
+    let(:guard) { %{ruby -e 'exit 1 unless File.exist?("./nested.json")'} }
 
     it "guard inherits :cwd from resource and runs" do
       resource.cwd CHEF_SPEC_DATA

data/spec/functional/resource/windows_certificate_spec.rb

@@ -56,6 +56,30 @@ describe Chef::Resource::WindowsCertificate, :windows_only do
   let(:store) { "Chef-Functional-Test" }
   let(:store_name) { "MY" }
   let(:store_location) { "LocalMachine" }
+  let(:test_cert_body) do
+    <<~CERT
+-----BEGIN CERTIFICATE-----
+MIIDQTCCAimgAwIBAgIQX3zqNCJbsKlEvzCz3Z9aNDANBgkqhkiG9w0BAQsFADAh
+MR8wHQYDVQQDDBZ3d3cuZHVtbXljaGVmdGVzdHMuY29tMCAXDTIwMDMwNTEwMjcw
+NVoYDzIxMjAwMzA1MTAzNzA2WjAhMR8wHQYDVQQDDBZ3d3cuZHVtbXljaGVmdGVz
+dHMuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuYKDb6woWIH
+HPPOrcVpgJFVxbkjgk+tsYwbIiqR9jtRaKE6nM/awOgn9/dFF4k8KB8Em0sUx7Vq
+J3YhK2N2cAacgP2Frqqf5znpNBBOg968RoZzGx0EiXFvLsqC4y8ggApWTbMXPRk4
+1a7GlpUpSqI3y5cLeEbzwGQKu8I1I+v7P2fTlnJPHarM7sBbL8bieukkFHYu78iV
+u1wpKOCCfs5DTmJu8WN+z1Mar9vyrWMBlt2wBBgNHPz5mcXUzJHTzaI/D9RGgBgF
+V0IkNqISx/IzR62jjj2g6MgTH4G/0mM6O5sxduM4yGmWZNZpVzh0yMLgH619MZlj
+SMQIN3U/SQIDAQABo3MwcTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYB
+BQUHAwIGCCsGAQUFBwMBMCEGA1UdEQQaMBiCFnd3dy5kdW1teWNoZWZ0ZXN0cy5j
+b20wHQYDVR0OBBYEFHwS3gs03m6RcpR+66u4OqGiZdYnMA0GCSqGSIb3DQEBCwUA
+A4IBAQCFHqMjHUfBZahIsKHQIcFCbC1NFh1ZHlJKZzrRBRwRzX19OttHGMyLpDd6
+tM9Ac6LLR8S4QIWg+HF3IrkN+vfTRDZAccj+tIwBRstmdsEz/rAJ79Vb/00mXZQx
+0FPiBDR3hE7On2oo24DU8kJP3v6TrunwtIomVGqrrkwZzvxqyW+WJMB2shGNFw5J
+mKYBiiXsHl4Bi7V4zhXssrLp877sqpNLeXloXBmAlT39SwQTP9ImZaV5R6udqlvo
+Gfgm5PH/WeK6MV3n5ik0v1rS0LwR2o82WlIB6a4iSEbzY3qSLsWOwt8o5QjAVzCR
+tNdbdS3U8nrG73iA2clmF57ARQWC
+-----END CERTIFICATE-----
+    CERT
+  end
   let(:download_cert_url) { "https://testingchef.blob.core.windows.net/files/test.cer" }
   let(:cert_output_path) { ::File.join(Chef::Config[:file_cache_path], "output.cer") }
   let(:pfx_output_path) { ::File.join(Chef::Config[:file_cache_path], "output.pfx") }
@@ -128,6 +152,7 @@ describe Chef::Resource::WindowsCertificate, :windows_only do
     end
 
     it "can add a certificate from a valid url" do
+      stub_request(:get, download_cert_url).to_return(body: test_cert_body)
       resource.source = download_cert_url
       resource.run_action(:create)
 

data/spec/unit/client_spec.rb

@@ -119,8 +119,8 @@ shared_context "a client run" do
     #   Make sure Client#register thinks the client key doesn't
     #   exist, so it tries to register and create one.
     allow(Chef::HTTP::Authenticator).to receive(:detect_certificate_key).with(fqdn).and_return(false)
-    allow(File).to receive(:exists?).and_call_original
-    expect(File).to receive(:exists?)
+    allow(File).to receive(:exist?).and_call_original
+    expect(File).to receive(:exist?)
       .with(Chef::Config[:client_key])
       .exactly(:once)
       .and_return(api_client_exists?)

data/spec/unit/mixin/homebrew_user_spec.rb

@@ -47,6 +47,8 @@ describe Chef::Mixin::HomebrewUser do
     let(:user) { nil }
     let(:brew_owner) { 2001 }
     let(:default_brew_path) { "/usr/local/bin/brew" }
+    let(:default_brew_path_arm) { "/opt/homebrew/bin/brew" }
+    let(:default_brew_path_linux) { "/home/linuxbrew/.linuxbrew/bin/brew" }
     let(:stat_double) do
       d = double
       expect(d).to receive(:uid).and_return(brew_owner)
@@ -59,16 +61,38 @@ describe Chef::Mixin::HomebrewUser do
         expect(Etc).to receive(:getpwuid).with(brew_owner).and_return(OpenStruct.new(name: "name"))
       end
 
-      it "returns the owner of the brew executable when it is at a default location" do
-        expect(File).to receive(:exist?).with(default_brew_path).and_return(true)
-        expect(File).to receive(:stat).with(default_brew_path).and_return(stat_double)
+      def false_unless_specific_value(object, method, value)
+        allow(object).to receive(method).and_return(false)
+        allow(object).to receive(method).with(value).and_return(true)
+      end
+
+      it "returns the owner of the brew executable when it is at a default location for x86_64 machines" do
+        false_unless_specific_value(File, :exist?, default_brew_path)
+        false_unless_specific_value(File, :executable?, default_brew_path)
+        allow(File).to receive(:stat).with(default_brew_path).and_return(stat_double)
+        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
+      end
+
+      it "returns the owner of the brew executable when it is at a default location for arm machines" do
+        false_unless_specific_value(File, :exist?, default_brew_path_arm)
+        false_unless_specific_value(File, :executable?, default_brew_path_arm)
+        allow(File).to receive(:stat).with(default_brew_path_arm).and_return(stat_double)
+        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
+      end
+
+      it "returns the owner of the brew executable when it is at a default location for linux machines" do
+        false_unless_specific_value(File, :exist?, default_brew_path_linux)
+        false_unless_specific_value(File, :executable?, default_brew_path_linux)
+        allow(File).to receive(:stat).with(default_brew_path_linux).and_return(stat_double)
         expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
       end
 
       it "returns the owner of the brew executable when it is not at a default location" do
-        expect(File).to receive(:exist?).with(default_brew_path).and_return(false)
+        allow_any_instance_of(ExampleHomebrewUser).to receive(:which).and_return("/foo")
+        false_unless_specific_value(File, :exist?, "/foo")
+        false_unless_specific_value(File, :executable?, "/foo")
         allow(homebrew_user).to receive_message_chain(:shell_out, :stdout, :strip).and_return("/foo")
-        expect(File).to receive(:stat).with("/foo").and_return(stat_double)
+        allow(File).to receive(:stat).with("/foo").and_return(stat_double)
         expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
       end
 
@@ -78,8 +102,7 @@ describe Chef::Mixin::HomebrewUser do
   describe "when the homebrew user is not provided" do
 
     it "raises an error if no executable is found" do
-      expect(File).to receive(:exist?).with(default_brew_path).and_return(false)
-      allow(homebrew_user).to receive_message_chain(:shell_out, :stdout, :strip).and_return("")
+      expect(File).to receive(:exist?).and_return(nil).at_least(:once)
       expect { homebrew_user.find_homebrew_uid(user) }.to raise_error(Chef::Exceptions::CannotDetermineHomebrewOwner)
     end
 

data/spec/unit/node/vivid_mash_spec.rb

@@ -364,20 +364,53 @@ describe Chef::Node::AttrArray do
 
   context "#<<" do
     it "converts a Hash appended with #<< to a VividMash" do
+      expect(root).to receive(:reset_cache).with(nil)
       array << { "three" => "four" }
       expect(array[3].class).to eql(Chef::Node::VividMash)
     end
 
     it "deeply converts objects appended with #<<" do
+      expect(root).to receive(:reset_cache).with(nil)
       array << [ { "three" => [ 0, 1] } ]
       expect(array[3].class).to eql(Chef::Node::AttrArray)
       expect(array[3][0].class).to eql(Chef::Node::VividMash)
       expect(array[3][0]["three"].class).to eql(Chef::Node::AttrArray)
     end
+
+    it "does not invalidate root DeepMergeCache if VividMash top-level key" do
+      # We're checking that __path__ is used to avoid full DeepMergeCache invalidation
+      expect(root).to receive(:reset_cache).with("array")
+      expect(root).not_to receive(:reset_cache).with(nil)
+
+      attr_array = Chef::Node::AttrArray.new([ 0, 1, 2 ])
+      vivid = Chef::Node::VividMash.new(
+        { "one" => { "two" => { "three" => "four" } }, "array" => attr_array },
+        root
+      )
+      vivid["array"] << 3
+    end
+
+    it "does not send reset_cache with nil if VividMashi nested key" do
+      # We're checking that __path__ is used to avoid full DeepMergeCache invalidation,
+      # and that it is invalidating the top-level key
+      expect(root).to receive(:reset_cache).with("array")
+      expect(root).not_to receive(:reset_cache).with(nil)
+
+      attr_array = Chef::Node::AttrArray.new([ 0, 1, 2 ])
+      vivid = Chef::Node::VividMash.new(
+        {
+          "one" => { "two" => { "three" => "four" } },
+          "array" => { "nested" => attr_array },
+        },
+        root
+      )
+      vivid["array"]["nested"] << 3
+    end
   end
 
   context "#[]=" do
     it "assigning a Hash into an array converts it to VividMash" do
+      expect(root).to receive(:reset_cache).with(nil)
       array[0] = { "zero" => "zero2" }
       expect(array[0].class).to eql(Chef::Node::VividMash)
     end
@@ -385,6 +418,7 @@ describe Chef::Node::AttrArray do
 
   context "#push" do
     it "pushing a Hash into an array converts it to VividMash" do
+      expect(root).to receive(:reset_cache).with(nil)
       array.push({ "three" => "four" })
       expect(array[3].class).to eql(Chef::Node::VividMash)
     end
@@ -392,6 +426,7 @@ describe Chef::Node::AttrArray do
 
   context "#unshift" do
     it "unshifting a Hash into an array converts it to VividMash" do
+      expect(root).to receive(:reset_cache).with(nil)
       array.unshift({ "zero" => "zero2" })
       expect(array[0].class).to eql(Chef::Node::VividMash)
     end
@@ -399,6 +434,7 @@ describe Chef::Node::AttrArray do
 
   context "#insert" do
     it "inserting a Hash into an array converts it to VividMash" do
+      expect(root).to receive(:reset_cache).with(nil)
       array.insert(1, { "zero" => "zero2" })
       expect(array[1].class).to eql(Chef::Node::VividMash)
     end
@@ -406,6 +442,7 @@ describe Chef::Node::AttrArray do
 
   context "#collect!" do
     it "converts Hashes" do
+      expect(root).to receive(:reset_cache).at_least(:once).with(nil)
       array.collect! { |x| { "zero" => "zero2" } }
       expect(array[1].class).to eql(Chef::Node::VividMash)
     end
@@ -413,6 +450,7 @@ describe Chef::Node::AttrArray do
 
   context "#map!" do
     it "converts Hashes" do
+      expect(root).to receive(:reset_cache).with(nil)
       array.map! { |x| { "zero" => "zero2" } }
       expect(array[1].class).to eql(Chef::Node::VividMash)
     end
@@ -420,6 +458,7 @@ describe Chef::Node::AttrArray do
 
   context "#compact!" do
     it "VividMashes remain VividMashes" do
+      expect(root).to receive(:reset_cache).with(nil)
       array = Chef::Node::AttrArray.new(
         [ nil, { "one" => "two" }, nil ],
         root
@@ -432,6 +471,7 @@ describe Chef::Node::AttrArray do
 
   context "#fill" do
     it "inserts VividMashes for Hashes" do
+      expect(root).to receive(:reset_cache).at_least(:once).with(nil)
       array.fill({ "one" => "two" })
       expect(array[0].class).to eql(Chef::Node::VividMash)
     end
@@ -439,6 +479,7 @@ describe Chef::Node::AttrArray do
 
   context "#flatten!" do
     it "flattens sub-arrays maintaining VividMashes in them" do
+      expect(root).to receive(:reset_cache).with(nil)
       array = Chef::Node::AttrArray.new(
         [ [ { "one" => "two" } ], [ { "one" => "two" } ] ],
         root
@@ -451,6 +492,7 @@ describe Chef::Node::AttrArray do
 
   context "#replace" do
     it "replaces the array converting hashes to mashes" do
+      expect(root).to receive(:reset_cache).with(nil)
       array.replace([ { "foo" => "bar" } ])
       expect(array[0].class).to eql(Chef::Node::VividMash)
     end

data/spec/unit/provider/apt_repository_spec.rb

@@ -246,33 +246,43 @@ C5986B4F1257FFA86632CBA746181433FBB75451
   describe "#build_repo" do
     it "creates a repository string" do
       target = "deb      http://test/uri unstable main\n"
-      expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil)).to eql(target)
+      expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil, [])).to eql(target)
     end
 
     it "creates a repository string with spaces" do
       target = "deb      http://test/uri%20with%20spaces unstable main\n"
-      expect(provider.build_repo("http://test/uri with spaces", "unstable", "main", false, nil)).to eql(target)
+      expect(provider.build_repo("http://test/uri with spaces", "unstable", "main", false, nil, [])).to eql(target)
     end
 
     it "creates a repository string with no distribution" do
       target = "deb      http://test/uri main\n"
-      expect(provider.build_repo("http://test/uri", nil, "main", false, nil)).to eql(target)
+      expect(provider.build_repo("http://test/uri", nil, "main", false, nil, [])).to eql(target)
     end
 
     it "creates a repository string with source" do
       target = "deb      http://test/uri unstable main\ndeb-src  http://test/uri unstable main\n"
-      expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil, true)).to eql(target)
+      expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil, [], true)).to eql(target)
     end
 
-    it "creates a repository string with options" do
+    it "creates a repository string with trusted" do
       target = "deb      [trusted=yes] http://test/uri unstable main\n"
-      expect(provider.build_repo("http://test/uri", "unstable", "main", true, nil)).to eql(target)
+      expect(provider.build_repo("http://test/uri", "unstable", "main", true, nil, [])).to eql(target)
+    end
+
+    it "creates a repository string with custom options" do
+      target = "deb      [by-hash=no] http://test/uri unstable main\n"
+      expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil, ["by-hash=no"])).to eql(target)
+    end
+
+    it "creates a repository string with trusted, arch, and custom options" do
+      target = "deb      [arch=amd64 trusted=yes by-hash=no] http://test/uri unstable main\n"
+      expect(provider.build_repo("http://test/uri", "unstable", "main", true, "amd64", ["by-hash=no"])).to eql(target)
     end
 
     it "handles a ppa repo" do
       target = "deb      http://ppa.launchpad.net/chef/main/ubuntu unstable main\n"
       expect(provider).to receive(:make_ppa_url).with("ppa:chef/main").and_return("http://ppa.launchpad.net/chef/main/ubuntu")
-      expect(provider.build_repo("ppa:chef/main", "unstable", "main", false, nil)).to eql(target)
+      expect(provider.build_repo("ppa:chef/main", "unstable", "main", false, nil, [])).to eql(target)
     end
   end
 end

data/spec/unit/provider/launchd_spec.rb

@@ -197,7 +197,7 @@ describe Chef::Provider::Launchd do
     describe "with an :delete action" do
       describe "and the ld file is present" do
         before(:each) do
-          allow(File).to receive(:exists?).and_return(true)
+          allow(File).to receive(:exist?).and_return(true)
           allow(provider).to receive(
             :manage_service
           ).with(:disable).and_return(true)
@@ -218,7 +218,7 @@ describe Chef::Provider::Launchd do
 
       describe "and the ld file is not present" do
         before(:each) do
-          allow(File).to receive(:exists?).and_return(false)
+          allow(File).to receive(:exist?).and_return(false)
           allow(provider).to receive(
             :manage_plist
           ).with(:delete).and_return(true)

data/spec/unit/provider/mount/aix_spec.rb

@@ -65,8 +65,8 @@ describe Chef::Provider::Mount::Aix do
 
     @provider = Chef::Provider::Mount::Aix.new(@new_resource, @run_context)
 
-    allow(::File).to receive(:exists?).with("/dev/sdz1").and_return true
-    allow(::File).to receive(:exists?).with("/tmp/foo").and_return true
+    allow(::File).to receive(:exist?).with("/dev/sdz1").and_return true
+    allow(::File).to receive(:exist?).with("/tmp/foo").and_return true
   end
 
   def stub_mounted(provider, mounted_output)

data/spec/unit/provider/mount/linux_spec.rb

@@ -22,10 +22,11 @@ describe Chef::Provider::Mount::Linux do
   end
 
   before(:each) do
-    allow(::File).to receive(:exists?).with("/dev/sdz1").and_return true
-    allow(::File).to receive(:exists?).with("/tmp/foo").and_return true
-    allow(::File).to receive(:exists?).with("//192.168.11.102/Share/backup").and_return true
-    allow(::File).to receive(:exists?).with("//192.168.11.102/Share/backup folder").and_return true
+    allow(::File).to receive(:exist?).with("/etc/fstab").and_call_original
+    allow(::File).to receive(:exist?).with("/dev/sdz1").and_return true
+    allow(::File).to receive(:exist?).with("/tmp/foo").and_return true
+    allow(::File).to receive(:exist?).with("//192.168.11.102/Share/backup").and_return true
+    allow(::File).to receive(:exist?).with("//192.168.11.102/Share/backup folder").and_return true
     allow(::File).to receive(:realpath).with("/dev/sdz1").and_return "/dev/sdz1"
     allow(::File).to receive(:realpath).with("/tmp/foo").and_return "/tmp/foo"
   end
@@ -127,4 +128,4 @@ describe Chef::Provider::Mount::Linux do
     end
   end
 
-end
+end

data/spec/unit/provider/mount/mount_spec.rb

@@ -34,8 +34,8 @@ describe Chef::Provider::Mount::Mount do
 
     @provider = Chef::Provider::Mount::Mount.new(@new_resource, @run_context)
 
-    allow(::File).to receive(:exists?).with("/dev/sdz1").and_return true
-    allow(::File).to receive(:exists?).with("/tmp/foo").and_return true
+    allow(::File).to receive(:exist?).with("/dev/sdz1").and_return true
+    allow(::File).to receive(:exist?).with("/tmp/foo").and_return true
     allow(::File).to receive(:realpath).with("/dev/sdz1").and_return "/dev/sdz1"
     allow(::File).to receive(:realpath).with("/tmp/foo").and_return "/tmp/foo"
   end
@@ -83,12 +83,12 @@ describe Chef::Provider::Mount::Mount do
     end
 
     it "should raise an error if the mount device does not exist" do
-      allow(::File).to receive(:exists?).with("/dev/sdz1").and_return false
+      allow(::File).to receive(:exist?).with("/dev/sdz1").and_return false
       expect { @provider.load_current_resource; @provider.mountable? }.to raise_error(Chef::Exceptions::Mount)
     end
 
     it "should not call mountable? with load_current_resource - CHEF-1565" do
-      allow(::File).to receive(:exists?).with("/dev/sdz1").and_return false
+      allow(::File).to receive(:exist?).with("/dev/sdz1").and_return false
       expect(@provider).to receive(:mounted?).and_return(true)
       expect(@provider).to receive(:enabled?).and_return(true)
       expect(@provider).not_to receive(:mountable?)
@@ -100,12 +100,12 @@ describe Chef::Provider::Mount::Mount do
       @new_resource.device_type :uuid
       @new_resource.device "d21afe51-a0fe-4dc6-9152-ac733763ae0a"
       expect(@provider).to receive(:shell_out_compacted).with("/sbin/findfs", "UUID=d21afe51-a0fe-4dc6-9152-ac733763ae0a").and_return(status)
-      expect(::File).to receive(:exists?).with("").and_return(false)
+      expect(::File).to receive(:exist?).with("").and_return(false)
       expect { @provider.load_current_resource; @provider.mountable? }.to raise_error(Chef::Exceptions::Mount)
     end
 
     it "should raise an error if the mount point does not exist" do
-      allow(::File).to receive(:exists?).with("/tmp/foo").and_return false
+      allow(::File).to receive(:exist?).with("/tmp/foo").and_return false
       expect { @provider.load_current_resource; @provider.mountable? }.to raise_error(Chef::Exceptions::Mount)
     end
 
@@ -521,8 +521,8 @@ describe Chef::Provider::Mount::Mount do
 
         @provider = Chef::Provider::Mount::Mount.new(@new_resource, @run_context)
 
-        allow(::File).to receive(:exists?).with("cephserver:6789:/").and_return true
-        allow(::File).to receive(:exists?).with("/tmp/bar").and_return true
+        allow(::File).to receive(:exist?).with("cephserver:6789:/").and_return true
+        allow(::File).to receive(:exist?).with("/tmp/bar").and_return true
         allow(::File).to receive(:realpath).with("cephserver:6789:/").and_return "cephserver:6789:/"
         allow(::File).to receive(:realpath).with("/tmp/bar").and_return "/tmp/foo"
       end