berkshelf 3.0.0.beta7 → 3.0.0.beta8

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe BaseFormatter do
+    it 'has abstract methods for all the messaging modes' do
+      expect {
+        subject.install('my_coobook','1.2.3','http://community')
+      }.to raise_error(AbstractFunction)
+
+      expect {
+        subject.use('my_coobook','1.2.3')
+      }.to raise_error(AbstractFunction)
+
+      expect {
+        subject.use('my_coobook','1.2.3','http://community')
+      }.to raise_error(AbstractFunction)
+
+      expect {
+        subject.upload('my_coobook','1.2.3','http://chef_server')
+      }.to raise_error(AbstractFunction)
+
+      expect {
+        subject.msg('something you to know')
+      }.to raise_error(AbstractFunction)
+
+      expect {
+        subject.error('whoa this is bad')
+      }.to raise_error(AbstractFunction)
+
+      expect {
+        subject.fetch(double('dependency'))
+      }.to raise_error(AbstractFunction)
+    end
+  end
+end

data/spec/unit/berkshelf/formatters/human_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe HumanFormatter do
+    it_behaves_like 'a formatter object'
+  end
+end

data/spec/unit/berkshelf/formatters/json_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe JsonFormatter do
+    it_behaves_like 'a formatter object'
+  end
+end

data/spec/unit/berkshelf/formatters/null_spec.rb

@@ -1,17 +1,13 @@
 require 'spec_helper'
 
-describe Berkshelf::Formatters::Null do
-  before { Berkshelf.set_format(:null) }
+module Berkshelf
+  describe NullFormatter do
+    it_behaves_like 'a formatter object'
 
-  [:install, :package, :foo, :bar, :bacon].each do |meth|
-    it "does not raise an error for :#{meth}" do
-      expect {
-        subject.send(meth)
-      }.to_not raise_error
-    end
-
-    it "returns nil for :#{meth}" do
-      expect(subject.send(meth)).to be_nil
+    it 'does not raise an error for abstract metods methods' do
+      expect { subject.install }.to_not raise_error
+      expect { subject.use }.to_not raise_error
+      expect { subject.msg }.to_not raise_error
     end
   end
 end

data/spec/unit/berkshelf/location_spec.rb

@@ -1,156 +1,28 @@
 require 'spec_helper'
 
-describe Berkshelf::Location do
-  describe "ClassMethods" do
-    describe "::init" do
-      let(:dependency) { double('dependency') }
+module Berkshelf
+  describe Location do
+    let(:dependency) { double(name: 'bacon') }
 
-      it 'returns an instance of PathLocation given a path: option key' do
-        result = described_class.init(dependency, path: '/Users/reset/code')
-        expect(result).to be_a(Berkshelf::PathLocation)
+    describe '.init' do
+      it 'finds a :path location by key' do
+        instance = described_class.init(dependency, path: '~/Dev/meats/bacon')
+        expect(instance).to be_a(PathLocation)
       end
 
-      it 'returns an instance of GitLocation given a git: option key' do
-        result = described_class.init(dependency, git: 'git://github.com/something.git')
-        expect(result).to be_a(Berkshelf::GitLocation)
+      it 'finds a :git location by key' do
+        instance = described_class.init(dependency, git: 'git://foo.com/meats/bacon.git')
+        expect(instance).to be_a(GitLocation)
       end
 
-      context 'given two location_keys' do
-        it 'raises an InternalError' do
-          expect {
-            described_class.init(dependency, git: :value, path: :value)
-          }.to raise_error(Berkshelf::InternalError)
-        end
+      it 'finds a :github location by key' do
+        instance = described_class.init(dependency, github: 'meats/bacon')
+        expect(instance).to be_a(GitLocation)
       end
