berkshelf 1.3.1 → 1.4.0.rc1

data/lib/berkshelf/errors.rb

@@ -65,7 +65,6 @@ module Berkshelf
   class DuplicateSourceDefined < BerkshelfError; status_code(105); end
   class NoSolution < BerkshelfError; status_code(106); end
   class CookbookSyntaxError < BerkshelfError; status_code(107); end
-  class UploadFailure < BerkshelfError; status_code(108); end
   class BerksConfigNotFound < BerkshelfError; status_code(109); end
 
   class InvalidGitURI < BerkshelfError
@@ -150,4 +149,7 @@ module Berkshelf
   class CommunitySiteError < BerkshelfError; status_code(123); end
   class CookbookValidationFailure < BerkshelfError; status_code(124); end
   class ClientKeyFileNotFound < BerkshelfError; status_code(125); end
+
+  class UploadFailure < BerkshelfError; end
+  class FrozenCookbook < UploadFailure; status_code(126); end
 end

data/lib/berkshelf/locations/git_location.rb

@@ -20,6 +20,7 @@ module Berkshelf
     attr_accessor :uri
     attr_accessor :branch
     attr_accessor :rel
+    attr_reader :options
 
     alias_method :ref, :branch
     alias_method :tag, :branch
@@ -52,6 +53,8 @@ module Berkshelf
     #
     # @return [Berkshelf::CachedCookbook]
     def download(destination)
+      return local_revision(destination) if cached?(destination)
+
       ::Berkshelf::Git.checkout(clone, branch) if branch
       unless branch
         self.branch = ::Berkshelf::Git.rev_parse(clone)
@@ -104,5 +107,21 @@ module Berkshelf
 
         tmp_clone
       end
+
+      def cached?(destination)
+        revision_path(destination) && File.exists?(revision_path(destination))
+      end
+
+      def local_revision(destination)
+        path = revision_path(destination)
+        cached = Berkshelf::CachedCookbook.from_store_path(path)
+        validate_cached(cached)
+        return cached
+      end
+
+      def revision_path(destination)
+        return unless branch
+        File.join(destination, "#{name}-#{branch}")
+      end
   end
 end

data/lib/berkshelf/locations/path_location.rb

@@ -25,6 +25,7 @@ module Berkshelf
     set_location_key :path
 
     attr_accessor :path
+    attr_reader :name
 
     # @param [#to_s] name
     # @param [Solve::Constraint] version_constraint
@@ -43,7 +44,7 @@ module Berkshelf
     #
     # @return [Berkshelf::CachedCookbook]
     def download(destination)
-      cached = CachedCookbook.from_path(File.expand_path(path))
+      cached = CachedCookbook.from_path(path, name: name)
       validate_cached(cached)
 
       set_downloaded_status(true)

data/lib/berkshelf/logger.rb

@@ -0,0 +1,9 @@
+module Berkshelf
+  Logger = Celluloid::Logger
+
+  Logger.module_eval do
+    def self.fatal(string)
+      error(string)
+    end
+  end
+end

data/lib/berkshelf/mixin/logging.rb

@@ -0,0 +1,18 @@
+module Berkshelf
+  module Mixin
+    # @author Jamie Winsor <reset@riotgames.com>
+    module Logging
+      def log
+        Berkshelf::Logger
+      end
+
+      # Log an exception and it's backtrace to FATAL
+      #
+      # @param [Exception] ex
+      def log_exception(ex)
+        log.fatal("#{ex.class}: #{ex}")
+        log.fatal(ex.backtrace.join("\n")) unless ex.backtrace.nil?
+      end
+    end
+  end
+end

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "1.3.1"
+  VERSION = "1.4.0.rc1"
 end

data/spec/support/chef_api.rb

@@ -20,9 +20,9 @@ module Berkshelf
       # @param [#to_s] version
       def purge_cookbook(name, version = nil)
         if version.nil?
-          ridley.cookbook.delete_all(name, purge: true)
+          ridley.cookbook.delete_all(name)
         else
-          ridley.cookbook.delete(name, version, purge: true)
+          ridley.cookbook.delete(name, version)
         end
       rescue Ridley::Errors::HTTPNotFound
         true

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -1,411 +1,407 @@
 require 'spec_helper'
 
