omnibus 5.0.0 → 5.1.0

data/spec/unit/fetchers/git_fetcher_spec.rb

@@ -29,16 +29,16 @@ module Omnibus
       context 'when the repository is cloned' do
         before { allow(subject).to receive(:cloned?).and_return(true) }
         before { allow(subject).to receive(:resolved_version).and_return('12341235')}
-        context 'when the revision is difference' do
-          before { allow(subject).to receive(:same_revision?).and_return(false) }
+        context 'when the revision is not in the repo' do
+          before { allow(subject).to receive(:contains_revision?).and_return(false) }
 
           it 'returns true' do
             expect(subject.fetch_required?).to be_truthy
           end
         end
 
-        context 'when the same revision is checked out'  do
-          before { allow(subject).to receive(:same_revision?).and_return(true) }
+        context 'when the revision is present in the repo'  do
+          before { allow(subject).to receive(:contains_revision?).and_return(true) }
 
           it 'returns false' do
             expect(subject.fetch_required?).to be(false)
@@ -60,36 +60,23 @@ module Omnibus
     end
 
     describe '#clean' do
-      before { allow(subject).to receive(:git) }
-
-      context 'when the repository is cloned' do
-        before do
-          allow(subject).to receive(:cloned?).and_return(true)
-        end
-
-        it 'cleans the directory' do
-          expect(subject).to receive(:git).with('clean -fdx')
-          subject.clean
-        end
-
-        it 'returns true' do
-          expect(subject.clean).to be_truthy
-        end
+      before do
+        allow(subject).to receive(:git)
+        allow(subject).to receive(:resolved_version).and_return('12341235')
       end
 
-      context 'when the repository is not cloned' do
-        before do
-          allow(subject).to receive(:cloned?).and_return(false)
-        end
+      it 'checks out the working directory at the correct revision' do
+        expect(subject).to receive(:git_checkout)
+        subject.clean
+      end
 
-        it 'does not clean the repository' do
-          expect(subject).to_not receive(:git)
-          subject.clean
-        end
+      it 'cleans the directory' do
+        expect(subject).to receive(:git).with('clean -fdx')
+        subject.clean
+      end
 
-        it 'returns false' do
-          expect(subject.clean).to be(false)
-        end
+      it 'returns true' do
+        expect(subject.clean).to be_truthy
       end
     end
 
@@ -101,22 +88,9 @@ module Omnibus
       context 'when the repository is cloned' do
         before { allow(subject).to receive(:cloned?).and_return(true) }
 
-        context 'when the revision is different' do
-          before { allow(subject).to receive(:same_revision?).and_return(false) }
-
-          it 'fetches and resets to the resolved_version' do
-            expect(subject).to receive(:git_fetch)
-            subject.fetch
-          end
-        end
-
-        context 'when the revision is the same' do
-          before { allow(subject).to receive(:same_revision?).and_return(true) }
-
-          it 'does not fetch or reset' do
-            expect(subject).to_not receive(:git_fetch)
-            subject.fetch
-          end
+        it 'fetches the resolved_version' do
+          expect(subject).to receive(:git_fetch)
+          subject.fetch
         end
       end
 
@@ -125,13 +99,12 @@ module Omnibus
           allow(subject).to receive(:cloned?).and_return(false)
           allow(subject).to receive(:dir_empty?).and_return(true)
           allow(subject).to receive(:git_clone)
-          allow(subject).to receive(:git_checkout)
         end
 
         context 'but a directory does exist' do
           before { expect(subject).to receive(:dir_empty?).with(project_dir).and_return(false)}
 
-          it 'forcefully removes and recreateds the directory' do
+          it 'forcefully removes and recreates the directory' do
             expect(FileUtils).to receive(:rm_rf).with(project_dir).and_return(project_dir)
             expect(Dir).to receive(:mkdir).with(project_dir).and_return(0)
             subject.fetch
@@ -142,21 +115,12 @@ module Omnibus
           expect(subject).to receive(:git_clone).once
           subject.fetch
         end
-
-        it 'checks out the correct revision' do
-          expect(subject).to receive(:git_checkout).once
-          subject.fetch
-        end
       end
     end
 
     describe '#version_for_cache' do
-      let(:revision) { 'abcd1234' }
-
-      before { allow(subject).to receive(:current_revision).and_return(revision) }
-
-      it 'returns the shasum of the project_dir' do
-        expect(subject.version_for_cache).to eq("revision:#{revision}")
+      it 'returns the shasum of the commit that we expect to be at' do
+        expect(subject.version_for_cache).to eq('revision:123abcd1234')
       end
     end
   end

data/spec/unit/fetchers/net_fetcher_spec.rb

@@ -2,8 +2,9 @@ require 'spec_helper'
 
 module Omnibus
   describe NetFetcher do
-    let(:project_dir) { '/tmp/project' }
-    let(:build_dir) { '/tmp/build' }
+    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' }
     end