-    end
-  end
-end
-
-describe Berkshelf::Location::Base do
-  describe "ClassMethods" do
-    subject { Class.new(described_class) }
-
-    describe "::set_location_key" do
-      before do
-        @original = Berkshelf::Dependency.class_variable_get :@@location_keys
-        Berkshelf::Dependency.class_variable_set :@@location_keys, {}
-      end
-
-      after do
-        Berkshelf::Dependency.class_variable_set :@@location_keys, @original
-      end
-
-      it 'adds the given location key Berkshelf::Dependency.location_keys' do
-        subject.set_location_key(:reset)
-
-        expect(Berkshelf::Dependency.location_keys).to have(1).item
-        expect(Berkshelf::Dependency.location_keys).to include(:reset)
-        expect(Berkshelf::Dependency.location_keys[:reset]).to eq(subject)
-      end
-    end
-
-    describe "::location_key" do
-      before do
-        @original = Berkshelf::Dependency.class_variable_get :@@location_keys
-        Berkshelf::Dependency.class_variable_set :@@location_keys, {}
-      end
-
-      after do
-        Berkshelf::Dependency.class_variable_set :@@location_keys, @original
-      end
-
-      it "returns the class' registered location key" do
-        subject.set_location_key(:reset)
-        expect(subject.location_key).to eq(:reset)
-      end
-    end
-
-    describe "::set_valid_options" do
-      before do
-        @original = Berkshelf::Dependency.class_variable_get :@@valid_options
-        Berkshelf::Dependency.class_variable_set :@@valid_options, []
-      end
-
-      after do
-        Berkshelf::Dependency.class_variable_set :@@valid_options, @original
-      end
-
-      it 'adds the given symbol to the list of valid options on Berkshelf::Dependency' do
-        subject.set_valid_options(:mundo)
-
-        expect(Berkshelf::Dependency.valid_options).to have(1).item
-        expect(Berkshelf::Dependency.valid_options).to include(:mundo)
-      end
-
-      it 'adds parameters to the list of valid options on the Berkshelf::Dependency' do
-        subject.set_valid_options(:riot, :arenanet)
-
-        expect(Berkshelf::Dependency.valid_options).to have(2).items
-        expect(Berkshelf::Dependency.valid_options).to include(:riot)
-        expect(Berkshelf::Dependency.valid_options).to include(:arenanet)
-      end
-    end
-  end
-
-  let(:name) { "nginx" }
-  let(:constraint) { double('constraint') }
-  let(:dependency) { double('dependency', name: name, version_constraint: constraint) }
-  subject { Class.new(Berkshelf::Location::Base).new(dependency) }
-
-  describe "#download" do
-    context "when #do_download is not defined" do
-      it "raises a AbstractFunction" do
-        expect { subject.download }.to raise_error(Berkshelf::AbstractFunction)
-      end
-    end
-
-    context "when #do_download is defined" do
-      let(:cached) { double('cached') }
-      before { subject.stub(do_download: cached) }
-
-      it "validates the returned cached cookbook" do
-        subject.should_receive(:validate_cached).with(cached).and_return(true)
-        subject.download
-      end
-
-      it "returns the cached cookbook if valid" do
-        subject.stub(validate_cached: true)
-
-        expect(subject.download).to eq(cached)
-      end
-    end
-  end
-
-  describe '#validate_cached' do
-    let(:cached) { double('cached-cb', cookbook_name: name, version: '0.1.0') }
-
-    it 'raises a CookbookValidationFailure error if the version constraint does not satisfy the cached version' do
-      constraint.should_receive(:satisfies?).with(cached.version).and_return(false)
-
-      expect {
-        subject.validate_cached(cached)
-      }.to raise_error(Berkshelf::CookbookValidationFailure)
-    end
-
-    it 'returns true if cached_cookbooks satisfies the version constraint' do
-      constraint.should_receive(:satisfies?).with(cached.version).and_return(true)
-      expect(subject.validate_cached(cached)).to be_true
-    end
-
-    context "when the cached_cookbooks satisfies the version constraint" do
-      it "returns true if the name of the cached_cookbook matches the name of the location" do
-        constraint.should_receive(:satisfies?).with(cached.version).and_return(true)
-        cached.stub(:name) { name }
-        expect(subject.validate_cached(cached)).to be_true
-      end
-
-      it "warns about the MismatchedCookbookName if the cached_cookbook's name does not match the location's" do
-        constraint.should_receive(:satisfies?).with(cached.version).and_return(true)
-        cached.stub(:cookbook_name) { "artifact" }
-        msg = Berkshelf::MismatchedCookbookName.new(dependency, cached).to_s
 
