omnibus 3.2.2 → 4.0.0.beta.1

data/spec/unit/digestable_spec.rb

@@ -22,16 +22,16 @@ module Omnibus
       let(:io)      { StringIO.new }
 
       it 'inspects the file types of glob entries' do
-        expect(Dir).to receive(:glob).with(glob).and_return([subdir])
+        expect(FileSyncer).to receive(:glob).with(glob).and_return([subdir])
         expect(File).to receive(:ftype).with(subdir).and_return('directory')
-        expect(subject.digest_directory(path)).to eq('d4635f6b4c2a85ba603e1f9e6a65bd68')
+        expect(subject.digest_directory(path)).to eq('8b91792e7917b1152d8494670caaeb85')
       end
 
       it 'inspects the contents of the files' do
-        expect(Dir).to receive(:glob).with(glob).and_return([subfile])
+        expect(FileSyncer).to receive(:glob).with(glob).and_return([subfile])
         expect(File).to receive(:ftype).with(subfile).and_return('file')
         expect(File).to receive(:open).with(subfile).and_yield(io)
-        expect(subject.digest_directory(path)).to eq('73d045a78027e674811c36f3dbd09433')
+        expect(subject.digest_directory(path)).to eq('c8f023976b95ace2ae3678540fd3b4f1')
       end
     end
   end

data/spec/unit/fetchers/git_fetcher_spec.rb

@@ -2,77 +2,148 @@ require 'spec_helper'
 
 module Omnibus
   describe GitFetcher do
+    let(:source_path) { '/local/path' }
+    let(:project_dir) { '/project/dir' }
+
     let(:software) do
       double(Software,
-        name: 'project',
-        source: { git: 'git@example.com:test/project.git' },
-        version: '0.0.1',
-        project_dir: '/tmp/project',
+        name: 'software',
+        source: { path: source_path },
+        project_dir: project_dir,
       )
     end
 
     subject { described_class.new(software) }
 
-    describe '#fetch' do
-      context 'when the project is cloned' do
-        before do
-          allow(subject).to receive(:existing_git_clone?).and_return(true)
-          allow(subject).to receive(:fetch_updates)
+    describe '#fetch_required?' do
+      context 'when the repository is not cloned' do
+        before { allow(subject).to receive(:cloned?).and_return(false) }
+
+        it 'returns true' do
+          expect(subject.fetch_required?).to be_truthy
         end
+      end
 
-        context 'when the rev matches' do
-          before { allow(subject).to receive(:current_rev_matches_target_rev?).and_return(true) }
+      context 'when the repository is cloned' do
+        before { allow(subject).to receive(:cloned?).and_return(true) }
 
-          it 'does not fetch updates' do
-            expect(subject).to_not receive(:fetch_updates)
-            subject.fetch
+        context 'when the revision is difference' do
+          before { allow(subject).to receive(:same_revision?).and_return(false) }
+
+          it 'returns true' do
+            expect(subject.fetch_required?).to be_truthy
           end
         end
 
-        context 'when the rev does not match' do
-          before { allow(subject).to receive(:current_rev_matches_target_rev?).and_return(false) }
+        context 'when the same revision is checked out'  do
+          before { allow(subject).to receive(:same_revision?).and_return(true) }
 
-          it 'fetches the updates' do
-            expect(subject).to receive(:fetch_updates).once
-            subject.fetch
+          it 'returns false' do
+            expect(subject.fetch_required?).to be(false)
           end
         end
       end
+    end
+
+    describe '#version_guid' do
+      let(:revision) { 'abcd1234' }
+
+      before do
+        allow(subject).to receive(:current_revision).and_return(revision)
+      end
 
-      context 'when the project is not cloned' do
+      it 'returns the revision' do
+        expect(subject.version_guid).to eq("git:#{revision}")
+      end
+    end
+
+    describe '#clean' do
+      before { allow(subject).to receive(:git) }
+
+      context 'when the repository is cloned' do
         before do
-          allow(subject).to receive(:existing_git_clone?).and_return(false)
-          allow(subject).to receive(:clone)
-          allow(subject).to receive(:checkout)
+          allow(subject).to receive(:cloned?).and_return(true)
         end
 
-        it 'clones the project' do
-          expect(subject).to receive(:clone).once
-          subject.fetch
+        it 'gleans the directory' do
+          expect(subject).to receive(:git).with('clean -fdx')
+          subject.clean
         end
 
-        it 'checkouts the ref' do
-          expect(subject).to receive(:checkout).once
-          subject.fetch
+        it 'returns true' do
+          expect(subject.clean).to be_truthy
         end
       end
 
