chef 17.4.38-universal-mingw32 → 17.7.22-universal-mingw32

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

@@ -39,7 +39,7 @@ describe Chef::Provider::Package::Windows, :windows_only do
     new_resource
   end
   let(:provider) { Chef::Provider::Package::Windows.new(new_resource, run_context) }
-  let(:cache_path) { 'c:\\cache\\' }
+  let(:cache_path) { "c:\\cache\\" }
 
   before(:each) do
     allow(::File).to receive(:exist?).with(new_resource.source).and_return(true)

data/spec/unit/provider/registry_key_spec.rb

@@ -274,7 +274,7 @@ describe Chef::Provider::RegistryKey do
   end
 
   context "when the key data is safe" do
-    let(:keyname) { 'HKLM\Software\Opscode\Testing\Safe' }
+    let(:keyname) { "HKLM\\Software\\Opscode\\Testing\\Safe" }
     let(:testval1) { { name: "one", type: :string, data: "1" } }
     let(:testval1_wrong_type) { { name: "one", type: :multi_string, data: "1" } }
     let(:testval1_wrong_data) { { name: "one", type: :string, data: "2" } }
@@ -295,7 +295,7 @@ describe Chef::Provider::RegistryKey do
 
   describe "action_create" do
     context "when key exists and type matches" do
-      let(:keyname) { 'hklm\\software\\opscode\\testing\\dword' }
+      let(:keyname) { "hklm\\software\\opscode\\testing\\dword" }
       let(:dword_passed_as_integer) { { name: "one", type: :dword, data: 12345 } }
       let(:testval1) { { name: "one", type: :dword, data: "12345" } }
       before do
@@ -349,7 +349,7 @@ describe Chef::Provider::RegistryKey do
       end
 
       context "and key does not exist" do
-        let(:keyname) { 'hklm\\software\\opscode\\testing\\sensitive\missing' }
+        let(:keyname) { "hklm\\software\\opscode\\testing\\sensitive\\missing" }
         let(:testval1) { { name: "one", type: :string, data: "first_value" } }
 
         before(:each) do
@@ -368,7 +368,7 @@ describe Chef::Provider::RegistryKey do
 
   describe "action_create_if_missing" do
     context "when sensitive is true" do
-      let(:keyname) { 'hklm\\software\\opscode\\testing\\create_if_missing\\sensitive' }
+      let(:keyname) { "hklm\\software\\opscode\\testing\\create_if_missing\\sensitive" }
       let(:testval1) { { name: "one", type: :string, data: "first_value" } }
 
       before(:each) do

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

@@ -321,4 +321,14 @@ describe Chef::Provider::RemoteFile::HTTP do
 
   end
 
+  describe "#http_client_opts" do
+    before do
+      new_resource.http_options({ retries: 2, retry_delay: 3 })
+    end
+
+    it "should set http client options" do
+      expect(fetcher.send(:http_client_opts)).to eq({ retries: 2, retry_delay: 3 })
+    end
+  end
+
 end

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

@@ -33,7 +33,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
 
   # Actual response from Win32::Service.config_info('chef-client')
   let(:chef_service_binary_path_name) do
-    'C:\\opscode\\chef\\embedded\\bin\\ruby.exe C:\\opscode\\chef\\bin\\chef-windows-service'
+    "C:\\opscode\\chef\\embedded\\bin\\ruby.exe C:\\opscode\\chef\\bin\\chef-windows-service"
   end
   let(:chef_service_config_info) do
     double("Struct::ServiceConfigInfo",
@@ -153,11 +153,11 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
           service_type: "share process",
           start_type: "demand start",
           error_control: "normal",
-          binary_path_name: 'C:\\Windows\\system32\\svchost.exe -k LocalServiceNetworkRestricted',
+          binary_path_name: "C:\\Windows\\system32\\svchost.exe -k LocalServiceNetworkRestricted",
           load_order_group: "TDI",
           tag_id: 0,
           dependencies: %w{NSI Tdx Afd},
-          service_start_name: 'NT Authority\\LocalService',
+          service_start_name: "NT Authority\\LocalService",
           display_name: "DHCP Client")
       )
     end
@@ -169,11 +169,11 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
             service_type: "share process",
             start_type: "demand start",
             error_control: "normal",