-        Berkshelf.ui.should_receive(:warn).with(msg)
-        subject.validate_cached(cached)
+      it 'returns nil when a location cannot be found' do
+        instance = described_class.init(dependency, lamesauce: 'meats/bacon')
+        expect(instance).to be_nil
       end
     end
   end

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

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe BaseLocation do
+    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
+        expect { subject.installed? }.to raise_error(AbstractFunction)
+      end
+    end
+
+    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
+        expect { subject.cached_cookbook }.to raise_error(AbstractFunction)
+      end
+    end
+
+    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
+        before { File.stub(:cookbook?).and_return(false) }
+
+        it 'raises an error' do
+          expect {
+            subject.validate_cached!('/foo/bar')
+          }.to raise_error(NotACookbook)
+        end
+      end
+
+      context 'when the path is a cookbook' do
+        let(:cookbook) do
+          double('cookbook',
+            cookbook_name: 'cookbook',
+            version: '0.1.0',
+          )
+        end
+
+        before do
+          File.stub(:cookbook?).and_return(true)
+          CachedCookbook.stub(:from_path).and_return(cookbook)
+        end
+
+        it 'raises an error if the constraint does not satisfy' do
+          constraint.stub(: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')
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe GitLocation do
+    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')
+    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')
+      end
+
+      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')
+      end
+
+      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')
+      end
+
+      it 'adds the ref' do
+        instance = described_class.new(dependency,
+          git: 'https://repo.com', ref: 'abc123')
+        expect(instance.ref).to eq('abc123')
+      end
+
+      it 'sets the revision' do
+        instance = described_class.new(dependency,
+          git: 'https://repo.com', revision: 'abcde12345')
+        expect(instance.revision).to eq('abcde12345')
+      end
+
+      it 'sets the rel' do
+        instance = described_class.new(dependency,
+          git: 'https://repo.com', rel: 'internal/path')
+        expect(instance.rel).to eq('internal/path')
+      end
+
+      context 'rev_parse' do
+        def rev_parse(instance)
+          instance.instance_variable_get(:@rev_parse)
+        end
+
+        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')
+        end
+
+        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')
+        end
+
+        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')
+        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')
+        end
+      end
+    end
+
+    describe '#installed?' do
+      it 'returns false when there is no revision' do
+        subject.stub(: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
+      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
+      end
+    end
+
+    describe '#install' do
+      before do
+        File.stub(:chmod)
+        FileUtils.stub(:cp_r)
+        subject.stub(:validate_cached!)
+        subject.stub(: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
+
+          subject.stub(:cached?).and_return(true)
+          expect(subject).to receive(:git).with(
+            'fetch --force --tags https://repo.com "refs/heads/*:refs/heads/*"'
+          )
+          subject.install
+        end
+      end
+
+      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
+
+          cache_path = subject.send(:cache_path)
+          subject.stub(:cached?).and_return(false)
+          expect(subject).to receive(:git).with(
+            %|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
+        subject.stub(: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)
+
+        expect(CachedCookbook).to receive(:from_path).once
+        subject.cached_cookbook
+      end
+    end
+
+    describe '#==' do
+      let(:other) { subject.dup }
+
+      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
+        other.stub(: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')
+        expect(subject).to_not eq(other)
+      end
+
+      it 'returns false when the branch is different' do
+        other.stub(: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')
+        expect(subject).to_not eq(other)
+      end
+
+      it 'returns false when the ref is different' do
+        other.stub(: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')
+        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)')
+      end
+
+      it 'prefers the branch' do
+        subject.stub(: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)
+        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)
+        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}/, '')
+            git: https://repo.com
+            revision: defjkl123456
+            ref: abc123
+            branch: ham
+            tag: v1.2.3
+            rel: hi
+        EOH
+      end
+
+      it 'does not include the branch if missing' do
+        subject.stub(: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)
+        expect(subject.to_lock).to_not include('tag')
+      end
+
+      it 'does not include the rel if missing' do
+        subject.stub(:rel).and_return(nil)
+        expect(subject.to_lock).to_not include('rel')
+      end
+    end
+
+    describe '#git' do
+      before { described_class.send(:public, :git) }
+
+      it 'raises an error if Git is not installed' do
+        Berkshelf.stub(:which).and_return(false)
+        expect { subject.git('foo') }.to raise_error(GitLocation::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)
+        expect { subject.git('foo') }.to raise_error(GitLocation::GitCommandError)
+      end
+    end
+  end
+end