berkshelf 5.5.0 → 5.6.0

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

@@ -1,52 +1,52 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Berkshelf
   describe BaseLocation do
-    let(:constraint) { double('constraint') }
-    let(:dependency) { double('dependency', name: 'cookbook', version_constraint: constraint) }
+    let(:constraint) { double("constraint") }
+    let(:dependency) { double("dependency", name: "cookbook", version_constraint: constraint) }
 
     subject { described_class.new(dependency) }
 
-    describe '#installed?' do
-      it 'is an abstract function' do
+    describe "#installed?" do
+      it "is an abstract function" do
         expect { subject.installed? }.to raise_error(AbstractFunction)
       end
     end
 
-    describe '#install' do
-      it 'is an abstract function' do
+    describe "#install" do
+      it "is an abstract function" do
         expect { subject.install }.to raise_error(AbstractFunction)
       end
     end
 
-    describe '#cached_cookbook' do
-      it 'is an abstract function' do
+    describe "#cached_cookbook" do
+      it "is an abstract function" do
         expect { subject.cached_cookbook }.to raise_error(AbstractFunction)
       end
     end
 
-    describe '#to_lock' do
-      it 'is an abstract function' do
+    describe "#to_lock" do
+      it "is an abstract function" do
         expect { subject.to_lock }.to raise_error(AbstractFunction)
       end
     end
 
-    describe '#validate_cached!' do
-      context 'when the path is not a cookbook' do
+    describe "#validate_cached!" do
+      context "when the path is not a cookbook" do
         before { allow(File).to receive(:cookbook?).and_return(false) }
 
-        it 'raises an error' do
-          expect {
-            subject.validate_cached!('/foo/bar')
-          }.to raise_error(NotACookbook)
+        it "raises an error" do
+          expect do
+            subject.validate_cached!("/foo/bar")
+          end.to raise_error(NotACookbook)
         end
       end
 
-      context 'when the path is a cookbook' do
+      context "when the path is a cookbook" do
         let(:cookbook) do
-          double('cookbook',
-            cookbook_name: 'cookbook',
-            version: '0.1.0',
+          double("cookbook",
+            cookbook_name: "cookbook",
+            version: "0.1.0"
           )
         end
 
@@ -55,32 +55,32 @@ module Berkshelf
           allow(CachedCookbook).to receive(:from_path).and_return(cookbook)
         end
 
-        it 'raises an error if the metadata does not have a name attribute' do
+        it "raises an error if the metadata does not have a name attribute" do
           allow(CachedCookbook).to receive(:from_path)
             .and_raise(ArgumentError)
 
-          expect {
+          expect do
             subject.validate_cached!(cookbook)
-          }.to raise_error(InternalError)
+          end.to raise_error(InternalError)
         end
 
-        it 'raises an error if the constraint does not satisfy' do
-          allow(constraint).to receive(:satisfies?).with('0.1.0').and_return(false)
-          expect {
+        it "raises an error if the constraint does not satisfy" do
+          allow(constraint).to receive(:satisfies?).with("0.1.0").and_return(false)
+          expect do
             subject.validate_cached!(cookbook)
-          }.to raise_error(CookbookValidationFailure)
+          end.to raise_error(CookbookValidationFailure)
         end
 
-        it 'raises an error if the names do not match' do
-          allow(constraint).to receive(:satisfies?).with('0.1.0').and_return(true)
-          allow(cookbook).to receive(:cookbook_name).and_return('different_name')
-          expect {
+        it "raises an error if the names do not match" do
+          allow(constraint).to receive(:satisfies?).with("0.1.0").and_return(true)
+          allow(cookbook).to receive(:cookbook_name).and_return("different_name")
+          expect do
             subject.validate_cached!(cookbook)
-          }.to raise_error(MismatchedCookbookName)
+          end.to raise_error(MismatchedCookbookName)
         end
 
-        it 'returns true when the validation succeeds' do
-          allow(constraint).to receive(:satisfies?).with('0.1.0').and_return(true)
+        it "returns true when the validation succeeds" do
+          allow(constraint).to receive(:satisfies?).with("0.1.0").and_return(true)
           expect(subject.validate_cached!(cookbook)).to be(true)
         end
       end

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

@@ -1,100 +1,100 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Berkshelf
   describe GitLocation do
-    let(:dependency) { double(name: 'bacon') }
+    let(:dependency) { double(name: "bacon") }
 
     subject do
-      described_class.new(dependency, git: 'https://repo.com', branch: 'ham',
-        tag: 'v1.2.3', ref: 'abc123', revision: 'defjkl123456', rel: 'hi')
+      described_class.new(dependency, git: "https://repo.com", branch: "ham",
+                                      tag: "v1.2.3", ref: "abc123", revision: "defjkl123456", rel: "hi")
     end
 
-    describe '.initialize' do
-      it 'sets the uri' do
-        instance = described_class.new(dependency, git: 'https://repo.com')
-        expect(instance.uri).to eq('https://repo.com')
+    describe ".initialize" do
+      it "sets the uri" do
+        instance = described_class.new(dependency, git: "https://repo.com")
+        expect(instance.uri).to eq("https://repo.com")
       end
 
-      it 'sets the branch' do
+      it "sets the branch" do
         instance = described_class.new(dependency,
-          git: 'https://repo.com', branch: 'magic_new_feature')
-        expect(instance.branch).to eq('magic_new_feature')
+          git: "https://repo.com", branch: "magic_new_feature")
+        expect(instance.branch).to eq("magic_new_feature")
       end
 
