berkshelf 3.1.5 → 3.2.0

data/spec/unit/berkshelf/locations/base_spec.rb

@@ -33,7 +33,7 @@ module Berkshelf
 
     describe '#validate_cached!' do
       context 'when the path is not a cookbook' do
-        before { File.stub(:cookbook?).and_return(false) }
+        before { allow(File).to receive(:cookbook?).and_return(false) }
 
         it 'raises an error' do
           expect {
@@ -51,28 +51,37 @@ module Berkshelf
         end
 
         before do
-          File.stub(:cookbook?).and_return(true)
-          CachedCookbook.stub(:from_path).and_return(cookbook)
+          allow(File).to receive(:cookbook?).and_return(true)
+          allow(CachedCookbook).to receive(:from_path).and_return(cookbook)
+        end
+
+        it 'raises an error if the metadata does not have a name attribute' do
+          allow(CachedCookbook).to receive(:from_path)
+            .and_raise(ArgumentError)
+
+          expect {
+            subject.validate_cached!(cookbook)
+          }.to raise_error(InternalError)
         end
 
         it 'raises an error if the constraint does not satisfy' do
-          constraint.stub(:satisfies?).with('0.1.0').and_return(false)
+          allow(constraint).to receive(:satisfies?).with('0.1.0').and_return(false)
           expect {
             subject.validate_cached!(cookbook)
           }.to raise_error(CookbookValidationFailure)
         end
 
         it 'raises an error if the names do not match' do
-          constraint.stub(:satisfies?).with('0.1.0').and_return(true)
-          cookbook.stub(:cookbook_name).and_return('different_name')
+          allow(constraint).to receive(:satisfies?).with('0.1.0').and_return(true)
+          allow(cookbook).to receive(:cookbook_name).and_return('different_name')
           expect {
             subject.validate_cached!(cookbook)
           }.to raise_error(MismatchedCookbookName)
         end
 
         it 'returns true when the validation succeeds' do
-          constraint.stub(:satisfies?).with('0.1.0').and_return(true)
-          expect(subject.validate_cached!(cookbook)).to be_true
+          allow(constraint).to receive(:satisfies?).with('0.1.0').and_return(true)
+          expect(subject.validate_cached!(cookbook)).to be(true)
         end
       end
     end

data/spec/unit/berkshelf/locations/git_spec.rb

@@ -77,36 +77,36 @@ module Berkshelf
 
     describe '#installed?' do
       it 'returns false when there is no revision' do
-        subject.stub(:revision).and_return(nil)
-        expect(subject.installed?).to be_false
+        allow(subject).to receive(:revision).and_return(nil)
+        expect(subject.installed?).to be(false)
       end
 
       it 'returns false when the install_path does not exist' do
-        subject.stub(:revision).and_return('abcd1234')
-        subject.stub(:install_path).and_return(double(exist?: false))
-        expect(subject.installed?).to be_false
+        allow(subject).to receive(:revision).and_return('abcd1234')
+        allow(subject).to receive(:install_path).and_return(double(exist?: false))
+        expect(subject.installed?).to be(false)
       end
 
       it 'returns true when the location is installed' do
-        subject.stub(:revision).and_return('abcd1234')
-        subject.stub(:install_path).and_return(double(exist?: true))
-        expect(subject.installed?).to be_true
+        allow(subject).to receive(:revision).and_return('abcd1234')
+        allow(subject).to receive(:install_path).and_return(double(exist?: true))
+        expect(subject.installed?).to be(true)
       end
     end
 
     describe '#install' do
       before do
-        File.stub(:chmod)
-        FileUtils.stub(:cp_r)
-        subject.stub(:validate_cached!)
-        subject.stub(:git)
+        allow(File).to receive(:chmod)
+        allow(FileUtils).to receive(:cp_r)
+        allow(subject).to receive(:validate_cached!)
+        allow(subject).to receive(:git)
       end
 
       context 'when the repository is cached' do
         it 'pulls a new version' do
-          Dir.stub(:chdir) { |args, &b| b.call } # Force eval the chdir block
+          allow(Dir).to receive(:chdir) { |args, &b| b.call } # Force eval the chdir block
 
-          subject.stub(:cached?).and_return(true)
+          allow(subject).to receive(:cached?).and_return(true)
           expect(subject).to receive(:git).with(
             'fetch --force --tags https://repo.com "refs/heads/*:refs/heads/*"'
           )
@@ -116,10 +116,10 @@ module Berkshelf
 
       context 'when the revision is not cached' do
         it 'clones the repository' do
-          Dir.stub(:chdir) { |args, &b| b.call } # Force eval the chdir block
+          allow(Dir).to receive(:chdir) { |args, &b| b.call } # Force eval the chdir block
 
           cache_path = subject.send(:cache_path)
-          subject.stub(:cached?).and_return(false)
+          allow(subject).to receive(:cached?).and_return(false)
           expect(subject).to receive(:git).with(
             %|clone https://repo.com "#{cache_path}" --bare --no-hardlinks|
           )
@@ -130,13 +130,13 @@ module Berkshelf
 
     describe '#cached_cookbook' do
       it 'returns nil if the cookbook is not installed' do
-        subject.stub(:installed?).and_return(false)
+        allow(subject).to receive(:installed?).and_return(false)
         expect(subject.cached_cookbook).to be_nil
       end
 
       it 'returns the cookbook at the install_path' do
-        subject.stub(:installed?).and_return(true)
-        CachedCookbook.stub(:from_path)
+        allow(subject).to receive(:installed?).and_return(true)
+        allow(CachedCookbook).to receive(:from_path)
 
         expect(CachedCookbook).to receive(:from_path).once
         subject.cached_cookbook
@@ -151,32 +151,32 @@ module Berkshelf
       end
 
       it 'returns false when the other location is not an GitLocation' do
-        other.stub(:is_a?).and_return(false)
+        allow(other).to receive(:is_a?).and_return(false)
         expect(subject).to_not eq(other)
       end
 
       it 'returns false when the uri is different' do
-        other.stub(:uri).and_return('different')
+        allow(other).to receive(:uri).and_return('different')
         expect(subject).to_not eq(other)
       end
 
       it 'returns false when the branch is different' do
-        other.stub(:branch).and_return('different')
+        allow(other).to receive(:branch).and_return('different')
         expect(subject).to_not eq(other)
       end
 
       it 'returns false when the tag is different' do
-        other.stub(:tag).and_return('different')
+        allow(other).to receive(:tag).and_return('different')
         expect(subject).to_not eq(other)
       end
 
       it 'returns false when the ref is different' do
-        other.stub(:ref).and_return('different')
+        allow(other).to receive(:ref).and_return('different')
         expect(subject).to_not eq(other)
       end
 
       it 'returns false when the rel is different' do
-        other.stub(:rel).and_return('different')
+        allow(other).to receive(:rel).and_return('different')
         expect(subject).to_not eq(other)
       end
     end
@@ -187,18 +187,18 @@ module Berkshelf
       end
 
       it 'prefers the branch' do
-        subject.stub(:tag).and_return(nil)
+        allow(subject).to receive(:tag).and_return(nil)
         expect(subject.to_s).to eq('https://repo.com (at ham/hi)')
       end
 
       it 'falls back to the ref' do
-        subject.stub(:tag).and_return(nil)
-        subject.stub(:branch).and_return(nil)
+        allow(subject).to receive(:tag).and_return(nil)
+        allow(subject).to receive(:branch).and_return(nil)
         expect(subject.to_s).to eq('https://repo.com (at abc123/hi)')
       end
 
       it 'does not use the rel if missing' do
-        subject.stub(:rel).and_return(nil)
+        allow(subject).to receive(:rel).and_return(nil)
         expect(subject.to_s).to eq('https://repo.com (at v1.2.3)')
       end
     end
@@ -216,17 +216,17 @@ module Berkshelf
       end
 
       it 'does not include the branch if missing' do
-        subject.stub(:branch).and_return(nil)
+        allow(subject).to receive(:branch).and_return(nil)
         expect(subject.to_lock).to_not include('branch')
       end
 
       it 'does not include the tag if missing' do
-        subject.stub(:tag).and_return(nil)
+        allow(subject).to receive(:tag).and_return(nil)
         expect(subject.to_lock).to_not include('tag')
       end
 
       it 'does not include the rel if missing' do
-        subject.stub(:rel).and_return(nil)
+        allow(subject).to receive(:rel).and_return(nil)
         expect(subject.to_lock).to_not include('rel')
       end
     end
@@ -235,13 +235,13 @@ module Berkshelf
       before { described_class.send(:public, :git) }
 
       it 'raises an error if Git is not installed' do
-        Berkshelf.stub(:which).and_return(false)
+        allow(Berkshelf).to receive(:which).and_return(false)
         expect { subject.git('foo') }.to raise_error(GitNotInstalled)
       end
 
       it 'raises an error if the command fails' do
         shell_out = double('shell_out', success?: false, stderr: nil)
-        Buff::ShellOut.stub(:shell_out).and_return(shell_out)
+        allow(Buff::ShellOut).to receive(:shell_out).and_return(shell_out)
         expect { subject.git('foo') }.to raise_error(GitCommandError)
       end
     end

data/spec/unit/berkshelf/locations/path_spec.rb

@@ -18,7 +18,7 @@ module Berkshelf
 
     describe '#installed?' do
       it 'returns false' do
-        expect(subject.installed?).to be_false
+        expect(subject.installed?).to be(false)
       end
     end
 
@@ -83,7 +83,7 @@ module Berkshelf
       end
 
       it 'includes the metadata attribute' do
-        subject.stub(:metadata?).and_return(true)
+        allow(subject).to receive(:metadata?).and_return(true)
         expect(subject.to_lock).to eq <<-EOH.gsub(/^ {10}/, '')
               path: #{relative_path}
               metadata: true
@@ -99,7 +99,7 @@ module Berkshelf
 
     describe '#inspect' do
       it 'includes the right information' do
-        subject.stub(:metadata?).and_return(true)
+        allow(subject).to receive(:metadata?).and_return(true)
         expect(subject.inspect).to eq("#<Berkshelf::PathLocation metadata: true, path: #{relative_path}>")
       end
     end

data/spec/unit/berkshelf/lockfile_parser_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Berkshelf::Lockfile do
   before do
-    subject.stub(:filepath).and_return(fixture) if defined?(fixture)
+    allow(subject).to receive(:filepath).and_return(fixture) if defined?(fixture)
     subject.parse
   end
 

data/spec/unit/berkshelf/lockfile_spec.rb

@@ -4,6 +4,20 @@ describe Berkshelf::Lockfile do
   let(:filepath) { fixtures_path.join('lockfiles/default.lock').to_s }
   subject { Berkshelf::Lockfile.new(filepath: filepath) }
 
+  describe '.from_berksfile' do
+    let(:berksfile) do
+      double('Berksfile',
+        filepath: '/path/to/Bacon',
+      )
+    end
+
+    subject { described_class.from_berksfile(berksfile) }
+
+    it 'uses the basename of the Berksfile' do
+      expect(subject.filepath).to eq("/path/to/Bacon.lock")
+    end
+  end
+
   describe '.initialize' do
     subject { described_class.new(filepath: filepath) }
 
@@ -23,7 +37,7 @@ describe Berkshelf::Lockfile do
     let(:parser) { double('parser', run: true) }
 
     before do
-      Berkshelf::Lockfile::LockfileParser.stub(:new).and_return(parser)
+      allow(Berkshelf::Lockfile::LockfileParser).to receive(:new).and_return(parser)
     end
 
     it 'creates a new parser object' do
@@ -33,23 +47,23 @@ describe Berkshelf::Lockfile do
     end
 
     it 'returns true (always)' do
-      expect(subject.parse).to be_true
+      expect(subject.parse).to be(true)
     end
   end
 
   describe '#present?' do
     it 'returns true when the file exists' do
-      expect(subject.present?).to be_true
+      expect(subject.present?).to be(true)
     end
 
     it 'returns false when the file does not exist' do
-      File.stub(:exists?).and_return(false)
-      expect(subject.present?).to be_false
+      allow(File).to receive(:exists?).and_return(false)
+      expect(subject.present?).to be(false)
     end
 
     it 'returns false when the file is empty' do
-      File.stub(:read).and_return('')
-      expect(subject.present?).to be_false
+      allow(File).to receive(:read).and_return('')
+      expect(subject.present?).to be(false)
     end
   end
 
@@ -66,10 +80,10 @@ describe Berkshelf::Lockfile do
       )
       berksfile = double('berksfile', dependencies: [apt])
       subject.instance_variable_set(:@berksfile, berksfile)