-            binary_path_name: 'C:\\Windows\\system32\\svchost.exe -k LocalServiceNetworkRestricted',
+            binary_path_name: "C:\\Windows\\system32\\svchost.exe -k LocalServiceNetworkRestricted",
             load_order_group: "TDI",
             tag_id: 0,
             dependencies: %w{NSI Tdx Afd},
-            service_start_name: 'NT Authority\\LocalService',
+            service_start_name: "NT Authority\\LocalService",
             display_name: "DHCP Client")
         )
       end

data/spec/unit/provider/subversion_spec.rb

@@ -190,7 +190,7 @@ describe Chef::Provider::Subversion do
   it "runs an export with the --force option" do
     allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
     expected_cmd = "svn export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, {})
+    expect(@provider).to receive(:shell_out!).with(expected_cmd)
     @provider.run_action(:force_export)
     expect(@resource).to be_updated
   end
@@ -198,7 +198,7 @@ describe Chef::Provider::Subversion do
   it "runs the checkout command for action_checkout" do
     allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
     expected_cmd = "svn checkout -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, {})
+    expect(@provider).to receive(:shell_out!).with(expected_cmd)
     @provider.run_action(:checkout)
     expect(@resource).to be_updated
   end
@@ -248,7 +248,7 @@ describe Chef::Provider::Subversion do
     allow(@provider).to receive(:find_current_revision).and_return("11410")
     allow(@provider).to receive(:current_revision_matches_target_revision?).and_return(false)
     expected_cmd = "svn update -q   -r12345 /my/deploy/dir"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, {})
+    expect(@provider).to receive(:shell_out!).with(expected_cmd)
     @provider.run_action(:sync)
     expect(@resource).to be_updated
   end
@@ -265,7 +265,7 @@ describe Chef::Provider::Subversion do
   it "runs the export_command on action_export" do
     allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
     expected_cmd = "svn export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, {})
+    expect(@provider).to receive(:shell_out!).with(expected_cmd)
     @provider.run_action(:export)
     expect(@resource).to be_updated
   end

data/spec/unit/provider/template_spec.rb

@@ -50,7 +50,7 @@ describe Chef::Provider::Template do
 
   let(:content) do
     content = double("Chef::Provider::File::Content::Template", template_location: "/foo/bar/baz")
-    allow(File).to receive(:exists?).with("/foo/bar/baz").and_return(true)
+    allow(File).to receive(:exist?).with("/foo/bar/baz").and_return(true)
     content
   end
 
@@ -76,7 +76,7 @@ describe Chef::Provider::Template do
     it "stops executing when the local template source can't be found" do
       setup_normal_file
       allow(content).to receive(:template_location).and_return("/baz/bar/foo")
-      allow(File).to receive(:exists?).with("/baz/bar/foo").and_return(false)
+      allow(File).to receive(:exist?).with("/baz/bar/foo").and_return(false)
       expect { provider.run_action(:create) }.to raise_error Chef::Mixin::WhyRun::ResourceRequirements::Assertion::AssertionFailure
     end
 

data/spec/unit/provider/windows_env_spec.rb

@@ -358,7 +358,7 @@ describe "windows_env provider", :windows_only do
   context "when environment is PATH" do
     describe "for PATH" do
       let(:system_root) { "%SystemRoot%" }
-      let(:system_root_value) { 'D:\Windows' }
+      let(:system_root_value) { "D:\\Windows" }
       let(:new_resource) do
         new_resource = Chef::Resource::WindowsEnv.new("PATH", run_context)
         new_resource.value(system_root)

data/spec/unit/provider/zypper_repository_spec.rb

@@ -103,7 +103,7 @@ describe Chef::Provider::ZypperRepository do
 
   describe "#escaped_repo_name" do
     it "returns an escaped repo name" do
-      expect(provider.escaped_repo_name).to eq('Nginx\\ Repository')
+      expect(provider.escaped_repo_name).to eq("Nginx\\ Repository")
     end
   end
 

data/spec/unit/resource/archive_file_spec.rb

@@ -17,19 +17,60 @@
 
 require "spec_helper"
 
-describe Chef::Resource::ArchiveFile do
+begin
+  require "ffi-libarchive"
+rescue LoadError
+  module Archive
+    class Reader
+      def close; end
+      def each_entry; end
+      def extract(entry, flags = 0, destination: nil); end
+    end
+  end
+end
+
+# Exclude this test on platforms where ffi-libarchive loading is broken
+describe Chef::Resource::ArchiveFile, :libarchive_loading_broken do
   let(:node) { Chef::Node.new }
   let(:events) { Chef::EventDispatch::Dispatcher.new }
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::ArchiveFile.new("foo", run_context) }
+  let(:destination) { Dir.mktmpdir }
+  let(:path) { File.expand_path("/tmp/foo.zip") }
+  let(:resource) do
+    r = Chef::Resource::ArchiveFile.new(path, run_context)
+    r.destination = destination
+    r
+  end
   let(:provider) { resource.provider_for_action(:extract) }
