omnibus 1.3.0 → 2.0.0.rc1

data/spec/fetchers/git_fetcher_spec.rb

@@ -1,86 +1,94 @@
 require 'spec_helper'
 
 describe Omnibus::GitFetcher do
-  let(:shell_out) {
+  let(:shell_out) do
     shell_out = double('Mixlib::ShellOut')
     stub_const('Mixlib::ShellOut', shell_out)
     shell_out
-  }
-  let(:software) {
-    double('software').tap { |s|
-      s.stub :name => 'project',
-             :source => { :git => 'git@example.com:test/project.git' },
-             :version => '0.0.1',
-             :project_dir => '/tmp/project'
-    }
-  }
+  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'
+    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|
-      shell_out.should_receive(:new)
-        .with('git clone git@example.com:test/project.git /tmp/project', :live_stream => STDOUT)
+      expect(shell_out).to receive(:new)
+        .with('git clone git@example.com:test/project.git /tmp/project', live_stream: STDOUT)
         .ordered
         .and_return(g)
-      g.should_receive(:run_command).ordered
-      g.should_receive(:error!).ordered
+      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|
-      shell_out.should_receive(:new)
-        .with('git ls-remote origin 0.0.1*', :live_stream => STDOUT, :cwd => '/tmp/project')
+      expect(shell_out).to receive(:new)
+        .with('git ls-remote origin 0.0.1*', live_stream: STDOUT, cwd: '/tmp/project')
         .ordered
         .and_return(g)
-      g.should_receive(:run_command).ordered
-      g.should_receive(:error!).ordered
-      g.stub(:stdout => git_ls_remote_out)
+      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 {
+
+  describe '#fetch' do
+    context 'when the project is not cloned yet' do
+      before do
         File.stub(:exist?).with('/tmp/project/.git').and_return(false)
-      }
-      context "when the source repository is accessible" do
-        subject {
+      end
+
+      context 'when the source repository is accessible' do
+        subject do
           Omnibus::GitFetcher.new software
-        }
-        context "when the ref exists" do
-          let(:git_ls_remote_out) {
+        end
+
+        context 'when the ref exists' do
+          let(:git_ls_remote_out) do
             'a2ed66c01f42514bcab77fd628149eccb4ecee28	refs/tags/0.0.1'
-          }
+          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|
-              shell_out.should_receive(:new)
-                .with('git checkout a2ed66c01f42514bcab77fd628149eccb4ecee28', :live_stream => STDOUT, :cwd => '/tmp/project')
+              expect(shell_out).to receive(:new)
+                .with('git checkout a2ed66c01f42514bcab77fd628149eccb4ecee28', live_stream: STDOUT, cwd: '/tmp/project')
                 .ordered
                 .and_return(g)
-              g.should_receive(:run_command).ordered
-              g.should_receive(:error!).ordered
+              expect(g).to receive(:run_command).ordered
+              expect(g).to receive(:error!).ordered
             end
 
             expect { subject.fetch }.to_not raise_error
           end
         end
-        context "when the ref does not exist" do
-          let(:git_ls_remote_out) {
-            ''
-          }
+
+        context 'when the ref does not exist' do
+          let(:git_ls_remote_out) { '' }
+
           it 'should clone the Git repository and then fail while retrying 3 times' do
-             4.times {
-               expect_git_clone
-               4.times {
-                 expect_git_ls_remote
-               }
-             }
-            Omnibus::Fetcher::ErrorReporter.any_instance
-              .should_receive(:explain).with(%q|Failed to find any commits for the ref '0.0.1'|)
-            subject.should_receive(:log).with(%r|git ls-remote failed|).at_least(1).times
-            subject.should_receive(:log).with(%r|git clone/fetch failed|).at_least(1).times
+            4.times do
+              expect_git_clone
+              4.times do
+                expect_git_ls_remote
+              end
+            end
+
+            expect_any_instance_of(Omnibus::Fetcher::ErrorReporter).to receive(:explain)
+              .with(%q|Failed to find any commits for the ref '0.0.1'|)
+            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(/Could not parse SHA reference/)
@@ -90,4 +98,3 @@ describe Omnibus::GitFetcher do
     end
   end
 end