-module Berkshelf
-  describe Berksfile do
-    let(:content) do
+describe Berkshelf::Berksfile do
+  let(:content) do
 <<-EOF
 cookbook 'ntp', '<= 1.0.0'
 cookbook 'mysql'
 cookbook 'nginx', '< 0.101.2'
 cookbook 'ssh_known_hosts2', :git => 'https://github.com/erikh/chef-ssh_known_hosts2.git'
 EOF
-    end
+  end
 
-    describe "ClassMethods" do
-      subject { Berksfile }
+  describe "ClassMethods" do
+    subject { described_class }
 
-      describe "::from_file" do
-        let(:cookbook_file) { fixtures_path.join('lockfile_spec', 'with_lock', 'Berksfile') }
+    describe "::from_file" do
+      let(:cookbook_file) { fixtures_path.join('lockfile_spec', 'with_lock', 'Berksfile') }
 
-        it "reads a Berksfile and returns an instance Berksfile" do
-          subject.from_file(cookbook_file).should be_a(Berksfile)
-        end
+      it "reads a Berksfile and returns an instance Berksfile" do
+        subject.from_file(cookbook_file).should be_a(Berkshelf::Berksfile)
+      end
 
-        context "when Berksfile does not exist at given path" do
-          let(:bad_path) { tmp_path.join("thisdoesnotexist") }
+      context "when Berksfile does not exist at given path" do
+        let(:bad_path) { tmp_path.join("thisdoesnotexist") }
 
-          it "raises BerksfileNotFound" do
-            lambda {
-              subject.from_file(bad_path)
-            }.should raise_error(BerksfileNotFound)
-          end
+        it "raises BerksfileNotFound" do
+          lambda {
+            subject.from_file(bad_path)
+          }.should raise_error(Berkshelf::BerksfileNotFound)
         end
       end
+    end
+
+    describe "::vendor" do
+      let(:cached_cookbooks) { [] }
+      let(:tmpdir) { Dir.mktmpdir(nil, tmp_path) }
 
-      describe "::vendor" do
-        let(:cached_cookbooks) { [] }
-        let(:tmpdir) { Dir.mktmpdir(nil, tmp_path) }
+      it "returns the expanded filepath of the vendor directory" do
+        subject.vendor(cached_cookbooks, tmpdir).should eql(tmpdir)
+      end
 
-        it "returns the expanded filepath of the vendor directory" do
-          subject.vendor(cached_cookbooks, tmpdir).should eql(tmpdir)
+      context "with a chefignore" do
+        it "finds a chefignore file" do
+          Berkshelf::Chef::Cookbook::Chefignore.should_receive(:find_relative_to).and_return(File.expand_path('chefignore'))
+          subject.vendor(cached_cookbooks, tmpdir)
         end
 
-        context "with a chefignore" do
-          before(:each) do
-            File.stub(:exists?).and_return(true)
-            Berkshelf::Chef::Cookbook::Chefignore.any_instance.stub(:remove_ignores_from).and_return(['metadata.rb'])
-          end
-
-          it "finds a chefignore file" do
-            Berkshelf::Chef::Cookbook::Chefignore.should_receive(:new).with(File.expand_path('chefignore'))
-            subject.vendor(cached_cookbooks, tmpdir)
-          end
-
-          it "removes files in chefignore" do
-            cached_cookbooks = [ CachedCookbook.from_path(fixtures_path.join('cookbooks/example_cookbook')) ]
-            FileUtils.should_receive(:cp_r).with(['metadata.rb'], anything()).exactly(1).times
-            FileUtils.should_receive(:cp_r).with(anything(), anything(), anything()).once
-            subject.vendor(cached_cookbooks, tmpdir)
-          end
+        it "ignores files specified by a chefignore if a chefignore is present" do
+          Berkshelf::Chef::Cookbook::Chefignore.should_receive(:find_relative_to).and_return(File.expand_path('chefignore'))
+          Berkshelf::Chef::Cookbook::Chefignore.any_instance.stub(:remove_ignores_from).and_return(['metadata.rb'])
+          subject.vendor(cached_cookbooks, tmpdir)
         end
       end
     end
+  end
 
