omnibus 3.0.0 → 3.1.0

data/spec/unit/config_spec.rb

@@ -6,7 +6,10 @@ module Omnibus
       expect(described_class).to be_a(Mixlib::Config)
     end
 
-    before { described_class.reset }
+    before do
+      described_class.reset
+      stub_ohai(platform: 'linux')
+    end
 
     shared_examples 'a configurable' do |id, default|
       it "responds to .#{id}" do
@@ -40,5 +43,19 @@ module Omnibus
     include_examples 'a configurable', :solaris_compiler, nil
     include_examples 'a configurable', :append_timestamp, true
     include_examples 'a configurable', :build_retries, 3
+
+    context 'on Windows' do
+      before do
+        stub_ohai(platform: 'windows')
+        stub_const('File::ALT_SEPARATOR', '\\')
+      end
+
+      include_examples 'a configurable', :cache_dir, 'C:\\omnibus-ruby\\cache'
+      include_examples 'a configurable', :install_path_cache_dir, 'C:\\omnibus-ruby\\cache\\install_path'
+      include_examples 'a configurable', :source_dir, 'C:\\omnibus-ruby\\src'
+      include_examples 'a configurable', :build_dir, 'C:\\omnibus-ruby\\build'
+      include_examples 'a configurable', :package_dir, 'C:\\omnibus-ruby\\pkg'
+      include_examples 'a configurable', :package_tmp, 'C:\\omnibus-ruby\\pkg-tmp'
+    end
   end
 end

data/spec/unit/fetchers/git_fetcher_spec.rb

@@ -1,101 +1,76 @@
 require 'spec_helper'
 
-describe Omnibus::GitFetcher do
-  let(:shell_out) do
-    shell_out = double('Mixlib::ShellOut')
-    stub_const('Mixlib::ShellOut', shell_out)
-    shell_out
-  end
-  let(:software) do
-    double('software').tap do |s|
-      s.stub name: 'project',
-             source: { git: 'git@example.com:test/project.git' },
-             version: '0.0.1',
-             project_dir: '/tmp/project'
+module Omnibus
+  describe GitFetcher do
+    let(:software) do
+      double(Software,
+        name: 'project',
+        source: { git: 'git@example.com:test/project.git' },
+        version: '0.0.1',
+        project_dir: '/tmp/project',
+      )
     end
-  end
-
-  def expect_git_clone_and_ls_remote
-    expect_git_clone
-    expect_git_ls_remote
-  end
 
-  def expect_git_clone
-    double('git_clone').tap do |g|
-      expect(shell_out).to receive(:new)
-        .with('git clone git@example.com:test/project.git /tmp/project', live_stream: STDOUT)
-        .ordered
-        .and_return(g)
-      expect(g).to receive(:run_command).ordered
-      expect(g).to receive(:error!).ordered
-    end
-  end
-
-  def expect_git_ls_remote
-    double('git_ls_remote').tap do |g|
-      expect(shell_out).to receive(:new)
-        .with('git ls-remote origin 0.0.1*', live_stream: STDOUT, cwd: '/tmp/project')
-        .ordered
-        .and_return(g)
-      expect(g).to receive(:run_command).ordered
-      expect(g).to receive(:error!).ordered
-      g.stub(stdout: git_ls_remote_out)
-    end
-  end
-
-  describe '#fetch' do
-    context 'when the project is not cloned yet' do
-      before do
-        File.stub(:exist?).with('/tmp/project/.git').and_return(false)
-      end
+    subject { described_class.new(software) }
 
-      context 'when the source repository is accessible' do
-        subject do
-          Omnibus::GitFetcher.new software
+    describe '#fetch' do
+      context 'when the project is cloned' do
+        before do
+          subject.stub(:existing_git_clone?).and_return(true)
+          subject.stub(:fetch_updates)
         end
 
-        context 'when the ref exists' do
-          let(:git_ls_remote_out) do
-            'a2ed66c01f42514bcab77fd628149eccb4ecee28	refs/tags/0.0.1'
+        context 'when the rev matches' do
+          before { subject.stub(:current_rev_matches_target_rev?).and_return(true) }
+
+          it 'does not fetch updates' do
+            expect(subject).to_not receive(:fetch_updates)
+            subject.fetch
           end