-

data/spec/fetchers/net_fetcher_spec.rb

@@ -1,61 +1,56 @@
 require 'spec_helper'
 
 describe Omnibus::NetFetcher do
-  it "should download and uncompress zip files" do
+  it 'should download and uncompress zip files' do
     software_mock = double('software')
-    software_mock.stub :project_file => 'file.zip',
-                       :name         => 'file',
-                       :source       => '/tmp/out',
-                       :checksum     => 'abc123',
-                       :source_uri   => 'http://example.com/file.zip',
-                       :source_dir   => '/tmp/out',
-                       :project_dir  => '/tmp/project'
+    software_mock.stub project_file: 'file.zip',
+                       name: 'file',
+                       source: '/tmp/out',
+                       checksum: 'abc123',
+                       source_uri: 'http://example.com/file.zip',
+                       source_dir: '/tmp/out',
+                       project_dir: '/tmp/project'
     net_fetcher = Omnibus::NetFetcher.new software_mock
-    net_fetcher.extract_cmd.should == 'unzip file.zip -d /tmp/out'
+    expect(net_fetcher.extract_cmd).to eq('unzip file.zip -d /tmp/out')
   end
-  it "should download and uncompress .tar.xz files" do
+  it 'should download and uncompress .tar.xz files' do
     software_mock = double('software')
-    software_mock.stub :project_file => 'file.tar.xz',
-                       :name         => 'file',
-                       :source       => '/tmp/out',
-                       :checksum     => 'abc123',
-                       :source_uri   => 'http://example.com/file.tar.xz',
-                       :source_dir   => '/tmp/out',
-                       :project_dir  => '/tmp/project'
+    software_mock.stub project_file: 'file.tar.xz',
+                       name: 'file',
+                       source: '/tmp/out',
+                       checksum: 'abc123',
+                       source_uri: 'http://example.com/file.tar.xz',
+                       source_dir: '/tmp/out',
+                       project_dir: '/tmp/project'
     net_fetcher = Omnibus::NetFetcher.new software_mock
-    net_fetcher.extract_cmd.should == 'xz -dc file.tar.xz | ( cd /tmp/out && tar -xf - )'
+    expect(net_fetcher.extract_cmd).to eq('xz -dc file.tar.xz | ( cd /tmp/out && tar -xf - )')
   end
-  it "should download and uncompress .txz files" do
+  it 'should download and uncompress .txz files' do
     software_mock = double('software')
-    software_mock.stub :project_file => 'file.txz',
-                       :name         => 'file',
-                       :source       => '/tmp/out',
-                       :checksum     => 'abc123',
-                       :source_uri   => 'http://example.com/file.txz',
-                       :source_dir   => '/tmp/out',
-                       :project_dir  => '/tmp/project'
+    software_mock.stub project_file: 'file.txz',
+                       name: 'file',
+                       source: '/tmp/out',
+                       checksum: 'abc123',
+                       source_uri: 'http://example.com/file.txz',
+                       source_dir: '/tmp/out',
+                       project_dir: '/tmp/project'
     net_fetcher = Omnibus::NetFetcher.new software_mock
-    net_fetcher.extract_cmd.should == 'xz -dc file.txz | ( cd /tmp/out && tar -xf - )'
+    expect(net_fetcher.extract_cmd).to eq('xz -dc file.txz | ( cd /tmp/out && tar -xf - )')
   end
 
-  describe "http_proxy helper" do
+  describe 'http_proxy helper' do
     before(:each) do
       software_mock = double('software')
-      software_mock.stub(:project_file => 'file.txz',
-                         :name         => 'file',
-                         :source       => '/tmp/out',
-                         :checksum     => 'abc123',
-                         :source_uri   => 'http://example.com/file.txz',
-                         :source_dir   => '/tmp/out',
-                         :project_dir  => '/tmp/project')
+      software_mock.stub project_file: 'file.txz',
+                         name: 'file',
+                         source: '/tmp/out',
+                         checksum: 'abc123',
+                         source_uri: 'http://example.com/file.txz',
+                         source_dir: '/tmp/out',
+                         project_dir: '/tmp/project'
       @net_fetcher = Omnibus::NetFetcher.new(software_mock)