-      context 'when something fails' do
-        let(:error_reporter) { double(Fetcher::ErrorReporter, explain: nil) }
-
+      context 'when the repository is not cloned' do
         before do
-          allow(subject).to receive(:existing_git_clone?).and_return(false)
-          allow(subject).to receive(:clone).and_raise(RuntimeError)
+          allow(subject).to receive(:cloned?).and_return(false)
+        end
 
-          allow(Fetcher::ErrorReporter).to receive(:new).and_return(error_reporter)
+        it 'does not clean the repository' do
+          expect(subject).to_not receive(:git)
+          subject.clean
         end
 
-        it 'retries 4 times' do
-          allow(subject).to receive(:sleep)
-          expect(subject).to receive(:clone).exactly(4).times
-          expect { subject.fetch }.to raise_error(RuntimeError)
+        it 'returns false' do
+          expect(subject.clean).to be(false)
         end
       end
     end
+
+    describe '#fetch' do
+      before do
+        allow(subject).to receive(:create_required_directories)
+        allow(subject).to receive(:git_fetch)
+        allow(subject).to receive(:git_clone)
+        allow(subject).to receive(:git_checkout)
+      end
+
+      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' 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
+        end
+      end
+
+      context 'when the repository is not cloned' do
+        before { allow(subject).to receive(:cloned?).and_return(false) }
+
+        it 'clones the repository' do
+          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}")
+      end
+    end
   end
 end

data/spec/unit/fetchers/net_fetcher_spec.rb

@@ -2,116 +2,226 @@ require 'spec_helper'
 
 module Omnibus
   describe NetFetcher do
-    let(:software_mock) do
+    let(:project_dir) { '/tmp/project' }
+
+    let(:software) do
       double(Software,
-        project_file: 'file.tar.gz',
+        downloaded_file: 'file.tar.gz',
         name: 'file',
-        source: '/tmp/out',
+        source: { url: 'https://get.example.com/file.tar.gz', md5: 'abcd1234' },
         checksum: 'abc123',
         source_uri: 'http://example.com/file.tar.gz',
-        project_dir: '/tmp/project',
+        project_dir: project_dir,
       )
     end
 
+    let(:cache_dir) { '/cache' }
+
     before do
-      Config.source_dir('/tmp/out')
+      Config.cache_dir(cache_dir)
     end
 
-    shared_examples 'an extractor' do |extension, command|
-      context "when the file is a .#{extension}" do
-        before do
-          allow(software_mock).to receive(:project_file).and_return("file.#{extension}")
-          allow(software_mock).to receive(:source_uri).and_return("http://example.com/file.#{extension}")
+    subject { described_class.new(software) }
+
+    describe '#fetch_required?' do
+      context 'when file is not downloaded' do
+        before { allow(File).to receive(:exist?).and_return(false) }
+
+        it 'returns true' do
+          expect(subject.fetch_required?).to be_truthy
         end
+      end
 
-        it 'has the correct extract command' do
-          expect(subject.extract_cmd).to eq(command)
+      context 'when the file is downloaded' do
+        before { allow(File).to receive(:exist?).and_return(true) }
+
+        context 'when the shasums differ' do
+          before do
+            allow(subject).to receive(:digest).and_return('abcd1234')
+            allow(subject).to receive(:checksum).and_return('efgh5678')
+          end
+
+          it 'returns true' do
+            expect(subject.fetch_required?).to be_truthy
+          end
         end
+
+        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')
+          end
+
+          it 'returns true' do
+            expect(subject.fetch_required?).to be(false)
+          end
+        end
+      end
+    end
+
+    describe '#version_guid' do
+      it 'returns the shasum' do
+        expect(subject.version_guid).to eq('md5:abcd1234')
       end
     end
 
-    subject { described_class.new(software_mock) }
+    describe '#clean' do
+      before do
+        allow(FileUtils).to receive(:rm_rf)
+        allow(subject).to receive(:extract)
+      end
+
+      context 'when the project directory exists' do
+        before { allow(File).to receive(:exist?).and_return(true) }
 
-    describe '#extract_cmd' do
-      context 'on Windows' do
-        before { stub_ohai(platform: 'windows', version: '2012') }
-
-        it_behaves_like 'an extractor', '7z',      '7z.exe x file.7z -o/tmp/out -r -y'
-        it_behaves_like 'an extractor', 'zip',     '7z.exe x file.zip -o/tmp/out -r -y'
-        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'
+        it 'extracts the archive' do
+          expect(subject).to receive(:extract)
+          subject.clean
+        end
+
+        it 'returns true' do
+          expect(subject.clean).to be_truthy
+        end
+
+        it 'removes the project directory' do
+          expect(FileUtils).to receive(:rm_rf).with(project_dir)
+          subject.clean
+        end
       end
 