+        end
 
-          it 'should clone the Git repository and then check out the commit' do
-            1.times { expect_git_clone_and_ls_remote }
-            double('git_checkout').tap do |g|
-              expect(shell_out).to receive(:new)
-                .with('git checkout a2ed66c01f42514bcab77fd628149eccb4ecee28', live_stream: STDOUT, cwd: '/tmp/project')
-                .ordered
-                .and_return(g)
-              expect(g).to receive(:run_command).ordered
-              expect(g).to receive(:error!).ordered
-            end
+        context 'when the rev does not match' do
+          before { subject.stub(:current_rev_matches_target_rev?).and_return(false) }
 
-            expect { subject.fetch }.to_not raise_error
+          it 'fetches the updates' do
+            expect(subject).to receive(:fetch_updates).once
+            subject.fetch
           end
         end
+      end
+
+      context 'when the project is not cloned' do
+        before do
+          subject.stub(:existing_git_clone?).and_return(false)
+          subject.stub(:clone)
+          subject.stub(:checkout)
+        end
 
-        context 'when the ref does not exist' do
-          let(:git_ls_remote_out) { '' }
-          let(:error_reporter) { double('ErrorReporter', explain: nil) }
+        it 'clones the project' do
+          expect(subject).to receive(:clone).once
+          subject.fetch
+        end
 
-          before { Omnibus::Fetcher::ErrorReporter.stub(:new).and_return(error_reporter) }
+        it 'checkouts the ref' do
+          expect(subject).to receive(:checkout).once
+          subject.fetch
+        end
+      end
 
-          it 'should clone the Git repository and then fail while retrying 3 times' do
-            expect(error_reporter).to receive(:explain)
-              .with(%(Failed to fetch git repository 'git@example.com:test/project.git'))
+      context 'when something fails' do
+        let(:error_reporter) { double(Fetcher::ErrorReporter, explain: nil) }
 
-            4.times do
-              expect_git_clone
-            end
+        before do
+          subject.stub(:existing_git_clone?).and_return(false)
+          subject.stub(:clone).and_raise(RuntimeError)
 
-            expect_git_ls_remote
+          Fetcher::ErrorReporter.stub(:new).and_return(error_reporter)
+        end
 
-            expect(subject).to receive(:log).with(/git ls\-remote failed/).at_least(1).times
-            expect(subject).to receive(:log).with(/git clone\/fetch failed/).at_least(1).times
-            # Prevent sleeping to run the spec fast
-            subject.stub(:sleep)
-            expect { subject.fetch }.to raise_error(Omnibus::UnresolvableGitReference)
-          end
+        it 'retries 4 times' do
+          subject.stub(:sleep)
+          expect(subject).to receive(:clone).exactly(4).times
+          expect { subject.fetch }.to raise_error(RuntimeError)
         end
       end
     end

data/spec/unit/fetchers/net_fetcher_spec.rb

@@ -49,27 +49,17 @@ describe Omnibus::NetFetcher do
                          source_dir: '/tmp/out',
                          project_dir: '/tmp/project'
       @net_fetcher = Omnibus::NetFetcher.new(software_mock)
-      env_vars = %w(HTTP_PROXY HTTP_PROXY_USER HTTP_PROXY_PASS http_proxy http_proxy_user http_proxy_pass)
-      @orig_env = env_vars.reduce({}) do |h, var|
-        h[var] = ENV.delete(var)
-        h
-      end
-    end
-
-    after(:each) do
-      # restore ENV hash
-      @orig_env.each { |var, val| ENV[var] = val }
     end
 
     describe 'get_env handles upper and lower case env vars' do
       it 'lower via upper' do
-        ENV['lower'] = 'abc'
+        stub_env('lower', 'abc')
         expect(@net_fetcher.get_env('LOWER')).to eq('abc')
         expect(@net_fetcher.get_env('lower')).to eq('abc')
       end
 
       it 'upper via lower' do
-        ENV['UPPER'] = 'abc'
+        stub_env('UPPER', 'abc')
         expect(@net_fetcher.get_env('upper')).to eq('abc')
         expect(@net_fetcher.get_env('UPPER')).to eq('abc')
       end
