chef 18.1.29-x64-mingw-ucrt → 18.3.0-x64-mingw-ucrt

data/spec/functional/resource/macos_userdefaults_spec.rb

@@ -38,12 +38,12 @@ describe Chef::Resource::MacosUserDefaults, :macos_only do
       expect(resource.domain).to eq("NSGlobalDomain")
     end
 
-    it "nil for the host property" do
-      expect(resource.host).to be_nil
+    it ":all for the host property" do
+      expect(resource.host).to eq(:all)
     end
 
-    it "nil for the user property" do
-      expect(resource.user).to be_nil
+    it ":current for the user property" do
+      expect(resource.user).to eq(:current)
     end
 
     it ":write for resource action" do

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

data/spec/unit/provider/package/chocolatey_spec.rb

@@ -49,6 +49,10 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
     allow(provider).to receive(:shell_out_compacted!).with(choco_exe, "list", "-l", "-r", { returns: [0, 2], timeout: timeout }).and_return(local_list_obj)
   end
 
+  after(:each) do
+    described_class.instance_variable_set(:@get_choco_version, nil)
+  end
+
   def allow_remote_list(package_names, args = nil)
     remote_list_stdout = <<~EOF
       Chocolatey v0.9.9.11
@@ -61,9 +65,9 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
     remote_list_obj = double(stdout: remote_list_stdout)
     package_names.each do |pkg|
       if args
-        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, "list", "-r", pkg, *args, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
+        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, described_class.query_command, "-r", pkg, *args, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
       else
-        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, "list", "-r", pkg, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
+        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, described_class.query_command, "-r", pkg, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
       end
     end
   end
@@ -78,6 +82,18 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
     end
   end
 
+  describe "choco searches change with the version" do
+    it "Choco V1 uses List" do
+      allow(described_class).to receive(:get_choco_version).and_return("1.4.0")
+      expect(provider.query_command).to eql("list")
+    end
+
+    it "Choco V2 uses Search" do
+      allow(described_class).to receive(:get_choco_version).and_return("2.1.0")
+      expect(provider.query_command).to eql("search")
+    end
+  end
+
   describe "#candidate_version" do
     it "should set the candidate_version to the latest version when not pinning" do
       allow_remote_list(["git"])
@@ -150,7 +166,7 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
       new_resource.package_name("package-does-not-exist")
       new_resource.returns([0])
       allow(provider).to receive(:shell_out_compacted!)
-        .with(choco_exe, "list", "-r", new_resource.package_name.first, { returns: new_resource.returns, timeout: timeout })
+        .with(choco_exe, described_class.query_command, "-r", new_resource.package_name.first, { returns: new_resource.returns, timeout: timeout })
         .and_raise(Mixlib::ShellOut::ShellCommandFailed, "Expected process to exit with [0], but received '2'")
       expect { provider.send(:available_packages) }.to raise_error(Mixlib::ShellOut::ShellCommandFailed, "Expected process to exit with [0], but received '2'")
     end

data/spec/unit/provider/package/rpm_spec.rb

@@ -41,7 +41,7 @@ describe Chef::Provider::Package::Rpm do
   let(:rpm_q_status) { instance_double("Mixlib::ShellOut", exitstatus: rpm_q_exitstatus, stdout: rpm_q_stdout) }
 
   before(:each) do
-    allow(::File).to receive(:exist?).with("PLEASE STUB File.exists? EXACTLY").and_return(true)
+    allow(::File).to receive(:exist?).with("PLEASE STUB File.exist? EXACTLY").and_return(true)
 
     # Ensure all shell out usage is stubbed with exact arguments
     allow(provider).to receive(:shell_out_compacted!).with("PLEASE STUB YOUR SHELLOUT CALLS").and_return(nil)
@@ -412,7 +412,7 @@ describe Chef::Provider::Package::Rpm do
 
     let(:new_resource) do
       # When we pass a source in as the name, then #initialize in the
-      # provider will call File.exists?. Because of the ordering in our
+      # provider will call File.exist?. Because of the ordering in our
       # let() bindings and such, we have to set the stub here and not in a
       # before block.
       allow(::File).to receive(:exist?).with(package_source).and_return(true)

data/spec/unit/provider/package/zypper_spec.rb

@@ -491,4 +491,14 @@ describe Chef::Provider::Package::Zypper do
       provider.remove_package(%w{emacs vim}, ["1.0", "2.0"])
     end
   end
+
+  describe "resolve_available_version" do
+    it "should return correct version if multiple packages are shown" do
+      status = double(stdout: "S  | Name                     | Type    | Version             | Arch   | Repository\n---+--------------------------+---------+---------------------+--------+-------------------------------------------------------------\n   | apache2-mod_wsgi         | package | 4.7.1-150400.3.3.1  | x86_64 | Update repository with updates from SUSE Linux Enterprise 15\n   | apache2-mod_wsgi         | package | 4.7.1-150400.1.52   | x86_64 | Main Repository\ni+ | apache2-mod_wsgi-python3 | package | 4.5.18-150000.4.6.1 | x86_64 | Update repository with updates from SUSE Linux Enterprise 15\nv  | apache2-mod_wsgi-python3 | package | 4.5.18-4.3.1        | x86_64 | Main Repository\n", exitstatus: 0)
+
+      allow(provider).to receive(:shell_out_compacted!).and_return(status)
+      result = provider.send(:resolve_available_version, "apache2-mod_wsgi-python3", nil)
+      expect(result).to eq("4.5.18-150000.4.6.1")
+    end
+  end
 end