-    let(:source_one) { double('source_one', name: "nginx") }
-    let(:source_two) { double('source_two', name: "mysql") }
+  let(:source_one) { double('source_one', name: "nginx") }
+  let(:source_two) { double('source_two', name: "mysql") }
 
-    subject { Berksfile.new(tmp_path.join("Berksfile")) }
+  subject { described_class.new(tmp_path.join("Berksfile")) }
 
-    describe "#cookbook" do
-      let(:name) { "artifact" }
-      let(:constraint) { double('constraint') }
-      let(:default_options) { { group: [] } }
+  describe "#cookbook" do
+    let(:name) { "artifact" }
+    let(:constraint) { double('constraint') }
+    let(:default_options) { { group: [] } }
 
-      it "sends the add_source message with the name, constraint, and options to the instance of the includer" do
-        subject.should_receive(:add_source).with(name, constraint, default_options)
+    it "sends the add_source message with the name, constraint, and options to the instance of the includer" do
+      subject.should_receive(:add_source).with(name, constraint, default_options)
 
-        subject.cookbook name, constraint, default_options
-      end
+      subject.cookbook name, constraint, default_options
+    end
 
-      it "merges the default options into specified options" do
-        subject.should_receive(:add_source).with(name, constraint, path: "/Users/reset", group: [])
+    it "merges the default options into specified options" do
+      subject.should_receive(:add_source).with(name, constraint, path: "/Users/reset", group: [])
 
-        subject.cookbook name, constraint, path: "/Users/reset"
-      end
+      subject.cookbook name, constraint, path: "/Users/reset"
+    end
 
-      it "converts a single specified group option into an array of groups" do
-        subject.should_receive(:add_source).with(name, constraint, group: [:production])
+    it "converts a single specified group option into an array of groups" do
+      subject.should_receive(:add_source).with(name, constraint, group: [:production])
 
-        subject.cookbook name, constraint, group: :production
-      end
+      subject.cookbook name, constraint, group: :production
+    end
 
-      context "when no constraint specified" do
-        it "sends the add_source message with a nil value for constraint" do
-          subject.should_receive(:add_source).with(name, nil, default_options)
+    context "when no constraint specified" do
+      it "sends the add_source message with a nil value for constraint" do
+        subject.should_receive(:add_source).with(name, nil, default_options)
 
-          subject.cookbook name, default_options
-        end
+        subject.cookbook name, default_options
       end
+    end
 
-      context "when no options specified" do
-        it "sends the add_source message with an empty Hash for the value of options" do
-          subject.should_receive(:add_source).with(name, constraint, default_options)
+    context "when no options specified" do
+      it "sends the add_source message with an empty Hash for the value of options" do
+        subject.should_receive(:add_source).with(name, constraint, default_options)
 
-          subject.cookbook name, constraint
-        end
+        subject.cookbook name, constraint
       end
     end
+  end
 
-    describe '#group' do
-      let(:name) { "artifact" }
-      let(:group) { "production" }
+  describe '#group' do
+    let(:name) { "artifact" }
+    let(:group) { "production" }
 
-      it "sends the add_source message with an array of groups determined by the parameter passed to the group block" do
-        subject.should_receive(:add_source).with(name, nil, group: [group])
+    it "sends the add_source message with an array of groups determined by the parameter passed to the group block" do
+      subject.should_receive(:add_source).with(name, nil, group: [group])
 
-        subject.group group do
-          subject.cookbook name
-        end
+      subject.group group do
+        subject.cookbook name
       end
     end
+  end
 
-    describe "#metadata" do
-      let(:cb_path) { fixtures_path.join('cookbooks/example_cookbook') }
-      subject { Berksfile.new(cb_path.join("Berksfile")) }
+  describe "#metadata" do
+    let(:cb_path) { fixtures_path.join('cookbooks/example_cookbook') }
+    subject { described_class.new(cb_path.join("Berksfile")) }
 
-      before(:each) { Dir.chdir(cb_path) }
+    before(:each) { Dir.chdir(cb_path) }
 
-      it "sends the add_source message with an explicit version constraint and the path to the cookbook" do
-        subject.should_receive(:add_source).with("example_cookbook", "= 0.5.0", path: cb_path.to_s)
+    it "sends the add_source message with an explicit version constraint and the path to the cookbook" do
+      subject.should_receive(:add_source).with("example_cookbook", "= 0.5.0", path: cb_path.to_s)
 