-      context 'on Linux' do
-        before { stub_ohai(platform: 'ubuntu', version: '12.04') }
-
-        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'
+      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)
+          subject.clean
+        end
+
+        it 'returns false' do
+          expect(subject.clean).to be(false)
+        end
       end
     end
 
-    describe '#get_env' do
-      it 'handles upper via lower' do
-        stub_env('lower', 'abc')
-        expect(subject.get_env('LOWER')).to eq('abc')
-        expect(subject.get_env('lower')).to eq('abc')
+    describe '#version_for_cache' do
+      before do
+        allow(software).to receive(:source).and_return({
+          url: 'https://url',
+          md5: 'abcd1234',
+        })
       end
 
-      it 'handles lower via upper' do
-        stub_env('UPPER', 'abc')
-        expect(subject.get_env('upper')).to eq('abc')
-        expect(subject.get_env('UPPER')).to eq('abc')
+      it 'returns the download URL and md5' do
+        expect(subject.version_for_cache).to eq('download_url:https://url|md5:abcd1234')
       end
     end
 
-    describe '#http_proxy' do
-      it 'returns nil when no proxy is set in env' do
-        expect(subject.http_proxy).to be_nil
+    shared_examples 'an extractor' do |extension, command|
+      context "when the file is a .#{extension}" do
+        before do
+          software.source[:url] = "https://example.com/file.#{extension}"
+        end
+
+        it 'is the right command' do
+          expect(subject.send(:extract_command)).to eq(command)
+        end
       end
+    end
 
-      it 'returns a URI object when HTTP_PROXY is set' do
-        stub_env('HTTP_PROXY', 'http://my.proxy')
-        expect(subject.http_proxy).to eq(URI.parse('http://my.proxy'))
+    describe '#extract' do
+      before do
+        described_class.send(:public, :extract)
       end
 
-      it 'sets user and pass from env when set' do
-        stub_env('HTTP_PROXY', 'my.proxy')
-        stub_env('HTTP_PROXY_USER', 'alex')
-        stub_env('HTTP_PROXY_PASS', 'sesame')
-        expect(subject.http_proxy).to eq(URI.parse('http://alex:sesame@my.proxy'))
+      context 'when the downloaded file is a folder' do
+        before do
+          allow(FileUtils).to receive(:cp_r)
+          allow(File).to receive(:directory?).and_return(true)
+          allow(subject).to receive(:extract_command)
+          software.source[:url] = 'https://example.com/folder'
+        end
+
+        it 'copies the entire directory to project_dir' do
+          expect(FileUtils).to receive(:cp_r).with("#{cache_dir}/folder", project_dir)
+          subject.extract
+        end
       end
 
-      it 'uses user and pass in URL before those in env' do
-        stub_env('HTTP_PROXY', 'sally:peanut@my.proxy')
-        stub_env('HTTP_PROXY_USER', 'alex')
-        stub_env('HTTP_PROXY_PASS', 'sesame')
-        expect(subject.http_proxy).to eq(URI.parse('http://sally:peanut@my.proxy'))
+      context 'when the downloaded file is a regular file' do
+        before do
+          allow(FileUtils).to receive(:mkdir_p)
+          allow(FileUtils).to receive(:cp)
+          allow(File).to receive(:directory?).and_return(false)
+          allow(subject).to receive(:extract_command)
+          software.source[:url] = 'https://example.com/file'
+        end
+
+        it 'copies the file into the project_dir' do
+          expect(FileUtils).to receive(:cp).with("#{cache_dir}/file", "#{project_dir}/")
+          subject.extract
+        end
       end
     end
 
-    describe '#excluded_from_proxy?' do
-      it 'proxies if host does not match exclude list' do
-        stub_env('NO_PROXY', 'google.com,www.buz.org')
-        expect(subject.excluded_from_proxy?('should.proxy.com')).to be_falsey
-        expect(subject.excluded_from_proxy?('www.buzz.org')).to be_falsey
+    describe '#extract_command' do
+      before { Config.source_dir('/tmp/out') }
+
+      context 'on Windows' do
+        before do
+          Config.cache_dir('C:')
+          stub_ohai(platform: 'windows', version: '2012')
+        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
 
-      it 'does not proxy if host matches exclude list' do
-        stub_env('NO_PROXY', 'google.com,www.buz.org')
-        expect(subject.excluded_from_proxy?('http://google.com')).to be_truthy
-        expect(subject.excluded_from_proxy?('www.buz.org')).to be_truthy
+      context 'on Linux' do
+        before do
+          Config.cache_dir('/')
+          stub_ohai(platform: 'ubuntu', version: '12.04')
+          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('/')
+
+          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')
+        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