omnibus 5.4.0 → 5.5.0

data/spec/unit/fetchers/net_fetcher_spec.rb

@@ -1,23 +1,23 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Omnibus
   describe NetFetcher do
-    let(:root_prefix) { '' }
+    let(:root_prefix) { "" }
     let(:project_dir) { "#{root_prefix}/tmp/project" }
     let(:build_dir) { "#{root_prefix}/tmp/build" }
     let(:source) do
-      { url: 'https://get.example.com/file.tar.gz', md5: 'abcd1234' }
+      { url: "https://get.example.com/file.tar.gz", md5: "abcd1234" }
     end
 
     let(:manifest_entry) do
       double(Omnibus::ManifestEntry,
-             name: 'file',
+             name: "file",
              locked_version: "1.2.3",
-             described_version: '1.2.3',
+             described_version: "1.2.3",
              locked_source: source)
     end
 
-    let(:cache_dir) { '/cache' }
+    let(:cache_dir) { "/cache" }
 
     before do
       Config.cache_dir(cache_dir)
@@ -26,35 +26,35 @@ module Omnibus
     subject { described_class.new(manifest_entry, project_dir, build_dir) }
 
     describe '#fetch_required?' do
-      context 'when file is not downloaded' do
+      context "when file is not downloaded" do
         before { allow(File).to receive(:exist?).and_return(false) }
 
-        it 'returns true' do
+        it "returns true" do
           expect(subject.fetch_required?).to be_truthy
         end
       end
 
-      context 'when the file is downloaded' do
+      context "when the file is downloaded" do
         before { allow(File).to receive(:exist?).and_return(true) }
 
-        context 'when the shasums differ' do
+        context "when the shasums differ" do
           before do
-            allow(subject).to receive(:digest).and_return('abcd1234')
-            allow(subject).to receive(:checksum).and_return('efgh5678')
+            allow(subject).to receive(:digest).and_return("abcd1234")
+            allow(subject).to receive(:checksum).and_return("efgh5678")
           end
 
-          it 'returns true' do
+          it "returns true" do
             expect(subject.fetch_required?).to be_truthy
           end
         end
 
-        context 'when the shasums are the same' do
+        context "when the shasums are the same" do
           before do
-            allow(subject).to receive(:digest).and_return('abcd1234')
-            allow(subject).to receive(:checksum).and_return('abcd1234')
+            allow(subject).to receive(:digest).and_return("abcd1234")
+            allow(subject).to receive(:checksum).and_return("abcd1234")
           end
 
-          it 'returns true' do
+          it "returns true" do
             expect(subject.fetch_required?).to be(false)
           end
         end
@@ -62,39 +62,39 @@ module Omnibus
     end
 
     describe '#version_guid' do
-      context 'source with md5' do
-        it 'returns the shasum' do
-          expect(subject.version_guid).to eq('md5:abcd1234')
+      context "source with md5" do
+        it "returns the shasum" do
+          expect(subject.version_guid).to eq("md5:abcd1234")
         end
       end
 
-      context 'source with sha1' do
+      context "source with sha1" do
         let(:source) do
-          { url: 'https://get.example.com/file.tar.gz', sha1: 'abcd1234' }
+          { url: "https://get.example.com/file.tar.gz", sha1: "abcd1234" }
         end
 
-        it 'returns the shasum' do
-          expect(subject.version_guid).to eq('sha1:abcd1234')
+        it "returns the shasum" do
+          expect(subject.version_guid).to eq("sha1:abcd1234")
         end
       end
 
-      context 'source with sha256' do
+      context "source with sha256" do
         let(:source) do
-          { url: 'https://get.example.com/file.tar.gz', sha256: 'abcd1234' }
+          { url: "https://get.example.com/file.tar.gz", sha256: "abcd1234" }
         end
 
-        it 'returns the shasum' do
-          expect(subject.version_guid).to eq('sha256:abcd1234')
+        it "returns the shasum" do
+          expect(subject.version_guid).to eq("sha256:abcd1234")
         end
       end
 
-      context 'source with sha512' do
+      context "source with sha512" do
         let(:source) do
-          { url: 'https://get.example.com/file.tar.gz', sha512: 'abcd1234' }
+          { url: "https://get.example.com/file.tar.gz", sha512: "abcd1234" }
         end
 
-        it 'returns the shasum' do
-          expect(subject.version_guid).to eq('sha512:abcd1234')
+        it "returns the shasum" do
+          expect(subject.version_guid).to eq("sha512:abcd1234")
         end
       end
     end