-        subject.metadata
-      end
+      subject.metadata
     end
+  end
 
-    describe "#site" do
-      let(:uri) { "http://opscode/v1" }
+  describe "#site" do
+    let(:uri) { "http://opscode/v1" }
 
-      it "sends the add_location to the instance of the implementing class with a SiteLocation" do
-        subject.should_receive(:add_location).with(:site, uri)
+    it "sends the add_location to the instance of the implementing class with a SiteLocation" do
+      subject.should_receive(:add_location).with(:site, uri)
 
-        subject.site(uri)
-      end
+      subject.site(uri)
+    end
 
-      context "given the symbol :opscode" do
-        it "sends an add_location message with the default Opscode Community API as the first parameter" do
-          subject.should_receive(:add_location).with(:site, :opscode)
+    context "given the symbol :opscode" do
+      it "sends an add_location message with the default Opscode Community API as the first parameter" do
+        subject.should_receive(:add_location).with(:site, :opscode)
 
-          subject.site(:opscode)
-        end
+        subject.site(:opscode)
       end
     end
+  end
 
-    describe "#chef_api" do
-      let(:uri) { "http://chef:8080/" }
+  describe "#chef_api" do
+    let(:uri) { "http://chef:8080/" }
 
-      it "sends and add_location message with the type :chef_api and the given URI" do
-        subject.should_receive(:add_location).with(:chef_api, uri, {})
+    it "sends and add_location message with the type :chef_api and the given URI" do
+      subject.should_receive(:add_location).with(:chef_api, uri, {})
 
-        subject.chef_api(uri)
-      end
+      subject.chef_api(uri)
+    end
 
-      it "also sends any options passed" do
-        options = { node_name: "reset", client_key: "/Users/reset/.chef/reset.pem" }
-        subject.should_receive(:add_location).with(:chef_api, uri, options)
+    it "also sends any options passed" do
+      options = { node_name: "reset", client_key: "/Users/reset/.chef/reset.pem" }
+      subject.should_receive(:add_location).with(:chef_api, uri, options)
 
-        subject.chef_api(uri, options)
-      end
+      subject.chef_api(uri, options)
+    end
 
-      context "given the symbol :config" do
-        it "sends an add_location message with the the type :chef_api and the URI :config" do
-          subject.should_receive(:add_location).with(:chef_api, :config, {})
+    context "given the symbol :config" do
+      it "sends an add_location message with the the type :chef_api and the URI :config" do
+        subject.should_receive(:add_location).with(:chef_api, :config, {})
 
-          subject.chef_api(:config)
-        end
+        subject.chef_api(:config)
       end
     end
+  end
 
-    describe "#sources" do
-      let(:groups) do
-        [
-          :nautilus,
-          :skarner
-        ]
-      end
+  describe "#sources" do
+    let(:groups) do
+      [
+        :nautilus,
+        :skarner
+      ]
+    end
 
-      it "returns all CookbookSources added to the instance of Berksfile" do
-        subject.add_source(source_one.name)
-        subject.add_source(source_two.name)
+    it "returns all CookbookSources added to the instance of Berksfile" do
+      subject.add_source(source_one.name)
+      subject.add_source(source_two.name)
 
-        subject.sources.should have(2).items
-        subject.should have_source(source_one.name)
-        subject.should have_source(source_two.name)
-      end
+      subject.sources.should have(2).items
+      subject.should have_source(source_one.name)
+      subject.should have_source(source_two.name)
+    end
 
-      context "given the option :except" do
-        before(:each) do
-          source_one.stub(:groups) { [:default, :skarner] }
-          source_two.stub(:groups) { [:default, :nautilus] }
-        end
+    context "given the option :except" do
+      before(:each) do
+        source_one.stub(:groups) { [:default, :skarner] }
+        source_two.stub(:groups) { [:default, :nautilus] }
+      end
 
-        it "returns all of the sources except the ones in the given groups" do
-          subject.add_source(source_one.name, nil, group: [:default, :skarner])
-          subject.add_source(source_two.name, nil, group: [:default, :nautilus])
-          filtered = subject.sources(except: :nautilus)
+      it "returns all of the sources except the ones in the given groups" do
+        subject.add_source(source_one.name, nil, group: [:default, :skarner])
+        subject.add_source(source_two.name, nil, group: [:default, :nautilus])
+        filtered = subject.sources(except: :nautilus)
 