-      it 'sets the tag' do
+      it "sets the tag" do
         instance = described_class.new(dependency,
-          git: 'https://repo.com', tag: 'v1.2.3')
-        expect(instance.tag).to eq('v1.2.3')
+          git: "https://repo.com", tag: "v1.2.3")
+        expect(instance.tag).to eq("v1.2.3")
       end
 
-      it 'adds the ref' do
+      it "adds the ref" do
         instance = described_class.new(dependency,
-          git: 'https://repo.com', ref: 'abc123')
-        expect(instance.ref).to eq('abc123')
+          git: "https://repo.com", ref: "abc123")
+        expect(instance.ref).to eq("abc123")
       end
 
-      it 'sets the revision' do
+      it "sets the revision" do
         instance = described_class.new(dependency,
-          git: 'https://repo.com', revision: 'abcde12345')
-        expect(instance.revision).to eq('abcde12345')
+          git: "https://repo.com", revision: "abcde12345")
+        expect(instance.revision).to eq("abcde12345")
       end
 
-      it 'sets the rel' do
+      it "sets the rel" do
         instance = described_class.new(dependency,
-          git: 'https://repo.com', rel: 'internal/path')
-        expect(instance.rel).to eq('internal/path')
+          git: "https://repo.com", rel: "internal/path")
+        expect(instance.rel).to eq("internal/path")
       end
 
-      context 'rev_parse' do
+      context "rev_parse" do
         def rev_parse(instance)
           instance.instance_variable_get(:@rev_parse)
         end
 
-        it 'uses the :ref option with priority' do
+        it "uses the :ref option with priority" do
           instance = described_class.new(dependency,
-            git: 'https://repo.com', ref: 'abc123', branch: 'magic_new_feature')
-          expect(rev_parse(instance)).to eq('abc123')
+            git: "https://repo.com", ref: "abc123", branch: "magic_new_feature")
+          expect(rev_parse(instance)).to eq("abc123")
         end
 
-        it 'uses the :branch option with priority' do
+        it "uses the :branch option with priority" do
           instance = described_class.new(dependency,
-            git: 'https://repo.com', branch: 'magic_new_feature', tag: 'v1.2.3')
-          expect(rev_parse(instance)).to eq('magic_new_feature')
+            git: "https://repo.com", branch: "magic_new_feature", tag: "v1.2.3")
+          expect(rev_parse(instance)).to eq("magic_new_feature")
         end
 
-        it 'uses the :tag option' do
+        it "uses the :tag option" do
           instance = described_class.new(dependency,
-            git: 'https://repo.com', tag: 'v1.2.3')
-          expect(rev_parse(instance)).to eq('v1.2.3')
+            git: "https://repo.com", tag: "v1.2.3")
+          expect(rev_parse(instance)).to eq("v1.2.3")
         end
 
         it 'uses "master" when none is given' do