@@ -80,26 +70,26 @@ describe Omnibus::NetFetcher do
     end
 
     it 'should return a URI object when HTTP_PROXY is set' do
-      ENV['HTTP_PROXY'] = 'http://my.proxy'
+      stub_env('HTTP_PROXY', 'http://my.proxy')
       expect(@net_fetcher.http_proxy).to eq(URI.parse('http://my.proxy'))
     end
 
     it 'sets user and pass from env when set' do
-      ENV['HTTP_PROXY'] = 'my.proxy'
-      ENV['HTTP_PROXY_USER'] = 'alex'
-      ENV['HTTP_PROXY_PASS'] = 'sesame'
+      stub_env('HTTP_PROXY', 'my.proxy')
+      stub_env('HTTP_PROXY_USER', 'alex')
+      stub_env('HTTP_PROXY_PASS', 'sesame')
       expect(@net_fetcher.http_proxy).to eq(URI.parse('http://alex:sesame@my.proxy'))
     end
 
     it 'uses user and pass in URL before those in env' do
-      ENV['HTTP_PROXY'] = 'sally:peanut@my.proxy'
-      ENV['HTTP_PROXY_USER'] = 'alex'
-      ENV['HTTP_PROXY_PASS'] = 'sesame'
+      stub_env('HTTP_PROXY', 'sally:peanut@my.proxy')
+      stub_env('HTTP_PROXY_USER', 'alex')
+      stub_env('HTTP_PROXY_PASS', 'sesame')
       expect(@net_fetcher.http_proxy).to eq(URI.parse('http://sally:peanut@my.proxy'))
     end
 
     it "proxies if host doesn't match exclude list" do
-      ENV['NO_PROXY'] = 'google.com,www.buz.org'
+      stub_env('NO_PROXY', 'google.com,www.buz.org')
       a_url = URI.parse('http://should.proxy.com/123')
       expect(@net_fetcher.excluded_from_proxy?(a_url.host)).to be_false
 
@@ -108,7 +98,7 @@ describe Omnibus::NetFetcher do
     end
 
     it 'does not proxy if host matches exclude list' do
-      ENV['NO_PROXY'] = 'google.com,www.buz.org'
+      stub_env('NO_PROXY', 'google.com,www.buz.org')
       a_url = URI.parse('http://google.com/hello')
       expect(@net_fetcher.excluded_from_proxy?(a_url.host)).to be_true
 

data/spec/unit/install_path_cache_spec.rb

@@ -1,175 +1,203 @@
 require 'spec_helper'
-require 'omnibus/util'
-require 'omnibus/install_path_cache'
-
-describe Omnibus::InstallPathCache do
-  let(:install_path) { '/opt/chef' }
-
-  let(:project) do
-    raw_project = <<-EOH
-name "demo"
-install_path "/opt/demo"
-build_version "1.0.0"
-maintainer 'Chef Software, Inc'
-homepage 'http://getchef.com'
-dependency 'preparation'
-dependency 'snoopy'
-dependency 'zlib'
-EOH
-    project = Omnibus::Project.new(raw_project, 'demo.rb')
-    project
-  end
-
-  let(:fake_software_config_file) do
-    File.join(Omnibus::RSpec::SPEC_DATA, 'software', 'zlib.rb')
-  end
 
-  let(:zlib) do
-    software = Omnibus::Software.new('', fake_software_config_file, project)
-    software.name('zlib')
-    software.default_version('1.7.2')
-    software
-  end
+module Omnibus
+  describe InstallPathCache do
+    before do
+      # Stub to prevent a real Ohai run for faster specs
+      Ohai.stub(:platform).and_return('linux')
+    end
 
-  let(:snoopy) do
-    software = Omnibus::Software.new('', 'snoopy.rb', project)
-    software.name('snoopy')
-    software.default_version('1.0.0')
-    software
-  end
+    let(:install_path) { '/opt/chef' }
 