-      env_vars = ['HTTP_PROXY',
-                  'HTTP_PROXY_USER',
-                  'HTTP_PROXY_PASS',
-                  'http_proxy',
-                  'http_proxy_user',
-                  'http_proxy_pass']
-      @orig_env = env_vars.inject({}) do |h, var|
+      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
@@ -66,60 +61,59 @@ describe Omnibus::NetFetcher do
       @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"
-        @net_fetcher.get_env('LOWER').should == "abc"
-        @net_fetcher.get_env('lower').should == "abc"
+    describe 'get_env handles upper and lower case env vars' do
+      it 'lower via upper' do
+        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"
-        @net_fetcher.get_env('upper').should == "abc"
-        @net_fetcher.get_env('UPPER').should == "abc"
+      it 'upper via lower' do
+        ENV['UPPER'] = 'abc'
+        expect(@net_fetcher.get_env('upper')).to eq('abc')
+        expect(@net_fetcher.get_env('UPPER')).to eq('abc')
       end
     end
 
-    it "should return nil when no proxy is set in env" do
-      @net_fetcher.http_proxy.should be_nil
+    it 'should return nil when no proxy is set in env' do
+      expect(@net_fetcher.http_proxy).to be_nil
     end
 
-    it "should return a URI object when HTTP_PROXY is set" do
-      ENV['HTTP_PROXY'] = "http://my.proxy"
-      @net_fetcher.http_proxy.should == URI.parse("http://my.proxy")
+    it 'should return a URI object when HTTP_PROXY is set' do
+      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"
-      @net_fetcher.http_proxy.should == URI.parse("http://alex:sesame@my.proxy")
+    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'
+      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"
-      @net_fetcher.http_proxy.should == URI.parse("http://sally:peanut@my.proxy")
+    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'
+      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"
-      a_url = URI.parse("http://should.proxy.com/123")
-      @net_fetcher.excluded_from_proxy?(a_url.host).should be_false
+      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
 
-      b_url = URI.parse("http://buz.org/123")
-      @net_fetcher.excluded_from_proxy?(b_url.host).should be_false
+      b_url = URI.parse('http://buz.org/123')
+      expect(@net_fetcher.excluded_from_proxy?(b_url.host)).to be_false
     end
 
-    it "does not proxy if host matches exclude list" do
-      ENV['NO_PROXY'] = "google.com,www.buz.org"
-      a_url = URI.parse("http://google.com/hello")
-      @net_fetcher.excluded_from_proxy?(a_url.host).should be_true
+    it 'does not proxy if host matches exclude list' do
+      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
 
-      b_url = URI.parse("http://www.buz.org/123")
-      @net_fetcher.excluded_from_proxy?(b_url.host).should be_true
+      b_url = URI.parse('http://www.buz.org/123')
+      expect(@net_fetcher.excluded_from_proxy?(b_url.host)).to be_true
     end
   end
 end
-

data/spec/omnibus_spec.rb