-      subject.stub(:find).with(apt).and_return(apt)
-      subject.graph.stub(:find).with(apt).and_return(apt)
+      allow(subject).to receive(:find).with(apt).and_return(apt)
+      allow(subject.graph).to receive(:find).with(apt).and_return(apt)
 
-      expect(subject.trusted?).to be_true
+      expect(subject.trusted?).to be(true)
     end
 
     it 'returns true when the lockfile is trusted with transitive dependencies' do
@@ -85,11 +99,11 @@ describe Berkshelf::Lockfile do
       bacon = double(name: 'bacon', version: '1.0.0', dependencies: {})
       berksfile = double('berksfile', dependencies: [apt])
       subject.instance_variable_set(:@berksfile, berksfile)
-      subject.stub(:find).with(apt).and_return(apt)
-      subject.graph.stub(:find).with('bacon').and_return(bacon)
-      subject.graph.stub(:find).with(apt).and_return(apt)
+      allow(subject).to receive(:find).with(apt).and_return(apt)
+      allow(subject.graph).to receive(:find).with('bacon').and_return(bacon)
+      allow(subject.graph).to receive(:find).with(apt).and_return(apt)
 
-      expect(subject.trusted?).to be_true
+      expect(subject.trusted?).to be(true)
     end
 
     it 'returns true when the lockfile is trusted with cyclic transitive dependencies' do