-  let(:preparation) do
-    software = Omnibus::Software.new('', 'preparation.rb', project)
-    software.name('preparation')
-    software.default_version('1.0.0')
-    software
-  end
+    let(:project) do
+      raw_project = <<-EOH
+  name "demo"
+  install_path "/opt/demo"
+  build_version "1.0.0"
+  maintainer 'Chef Software, Inc'
+  homepage 'http://getchef.com'
+  dependency 'preparation'
+  dependency 'snoopy'
+  dependency 'zlib'
+  EOH
+      project = Omnibus::Project.new(raw_project, 'demo.rb')
+      project
+    end
 
-  let(:cache_path) { "/var/cache/omnibus/cache/install_path#{install_path}" }
+    let(:fake_software_config_file) do
+      File.join(Omnibus::RSpec::SPEC_DATA, 'software', 'zlib.rb')
+    end
 
-  let(:ipc) do
-    project.library.component_added(preparation)
-    project.library.component_added(snoopy)
-    project.library.component_added(zlib)
-    Omnibus::InstallPathCache.new(install_path, zlib)
-  end
+    let(:zlib) do
+      software = Omnibus::Software.new('', fake_software_config_file, project)
+      software.name('zlib')
+      software.default_version('1.7.2')
+      software
+    end
 
-  describe '#cache_path' do
-    it 'returns the install path appended to the install_cache path' do
-      expect(ipc.cache_path).to eq('/var/cache/omnibus/cache/install_path/opt/chef')
+    let(:snoopy) do
+      software = Omnibus::Software.new('', 'snoopy.rb', project)
+      software.name('snoopy')
+      software.default_version('1.0.0')
+      software
     end
-  end
 
-  describe '#cache_path_exists?' do
-    it 'checks for existence' do
-      expect(File).to receive(:directory?).with(ipc.cache_path)
-      ipc.cache_path_exists?
+    let(:preparation) do
+      software = Omnibus::Software.new('', 'preparation.rb', project)
+      software.name('preparation')
+      software.default_version('1.0.0')
+      software
     end
-  end
 
-  describe '#tag' do
-    # 13b3f7f2653e40b9d5b393659210775ac5b56f7e0009f82f85b83f5132409362
-    #
-    # Is the sha256sum of:
-    # cat spec/data/software/zlib.rb > t
-    # echo -n 'preparation-1.0.0-snoopy-1.0.0' >> t
-    # sha256sum t
-    it 'returns a tag with the softwares name, version, and hash of deps name+version' do
-      expect(ipc.tag).to eql('zlib-1.7.2-13b3f7f2653e40b9d5b393659210775ac5b56f7e0009f82f85b83f5132409362')
+    let(:cache_path) { "/var/cache/omnibus/cache/install_path#{install_path}" }
+
+    let(:ipc) do
+      project.library.component_added(preparation)
+      project.library.component_added(snoopy)
+      project.library.component_added(zlib)
+      Omnibus::InstallPathCache.new(install_path, zlib)
     end
 
-    describe 'with no deps' do
-      let(:ipc) do
-        Omnibus::InstallPathCache.new(install_path, zlib)
+    describe '#cache_path' do
+      it 'returns the install path appended to the install_cache path' do
+        expect(ipc.cache_path).to eq('/var/cache/omnibus/cache/install_path/opt/chef')
       end
+    end
 
-      it 'uses the shasum of the software config file' do
-        # gsha256sum spec/data/software/zlib.rb
-        # 363e6cc2475fcdd6e18b2dc10f6022d1cab498b9961e8225d8a309d18ed3c94b  spec/data/software/zlib.rb
-        expect(ipc.tag).to eql('zlib-1.7.2-363e6cc2475fcdd6e18b2dc10f6022d1cab498b9961e8225d8a309d18ed3c94b')
+    describe '#cache_path_exists?' do
+      it 'checks for existence' do
+        expect(File).to receive(:directory?).with(ipc.cache_path)
+        ipc.cache_path_exists?
       end
     end
-  end
 