@@ -101,14 +102,15 @@ module Omnibus
     describe '#clean' do
       before do
         allow(FileUtils).to receive(:rm_rf)
-        allow(subject).to receive(:extract)
+        allow(subject).to receive(:deploy)
+        allow(subject).to receive(:create_required_directories)
       end
 
       context 'when the project directory exists' do
         before { allow(File).to receive(:exist?).and_return(true) }
 
-        it 'extracts the archive' do
-          expect(subject).to receive(:extract)
+        it 'deploys the archive' do
+          expect(subject).to receive(:deploy)
           subject.clean
         end
 
@@ -125,8 +127,8 @@ module Omnibus
       context 'when the project directory does not exist' do
         before { allow(File).to receive(:exist?).and_return(false) }
 
-        it 'extracts the archive' do
-          expect(subject).to receive(:extract)
+        it 'deploys the archive' do
+          expect(subject).to receive(:deploy)
           subject.clean
         end
 
@@ -187,7 +189,7 @@ module Omnibus
 
       let(:tempfile_path) { "/tmp/intermediate_path/tempfile_path.random_garbage.tmp" }
 
-      let(:fetched_file) { instance_double("File", path: tempfile_path) }
+      let(:fetched_file) { instance_double("TempFile", path: tempfile_path) }
 
       let(:destination_path) { "/cache/file.tar.gz" }
 
@@ -212,8 +214,9 @@ module Omnibus
 
           fetched_file
         end
-        expect(FileUtils).to receive(:cp).with(tempfile_path, destination_path)
         expect(fetched_file).to receive(:close)
+        expect(FileUtils).to receive(:cp).with(tempfile_path, destination_path)
+        expect(fetched_file).to receive(:unlink)
       end
 
       it "downloads the thing" do
@@ -246,27 +249,35 @@ module Omnibus
 
     end
 
-    shared_examples 'an extractor' do |extension, command|
+    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',
                  locked_version: "1.2.3",
                  described_version: '1.2.3',
-                 locked_source: { url: "https://get.example.com/file.#{extension}", md5: 'abcd1234' })
+                 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 'is the right command' do
-          expect(subject.send(:extract_command)).to eq(command)
+        it 'shells out with the right commands' do
+          commands.each do |command|
+            if command.is_a?(String)
+              expect(subject).to receive(:shellout!).with(command)
+            else
+              expect(subject).to receive(:shellout!).with(*command)
+            end
+          end
+          subject.send(:extract)
         end
       end
     end
 
-    describe '#extract' do
+    describe '#deploy' do
       before do
-        described_class.send(:public, :extract)
+        described_class.send(:public, :deploy)
       end
 
       context 'when the downloaded file is a folder' do
@@ -281,14 +292,12 @@ module Omnibus
         subject { described_class.new(manifest_entry, project_dir, build_dir) }
 
         before do
-          allow(FileUtils).to receive(:cp_r)
           allow(File).to receive(:directory?).and_return(true)
         end
 
         it 'copies the entire directory to project_dir' do
-          allow(subject).to receive(:extract_command)
-          expect(FileUtils).to receive(:cp_r).with("#{cache_dir}/folder", project_dir)
-          subject.extract
+          expect(FileUtils).to receive(:cp_r).with("#{cache_dir}/folder/.", project_dir)
+          subject.deploy
         end
       end
 
@@ -304,37 +313,95 @@ module Omnibus
         subject { described_class.new(manifest_entry, project_dir, build_dir) }
 
         before do
-          allow(FileUtils).to receive(:mkdir_p)
-          allow(FileUtils).to receive(:cp)
           allow(File).to receive(:directory?).and_return(false)
         end
 
         it 'copies the file into the project_dir' do
-          allow(subject).to receive(:extract_command)
-          expect(FileUtils).to receive(:cp).with("#{cache_dir}/file", "#{project_dir}/")
-          subject.extract
+          expect(FileUtils).to receive(:cp).with("#{cache_dir}/file", "#{project_dir}")
+          subject.deploy
         end
       end
     end
 
-    describe '#extract_command' do
-      before { Config.source_dir('/tmp/out') }
+    describe '#extract' do
 
       context 'on Windows' do
+        let(:root_prefix) { 'C:' }
+
         before do