@@ -111,11 +125,11 @@ describe Berkshelf::Lockfile do
       )
       berksfile = double('berksfile', dependencies: [apt])
       subject.instance_variable_set(:@berksfile, berksfile)
-      subject.stub(:find).with(apt).and_return(apt)
-      subject.graph.stub(:find).with('bacon').and_return(bacon)
-      subject.graph.stub(:find).with(apt).and_return(apt)
+      allow(subject).to receive(:find).with(apt).and_return(apt)
+      allow(subject.graph).to receive(:find).with('bacon').and_return(bacon)
+      allow(subject.graph).to receive(:find).with(apt).and_return(apt)
 
-      expect(subject.trusted?).to be_true
+      expect(subject.trusted?).to be(true)
     end
 
     it 'returns false when the lockfile is not trusted because of transitive dependencies' do
@@ -130,10 +144,10 @@ describe Berkshelf::Lockfile do
       )
       berksfile = double('berksfile', dependencies: [apt])
       subject.instance_variable_set(:@berksfile, berksfile)
-      subject.stub(:find).with(apt).and_return(apt)
-      subject.graph.stub(:find).with(apt).and_return(apt)
+      allow(subject).to receive(:find).with(apt).and_return(apt)
+      allow(subject.graph).to receive(:find).with(apt).and_return(apt)
 