-          filtered.should have(1).item
-          filtered.first.name.should eql(source_one.name)
-        end
+        filtered.should have(1).item
+        filtered.first.name.should eql(source_one.name)
       end
+    end
 
-      context "given the option :only" do
-        before(:each) do
-          source_one.stub(:groups) { [:default, :skarner] }
-          source_two.stub(:groups) { [:default, :nautilus] }
-        end
+    context "given the option :only" do
+      before(:each) do
+        source_one.stub(:groups) { [:default, :skarner] }
+        source_two.stub(:groups) { [:default, :nautilus] }
+      end
 
-        it "returns only the sources in the givne groups" do
-          subject.add_source(source_one.name, nil, group: [:default, :skarner])
-          subject.add_source(source_two.name, nil, group: [:default, :nautilus])
-          filtered = subject.sources(only: :nautilus)
+      it "returns only the sources in the givne groups" do
+        subject.add_source(source_one.name, nil, group: [:default, :skarner])
+        subject.add_source(source_two.name, nil, group: [:default, :nautilus])
+        filtered = subject.sources(only: :nautilus)
 
-          filtered.should have(1).item
-          filtered.first.name.should eql(source_two.name)
-        end
+        filtered.should have(1).item
+        filtered.first.name.should eql(source_two.name)
       end
+    end
 
-      context "when a value for :only and :except is given" do
-        it "raises an ArgumentError" do
-          lambda {
-            subject.sources(only: [:default], except: [:other])
-          }.should raise_error(Berkshelf::ArgumentError, "Cannot specify both :except and :only")
-        end
+    context "when a value for :only and :except is given" do
+      it "raises an ArgumentError" do
+        lambda {
+          subject.sources(only: [:default], except: [:other])
+        }.should raise_error(Berkshelf::ArgumentError, "Cannot specify both :except and :only")
       end
     end
+  end
 
-    describe "#groups" do
-      before(:each) do
-        subject.stub(:sources) { [source_one, source_two] }
-        source_one.stub(:groups) { [:nautilus, :skarner] }
-        source_two.stub(:groups) { [:nautilus, :riven] }
-      end
+  describe "#groups" do
+    before(:each) do
+      subject.stub(:sources) { [source_one, source_two] }
+      source_one.stub(:groups) { [:nautilus, :skarner] }
+      source_two.stub(:groups) { [:nautilus, :riven] }
+    end
 
-      it "returns a hash containing keys for every group a source is a member of" do
-        subject.groups.keys.should have(3).items
-        subject.groups.should have_key(:nautilus)
-        subject.groups.should have_key(:skarner)
-        subject.groups.should have_key(:riven)
-      end
+    it "returns a hash containing keys for every group a source is a member of" do
+      subject.groups.keys.should have(3).items
+      subject.groups.should have_key(:nautilus)
+      subject.groups.should have_key(:skarner)
+      subject.groups.should have_key(:riven)
+    end
 
-      it "returns an Array of CookbookSources who are members of the group for value" do
-        subject.groups[:nautilus].should have(2).items
-        subject.groups[:riven].should have(1).item
-      end
+    it "returns an Array of CookbookSources who are members of the group for value" do
+      subject.groups[:nautilus].should have(2).items
+      subject.groups[:riven].should have(1).item
     end
+  end
 
-    describe "#resolve" do
-      let(:resolver) { double('resolver') }
-      before(:each) { Berkshelf::Resolver.stub(:new) { resolver } }
+  describe "#resolve" do
+    let(:resolver) { double('resolver') }
+    before(:each) { Berkshelf::Resolver.stub(:new) { resolver } }
 
-      it "resolves the Berksfile" do
-        resolver.should_receive(:resolve).and_return([double('cached_cookbook_one'), double('cached_cookbook_two')])
-        solution = subject.resolve
-        solution.should have(2).items
-      end
+    it "resolves the Berksfile" do
+      resolver.should_receive(:resolve).and_return([double('cached_cookbook_one'), double('cached_cookbook_two')])
+      solution = subject.resolve
+      solution.should have(2).items
     end
+  end
 