@@ -106,72 +106,72 @@ module Omnibus
         allow(subject).to receive(:create_required_directories)
       end
 
-      context 'when the project directory exists' do
+      context "when the project directory exists" do
         before { allow(File).to receive(:exist?).and_return(true) }
 
-        it 'deploys the archive' do
+        it "deploys the archive" do
           expect(subject).to receive(:deploy)
           subject.clean
         end
 
-        it 'returns true' do
+        it "returns true" do
           expect(subject.clean).to be_truthy
         end
 
-        it 'removes the project directory' do
+        it "removes the project directory" do
           expect(FileUtils).to receive(:rm_rf).with(project_dir)
           subject.clean
         end
       end
 
-      context 'when the project directory does not exist' do
+      context "when the project directory does not exist" do
         before { allow(File).to receive(:exist?).and_return(false) }
 
-        it 'deploys the archive' do
+        it "deploys the archive" do
           expect(subject).to receive(:deploy)
           subject.clean
         end
 
-        it 'returns false' do
+        it "returns false" do
           expect(subject.clean).to be(false)
         end
       end
     end
 
     describe '#version_for_cache' do
-      context 'source with md5' do
-        it 'returns the download URL and md5' do
-          expect(subject.version_for_cache).to eq('download_url:https://get.example.com/file.tar.gz|md5:abcd1234')
+      context "source with md5" do
+        it "returns the download URL and md5" do
+          expect(subject.version_for_cache).to eq("download_url:https://get.example.com/file.tar.gz|md5:abcd1234")
         end
       end
 
-      context 'source with sha1' do
+      context "source with sha1" do
         let(:source) do
-          { url: 'https://get.example.com/file.tar.gz', sha1: 'abcd1234' }
+          { url: "https://get.example.com/file.tar.gz", sha1: "abcd1234" }
         end
 
-        it 'returns the download URL and sha1' do
-          expect(subject.version_for_cache).to eq('download_url:https://get.example.com/file.tar.gz|sha1:abcd1234')
+        it "returns the download URL and sha1" do
+          expect(subject.version_for_cache).to eq("download_url:https://get.example.com/file.tar.gz|sha1:abcd1234")
         end
       end
 
-      context 'source with sha256' do
+      context "source with sha256" do
         let(:source) do
-          { url: 'https://get.example.com/file.tar.gz', sha256: 'abcd1234' }
+          { url: "https://get.example.com/file.tar.gz", sha256: "abcd1234" }
         end
 
-        it 'returns the download URL and sha256' do
-          expect(subject.version_for_cache).to eq('download_url:https://get.example.com/file.tar.gz|sha256:abcd1234')
+        it "returns the download URL and sha256" do
+          expect(subject.version_for_cache).to eq("download_url:https://get.example.com/file.tar.gz|sha256:abcd1234")
         end
       end
 
-      context 'source with sha512' do
+      context "source with sha512" do
         let(:source) do
-          { url: 'https://get.example.com/file.tar.gz', sha512: 'abcd1234' }
+          { url: "https://get.example.com/file.tar.gz", sha512: "abcd1234" }
         end
 
-        it 'returns the download URL and sha1' do
-          expect(subject.version_for_cache).to eq('download_url:https://get.example.com/file.tar.gz|sha512:abcd1234')
+        it "returns the download URL and sha1" do
+          expect(subject.version_for_cache).to eq("download_url:https://get.example.com/file.tar.gz|sha512:abcd1234")
         end
       end
     end
@@ -183,7 +183,7 @@ module Omnibus
           "Accept-Encoding" => "identity",
           :read_timeout => 60,
           :content_length_proc => an_instance_of(Proc),
-          :progress_proc => an_instance_of(Proc)
+          :progress_proc => an_instance_of(Proc),
         }
       end
 
@@ -206,7 +206,6 @@ module Omnibus
         $stdout = old_stdout
       end
 
-
       before do
         expect(subject).to receive(:open).with(source[:url], expected_open_opts) do |_url, open_uri_opts|
           open_uri_opts[:content_length_proc].call(reported_content_length)
@@ -249,20 +248,20 @@ module Omnibus
 
     end
 