-  describe '#create_cache_path' do
-    it 'runs git init if the cache path does not exist' do
-      allow(File).to receive(:directory?).with(ipc.cache_path).and_return(false)
-      allow(File).to receive(:directory?).with(File.dirname(ipc.cache_path)).and_return(false)
-      expect(FileUtils).to receive(:mkdir_p).with(File.dirname(ipc.cache_path))
-      expect(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} init -q")
-      ipc.create_cache_path
-    end
+    describe '#tag' do
+      # 13b3f7f2653e40b9d5b393659210775ac5b56f7e0009f82f85b83f5132409362
+      #
+      # Is the sha256sum of:
+      # cat spec/data/software/zlib.rb > t
+      # echo -n 'preparation-1.0.0-snoopy-1.0.0' >> t
+      # sha256sum t
+      it 'returns a tag with the softwares name, version, and hash of deps name+version' do
+        expect(ipc.tag).to eql('zlib-1.7.2-13b3f7f2653e40b9d5b393659210775ac5b56f7e0009f82f85b83f5132409362')
+      end
 
-    it 'does not run git init if the cache path exists' do
-      allow(File).to receive(:directory?).with(ipc.cache_path).and_return(true)
-      allow(File).to receive(:directory?).with(File.dirname(ipc.cache_path)).and_return(true)
-      expect(ipc).to_not receive(:shellout!).with("git --git-dir=#{cache_path} init -q")
-      ipc.create_cache_path
-    end
-  end
+      describe 'with no deps' do
+        let(:ipc) do
+          Omnibus::InstallPathCache.new(install_path, zlib)
+        end
 
-  describe '#incremental' do
-    before(:each) do
-      allow(ipc).to receive(:shellout!)
-      allow(ipc).to receive(:create_cache_path)
+        it 'uses the shasum of the software config file' do
+          # gsha256sum spec/data/software/zlib.rb
+          # 363e6cc2475fcdd6e18b2dc10f6022d1cab498b9961e8225d8a309d18ed3c94b  spec/data/software/zlib.rb
+          expect(ipc.tag).to eql('zlib-1.7.2-363e6cc2475fcdd6e18b2dc10f6022d1cab498b9961e8225d8a309d18ed3c94b')
+        end
+      end
     end
 
-    it 'creates the cache path' do
-      expect(ipc).to receive(:create_cache_path)
-      ipc.incremental
-    end
+    describe '#create_cache_path' do
+      it 'runs git init if the cache path does not exist' do
+        allow(File).to receive(:directory?)
+          .with(ipc.cache_path)
+          .and_return(false)
+        allow(File).to receive(:directory?)
+          .with(File.dirname(ipc.cache_path))
+          .and_return(false)
+        expect(FileUtils).to receive(:mkdir_p)
+          .with(File.dirname(ipc.cache_path))
+        expect(ipc).to receive(:quiet_shellout!)
+          .with("git --git-dir=#{cache_path} init -q")
+        ipc.create_cache_path
+      end
 
-    it 'adds all the changes to git' do
-      expect(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} add -A -f")
-      ipc.incremental
+      it 'does not run git init if the cache path exists' do
+        allow(File).to receive(:directory?)
+          .with(ipc.cache_path)
+          .and_return(true)
+        allow(File).to receive(:directory?)
+          .with(File.dirname(ipc.cache_path))
+          .and_return(true)
+        expect(ipc).to_not receive(:quiet_shellout!)
+          .with("git --git-dir=#{cache_path} init -q")
+        ipc.create_cache_path
+      end
     end
 
-    it 'commits the backup for the software' do
-      expect(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} commit -q -m 'Backup of #{ipc.tag}'")
-      ipc.incremental
-    end
+    describe '#incremental' do
+      before(:each) do
+        allow(ipc).to receive(:quiet_shellout!)
+        allow(ipc).to receive(:create_cache_path)
+      end
 
-    it 'tags the software backup' do
-      expect(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} tag -f '#{ipc.tag}'")
-      ipc.incremental
-    end
-  end
+      it 'creates the cache path' do
+        expect(ipc).to receive(:create_cache_path)
+        ipc.incremental
+      end
 
-  describe '#restore' do
-    let(:git_tag_output) { "#{ipc.tag}\n" }
+      it 'adds all the changes to git' do
+        expect(ipc).to receive(:quiet_shellout!)
+          .with("git --git-dir=#{cache_path} --work-tree=#{install_path} add -A -f")
+        ipc.incremental
+      end
 