+  let(:entry_time) { Time.new(2021, 5, 25, 2, 2, 0, "-05:00") }
+  let(:older_time) { entry_time - 100 }
+  let(:newer_time) { entry_time + 100 }
+
+  let(:archive_reader) { instance_double("Archive::Reader", close: nil) }
+  let(:archive_entry_1) { instance_double("Archive::Entry", pathname: "folder-1/", mtime: entry_time) }
+  let(:archive_entry_2) { instance_double("Archive::Entry", pathname: "folder-1/file-1.txt", mtime: entry_time) }
+  let(:archive_entry_3) { instance_double("Archive::Entry", pathname: "folder-1/folder-2/", mtime: entry_time) }
+  let(:archive_entry_4) { instance_double("Archive::Entry", pathname: "folder-1/folder-2/file-2.txt", mtime: entry_time) }
+
+  let(:archive_reader_with_strip_components_1) { instance_double("Archive::Reader", close: nil) }
+  let(:archive_entry_2_s1) { instance_double("Archive::Entry", pathname: "file-1.txt", mtime: entry_time) }
+  let(:archive_entry_3_s1) { instance_double("Archive::Entry", pathname: "folder-2/", mtime: entry_time) }
+  let(:archive_entry_4_s1) { instance_double("Archive::Entry", pathname: "folder-2/file-2.txt", mtime: entry_time) }
+
+  let(:archive_reader_with_strip_components_2) { instance_double("Archive::Reader", close: nil) }
+  let(:archive_entry_4_s2) { instance_double("Archive::Entry", pathname: "file-2.txt", mtime: entry_time) }
+
+  before do
+    allow(resource).to receive(:provider_for_action).with(:extract).and_return(provider)
+  end
 
   it "has a resource name of :archive_file" do
     expect(resource.resource_name).to eql(:archive_file)
   end
 
   it "has a name property of path" do
-    expect(resource.path).to match(/.*foo$/)
+    r = Chef::Resource::ArchiveFile.new("my-name", run_context)
+    expect(r.path).to match("my-name")
   end
 
   it "sets the default action as :extract" do
@@ -44,6 +85,376 @@ describe Chef::Resource::ArchiveFile do
     expect(resource.mode).to eql("755")
   end
 