@@ -0,0 +1,59 @@
+require 'omnibus'
+require 'spec_helper'
+
+describe Omnibus do
+  # evil class variables
+  before :each do
+    Omnibus.class_eval { @omnibus_software_root = nil }
+    Omnibus.class_eval { @software_dirs = nil }
+  end
+
+  after :each do
+    Omnibus.class_eval { @omnibus_software_root = nil }
+    Omnibus.class_eval { @software_dirs = nil }
+  end
+
+  describe '::omnibus_software_root' do
+    it 'reads the software_gem out of Omnibus::Config.software_gem' do
+      spec_array = [double(Gem::Specification, gem_dir: '/data')]
+      expect(Omnibus::Config).to receive(:software_gem)
+        .and_return('my-omnibus-software-gem')
+      expect(Gem::Specification).to receive(:find_all_by_name)
+        .with('my-omnibus-software-gem')
+        .and_return(spec_array)
+
+      Omnibus.omnibus_software_root
+    end
+
+    it 'uses the omnibus-software gem as the default' do
+      spec_array = [double(Gem::Specification, gem_dir: '/data')]
+      expect(Gem::Specification).to receive(:find_all_by_name)
+        .with('omnibus-software')
+        .and_return(spec_array)
+
+      Omnibus.omnibus_software_root
+    end
+  end
+
+  describe '#software_dirs' do
+    context 'omnibus_software_root not nil' do
+      before do
+        Omnibus.stub(:omnibus_software_root) { './data' }
+      end
+
+      it 'will include list of software from omnibus-software gem' do
+        expect(Omnibus.software_dirs.length).to eq(2)
+      end
+    end
+
+    context 'omnibus_software_root nil' do
+      before do
+        Omnibus.stub(:omnibus_software_root) { nil }
+      end
+
+      it 'will not include list of software from omnibus-software gem' do
+        expect(Omnibus.software_dirs.length).to eq(1)
+      end
+    end
+  end
+end

data/spec/overrides_spec.rb

@@ -2,113 +2,113 @@ require 'omnibus/overrides'
 require 'spec_helper'
 
 describe Omnibus::Overrides do
-  describe "#parse_file" do
+  describe '#parse_file' do
 
-    let(:overrides){Omnibus::Overrides.parse_file(file)}
-    subject{overrides}
+    let(:overrides) { Omnibus::Overrides.parse_file(file) }
+    subject { overrides }
 
-    context "with a valid overrides file" do
-      let(:file){ overrides_path("good") }
+    context 'with a valid overrides file' do
+      let(:file) { overrides_path('good') }
 
-      its(:size){should eq(5)}
-      its(["foo"]){should eq("1.2.3")}
-      its(["bar"]){should eq("0.0.1")}
-      its(["baz"]){should eq("deadbeefdeadbeefdeadbeefdeadbeef")}
-      its(["spunky"]){should eq("master")}
-      its(["monkey"]){should eq("release")}
+      its(:size) { should eq(5) }
+      its(['foo']) { should eq('1.2.3') }
+      its(['bar']) { should eq('0.0.1') }
+      its(['baz']) { should eq('deadbeefdeadbeefdeadbeefdeadbeef') }
+      its(['spunky']) { should eq('master') }
+      its(['monkey']) { should eq('release') }
     end
 
-    context "with an overrides file that contains a bad line" do
-      let(:file){ overrides_path("bad_line")}
-      
-      it "fails" do
-        expect{ overrides }.to raise_error(ArgumentError, "Invalid overrides line: 'THIS IS A BAD LINE'")
+    context 'with an overrides file that contains a bad line' do
+      let(:file) { overrides_path('bad_line') }
+
+      it 'fails' do
+        expect { overrides }.to raise_error(ArgumentError, "Invalid overrides line: 'THIS IS A BAD LINE'")
       end
     end
 
-    context "with an overrides file that contains duplicates" do
-      let(:file){ overrides_path("with_dupes") }
-      let(:duplicated_package){"erchef"}
-      it "fails" do
-        expect{ overrides }.to raise_error(ArgumentError, "Multiple overrides present for '#{duplicated_package}' in overrides file #{file}!")
+    context 'with an overrides file that contains duplicates' do
+      let(:file) { overrides_path('with_dupes') }
+      let(:duplicated_package) { 'erchef' }
+      it 'fails' do
+        expect { overrides }.to raise_error(ArgumentError, "Multiple overrides present for '#{duplicated_package}' in overrides file #{file}!")
       end
     end
 
     context "when passed 'nil'" do
-      let(:file){nil}
-      it{should be_nil}
+      let(:file) { nil }
+      it { should be_nil }
     end
-  end #parse_file
+  end # parse_file
 
-  describe "#resolve_override_file" do
+  describe '#resolve_override_file' do
     before :each do
       @original = ENV['OMNIBUS_OVERRIDE_FILE']
       ENV['OMNIBUS_OVERRIDE_FILE'] = env_override_file
     end