-    shared_examples 'an extractor' do |extension, source_options, commands|
+    shared_examples "an extractor" do |extension, source_options, commands|
       context "when the file is a .#{extension}" do
         let(:manifest_entry) do
           double(Omnibus::ManifestEntry,
-                 name: 'file',
+                 name: "file",
                  locked_version: "1.2.3",
-                 described_version: '1.2.3',
-                 locked_source: { url: "https://get.example.com/file.#{extension}", md5: 'abcd1234' }.merge(source_options)
+                 described_version: "1.2.3",
+                 locked_source: { url: "https://get.example.com/file.#{extension}", md5: "abcd1234" }.merge(source_options)
                 )
         end
 
         subject { described_class.new(manifest_entry, project_dir, build_dir) }
 
-        it 'shells out with the right commands' do
+        it "shells out with the right commands" do
           commands.each do |command|
             if command.is_a?(String)
               expect(subject).to receive(:shellout!).with(command)
@@ -280,13 +279,13 @@ module Omnibus
         described_class.send(:public, :deploy)
       end
 
-      context 'when the downloaded file is a folder' do
+      context "when the downloaded file is a folder" do
         let(:manifest_entry) do
           double(Omnibus::ManifestEntry,
-                 name: 'file',
+                 name: "file",
                  locked_version: "1.2.3",
-                 described_version: '1.2.3',
-                 locked_source: { url: "https://get.example.com/folder", md5: 'abcd1234' })
+                 described_version: "1.2.3",
+                 locked_source: { url: "https://get.example.com/folder", md5: "abcd1234" })
         end
 
         subject { described_class.new(manifest_entry, project_dir, build_dir) }
@@ -295,19 +294,19 @@ module Omnibus
           allow(File).to receive(:directory?).and_return(true)
         end
 
-        it 'copies the entire directory to project_dir' do
+        it "copies the entire directory to project_dir" do
           expect(FileUtils).to receive(:cp_r).with("#{cache_dir}/folder/.", project_dir)
           subject.deploy
         end
       end
 
-      context 'when the downloaded file is a regular file' do
+      context "when the downloaded file is a regular file" do
         let(:manifest_entry) do
           double(Omnibus::ManifestEntry,
-                 name: 'file',
+                 name: "file",
                  locked_version: "1.2.3",
-                 described_version: '1.2.3',
-                 locked_source: { url: "https://get.example.com/file", md5: 'abcd1234' })
+                 described_version: "1.2.3",
+                 locked_source: { url: "https://get.example.com/file", md5: "abcd1234" })
         end
 
         subject { described_class.new(manifest_entry, project_dir, build_dir) }
@@ -316,7 +315,7 @@ module Omnibus
           allow(File).to receive(:directory?).and_return(false)
         end
 
-        it 'copies the file into the project_dir' do
+        it "copies the file into the project_dir" do
           expect(FileUtils).to receive(:cp).with("#{cache_dir}/file", "#{project_dir}")
           subject.deploy
         end
@@ -325,143 +324,143 @@ module Omnibus
 
     describe '#extract' do
 
-      context 'on Windows' do
-        let(:root_prefix) { 'C:' }
+      context "on Windows" do
+        let(:root_prefix) { "C:" }
 
         before do
-          Config.cache_dir('C:/')
-          stub_ohai(platform: 'windows', version: '2012')
-          allow(Dir).to receive(:mktmpdir).and_yield('C:/tmp_dir')
+          Config.cache_dir("C:/")
+          stub_ohai(platform: "windows", version: "2012")
+          allow(Dir).to receive(:mktmpdir).and_yield("C:/tmp_dir")
         end
 