-          instance = described_class.new(dependency, git: 'https://repo.com')
-          expect(rev_parse(instance)).to eq('master')
+          instance = described_class.new(dependency, git: "https://repo.com")
+          expect(rev_parse(instance)).to eq("master")
         end
       end
     end
 
-    describe '#installed?' do
-      it 'returns false when there is no revision' do
+    describe "#installed?" do
+      it "returns false when there is no revision" do
         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
-        allow(subject).to receive(:revision).and_return('abcd1234')
+      it "returns false when the install_path does not exist" do
+        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
-        allow(subject).to receive(:revision).and_return('abcd1234')
+      it "returns true when the location is installed" do
+        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
+    describe "#install" do
       before do
         allow(File).to receive(:chmod)
         allow(FileUtils).to receive(:cp_r)
@@ -102,8 +102,8 @@ module Berkshelf
         allow(subject).to receive(:git)
       end
 
-      context 'when the repository is cached' do
-        it 'pulls a new version' do
+      context "when the repository is cached" do
+        it "pulls a new version" do
           allow(Dir).to receive(:chdir) { |args, &b| b.call } # Force eval the chdir block
 
           allow(subject).to receive(:cached?).and_return(true)
@@ -114,27 +114,27 @@ module Berkshelf
         end
       end
 
-      context 'when the revision is not cached' do
-        it 'clones the repository' do
+      context "when the revision is not cached" do
+        it "clones the repository" do
           allow(Dir).to receive(:chdir) { |args, &b| b.call } # Force eval the chdir block
 
           cache_path = subject.send(:cache_path)
           allow(subject).to receive(:cached?).and_return(false)
           expect(subject).to receive(:git).with(
-            %|clone https://repo.com "#{cache_path}" --bare --no-hardlinks|
+            %{clone https://repo.com "#{cache_path}" --bare --no-hardlinks}
           )
           subject.install
         end
       end
     end
 
-    describe '#cached_cookbook' do
-      it 'returns nil if the cookbook is not installed' do
+    describe "#cached_cookbook" do
+      it "returns nil if the cookbook is not installed" do
         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
+      it "returns the cookbook at the install_path" do
         allow(subject).to receive(:installed?).and_return(true)
         allow(CachedCookbook).to receive(:from_path)
 
@@ -143,69 +143,69 @@ module Berkshelf
       end
     end
 
-    describe '#==' do
+    describe "#==" do
       let(:other) { subject.dup }
 
-      it 'returns true when everything matches' do
+      it "returns true when everything matches" do
         expect(subject).to eq(other)
       end
 
-      it 'returns false when the other location is not an GitLocation' do
+      it "returns false when the other location is not an GitLocation" do
         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
-        allow(other).to receive(:uri).and_return('different')
+      it "returns false when the uri is different" do
+        allow(other).to receive(:uri).and_return("different")
         expect(subject).to_not eq(other)
       end
 
-      it 'returns false when the branch is different' do
-        allow(other).to receive(:branch).and_return('different')
+      it "returns false when the branch is different" do
+        allow(other).to receive(:branch).and_return("different")
         expect(subject).to_not eq(other)
       end
 
-      it 'returns false when the tag is different' do
-        allow(other).to receive(:tag).and_return('different')
+      it "returns false when the tag is different" do
+        allow(other).to receive(:tag).and_return("different")
         expect(subject).to_not eq(other)
       end
 
-      it 'returns false when the ref is different' do
-        allow(other).to receive(:ref).and_return('different')
+      it "returns false when the ref is different" do
+        allow(other).to receive(:ref).and_return("different")
         expect(subject).to_not eq(other)
       end
 
-      it 'returns false when the rel is different' do
-        allow(other).to receive(:rel).and_return('different')
+      it "returns false when the rel is different" do
+        allow(other).to receive(:rel).and_return("different")
         expect(subject).to_not eq(other)
       end
     end
 
-    describe '#to_s' do
-      it 'prefers the tag' do
-        expect(subject.to_s).to eq('https://repo.com (at v1.2.3/hi)')
+    describe "#to_s" do
+      it "prefers the tag" do
+        expect(subject.to_s).to eq("https://repo.com (at v1.2.3/hi)")
       end
 
-      it 'prefers the branch' do
+      it "prefers the branch" do
         allow(subject).to receive(:tag).and_return(nil)
-        expect(subject.to_s).to eq('https://repo.com (at ham/hi)')
+        expect(subject.to_s).to eq("https://repo.com (at ham/hi)")
       end
 
-      it 'falls back to the ref' do
+      it "falls back to the ref" do
         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)')