-    describe "#install" do
-      let(:resolver) { double('resolver') }
-      before(:each) { Berkshelf::Resolver.stub(:new) { resolver } }
+  describe "#install" do
+    let(:resolver) { double('resolver') }
+    before(:each) { Berkshelf::Resolver.stub(:new) { resolver } }
 
-      context "when a lockfile is not present" do
-        before(:each) do
-          subject.should_receive(:lockfile_present?).and_return(false)
-          resolver.should_receive(:sources).and_return([])
-        end
+    context "when a lockfile is not present" do
+      before(:each) do
+        subject.should_receive(:lockfile_present?).and_return(false)
+        resolver.should_receive(:sources).and_return([])
+      end
 
-        let(:cached_cookbooks) do
-          [
-            double('cached_one'),
-            double('cached_two')
-          ]
-        end
+      let(:cached_cookbooks) do
+        [
+          double('cached_one'),
+          double('cached_two')
+        ]
+      end
 
-        it "returns the result from sending the message resolve to resolver" do
-          resolver.should_receive(:resolve).and_return(cached_cookbooks)
+      it "returns the result from sending the message resolve to resolver" do
+        resolver.should_receive(:resolve).and_return(cached_cookbooks)
 
-          subject.install.should eql(cached_cookbooks)
-        end
+        subject.install.should eql(cached_cookbooks)
+      end
 
-        it "sets a value for self.cached_cookbooks equivalent to the return value" do
-          resolver.should_receive(:resolve).and_return(cached_cookbooks)
-          subject.install
+      it "sets a value for self.cached_cookbooks equivalent to the return value" do
+        resolver.should_receive(:resolve).and_return(cached_cookbooks)
+        subject.install
 
-          subject.cached_cookbooks.should eql(cached_cookbooks)
-        end
+        subject.cached_cookbooks.should eql(cached_cookbooks)
+      end
 
-        it "creates a new resolver and finds a solution by calling resolve on the resolver" do
-          resolver.should_receive(:resolve)
+      it "creates a new resolver and finds a solution by calling resolve on the resolver" do
+        resolver.should_receive(:resolve)
 
-          subject.install
-        end
+        subject.install
+      end
 
-        it "writes a lockfile with the resolvers sources" do
-          resolver.should_receive(:resolve)
-          subject.should_receive(:write_lockfile).with([])
+      it "writes a lockfile with the resolvers sources" do
+        resolver.should_receive(:resolve)
+        subject.should_receive(:write_lockfile).with([])
 
-          subject.install
-        end
+        subject.install
       end
+    end
 
-      context "when a lockfile is present" do
-        before(:each) { subject.should_receive(:lockfile_present?).and_return(true) }
+    context "when a lockfile is present" do
+      before(:each) { subject.should_receive(:lockfile_present?).and_return(true) }
 
-        it "does not write a new lock file" do
-          resolver.should_receive(:resolve)
-          subject.should_not_receive(:write_lockfile)
+      it "does not write a new lock file" do
+        resolver.should_receive(:resolve)
+        subject.should_not_receive(:write_lockfile)
 
-          subject.install
-        end
+        subject.install
       end
+    end
 
-      context "when a value for :path is given" do
-        before(:each) { resolver.should_receive(:resolve) }
+    context "when a value for :path is given" do
+      before(:each) { resolver.should_receive(:resolve) }
 
-        it "sends the message 'vendor' to Berksfile with the value for :path" do
-          path = double('path')
-          subject.class.should_receive(:vendor).with(subject.cached_cookbooks, path)
+      it "sends the message 'vendor' to Berksfile with the value for :path" do
+        path = double('path')
+        subject.class.should_receive(:vendor).with(subject.cached_cookbooks, path)
 
-          subject.install(path: path)
-        end
+        subject.install(path: path)
       end
+    end
 
-      context "when a value for :except is given" do
-        before(:each) { resolver.should_receive(:resolve) }
+    context "when a value for :except is given" do
+      before(:each) { resolver.should_receive(:resolve) }
 
-        it "filters the sources and gives the results to the Resolver initializer" do
-          filtered = double('sources')
-          subject.should_receive(:sources).with(except: [:skip_me]).and_return(filtered)
-          Resolver.should_receive(:new).with(anything, sources: filtered)
+      it "filters the sources and gives the results to the Resolver initializer" do
+        filtered = double('sources')
+        subject.should_receive(:sources).with(except: [:skip_me]).and_return(filtered)
+        Berkshelf::Resolver.should_receive(:new).with(anything, sources: filtered)
 