-    let(:tag_cmd) do
-      cmd_double = double(Mixlib::ShellOut)
-      allow(cmd_double).to receive(:stdout).and_return(git_tag_output)
-      allow(cmd_double).to receive(:error!).and_return(cmd_double)
-      cmd_double
-    end
+      it 'commits the backup for the software' do
+        expect(ipc).to receive(:quiet_shellout!)
+          .with(%Q(git --git-dir=#{cache_path} --work-tree=#{install_path} commit -q -m "Backup of #{ipc.tag}"))
+        ipc.incremental
+      end
 
-    before(:each) do
-      allow(ipc).to receive(:shellout).with("git --git-dir=#{cache_path} --work-tree=#{install_path} tag -l #{ipc.tag}").and_return(tag_cmd)
-      allow(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} checkout -f '#{ipc.tag}'")
-      allow(ipc).to receive(:create_cache_path)
+      it 'tags the software backup' do
+        expect(ipc).to receive(:quiet_shellout!)
+          .with(%Q(git --git-dir=#{cache_path} --work-tree=#{install_path} tag -f "#{ipc.tag}"))
+        ipc.incremental
+      end
     end
 
-    it 'creates the cache path' do
-      expect(ipc).to receive(:create_cache_path)
-      ipc.restore
-    end
+    describe '#restore' do
+      let(:git_tag_output) { "#{ipc.tag}\n" }
 
-    it 'checks for a tag with the software and version, and if it finds it, checks it out' do
-      expect(ipc).to receive(:shellout).with("git --git-dir=#{cache_path} --work-tree=#{install_path} tag -l #{ipc.tag}").and_return(tag_cmd)
-      expect(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} checkout -f '#{ipc.tag}'")
-      ipc.restore
-    end
+      let(:tag_cmd) do
+        cmd_double = double(Mixlib::ShellOut)
+        allow(cmd_double).to receive(:stdout).and_return(git_tag_output)
+        allow(cmd_double).to receive(:error!).and_return(cmd_double)
+        cmd_double
+      end
+
+      before(:each) do
+        allow(ipc).to receive(:quiet_shellout)
+          .with(%Q(git --git-dir=#{cache_path} --work-tree=#{install_path} tag -l "#{ipc.tag}"))
+          .and_return(tag_cmd)
+        allow(ipc).to receive(:quiet_shellout!)
+          .with(%Q(git --git-dir=#{cache_path} --work-tree=#{install_path} checkout -f "#{ipc.tag}"))
+        allow(ipc).to receive(:create_cache_path)
+      end
 
-    describe 'if the tag does not exist' do
-      let(:git_tag_output) { "\n" }
+      it 'creates the cache path' do
+        expect(ipc).to receive(:create_cache_path)
+        ipc.restore
+      end
 
-      it 'does nothing' do
-        expect(ipc).to receive(:shellout).with("git --git-dir=#{cache_path} --work-tree=#{install_path} tag -l #{ipc.tag}").and_return(tag_cmd)
-        expect(ipc).to_not receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} checkout -f '#{ipc.tag}'")
+      it 'checks for a tag with the software and version, and if it finds it, checks it out' do
+        expect(ipc).to receive(:quiet_shellout)
+          .with(%Q(git --git-dir=#{cache_path} --work-tree=#{install_path} tag -l "#{ipc.tag}"))
+          .and_return(tag_cmd)
+        expect(ipc).to receive(:quiet_shellout!)
+          .with(%Q(git --git-dir=#{cache_path} --work-tree=#{install_path} checkout -f "#{ipc.tag}"))
         ipc.restore
       end
+
+      describe 'if the tag does not exist' do
+        let(:git_tag_output) { "\n" }
+
+        it 'does nothing' do
+          expect(ipc).to receive(:quiet_shellout)
+            .with(%Q(git --git-dir=#{cache_path} --work-tree=#{install_path} tag -l "#{ipc.tag}"))
+            .and_return(tag_cmd)
+          expect(ipc).to_not receive(:quiet_shellout!)
+            .with(%Q(git --git-dir=#{cache_path} --work-tree=#{install_path} checkout -f "#{ipc.tag}"))
+          ipc.restore
+        end
+      end
     end
   end
 end