berkshelf 2.0.18 → 3.0.0.beta1

data/spec/unit/berkshelf/downloader_spec.rb

@@ -1,190 +1,11 @@
 require 'spec_helper'
 
 describe Berkshelf::Downloader do
-  let(:locations) do
-    [
-      {
-        type: :chef_api,
-        value: double('capi'),
-        options: double('capi_opts')
-      },
-      {
-        type: :chef_api,
-        value: double('capi2'),
-        options: double('capi_opts2')
-      }
-    ]
+  describe "#download" do
+    pending
   end
 
-  describe '.initialize' do
-    context 'when no value for locations is given' do
-      it 'sets the @locations instance variable to a blank array' do
-        downloader = Berkshelf::Downloader.new(double('store'))
-        locations = downloader.instance_variable_get(:@locations)
-
-        expect(locations).to be_a(Array)
-        expect(locations).to be_empty
-      end
-    end
-
-    context 'when an explicit value of locations is given' do
-      it 'sets the @locations instance variable to the given locations' do
-        downloader = Berkshelf::Downloader.new(double('store'), locations: locations)
-        expect(downloader.instance_variable_get(:@locations)).to eq(locations)
-      end
-    end
-  end
-
-
-
-  let!(:cookbook_store) { Berkshelf::CookbookStore.new(tmp_path) }
-  subject { Berkshelf::Downloader.new(cookbook_store) }
-
-  describe '#download' do
-    let(:source) { double('source', name: 'artifact', version_constraint: '= 0.10.0', locked_version: '0.10.0') }
-    let(:location) { double('location') }
-    let(:cached_cookbook) { double('cached') }
-
-    context 'when the source has a location' do
-      before do
-        source.stub(:location).and_return(location)
-        location.should_receive(:download).with(subject.storage_path).and_return(cached_cookbook)
-        source.should_receive(:cached_cookbook=).with(cached_cookbook)
-      end
-
-      it "sends :download to the source's location and sets the source's cached_cookbook to the result" do
-        expect(subject.download(source)).to be_true
-      end
-
-      it 'returns an Array containing the cached_cookbook and location used to download' do
-        result = subject.download(source)
-
-        expect(result).to be_a(Array)
-        expect(result[0]).to eq(cached_cookbook)
-        expect(result[1]).to eq(location)
-      end
-    end
-
-    context 'when the source does not have a location' do
-      before do
-        source.stub(:location).and_return(nil)
-        subject.stub(:locations).and_return([{ type: :chef_api, value: :config, options: {} }])
-      end
-
-      it 'sends the :download message to the default location' do
-        Berkshelf::Location.should_receive(:init).with(source.name, source.version_constraint, chef_api: :config).and_return(location)
-        location.should_receive(:download).with(subject.storage_path).and_return(cached_cookbook)
-        source.should_receive(:cached_cookbook=).with(cached_cookbook)
-
-        subject.download(source)
-      end
-    end
-  end
-
-  describe '#locations' do
-    let(:type) { :site }
-    let(:value) { double('value') }
-    let(:options) { double('options') }
-
-    it 'returns an array of Hashes representing locations' do
-      subject.add_location(type, value, options)
-
-      subject.locations.each do |location|
-        expect(location).to be_a(Hash)
-      end
-    end
-
-    context 'when no locations are explicitly added' do
-      subject { Berkshelf::Downloader.new(double('store')) }
-
-      it 'returns an array of default locations' do
-        expect(subject.locations).to eq(Berkshelf::Downloader::DEFAULT_LOCATIONS)
-      end
-    end
-
-    context 'when locations are explicitly added' do
-      subject { Berkshelf::Downloader.new(double('store'), locations: locations) }
-
-      it 'contains only the locations passed to the initializer' do
-        expect(subject.locations).to eq(locations)
-      end
-
-      it 'does not include the array of default locations' do
-        expect(subject.locations).to_not include(Berkshelf::Downloader::DEFAULT_LOCATIONS)
-      end
-    end
-  end
-
-  describe '#add_location' do
-    let(:type) { :site }
-    let(:value) { double('value') }
-    let(:options) { double('options') }
-
-    it 'adds a hash to the end of the array of locations' do
-      subject.add_location(type, value, options)
-      expect(subject.locations).to have(1).item
-    end
-
-    it 'adds a hash with a type, value, and options key' do
-      subject.add_location(type, value, options)
-      location = subject.locations.last
-
-      [:type, :value, :options].each do |key|
-        expect(location).to have_key(key)
-      end
-    end
-
-    it 'sets the value of the given :value to the value of the key :value' do
-      subject.add_location(type, value, options)
-      expect(subject.locations.last[:value]).to eq(value)
-    end
-
-    it 'sets the value of the given :type to the value of the key :type' do
-      subject.add_location(type, value, options)
-      expect(subject.locations.last[:type]).to eq(type)
-    end
-
-    it 'sets the value of the given :options to the value of the key :options' do
-      subject.add_location(type, value, options)
-      expect(subject.locations.last[:options]).to eq(options)
-    end
-
-    it 'raises a DuplicateLocationDefined error if a location of the given type and value was already added' do
-      subject.add_location(type, value, options)
-
-      expect {
-        subject.add_location(type, value, options)
-      }.to raise_error(Berkshelf::DuplicateLocationDefined)
-    end
-
-    context 'adding multiple locations' do
-      let(:type_2) { :site }
-      let(:value_2) { double('value_2') }
-      let(:options_2) { double('options_2') }
-
-      it 'adds locations in the order they are added' do
-        subject.add_location(type, value, options)
-        subject.add_location(type_2, value_2, options_2)
-
-        expect(subject.locations).to have(2).items
-
-        expect(subject.locations[0][:value]).to eql(value)
-        expect(subject.locations[1][:value]).to eql(value_2)
-      end
-    end
-  end
-
-  describe '#has_location?' do
-    let(:type) { :site }
-    let(:value) { double('value') }
-
-    it 'returns true if a source of the given type and value was already added' do
-      subject.add_location(type, value)
-      expect(subject.has_location?(type, value)).to be_true
-    end
-
-    it 'returns false if a source of the given type and value was not added' do
-      expect(subject.has_location?(type, value)).to be_false
-    end
+  describe "#try_download" do
+    pending
   end
 end

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