-          subject.install(except: [:skip_me])
-        end
+        subject.install(except: [:skip_me])
       end
+    end
 
-      context "when a value for :only is given" do
-        before(:each) { resolver.should_receive(:resolve) }
+    context "when a value for :only is given" do
+      before(:each) { resolver.should_receive(:resolve) }
 
-        it "filters the sources and gives the results to the Resolver initializer" do
-          filtered = double('sources')
-          subject.should_receive(:sources).with(only: [:skip_me]).and_return(filtered)
+      it "filters the sources and gives the results to the Resolver initializer" do
+        filtered = double('sources')
+        subject.should_receive(:sources).with(only: [:skip_me]).and_return(filtered)
 
-          subject.install(only: [:skip_me])
-        end
+        subject.install(only: [:skip_me])
       end
     end
+  end
 
-    describe "#load" do
-      it "reads the content of a Berksfile and adds the sources to the Shelf" do
-        subject.load(content)
+  describe "#load" do
+    it "reads the content of a Berksfile and adds the sources to the Shelf" do
+      subject.load(content)
 
-        ['ntp', 'mysql', 'nginx', 'ssh_known_hosts2'].each do |name|
-          subject.should have_source(name)
-        end
+      ['ntp', 'mysql', 'nginx', 'ssh_known_hosts2'].each do |name|
+        subject.should have_source(name)
       end
+    end
 
-      it "returns an instance of Berksfile" do
-        subject.load(content).should be_a(Berksfile)
-      end
+    it "returns an instance of Berksfile" do
+      subject.load(content).should be_a(described_class)
     end
+  end
 
-    describe "#add_source" do
-      let(:name) { "cookbook_one" }
-      let(:constraint) { "= 1.2.0" }
-      let(:location) { { site: "http://site" } }
+  describe "#add_source" do
+    let(:name) { "cookbook_one" }
+    let(:constraint) { "= 1.2.0" }
+    let(:location) { { site: "http://site" } }
 
-      before(:each) do
-        subject.add_source(name, constraint, location)
-      end
+    before(:each) do
+      subject.add_source(name, constraint, location)
+    end
 
-      it "adds new cookbook source to the list of sources" do
-        subject.sources.should have(1).source
-      end
+    it "adds new cookbook source to the list of sources" do
+      subject.sources.should have(1).source
+    end
 
-      it "adds a cookbook source with a 'name' of the given name" do
-        subject.sources.first.name.should eql(name)
-      end
+    it "adds a cookbook source with a 'name' of the given name" do
+      subject.sources.first.name.should eql(name)
+    end
 
-      it "adds a cookbook source with a 'version_constraint' of the given constraint" do
-        subject.sources.first.version_constraint.to_s.should eql(constraint)
-      end
+    it "adds a cookbook source with a 'version_constraint' of the given constraint" do
+      subject.sources.first.version_constraint.to_s.should eql(constraint)
+    end
 
-      it "raises DuplicateSourceDefined if multiple sources of the same name are found" do
-        lambda {
-          subject.add_source(name)
-        }.should raise_error(DuplicateSourceDefined)
-      end
+    it "raises DuplicateSourceDefined if multiple sources of the same name are found" do
+      lambda {
+        subject.add_source(name)
+      }.should raise_error(Berkshelf::DuplicateSourceDefined)
     end
+  end
 
-    describe "#add_location" do
-      let(:type) { :site }
-      let(:value) { double('value') }
-      let(:options) { double('options') }
+  describe "#add_location" do
+    let(:type) { :site }
+    let(:value) { double('value') }
+    let(:options) { double('options') }
 
-      it "delegates 'add_location' to the downloader" do
-        subject.downloader.should_receive(:add_location).with(type, value, options)
+    it "delegates 'add_location' to the downloader" do
+      subject.downloader.should_receive(:add_location).with(type, value, options)
 
-        subject.add_location(type, value, options)
-      end
+      subject.add_location(type, value, options)
     end
   end
+
+  describe "#upload" do
+    pending
+  end
 end