-    
+
     after :each do
       ENV['OMNIBUS_OVERRIDE_FILE'] = @original
     end
-    
-    subject{ Omnibus::Overrides.resolve_override_file }
-    
-    context "with no environment variable set" do
-      let(:env_override_file){nil}
+
+    subject { Omnibus::Overrides.resolve_override_file }
+
+    context 'with no environment variable set' do
+      let(:env_override_file) { nil }
 
       before :each do
-        stub_const("Omnibus::Overrides::DEFAULT_OVERRIDE_FILE_NAME", new_default_file)
+        stub_const('Omnibus::Overrides::DEFAULT_OVERRIDE_FILE_NAME', new_default_file)
+      end
+
+      context 'and a non-existent overrides file' do
+        let(:new_default_file) { '/this/file/totally/does/not/exist.txt' }
+        it { should be_nil }
       end
-    
-      context "and a non-existent overrides file" do
-        let(:new_default_file){ "/this/file/totally/does/not/exist.txt" }
-        it{should be_nil}
+
+      context 'with an existing overrides file' do
+        let(:path) { overrides_path('good') }
+        let(:new_default_file) { path }
+        it { should eq(path) }
       end
-    
-      context "with an existing overrides file" do
-        let(:path){overrides_path("good")}
-        let(:new_default_file){ path }
-        it{should eq(path)}
-      end      
     end # no environment variable
 
-    context "with OMNIBUS_OVERRIDE_FILE environment variable set" do
-      context "to an existing file" do
-        let(:path){ overrides_path("good") }
-        let(:env_override_file){ path  }
-        it{should eq(path)}
+    context 'with OMNIBUS_OVERRIDE_FILE environment variable set' do
+      context 'to an existing file' do
+        let(:path) { overrides_path('good') }
+        let(:env_override_file) { path  }
+        it { should eq(path) }
       end
 
-      context "to a non-existent file" do
-        let(:env_override_file){ "/this/file/totally/does/not/exist.txt"}
-        it{should be_nil}
+      context 'to a non-existent file' do
+        let(:env_override_file) { '/this/file/totally/does/not/exist.txt' }
+        it { should be_nil }
       end
 
-      context "to a non-existent file, but with an existing DEFAULT_OVERRIDE_FILE_NAME file" do
-        let(:env_override_file){ "/this/file/totally/does/not/exist.txt"}
-        let(:new_default_file){overrides_path("good")}
+      context 'to a non-existent file, but with an existing DEFAULT_OVERRIDE_FILE_NAME file' do
+        let(:env_override_file) { '/this/file/totally/does/not/exist.txt' }
+        let(:new_default_file) { overrides_path('good') }
 
         it "should still return 'nil', because environment variable has priority" do
-          stub_const("Omnibus::Overrides::DEFAULT_OVERRIDE_FILE_NAME", new_default_file)
+          stub_const('Omnibus::Overrides::DEFAULT_OVERRIDE_FILE_NAME', new_default_file)
+
+          expect(File.exist?(Omnibus::Overrides::DEFAULT_OVERRIDE_FILE_NAME)).to be_true
+          expect(ENV['OMNIBUS_OVERRIDE_FILE']).to_not be_nil
 
-          File.exist?(Omnibus::Overrides::DEFAULT_OVERRIDE_FILE_NAME).should be_true
-          ENV['OMNIBUS_OVERRIDE_FILE'].should_not be_nil
-          
-          subject.should be_nil
+          expect(subject).to be_nil
         end
       end
     end
   end
 
-  describe "#overrides" do
-    context "when an overrides file cannot be found" do
+  describe '#overrides' do
+    context 'when an overrides file cannot be found' do
       before :each do
         Omnibus::Overrides.stub(:resolve_override_file).and_return(nil)
       end
-      
-      it "returns an empty hash" do
-        Omnibus::Overrides.overrides.should eq({})
+
+      it 'returns an empty hash' do
+        expect(Omnibus::Overrides.overrides).to eq({})
       end
     end
   end
-  
+
 end