@@ -7,7 +7,7 @@ describe Berkshelf::Formatters::Null do
     it "does not raise an error for :#{meth}" do
       expect {
         subject.send(meth)
-      }.to_not raise_error
+      }.to_not raise_error(Berkshelf::AbstractFunction)
     end
 
     it "returns nil for :#{meth}" do

data/spec/unit/berkshelf/formatters_spec.rb

@@ -77,8 +77,6 @@ describe Berkshelf::Formatters do
       end
     end
 
-
-
     subject do
       Class.new { include Berkshelf::Formatters::AbstractFormatter }.new
     end
@@ -107,6 +105,10 @@ describe Berkshelf::Formatters do
       expect {
         subject.error('whoa this is bad')
       }.to raise_error(Berkshelf::AbstractFunction)
+
+      expect {
+        subject.fetch(double('dependency'))
+      }.to raise_error(Berkshelf::AbstractFunction)
     end
   end
 end

data/spec/unit/berkshelf/git_spec.rb

@@ -18,7 +18,7 @@ describe Berkshelf::Git do
   end
 
   describe '.clone' do
-    let(:target) { clone_target_for('nginx') }
+    let(:target) { clone_path('nginx') }
 
     it 'clones the repository to the target path' do
       origin_uri = git_origin_for('nginx')
@@ -30,7 +30,7 @@ describe Berkshelf::Git do
   end
 
   describe '.checkout' do