+  it "strip_components property defaults to 0" do
+    expect(resource.strip_components).to eql(0)
+  end
+
+  describe "#action_extract" do
+    before do
+      allow(FileUtils).to receive(:mkdir_p)
+      allow(File).to receive(:exist?).and_call_original
+      allow(File).to receive(:exist?).with(path).and_return(true)
+      allow(File).to receive(:exist?).with(destination).and_return(true)
+
+      allow(Archive::Reader).to receive(:open_filename).with(path, nil, strip_components: 0).and_return(archive_reader)
+      allow(archive_reader).to receive(:each_entry)
+        .and_yield(archive_entry_1)
+        .and_yield(archive_entry_2)
+        .and_yield(archive_entry_3)
+        .and_yield(archive_entry_4)
+      allow(archive_reader).to receive(:extract).with(archive_entry_1, any_args)
+      allow(archive_reader).to receive(:extract).with(archive_entry_2, any_args)
+      allow(archive_reader).to receive(:extract).with(archive_entry_3, any_args)
+      allow(archive_reader).to receive(:extract).with(archive_entry_4, any_args)
+
+      allow(Archive::Reader).to receive(:open_filename).with(path, nil, strip_components: 1).and_return(archive_reader_with_strip_components_1)
+      allow(archive_reader_with_strip_components_1).to receive(:each_entry)
+        .and_yield(archive_entry_2_s1)
+        .and_yield(archive_entry_3_s1)
+        .and_yield(archive_entry_4_s1)
+      allow(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_2_s1, any_args)
+      allow(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_3_s1, any_args)
+      allow(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_4_s1, any_args)
+
+      allow(Archive::Reader).to receive(:open_filename).with(path, nil, strip_components: 2).and_return(archive_reader_with_strip_components_2)
+      allow(archive_reader_with_strip_components_2).to receive(:each_entry)
+        .and_yield(archive_entry_4_s2)
+      allow(archive_reader_with_strip_components_2).to receive(:extract).with(archive_entry_4_s2, any_args)
+
+      allow(File).to receive(:exist?).with("#{destination}/folder-1").and_return(true)
+      allow(File).to receive(:exist?).with("#{destination}/folder-1/file-1.txt").and_return(true)
+      allow(File).to receive(:exist?).with("#{destination}/folder-1/folder-2").and_return(true)
+      allow(File).to receive(:exist?).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(true)
+
+      allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(entry_time)
+      allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(entry_time)
+      allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(entry_time)
+      allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(entry_time)
+
+      resource.overwrite(true) # Force it to converge
+    end
+
+    context "when destination directory does not exist" do
+      before do
+        allow(File).to receive(:exist?).with(destination).and_return(false)
+      end
+
+      it "creates destination directory" do
+        expect(FileUtils).to receive(:mkdir_p).with(destination, { mode: 493 })
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when destination directory exists" do
+      before do
+        allow(File).to receive(:exist?).with(destination).and_return(true)
+      end
+
+      it "does not create destination directory" do
+        expect(FileUtils).not_to receive(:mkdir_p)
+        resource.run_action(:extract)
+      end
+
+      context "when overwrite is set to false" do
+        before do
+          resource.overwrite(false)
+        end
+
+        context "when files on disk have identical modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(entry_time)
+          end
+
+          it "does not extract archive" do
+            expect(provider).not_to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+
+        context "when files on disk have newer modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(newer_time)
+          end
+
+          it "does not extract archive" do
+            expect(provider).not_to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+
+        context "when files on disk have older modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(older_time)
+          end
+
+          it "does not extract archive" do
+            expect(provider).not_to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+      end
+
+      context "when overwrite is set to true" do
+        before do
+          resource.overwrite(true)
+        end
+
+        context "when files on disk have identical modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(entry_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(entry_time)
+          end
+
+          it "extracts archive" do
+            expect(provider).to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+
+        context "when files on disk have newer modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(newer_time)
+          end
+
+          it "extracts archive" do
+            expect(provider).to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+
+        context "when files on disk have older modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(older_time)
+          end
+
+          it "extracts archive" do
+            expect(provider).to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+      end
+
+      context "when overwrite is set to :auto" do
+        before do
+          resource.overwrite(:auto)
+        end
+
+        context "when strip_components is set to 0" do
+          before do
+            resource.strip_components(0)
+          end
+
+          context "when files on disk have identical modified times than what is in the archive" do
+            before do
+              allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(entry_time)
+              allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(entry_time)
+              allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(entry_time)
+              allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(entry_time)
+            end
+
+            context "when there is at least one missing files on disk" do
+              before do
+                expect(File).to receive(:exist?).with("#{destination}/folder-1").and_return(false)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/file-1.txt").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/folder-2").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(true)
+              end
+
+              it "extracts archive" do
+                expect(provider).to receive(:extract)
+                resource.run_action(:extract)
+              end
+            end
+
+            context "when there are no missing files on disk" do
+              before do
+                expect(File).to receive(:exist?).with("#{destination}/folder-1").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/file-1.txt").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/folder-2").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(true)
+              end
+
+              it "does not extract archive" do
+                expect(provider).not_to receive(:extract)
+                resource.run_action(:extract)
+              end
+            end
+          end
+        end
+
+        context "when strip_components is set to 1" do
+          before do
+            resource.strip_components(1)
+          end
+
+          context "when files on disk have identical modified times than what is in the archive" do
+            before do
+              allow(File).to receive(:mtime).with("#{destination}/file-1.txt").and_return(entry_time)
+              allow(File).to receive(:mtime).with("#{destination}/folder-2").and_return(entry_time)
+              allow(File).to receive(:mtime).with("#{destination}/folder-2/file-2.txt").and_return(entry_time)
+            end
+
+            context "when there is at least one missing files on disk" do
+              before do
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/file-1.txt")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/folder-2")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/folder-2/file-2.txt")
+                expect(File).to receive(:exist?).with("#{destination}/file-1.txt").and_return(false)
+                expect(File).to receive(:exist?).with("#{destination}/folder-2").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-2/file-2.txt").and_return(true)
+              end
+
+              it "extracts archive" do
+                expect(provider).to receive(:extract)
+                resource.run_action(:extract)
+              end
+            end
+
+            context "when there are no missing files on disk" do
+              before do
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/file-1.txt")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/folder-2")
+                expect(File).not_to receive(:exist?).with("#{destination}/folder-1/folder-2/file-2.txt")
+                expect(File).to receive(:exist?).with("#{destination}/file-1.txt").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-2").and_return(true)
+                expect(File).to receive(:exist?).with("#{destination}/folder-2/file-2.txt").and_return(true)
+              end
+
+              it "does not extract archive" do
+                expect(provider).not_to receive(:extract)
+                resource.run_action(:extract)
+              end
+            end
+          end
+        end
+
+        context "when files on disk have newer modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(newer_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(newer_time)
+          end
+
+          it "extracts archive" do
+            expect(provider).to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+
+        context "when files on disk have older modified times than what is in the archive" do
+          before do
+            allow(File).to receive(:mtime).with("#{destination}/folder-1").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/file-1.txt").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2").and_return(older_time)
+            allow(File).to receive(:mtime).with("#{destination}/folder-1/folder-2/file-2.txt").and_return(older_time)
+          end
+
+          it "extracts archive" do
+            expect(provider).to receive(:extract)
+            resource.run_action(:extract)
+          end
+        end
+      end
+    end
+
+    context "when strip_components is set to 0" do
+      before do
+        resource.strip_components(0)
+      end
+
+      it "does not strip any paths" do
+        expect(archive_reader).to receive(:extract).with(archive_entry_1, 4)
+        expect(archive_reader).to receive(:extract).with(archive_entry_2, 4)
+        expect(archive_reader).to receive(:extract).with(archive_entry_3, 4)
+        expect(archive_reader).to receive(:extract).with(archive_entry_4, 4)
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when strip_components is set to 1" do
+      before do
+        resource.strip_components(1)
+      end
+
+      it "strips leading number of paths specified in strip_components" do
+        expect(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_2_s1, 4)
+        expect(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_3_s1, 4)
+        expect(archive_reader_with_strip_components_1).to receive(:extract).with(archive_entry_4_s1, 4)
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when strip_components is set to 2" do
+      before do
+        resource.strip_components(2)
+      end
+
+      it "strips leading number of paths specified in strip_components" do
+        expect(archive_reader_with_strip_components_2).to receive(:extract).with(archive_entry_4_s2, 4)
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when owner property is set" do
+      before { resource.owner "root" }
+
+      it "chowns all archive file/directory paths" do
+        expect(FileUtils).to receive(:chown).with("root", nil, "#{destination}/folder-1/")
+        expect(FileUtils).to receive(:chown).with("root", nil, "#{destination}/folder-1/file-1.txt")
+        expect(FileUtils).to receive(:chown).with("root", nil, "#{destination}/folder-1/folder-2/")
+        expect(FileUtils).to receive(:chown).with("root", nil, "#{destination}/folder-1/folder-2/file-2.txt")
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when group property is set" do
+      before { resource.group "root" }
+
+      it "chowns all archive file/directory paths" do
+        expect(FileUtils).to receive(:chown).with(nil, "root", "#{destination}/folder-1/")
+        expect(FileUtils).to receive(:chown).with(nil, "root", "#{destination}/folder-1/file-1.txt")
+        expect(FileUtils).to receive(:chown).with(nil, "root", "#{destination}/folder-1/folder-2/")
+        expect(FileUtils).to receive(:chown).with(nil, "root", "#{destination}/folder-1/folder-2/file-2.txt")
+        resource.run_action(:extract)
+      end
+    end
+
+    context "when owner and group properties are set" do
+      before do
+        resource.owner "root"
+        resource.group "root"
+      end
+
+      it "chowns all archive file/directory paths" do
+        expect(FileUtils).to receive(:chown).with("root", "root", "#{destination}/folder-1/")
+        expect(FileUtils).to receive(:chown).with("root", "root", "#{destination}/folder-1/file-1.txt")
+        expect(FileUtils).to receive(:chown).with("root", "root", "#{destination}/folder-1/folder-2/")
+        expect(FileUtils).to receive(:chown).with("root", "root", "#{destination}/folder-1/folder-2/file-2.txt")
+        resource.run_action(:extract)
+      end
+    end
+  end
+
   it "mode property throws a deprecation warning if Integers are passed" do
     expect(Chef::Log).to receive(:deprecation)
     resource.mode 755