+        expect(subject.to_s).to eq("https://repo.com (at abc123/hi)")
       end
 
-      it 'does not use the rel if missing' do
+      it "does not use the rel if missing" do
         allow(subject).to receive(:rel).and_return(nil)
-        expect(subject.to_s).to eq('https://repo.com (at v1.2.3)')
+        expect(subject.to_s).to eq("https://repo.com (at v1.2.3)")
       end
     end
 
-    describe '#to_lock' do
-      it 'includes all the information' do
-        expect(subject.to_lock).to eq <<-EOH.gsub(/^ {8}/, '')
+    describe "#to_lock" do
+      it "includes all the information" do
+        expect(subject.to_lock).to eq <<-EOH.gsub(/^ {8}/, "")
             git: https://repo.com
             revision: defjkl123456
             ref: abc123
@@ -215,34 +215,34 @@ module Berkshelf
         EOH
       end
 
-      it 'does not include the branch if missing' do
+      it "does not include the branch if missing" do
         allow(subject).to receive(:branch).and_return(nil)
-        expect(subject.to_lock).to_not include('branch')
+        expect(subject.to_lock).to_not include("branch")
       end
 
-      it 'does not include the tag if missing' do
+      it "does not include the tag if missing" do
         allow(subject).to receive(:tag).and_return(nil)
-        expect(subject.to_lock).to_not include('tag')
+        expect(subject.to_lock).to_not include("tag")
       end
 
-      it 'does not include the rel if missing' do
+      it "does not include the rel if missing" do
         allow(subject).to receive(:rel).and_return(nil)
-        expect(subject.to_lock).to_not include('rel')
+        expect(subject.to_lock).to_not include("rel")
       end
     end
 
-    describe '#git' do
+    describe "#git" do
       before { described_class.send(:public, :git) }
 
-      it 'raises an error if Git is not installed' do
+      it "raises an error if Git is not installed" do
         allow(Berkshelf).to receive(:which).and_return(false)
-        expect { subject.git('foo') }.to raise_error(GitNotInstalled)
+        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)
+      it "raises an error if the command fails" do
+        shell_out = double("shell_out", success?: false, stderr: nil)
         allow(Buff::ShellOut).to receive(:shell_out).and_return(shell_out)
-        expect { subject.git('foo') }.to raise_error(GitCommandError)
+        expect { subject.git("foo") }.to raise_error(GitCommandError)
       end
     end
   end

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

@@ -1,104 +1,104 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Berkshelf
   describe PathLocation do
-    let(:berksfile) { double('berksfile', filepath: __FILE__) }
-    let(:constraint) { double('constraint', satisfies?: true) }
+    let(:berksfile) { double("berksfile", filepath: __FILE__) }
+    let(:constraint) { double("constraint", satisfies?: true) }
     let(:dependency) do