-        context 'when no extract overrides are present' do
-          it_behaves_like 'an extractor', '7z', {},
+        context "when no extract overrides are present" do
+          it_behaves_like "an extractor", "7z", {},
             ['7z.exe x C:\\file.7z -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'zip', {},
+          it_behaves_like "an extractor", "zip", {},
             ['7z.exe x C:\\file.zip -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'tar', {},
-            [['tar.exe xf C:\\file.tar -CC:\\tmp\\project', {returns: [0]}]]
-          it_behaves_like 'an extractor', 'tgz', {},
-            [['tar.exe zxf C:\\file.tgz -CC:\\tmp\\project', {returns: [0]}]]
-          it_behaves_like 'an extractor', 'tar.gz', {},
-            [['tar.exe zxf C:\\file.tar.gz -CC:\\tmp\\project', {returns: [0]}]]
-          it_behaves_like 'an extractor', 'tar.bz2', {},
-            [['tar.exe jxf C:\\file.tar.bz2 -CC:\\tmp\\project', {returns: [0]}]]
-          it_behaves_like 'an extractor', 'txz', {},
-            [['tar.exe Jxf C:\\file.txz -CC:\\tmp\\project', {returns: [0]}]]
-          it_behaves_like 'an extractor', 'tar.xz', {},
-            [['tar.exe Jxf C:\\file.tar.xz -CC:\\tmp\\project', {returns: [0]}]]
-          it_behaves_like 'an extractor', 'tar.lzma', {},
-            [['tar.exe --lzma -xf C:\\file.tar.lzma -CC:\\tmp\\project', {returns: [0]}]]
-        end
-
-        context 'when seven_zip extract strategy is chosen' do
-          it_behaves_like 'an extractor', '7z', { extract: :seven_zip },
+          it_behaves_like "an extractor", "tar", {},
+            [['tar xf C:\\file.tar -CC:\\tmp\\project', { returns: [0] }]]
+          it_behaves_like "an extractor", "tgz", {},
+            [['tar zxf C:\\file.tgz -CC:\\tmp\\project', { returns: [0] }]]
+          it_behaves_like "an extractor", "tar.gz", {},
+            [['tar zxf C:\\file.tar.gz -CC:\\tmp\\project', { returns: [0] }]]
+          it_behaves_like "an extractor", "tar.bz2", {},
+            [['tar jxf C:\\file.tar.bz2 -CC:\\tmp\\project', { returns: [0] }]]
+          it_behaves_like "an extractor", "txz", {},
+            [['tar Jxf C:\\file.txz -CC:\\tmp\\project', { returns: [0] }]]
+          it_behaves_like "an extractor", "tar.xz", {},
+            [['tar Jxf C:\\file.tar.xz -CC:\\tmp\\project', { returns: [0] }]]
+          it_behaves_like "an extractor", "tar.lzma", {},
+            [['tar --lzma -xf C:\\file.tar.lzma -CC:\\tmp\\project', { returns: [0] }]]
+        end
+
+        context "when seven_zip extract strategy is chosen" do
+          it_behaves_like "an extractor", "7z", { extract: :seven_zip },
             ['7z.exe x C:\\file.7z -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'zip', { extract: :seven_zip },
+          it_behaves_like "an extractor", "zip", { extract: :seven_zip },
             ['7z.exe x C:\\file.zip -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'tar', { extract: :seven_zip },
+          it_behaves_like "an extractor", "tar", { extract: :seven_zip },
             ['7z.exe x C:\\file.tar -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'tgz', { extract: :seven_zip },
+          it_behaves_like "an extractor", "tgz", { extract: :seven_zip },
             ['7z.exe x C:\\file.tgz -oC:\\tmp_dir -r -y',
              '7z.exe x C:\\tmp_dir\\file.tar -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'tar.gz', { extract: :seven_zip },
+          it_behaves_like "an extractor", "tar.gz", { extract: :seven_zip },
             ['7z.exe x C:\\file.tar.gz -oC:\\tmp_dir -r -y',
              '7z.exe x C:\\tmp_dir\\file.tar -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'tar.bz2', { extract: :seven_zip },
+          it_behaves_like "an extractor", "tar.bz2", { extract: :seven_zip },
             ['7z.exe x C:\\file.tar.bz2 -oC:\\tmp_dir -r -y',
              '7z.exe x C:\\tmp_dir\\file.tar -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'txz', { extract: :seven_zip },
+          it_behaves_like "an extractor", "txz", { extract: :seven_zip },
             ['7z.exe x C:\\file.txz -oC:\\tmp_dir -r -y',
              '7z.exe x C:\\tmp_dir\\file.tar -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'tar.xz', { extract: :seven_zip },
+          it_behaves_like "an extractor", "tar.xz", { extract: :seven_zip },
             ['7z.exe x C:\\file.tar.xz -oC:\\tmp_dir -r -y',
              '7z.exe x C:\\tmp_dir\\file.tar -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'tar.lzma', { extract: :seven_zip },
+          it_behaves_like "an extractor", "tar.lzma", { extract: :seven_zip },
             ['7z.exe x C:\\file.tar.lzma -oC:\\tmp_dir -r -y',
              '7z.exe x C:\\tmp_dir\\file.tar -oC:\\tmp\\project -r -y']
         end
 
-        context 'when lax_tar extract strategy is chosen' do
-          it_behaves_like 'an extractor', '7z', { extract: :lax_tar },
+        context "when lax_tar extract strategy is chosen" do
+          it_behaves_like "an extractor", "7z", { extract: :lax_tar },
             ['7z.exe x C:\\file.7z -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'zip', { extract: :lax_tar },
+          it_behaves_like "an extractor", "zip", { extract: :lax_tar },
             ['7z.exe x C:\\file.zip -oC:\\tmp\\project -r -y']
-          it_behaves_like 'an extractor', 'tar', { extract: :lax_tar },
-            [['tar.exe xf C:\\file.tar -CC:\\tmp\\project', {returns: [0, 1]}]]
-          it_behaves_like 'an extractor', 'tgz', { extract: :lax_tar },
-            [['tar.exe zxf C:\\file.tgz -CC:\\tmp\\project', {returns: [0, 1]}]]
-          it_behaves_like 'an extractor', 'tar.gz', { extract: :lax_tar },
-            [['tar.exe zxf C:\\file.tar.gz -CC:\\tmp\\project', {returns: [0, 1]}]]
-          it_behaves_like 'an extractor', 'tar.bz2', { extract: :lax_tar },
-            [['tar.exe jxf C:\\file.tar.bz2 -CC:\\tmp\\project', {returns: [0, 1]}]]
-          it_behaves_like 'an extractor', 'txz', { extract: :lax_tar },
-            [['tar.exe Jxf C:\\file.txz -CC:\\tmp\\project', {returns: [0, 1]}]]
-          it_behaves_like 'an extractor', 'tar.xz', { extract: :lax_tar },
-            [['tar.exe Jxf C:\\file.tar.xz -CC:\\tmp\\project', {returns: [0, 1]}]]
-          it_behaves_like 'an extractor', 'tar.lzma', { extract: :lax_tar },
-            [['tar.exe --lzma -xf C:\\file.tar.lzma -CC:\\tmp\\project', {returns: [0, 1]}]]
+          it_behaves_like "an extractor", "tar", { extract: :lax_tar },
+            [['tar xf C:\\file.tar -CC:\\tmp\\project', { returns: [0, 1] }]]
+          it_behaves_like "an extractor", "tgz", { extract: :lax_tar },
+            [['tar zxf C:\\file.tgz -CC:\\tmp\\project', { returns: [0, 1] }]]
+          it_behaves_like "an extractor", "tar.gz", { extract: :lax_tar },
+            [['tar zxf C:\\file.tar.gz -CC:\\tmp\\project', { returns: [0, 1] }]]
+          it_behaves_like "an extractor", "tar.bz2", { extract: :lax_tar },
+            [['tar jxf C:\\file.tar.bz2 -CC:\\tmp\\project', { returns: [0, 1] }]]
+          it_behaves_like "an extractor", "txz", { extract: :lax_tar },
+            [['tar Jxf C:\\file.txz -CC:\\tmp\\project', { returns: [0, 1] }]]
+          it_behaves_like "an extractor", "tar.xz", { extract: :lax_tar },
+            [['tar Jxf C:\\file.tar.xz -CC:\\tmp\\project', { returns: [0, 1] }]]
+          it_behaves_like "an extractor", "tar.lzma", { extract: :lax_tar },
+            [['tar --lzma -xf C:\\file.tar.lzma -CC:\\tmp\\project', { returns: [0, 1] }]]
         end
       end
 
-      context 'on Linux' do
+      context "on Linux" do
         before do
-          Config.cache_dir('/')
-          stub_ohai(platform: 'ubuntu', version: '12.04')
-          stub_const('File::ALT_SEPARATOR', nil)
-        end
-
-        context 'when gtar is not present' do
-          it_behaves_like 'an extractor', '7z', {},
-            ['7z x /file.7z -o/tmp/project -r -y']
-          it_behaves_like 'an extractor', 'zip', {},
-            ['unzip /file.zip -d /tmp/project']
-          it_behaves_like 'an extractor', 'tar', {},
-            ['tar xf /file.tar -C/tmp/project']
-          it_behaves_like 'an extractor', 'tgz', {},
-            ['tar zxf /file.tgz -C/tmp/project']
-          it_behaves_like 'an extractor', 'tar.gz', {},
-            ['tar zxf /file.tar.gz -C/tmp/project']
-          it_behaves_like 'an extractor', 'tar.bz2', {},
-            ['tar jxf /file.tar.bz2 -C/tmp/project']
-          it_behaves_like 'an extractor', 'txz', {},
-            ['tar Jxf /file.txz -C/tmp/project']
-          it_behaves_like 'an extractor', 'tar.xz', {},
-            ['tar Jxf /file.tar.xz -C/tmp/project']
-          it_behaves_like 'an extractor', 'tar.lzma', {},
-            ['tar --lzma -xf /file.tar.lzma -C/tmp/project']
-        end
-
-        context 'when gtar is present' do
+          Config.cache_dir("/")
+          stub_ohai(platform: "ubuntu", version: "12.04")
+          stub_const("File::ALT_SEPARATOR", nil)
+        end
+
+        context "when gtar is not present" do
+          it_behaves_like "an extractor", "7z", {},
+            ["7z x /file.7z -o/tmp/project -r -y"]
+          it_behaves_like "an extractor", "zip", {},
+            ["unzip /file.zip -d /tmp/project"]
+          it_behaves_like "an extractor", "tar", {},
+            ["tar xf /file.tar -C/tmp/project"]
+          it_behaves_like "an extractor", "tgz", {},
+            ["tar zxf /file.tgz -C/tmp/project"]
+          it_behaves_like "an extractor", "tar.gz", {},
+            ["tar zxf /file.tar.gz -C/tmp/project"]
+          it_behaves_like "an extractor", "tar.bz2", {},
+            ["tar jxf /file.tar.bz2 -C/tmp/project"]
+          it_behaves_like "an extractor", "txz", {},
+            ["tar Jxf /file.txz -C/tmp/project"]
+          it_behaves_like "an extractor", "tar.xz", {},
+            ["tar Jxf /file.tar.xz -C/tmp/project"]
+          it_behaves_like "an extractor", "tar.lzma", {},
+            ["tar --lzma -xf /file.tar.lzma -C/tmp/project"]
+        end
+
+        context "when gtar is present" do
           before do
-            Config.cache_dir('/')
+            Config.cache_dir("/")
 
-            stub_ohai(platform: 'ubuntu', version: '12.04')
-            stub_const('File::ALT_SEPARATOR', nil)
+            stub_ohai(platform: "ubuntu", version: "12.04")
+            stub_const("File::ALT_SEPARATOR", nil)
 
             allow(Omnibus).to receive(:which)
-            .with('gtar')
-            .and_return('/path/to/gtar')
+            .with("gtar")
+            .and_return("/path/to/gtar")
           end
 
-          it_behaves_like 'an extractor', '7z', {},
-            ['7z x /file.7z -o/tmp/project -r -y']
-          it_behaves_like 'an extractor', 'zip', {},
-            ['unzip /file.zip -d /tmp/project']
-          it_behaves_like 'an extractor', 'tar', {},
-            ['gtar xf /file.tar -C/tmp/project']
-          it_behaves_like 'an extractor', 'tgz', {},
-            ['gtar zxf /file.tgz -C/tmp/project']
-          it_behaves_like 'an extractor', 'tar.gz', {},
-            ['gtar zxf /file.tar.gz -C/tmp/project']
-          it_behaves_like 'an extractor', 'tar.bz2', {},
-            ['gtar jxf /file.tar.bz2 -C/tmp/project']
-          it_behaves_like 'an extractor', 'txz', {},
-            ['gtar Jxf /file.txz -C/tmp/project']
-          it_behaves_like 'an extractor', 'tar.xz', {},
-            ['gtar Jxf /file.tar.xz -C/tmp/project']
-          it_behaves_like 'an extractor', 'tar.lzma', {},
-            ['gtar --lzma -xf /file.tar.lzma -C/tmp/project']
+          it_behaves_like "an extractor", "7z", {},
+            ["7z x /file.7z -o/tmp/project -r -y"]
+          it_behaves_like "an extractor", "zip", {},
+            ["unzip /file.zip -d /tmp/project"]
+          it_behaves_like "an extractor", "tar", {},
+            ["gtar xf /file.tar -C/tmp/project"]
+          it_behaves_like "an extractor", "tgz", {},
+            ["gtar zxf /file.tgz -C/tmp/project"]
+          it_behaves_like "an extractor", "tar.gz", {},
+            ["gtar zxf /file.tar.gz -C/tmp/project"]
+          it_behaves_like "an extractor", "tar.bz2", {},
+            ["gtar jxf /file.tar.bz2 -C/tmp/project"]
+          it_behaves_like "an extractor", "txz", {},
+            ["gtar Jxf /file.txz -C/tmp/project"]
+          it_behaves_like "an extractor", "tar.xz", {},
+            ["gtar Jxf /file.tar.xz -C/tmp/project"]
+          it_behaves_like "an extractor", "tar.lzma", {},
+            ["gtar --lzma -xf /file.tar.lzma -C/tmp/project"]
         end
 
       end