-      expect(subject.trusted?).to be_false
+      expect(subject.trusted?).to be(false)
     end
 
     it 'returns false if the dependency is not in the lockfile' do
@@ -141,17 +155,17 @@ describe Berkshelf::Lockfile do
       berksfile = double('berksfile', dependencies: [apt])
       subject.instance_variable_set(:@berksfile, berksfile)
 
-      expect(subject.trusted?).to be_false
+      expect(subject.trusted?).to be(false)
     end
 
     it 'returns false if the dependency is not in the graph' do
       apt = double('apt', name: 'apt', version_constraint: nil)
       berksfile = double('berksfile', dependencies: [apt])
       subject.instance_variable_set(:@berksfile, berksfile)
-      subject.stub(:find).with(apt).and_return(true)
-      subject.graph.stub(:find).with(apt).and_return(nil)
+      allow(subject).to receive(:find).with(apt).and_return(true)
+      allow(subject.graph).to receive(:find).with(apt).and_return(nil)
 
-      expect(subject.trusted?).to be_false
+      expect(subject.trusted?).to be(false)
     end
 
     it 'returns false if the constraint is not satisfied' do
@@ -166,10 +180,10 @@ describe Berkshelf::Lockfile do
       )
       berksfile = double('berksfile', dependencies: [apt])
       subject.instance_variable_set(:@berksfile, berksfile)