data/spec/unit/provider/remote_file/http_spec.rb

@@ -251,7 +251,7 @@ describe Chef::Provider::RemoteFile::HTTP do
       end
 
       context "and the response has no Date or Last-Modified header" do
-        let(:last_response) { { "date" => nil, "last_modified" => nil } }
+        let(:last_response) { { "date" => nil, "last-modified" => nil } }
         it "does not set an mtime in the result" do
           # RFC 2616 suggests that servers that do not set a Date header do not
           # have a reliable clock, so no use in making them deal with dates.
@@ -265,19 +265,19 @@ describe Chef::Provider::RemoteFile::HTTP do
       context "and the response has a Last-Modified header" do
         let(:last_response) do
           # Last-Modified should be preferred to Date if both are set
-          { "date" => "Fri, 17 May 2013 23:23:23 GMT", "last_modified" => "Fri, 17 May 2013 11:11:11 GMT" }
+          { "date" => "Fri, 17 May 2013 23:23:23 GMT", "last-modified" => "Fri, 17 May 2013 11:11:11 GMT" }
         end
 
         it "sets the mtime to the Last-Modified time in the response" do
           fetcher.fetch
           expect(cache_control_data.etag).to be_nil
-          expect(cache_control_data.mtime).to eq(last_response["last_modified"])
+          expect(cache_control_data.mtime).to eq(last_response["last-modified"])
         end
       end
 
       context "and the response has a Date header but no Last-Modified header" do
         let(:last_response) do
-          { "date" => "Fri, 17 May 2013 23:23:23 GMT", "last_modified" => nil }
+          { "date" => "Fri, 17 May 2013 23:23:23 GMT", "last-modified" => nil }
         end
 
         it "sets the mtime to the Date in the response" do

data/spec/unit/resource/apt_repository_spec.rb

@@ -68,6 +68,11 @@ describe Chef::Resource::AptRepository do
     expect(resource.key).to eql(["key1"])
   end
 
+  it "allows setting options to a String and coerces it to an Array" do
+    resource.options = "by-hash=no"
+    expect(resource.options).to eql(["by-hash=no"])
+  end
+
   it "fails if the user provides a repo_name with a forward slash" do
     expect { resource.repo_name "foo/bar" }.to raise_error(ArgumentError)
   end

data/spec/unit/resource/macos_user_defaults_spec.rb

@@ -39,12 +39,12 @@ describe Chef::Resource::MacosUserDefaults, :macos_only do
       expect(resource.domain).to eq("NSGlobalDomain")
     end
 
-    it "nil for the host property" do
-      expect(resource.host).to be_nil
+    it ":all for the host property" do
+      expect(resource.host).to eq(:all)
     end
 
-    it "nil for the user property" do
-      expect(resource.user).to be_nil
+    it ":current for the user property" do
+      expect(resource.user).to eq(:current)
     end
 
     it ":write for resource action" do

data/spec/unit/resource/selinux_login_spec.rb

@@ -0,0 +1,73 @@
+#
+# 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::SelinuxLogin do
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::SelinuxLogin.new("fakey_fakerton", run_context) }
+  let(:provider) { resource.provider_for_action(:manage) }
+
+  it "sets login property as name_property" do
+    expect(resource.login).to eql("fakey_fakerton")
+  end
+
+  it "sets the default action as :manage" do
+    expect(resource.action).to eql([:manage])
+  end
+
+  it "supports :manage, :add, :modify, :delete actions" do
+    expect { resource.action :manage }.not_to raise_error
+    expect { resource.action :add }.not_to raise_error
+    expect { resource.action :modify }.not_to raise_error
+    expect { resource.action :delete }.not_to raise_error
+  end
+
+  describe "#semanage_login_args" do
+    let(:provider) { resource.provider_for_action(:modify) }
+
+    context "when no parameters are provided" do
+      it "returns an empty string" do
+        expect(provider.semanage_login_args).to eq("")
+      end
+    end
+
+    context "when all parameters are provided" do
+      it "returns all params" do
+        resource.user "user_u"
+        resource.range "s0"
+        expect(provider.semanage_login_args).to eq(" -s user_u -r s0")
+      end
+    end
+
+    context "when no user is provided" do
+      it "returns range param" do
+        resource.range "s0"
+        expect(provider.semanage_login_args).to eq(" -r s0")
+      end
+    end
+
+    context "when no range is provided" do
+      it "returns user param" do
+        resource.user "user_u"
+        expect(provider.semanage_login_args).to eq(" -s user_u")
+      end
+    end
+  end
+end