-    let(:repo_path) { clone_target_for('nginx') }
+    let(:repo_path) { clone_path('nginx') }
     let(:repo) {
       origin_uri = git_origin_for('nginx', tags: ['1.0.1', '1.0.2'], branches: ['topic', 'next_topic'])
       git.clone(origin_uri, repo_path)
@@ -48,7 +48,7 @@ describe Berkshelf::Git do
     end
 
     context 'with sha commit id' do
-      let(:ref) { git_sha_for_ref('nginx', '1.0.1') }
+      let(:ref) { sha_for_ref('nginx', '1.0.1') }
 
       it_behaves_like 'able to checkout git ref'
     end
@@ -63,7 +63,7 @@ describe Berkshelf::Git do
         before do
           git.checkout(repo, other_tag)
           Dir.chdir repo_path do
-            run! "echo 'uncommitted change' >> content_file"
+            shell_out "echo 'uncommitted change' >> content_file"
           end
         end
 
@@ -81,7 +81,7 @@ describe Berkshelf::Git do
         before do
           git.checkout(repo, other_branch)
           Dir.chdir repo_path do
-            run! "echo 'uncommitted change' >> content_file"
+            shell_out "echo 'uncommitted change' >> content_file"
           end
         end
 
@@ -91,23 +91,23 @@ describe Berkshelf::Git do
   end
 
   describe '.rev_parse' do
-    let(:repo_path) { clone_target_for('nginx') }
+    let(:repo_path) { clone_path('nginx') }
     before(:each) do |example|
       origin_uri = git_origin_for('nginx', tags: ['1.1.1'])
       Berkshelf::Git.clone(origin_uri, repo_path)
-      Berkshelf::Git.checkout(repo_path, git_sha_for_ref('nginx', '1.1.1'))
+      Berkshelf::Git.checkout(repo_path, sha_for_ref('nginx', '1.1.1'))
     end
 
     it 'returns the ref for HEAD' do
       rev = Berkshelf::Git.rev_parse(repo_path)
-      ref = git_sha_for_ref('nginx', '1.1.1')
+      ref = sha_for_ref('nginx', '1.1.1')
 
       expect(rev).to eql(ref)
     end
   end
 
   describe '.show_ref' do
-    let(:repo_path) { clone_target_for('nginx') }
+    let(:repo_path) { clone_path('nginx') }
     let(:tags) { ['1.0.1'] }
     let(:branches) { ['topic'] }
     let!(:repo) {
@@ -117,14 +117,14 @@ describe Berkshelf::Git do
 
     it 'returns the commit id for the given tag' do
       show = git.show_ref(repo_path, '1.0.1')
-      ref = git_sha_for_ref('nginx', '1.0.1')
+      ref = sha_for_ref('nginx', '1.0.1')
 
       expect(show).to eq(ref)
     end
 
     it 'returns the commit id for the given branch' do
       show = git.show_ref(repo_path, 'topic')
-      ref = git_sha_for_ref('nginx', 'topic')
+      ref = sha_for_ref('nginx', 'topic')
       expect(show).to eq(ref)
     end
 
@@ -141,7 +141,7 @@ describe Berkshelf::Git do
   end
 
   describe '.revision_from_ref' do
-    let(:repo_path) { clone_target_for('nginx') }
+    let(:repo_path) { clone_path('nginx') }
     let(:tags) { ['1.0.1'] }
     let(:branches) { ['topic'] }
     let!(:repo) {
@@ -150,7 +150,7 @@ describe Berkshelf::Git do
     }
 
     context 'with sha commit id' do
-      let(:revision) { git_sha_for_ref('nginx', '1.0.1') }
+      let(:revision) { sha_for_ref('nginx', '1.0.1') }
       it 'returns the passed revision' do
         rev = git.revision_from_ref(repo_path, revision)
         expect(rev).to eq(revision)
@@ -158,7 +158,7 @@ describe Berkshelf::Git do
     end
 
     context 'with tag' do
-      let(:revision) { git_sha_for_ref('nginx', '1.0.1') }
+      let(:revision) { sha_for_ref('nginx', '1.0.1') }
       it 'returns the revision' do
         rev = git.revision_from_ref(repo_path, '1.0.1')
         expect(rev).to eq(revision)
@@ -166,7 +166,7 @@ describe Berkshelf::Git do
     end
 
     context 'with branch' do
-      let(:revision) { git_sha_for_ref('nginx', 'topic') }
+      let(:revision) { sha_for_ref('nginx', 'topic') }
       it 'returns the revision' do
         rev = git.revision_from_ref(repo_path, 'topic')
         expect(rev).to eq(revision)

data/spec/unit/berkshelf/installer_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Berkshelf::Installer do
+  let(:berksfile) { double('berksfile') }
+  subject { described_class.new(berksfile) }
+
+  describe "#build_universe" do
+    let(:source_one) { double('one') }
+    let(:source_two) { double('two') }
+    let(:sources) { [ source_one, source_two ] }
+
+    before { berksfile.stub(sources: sources) }
+
+    it "sends the message #universe on each source" do
+      source_one.should_receive(:universe)
+      source_two.should_receive(:universe)
+
+      subject.build_universe
+    end
+  end
+
+  describe "#run" do
+    context 'when a lockfile is not present' do
+      pending
+    end
+
+    context 'when a value for :except is given' do
+      pending
+    end
+
+    context 'when a value for :only is given' do
+      pending
+    end
+  end
+
+  describe "#verify_licenses!" do
+    pending
+  end
+end

data/spec/unit/berkshelf/location_spec.rb

@@ -1,150 +1,123 @@
 require 'spec_helper'
 
 describe Berkshelf::Location do
-  # Since this is a module, we need to test the implementation via a class
-  let(:klass) { Class.new { include Berkshelf::Location } }
+  describe "ClassMethods" do
+    describe "::init" do
+      let(:dependency) { double('dependency') }
 
-  describe '.set_location_key' do
-    before do
-      @original = Berkshelf::CookbookSource.class_variable_get :@@location_keys
-      Berkshelf::CookbookSource.class_variable_set :@@location_keys, {}
-    end
-
-    after do
-      Berkshelf::CookbookSource.class_variable_set :@@location_keys, @original
-    end
-
-    it 'adds the given location key CookbookSource.location_keys' do
-      klass.set_location_key(:reset)
-
-      expect(Berkshelf::CookbookSource.location_keys).to have(1).item
-      expect(Berkshelf::CookbookSource.location_keys).to include(:reset)
-      expect(Berkshelf::CookbookSource.location_keys[:reset]).to eq(klass)
-    end
-  end
-
-  describe '.location_key' do
-    before do
-      @original = Berkshelf::CookbookSource.class_variable_get :@@location_keys
-      Berkshelf::CookbookSource.class_variable_set :@@location_keys, {}
-    end
+      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)
+      end
 
-    after do
-      Berkshelf::CookbookSource.class_variable_set :@@location_keys, @original
-    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)
+      end
 