-      subject.stub(:find).with(apt).and_return(apt)
-      subject.graph.stub(:find).with(apt).and_return(apt)
+      allow(subject).to receive(:find).with(apt).and_return(apt)
+      allow(subject.graph).to receive(:find).with(apt).and_return(apt)
 
-      expect(subject.trusted?).to be_false
+      expect(subject.trusted?).to be(false)
     end
 
     it 'returns false if the locations are different' do
@@ -183,13 +197,13 @@ describe Berkshelf::Lockfile do
         cached_cookbook: cookbook,
       )
       apt_master = apt.dup
-      apt_master.stub(location: 'github')
+      allow(apt_master).to receive_messages(location: 'github')
       berksfile = double('berksfile', dependencies: [apt])
       subject.instance_variable_set(:@berksfile, berksfile)
-      subject.stub(:find).with(apt).and_return(apt_master)
-      subject.graph.stub(:find).with(apt).and_return(apt)
+      allow(subject).to receive(:find).with(apt).and_return(apt_master)
+      allow(subject.graph).to receive(:find).with(apt).and_return(apt)
 
-      expect(subject.trusted?).to be_false
+      expect(subject.trusted?).to be(false)
     end
   end
 
@@ -197,12 +211,12 @@ describe Berkshelf::Lockfile do
     let(:connection) { double('connection') }
 
     before do
-      Berkshelf.stub(:ridley_connection).and_yield(connection)
+      allow(Berkshelf).to receive(:ridley_connection).and_yield(connection)
     end
 
     context 'when the Chef environment does not exist' do
       it 'raises an exception' do
-        connection.stub(:environment).and_return(double(find: nil))
+        allow(connection).to receive(:environment).and_return(double(find: nil))
         expect {
           subject.apply('production')
         }.to raise_error(Berkshelf::EnvironmentNotFound)
@@ -212,10 +226,10 @@ describe Berkshelf::Lockfile do
     it 'locks the environment cookbook versions' do
       apt = double(name: 'apt', locked_version: '1.0.0')
       jenkins = double(name: 'jenkins', locked_version: '1.4.5')
-      subject.graph.stub(:locks).and_return('apt' => apt, 'jenkins' => jenkins)
+      allow(subject.graph).to receive(:locks).and_return('apt' => apt, 'jenkins' => jenkins)
 
       environment = double('environment', :cookbook_versions= => nil, save: true)
-      connection.stub(:environment).and_return(double(find: environment))
+      allow(connection).to receive(:environment).and_return(double(find: environment))
 
       expect(environment).to receive(:cookbook_versions=).with(
         'apt' => '= 1.0.0',