-          Config.cache_dir('C:')
+          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', {},
+            ['7z.exe x C:\\file.7z -oC:\\tmp\\project -r -y']
+          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 },
+            ['7z.exe x C:\\file.7z -oC:\\tmp\\project -r -y']
+          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 },
+            ['7z.exe x C:\\file.tar -oC:\\tmp\\project -r -y']
+          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 },
+            ['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 },
+            ['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 },
+            ['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 },
+            ['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 },
+            ['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 },
+            ['7z.exe x C:\\file.7z -oC:\\tmp\\project -r -y']
+          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]}]]
         end
-
-        it_behaves_like 'an extractor', '7z',      '7z.exe x C:\\file.7z -o/tmp/out -r -y'
-        it_behaves_like 'an extractor', 'zip',     '7z.exe x C:\\file.zip -o/tmp/out -r -y'
-        it_behaves_like 'an extractor', 'tar',     'tar xf C:\\file.tar -C/tmp/out'
-        it_behaves_like 'an extractor', 'tgz',     'tar zxf C:\\file.tgz -C/tmp/out'
-        it_behaves_like 'an extractor', 'tar.gz',  'tar zxf C:\\file.tar.gz -C/tmp/out'
-        it_behaves_like 'an extractor', 'bz2',     'tar jxf C:\\file.bz2 -C/tmp/out'
-        it_behaves_like 'an extractor', 'tar.bz2', 'tar jxf C:\\file.tar.bz2 -C/tmp/out'
-        it_behaves_like 'an extractor', 'txz',     'tar Jxf C:\\file.txz -C/tmp/out'
-        it_behaves_like 'an extractor', 'tar.xz',  'tar Jxf C:\\file.tar.xz -C/tmp/out'
       end
 
       context 'on Linux' do
@@ -344,38 +411,59 @@ module Omnibus
           stub_const('File::ALT_SEPARATOR', nil)
         end
 
-        it_behaves_like 'an extractor', '7z',      '7z x /file.7z -o/tmp/out -r -y'
-        it_behaves_like 'an extractor', 'zip',     'unzip /file.zip -d /tmp/out'
-        it_behaves_like 'an extractor', 'tar',     'tar xf /file.tar -C/tmp/out'
-        it_behaves_like 'an extractor', 'tgz',     'tar zxf /file.tgz -C/tmp/out'
-        it_behaves_like 'an extractor', 'tar.gz',  'tar zxf /file.tar.gz -C/tmp/out'
-        it_behaves_like 'an extractor', 'bz2',     'tar jxf /file.bz2 -C/tmp/out'
-        it_behaves_like 'an extractor', 'tar.bz2', 'tar jxf /file.tar.bz2 -C/tmp/out'
-        it_behaves_like 'an extractor', 'txz',     'tar Jxf /file.txz -C/tmp/out'
-        it_behaves_like 'an extractor', 'tar.xz',  'tar Jxf /file.tar.xz -C/tmp/out'
-      end
-
-      context 'when gtar is present' do
-        before do
-          Config.cache_dir('/')
+        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('/')
 
-          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)
+            allow(Omnibus).to receive(:which)
             .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']
         end
 
-        it_behaves_like 'an extractor', '7z',      '7z x /file.7z -o/tmp/out -r -y'
-        it_behaves_like 'an extractor', 'zip',     'unzip /file.zip -d /tmp/out'
-        it_behaves_like 'an extractor', 'tar',     'gtar xf /file.tar -C/tmp/out'
-        it_behaves_like 'an extractor', 'tgz',     'gtar zxf /file.tgz -C/tmp/out'
-        it_behaves_like 'an extractor', 'tar.gz',  'gtar zxf /file.tar.gz -C/tmp/out'
-        it_behaves_like 'an extractor', 'bz2',     'gtar jxf /file.bz2 -C/tmp/out'
-        it_behaves_like 'an extractor', 'tar.bz2', 'gtar jxf /file.tar.bz2 -C/tmp/out'
-        it_behaves_like 'an extractor', 'txz',     'gtar Jxf /file.txz -C/tmp/out'
-        it_behaves_like 'an extractor', 'tar.xz',  'gtar Jxf /file.tar.xz -C/tmp/out'
       end
     end
   end

data/spec/unit/fetchers/path_fetcher_spec.rb

@@ -47,39 +47,8 @@ module Omnibus
     end
 
     describe '#clean' do
-      before do
-        allow(FileUtils).to receive(:rm_rf)
-        allow(subject).to receive(:fetch)
-      end
-
-      context 'when the directory exists' do
-        before do
-          allow(File).to receive(:exist?).with(project_dir).and_return(true)
-        end
-
-        it 'removes the directory' do
-          expect(FileUtils).to receive(:rm_rf).with(project_dir).once
-          subject.clean
-        end
-
-        it 'returns true' do
-          expect(subject.clean).to be_truthy
-        end
-      end
-
-      context 'when the directory does not exist' do
-        before do
-          allow(File).to receive(:exist?).with(project_dir).and_return(false)
-        end
-
-        it 'does not remove the directory' do
-          expect(FileUtils).to_not receive(:rm_rf)
-          subject.clean
-        end
-
-        it 'returns false' do
-          expect(subject.clean).to be(false)
-        end
+      it 'returns true' do
+        expect(subject.clean).to be_truthy
       end
     end
 
@@ -100,11 +69,11 @@ module Omnibus
 
       before do
         allow(subject).to receive(:digest_directory)
-          .with(project_dir, :sha256)
+          .with(source_path, :sha256, {})
           .and_return(shasum)
       end
 
-      it 'returns the shasum of the project_dir' do
+      it 'returns the shasum of the source directory' do
         expect(subject.version_for_cache).to eq("path:#{source_path}|shasum:#{shasum}")
       end
     end