-    it "returns the class' registered location key" do
-      klass.set_location_key(:reset)
-      expect(klass.location_key).to eq(:reset)
+      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
+      end
     end
   end
+end
 
-  describe '.set_valid_options' do
-    before do
-      @original = Berkshelf::CookbookSource.class_variable_get :@@valid_options
-      Berkshelf::CookbookSource.class_variable_set :@@valid_options, []
-    end
-
-    after do
-      Berkshelf::CookbookSource.class_variable_set :@@valid_options, @original
-    end
+describe Berkshelf::Location::Base do
+  describe "ClassMethods" do
+    subject { Class.new(described_class) }
 
-    it 'adds the given symbol to the list of valid options on CookbookSource' do
-      klass.set_valid_options(:mundo)
+    describe "::set_location_key" do
+      before do
+        @original = Berkshelf::Dependency.class_variable_get :@@location_keys
+        Berkshelf::Dependency.class_variable_set :@@location_keys, {}
+      end
 
-      expect(Berkshelf::CookbookSource.valid_options).to have(1).item
-      expect(Berkshelf::CookbookSource.valid_options).to include(:mundo)
-    end
+      after do
+        Berkshelf::Dependency.class_variable_set :@@location_keys, @original
+      end
 
-    it 'adds parameters to the list of valid options on the CookbookSource' do
-      klass.set_valid_options(:riot, :arenanet)
+      it 'adds the given location key Berkshelf::Dependency.location_keys' do
+        subject.set_location_key(:reset)
 
-      expect(Berkshelf::CookbookSource.valid_options).to have(2).items
-      expect(Berkshelf::CookbookSource.valid_options).to include(:riot)
-      expect(Berkshelf::CookbookSource.valid_options).to include(:arenanet)
+        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
-  end
 
-  describe '.solve_for_constraint' do
-    let(:constraint) { '~> 0.101.2' }
-    let(:versions) do
-      {
-        '0.101.2' => 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2',
-        '0.101.0' => 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_0',
-        '0.100.2' => 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_100_2',
-        '0.100.0' => 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_100_0'
-      }
-    end
+    describe "::location_key" do
+      before do
+        @original = Berkshelf::Dependency.class_variable_get :@@location_keys
+        Berkshelf::Dependency.class_variable_set :@@location_keys, {}
+      end
 