-      double('dependency',
-        name: 'nginx',
+      double("dependency",
+        name: "nginx",
         version_constraint: constraint,
-        berksfile: berksfile,
+        berksfile: berksfile
       )
     end
-    let(:path) { fixtures_path.join('cookbooks', 'example_cookbook') }
-    let(:relative_path) { Pathname.new('../../../fixtures/cookbooks/example_cookbook') }
+    let(:path) { fixtures_path.join("cookbooks", "example_cookbook") }
+    let(:relative_path) { Pathname.new("../../../fixtures/cookbooks/example_cookbook") }
 
     subject { described_class.new(dependency, path: path) }
 
-    describe '#installed?' do
-      it 'returns false' do
+    describe "#installed?" do
+      it "returns false" do
         expect(subject.installed?).to be(false)
       end
     end
 
-    describe '#install' do
-      it 'validates the cached cookbook' do
+    describe "#install" do
+      it "validates the cached cookbook" do
         expect(subject).to receive(:validate_cached!).with(path)
         subject.install
       end
     end
 
-    describe '#cached_cookbook' do
-      it 'loads the cached cookbook at the path' do
+    describe "#cached_cookbook" do
+      it "loads the cached cookbook at the path" do
         expect(CachedCookbook).to receive(:from_path).with(path)
         subject.cached_cookbook
       end
     end
 
-    describe '#relative_path' do
-      it 'returns the path to the Berksfile' do
+    describe "#relative_path" do
+      it "returns the path to the Berksfile" do
         expect(subject.relative_path).to eq(relative_path)
       end
     end
 
-    describe '#expanded_path' do
-      it 'returns the expanded path, relative to the Berksfile' do
+    describe "#expanded_path" do
+      it "returns the expanded path, relative to the Berksfile" do
         absolute_path = Pathname.new(File.expand_path(relative_path, File.dirname(berksfile.filepath)))
         expect(subject.expanded_path).to eq(absolute_path)
       end
     end
 
-    describe '#==' do
-      it 'is false when compared with a non-PathLocation' do
-        this = PathLocation.new(dependency, path: '.')
-        that = 'A string'
+    describe "#==" do
+      it "is false when compared with a non-PathLocation" do
+        this = PathLocation.new(dependency, path: ".")
+        that = "A string"
         expect(this).to_not eq(that)
       end
 
-      it 'is false when the metadata? is not the same' do
-        this = PathLocation.new(dependency, path: '.')
-        that = PathLocation.new(dependency, path: '.', metadata: true)
+      it "is false when the metadata? is not the same" do
+        this = PathLocation.new(dependency, path: ".")
+        that = PathLocation.new(dependency, path: ".", metadata: true)
         expect(this).to_not eq(that)
       end
 
-      it 'is false when the expanded paths are different' do
-        this = PathLocation.new(dependency, path: '.')
-        that = PathLocation.new(dependency, path: '..')
+      it "is false when the expanded paths are different" do
+        this = PathLocation.new(dependency, path: ".")
+        that = PathLocation.new(dependency, path: "..")
         expect(this).to_not eq(that)
       end
 
-      it 'is true when they are the same' do
-        this = PathLocation.new(dependency, path: '.', metadata: true)
-        that = PathLocation.new(dependency, path: '.', metadata: true)
+      it "is true when they are the same" do
+        this = PathLocation.new(dependency, path: ".", metadata: true)
+        that = PathLocation.new(dependency, path: ".", metadata: true)
         expect(this).to eq(that)
       end
     end
 
-    describe '#to_lock' do
-      it 'includes the path relative to the Berksfile' do
-        expect(subject.to_lock).to eq <<-EOH.gsub(/^ {10}/, '')
+    describe "#to_lock" do
+      it "includes the path relative to the Berksfile" do
+        expect(subject.to_lock).to eq <<-EOH.gsub(/^ {10}/, "")
               path: #{relative_path}
         EOH
       end
 
-      it 'includes the metadata attribute' do
+      it "includes the metadata attribute" do
         allow(subject).to receive(:metadata?).and_return(true)
-        expect(subject.to_lock).to eq <<-EOH.gsub(/^ {10}/, '')
+        expect(subject.to_lock).to eq <<-EOH.gsub(/^ {10}/, "")
               path: #{relative_path}
               metadata: true
         EOH
       end
     end
 
-    describe '#to_s' do
-      it 'uses the relative path' do
+    describe "#to_s" do
+      it "uses the relative path" do
         expect(subject.to_s).to eq("source at #{relative_path}")
       end
     end
 
-    describe '#inspect' do
-      it 'includes the right information' do
+    describe "#inspect" do
+      it "includes the right information" do
         allow(subject).to receive(:metadata?).and_return(true)
         expect(subject.inspect).to eq("#<Berkshelf::PathLocation metadata: true, path: #{relative_path}>")
       end