-    it 'returns an array with a string containing the version of the solution at index 0' do
-      result = klass.solve_for_constraint(constraint, versions)
-      expect(result[0]).to eq('0.101.2')
-    end
+      after do
+        Berkshelf::Dependency.class_variable_set :@@location_keys, @original
+      end
 
-    it 'returns an array containing a URI at index 0' do
-      result = klass.solve_for_constraint(constraint, versions)
-      expect(result[1]).to match(URI.regexp)
+      it "returns the class' registered location key" do
+        subject.set_location_key(:reset)
+        expect(subject.location_key).to eq(:reset)
+      end
     end
 
-    it 'returns the best match for the constraint and versions given' do
-      expect(klass.solve_for_constraint(constraint, versions)[0].to_s).to eql('0.101.2')
-    end
+    describe "::set_valid_options" do
+      before do
+        @original = Berkshelf::Dependency.class_variable_get :@@valid_options
+        Berkshelf::Dependency.class_variable_set :@@valid_options, []
+      end
 
-    context 'given a solution can not be found for constraint' do
-      it 'returns nil' do
-        result = klass.solve_for_constraint(Solve::Constraint.new('>= 1.0'), versions)
-        expect(result).to be_nil
+      after do
+        Berkshelf::Dependency.class_variable_set :@@valid_options, @original
       end
-    end
-  end
 
-  describe ';init' do
-    let(:name) { 'artifact' }
-    let(:constraint) { double('constraint') }
+      it 'adds the given symbol to the list of valid options on Berkshelf::Dependency' do
+        subject.set_valid_options(:mundo)
 
-    it 'returns an instance of SiteLocation given a site: option key' do
-      result = Berkshelf::Location.init(name, constraint, site: 'http://site/value')
-      expect(result).to be_a(Berkshelf::SiteLocation)
-    end
+        expect(Berkshelf::Dependency.valid_options).to have(1).item
+        expect(Berkshelf::Dependency.valid_options).to include(:mundo)
+      end
 
-    it 'returns an instance of PathLocation given a path: option key' do
-      result = Berkshelf::Location.init(name, constraint, path: '/Users/reset/code')
-      expect(result).to be_a(Berkshelf::PathLocation)
-    end
+      it 'adds parameters to the list of valid options on the Berkshelf::Dependency' do
+        subject.set_valid_options(:riot, :arenanet)
 
-    it 'returns an instance of GitLocation given a git: option key' do
-      result = Berkshelf::Location.init(name, constraint, git: 'git://github.com/something.git')
-      expect(result).to be_a(Berkshelf::GitLocation)
+        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
 
-    it 'returns an instance of SiteLocation when no option key is given that matches a registered location_key' do
-      result = Berkshelf::Location.init(name, constraint)
-      expect(result).to be_a(Berkshelf::SiteLocation)
-    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) }
 
-    context 'given two location_keys' do
-      it 'raises an InternalError' do
-        expect {
-          Berkshelf::Location.init(name, constraint, git: :value, path: :value)
-        }.to raise_error(Berkshelf::InternalError)
+  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
-  end
-
 
+    context "when #do_download is defined" do
+      let(:cached) { double('cached') }
+      before { subject.stub(do_download: cached) }
 
-  let(:name) { 'nginx' }
-  let(:constraint) { double('constraint') }
+      it "validates the returned cached cookbook" do
+        subject.should_receive(:validate_cached).with(cached).and_return(true)
+        subject.download
+      end
 
-  subject do
-    Class.new { include Berkshelf::Location }.new(name, constraint)
-  end
+      it "returns the cached cookbook if valid" do
+        subject.stub(validate_cached: true)
 
-  describe '#download' do
-    it 'raises a AbstractFunction if not defined' do
-      expect {
-        subject.download(double('destination'))
-      }.to raise_error(Berkshelf::AbstractFunction)
+        expect(subject.download).to eq(cached)
+      end
     end
   end
 
@@ -174,7 +147,7 @@ describe Berkshelf::Location do
       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(subject, cached).to_s
+        msg = Berkshelf::MismatchedCookbookName.new(dependency, cached).to_s
 
         Berkshelf.ui.should_receive(:warn).with(msg)
         subject.validate_cached(cached)