berkshelf 1.4.0.rc1 → 1.4.0

data/lib/berkshelf/community_rest.rb

@@ -1,5 +1,6 @@
 require 'open-uri'
 require 'retryable'
+require 'addressable/uri'
 
 module Berkshelf
   # @author Jamie Winsor <reset@riotgames.com>
@@ -12,7 +13,11 @@ module Berkshelf
       #
       # @return [String]
       def unpack(target, destination = Dir.mktmpdir)
-        Archive::Tar::Minitar.unpack(Zlib::GzipReader.new(File.open(target, 'rb')), destination)
+        if is_gzip_file(target)
+          Archive::Tar::Minitar.unpack(Zlib::GzipReader.new(File.open(target, 'rb')), destination)
+        elsif is_tar_file(target)
+          Archive::Tar::Minitar.unpack(target, destination)
+        end
         destination
       end
 
@@ -29,6 +34,17 @@ module Berkshelf
       def version_from_uri(uri)
         File.basename(uri.to_s).gsub('_', '.')
       end
+
+      private
+        def is_gzip_file(path)
+          # You cannot write "\x1F\x8B" because the default encoding of
+          # ruby >= 1.9.3 is UTF-8 and 8B is an invalid in UTF-8.
+          IO.binread(path, 2) == [0x1F, 0x8B].pack("C*")
+        end
+
+        def is_tar_file(path)
+          IO.binread(path, 8, 257) == "ustar  \0"
+        end
     end
 
     V1_API = 'http://cookbooks.opscode.com/api/v1/cookbooks'.freeze

data/lib/berkshelf/cookbook_generator.rb

@@ -17,6 +17,10 @@ module Berkshelf
       type: :boolean,
       default: false
 
+    class_option :chef_minitest,
+      type: :boolean,
+      default: false
+
     class_option :scmversion,
       type: :boolean,
       default: false

data/lib/berkshelf/cookbook_source.rb

@@ -68,6 +68,7 @@ module Berkshelf
 
     extend Forwardable
 
+    attr_reader :berksfile
     attr_reader :name
     attr_reader :options
     attr_reader :version_constraint
@@ -93,11 +94,12 @@ module Berkshelf
     #  @option options [String] :tag
     #    same as tag
     #  @option options [String] :locked_version
-    def initialize(name, options = {})
+    def initialize(berksfile, name, options = {})
       self.class.validate_options(options)
 
-      @name = name
-      @locked_version = Solve::Version.new(options[:locked_version]) if options[:locked_version]
+      @berksfile          = berksfile
+      @name               = name
+      @locked_version     = Solve::Version.new(options[:locked_version]) if options[:locked_version]
       @version_constraint = Solve::Constraint.new(options[:locked_version] || options[:constraint] || ">= 0.0.0")
 
       @cached_cookbook, @location = cached_and_location(options)
@@ -115,6 +117,13 @@ module Berkshelf
       end
     end
 
+    # Determine the CachedCookbook and Location information from the given options.
+    #
+    # @return [Array<CachedCookbook, Location>]
+    def cached_and_location(options = {})
+      from_path(options) || from_cache(options) || from_default(options)
+    end
+
     # Returns true if the cookbook source has already been downloaded. A cookbook
     # source is downloaded when a cached cookbook is present.
     #
@@ -178,13 +187,6 @@ module Berkshelf
 
     private
 
-      # Determine the CachedCookbook and Location information from the given options.
-      #
-      # @return [Array<CachedCookbook, Location>]
-      def cached_and_location(options = {})
-        from_path(options) || from_cache(options) || from_default(options)
-      end
-
       # Attempt to load a CachedCookbook from a local file system path (if the :path
       # option was given). If one is found, the location and cached_cookbook is
       # updated. Otherwise, this method will raise a CookbookNotFound exception.
@@ -196,12 +198,13 @@ module Berkshelf
       def from_path(options = {})
         return nil unless options[:path]
 
-        location = PathLocation.new(name, version_constraint, path: options[:path])
-        cached = CachedCookbook.from_path(location.path)
+        path     = File.expand_path(PathLocation.normalize_path(options[:path]), File.dirname(berksfile.filepath))
+        location = PathLocation.new(name, version_constraint, path: path)
+        cached   = CachedCookbook.from_path(location.path)
 
-        [cached, location]
-      rescue IOError
-        raise Berkshelf::CookbookNotFound
+        [ cached, location ]
+      rescue IOError => ex
+        raise Berkshelf::CookbookNotFound, ex
       end
 
       # Attempt to load a CachedCookbook from the local CookbookStore. This will save
@@ -214,9 +217,9 @@ module Berkshelf
         return nil unless File.exists?(path)
 
         location = PathLocation.new(name, version_constraint, path: path)
-        cached = CachedCookbook.from_path(path, name: name)
+        cached   = CachedCookbook.from_path(path, name: name)
 
-        [cached, location]
+        [ cached, location ]
       end
 
       # Use the default location, and a nil CachedCookbook. If there is no location
@@ -230,7 +233,7 @@ module Berkshelf
           location = Location.init(name, version_constraint, options)
         end
 
-        [nil, location]
+        [ nil, location ]
       end
 
       # The hypothetical location of this CachedCookbook, if it were to exist.

data/lib/berkshelf/init_generator.rb

@@ -29,6 +29,10 @@ module Berkshelf
       type: :boolean,
       default: false
 
+    class_option :chef_minitest,
+      type: :boolean,
+      default: false
+
     class_option :scmversion,
       type: :boolean,
       default: false
@@ -69,6 +73,12 @@ module Berkshelf
         template "Thorfile.erb", target.join("Thorfile")
       end
 
+      if options[:chef_minitest]
+        empty_directory target.join("files/default/tests/minitest/support")
+        template "default_test.rb.erb", target.join("files/default/tests/minitest/default_test.rb")
+        template "helpers.rb.erb", target.join("files/default/tests/minitest/support/helpers.rb")
+      end
+
       if options[:scmversion]
         create_file target.join("VERSION"), "0.1.0"
       end
@@ -108,7 +118,7 @@ module Berkshelf
           raise InvalidConfiguration.new Config.instance.errors
         end
       end
-      
+
 
       # Check for supporting gems for provided options
       #
@@ -138,14 +148,14 @@ module Berkshelf
 
       # Warn if the supporting gem for a default is not installed
       #
-      # @return [Boolean]  
+      # @return [Boolean]
       def assert_default_supported(option, gem_name = option.to_s)
         unless options[option]
           begin
             Gem::Specification.find_by_name(gem_name)
           rescue Gem::LoadError
             Berkshelf.ui.warn "By default, this cookbook was generated to support #{gem_name}, however, #{gem_name} is not installed."
-            Berkshelf.ui.warn "To skip support for #{gem_name}, use --#{option}"
+            Berkshelf.ui.warn "To skip support for #{gem_name}, use --#{option.to_s.gsub('_', '-')}"
             Berkshelf.ui.warn "To install #{gem_name}: gem install #{gem_name}"
             return false
           end

data/lib/berkshelf/locations/github_location.rb

@@ -11,7 +11,7 @@ module Berkshelf
 
     # Wraps GitLocation allowing the short form GitHub repo identifier
     # to be used in place of the complete repo url.
-    # 
+    #
     # @see GitLocation#initialize for parameter documentation
     #
     # @option options [String] :github

data/lib/berkshelf/locations/path_location.rb

@@ -36,7 +36,7 @@ module Berkshelf
     def initialize(name, version_constraint, options = {})
       @name               = name
       @version_constraint = version_constraint
-      @path               = self.class.normalize_path(options[:path])
+      @path               = options[:path]
       set_downloaded_status(true)
     end
 

data/lib/berkshelf/resolver.rb

@@ -3,16 +3,20 @@ module Berkshelf
   class Resolver
     extend Forwardable
 
+    # @return [Berkshelf::Berksfile]
+    attr_reader :berksfile
+    # @return [Solve::Graph]
     attr_reader :graph
 
-    # @param [Downloader] downloader
+    # @param [Berkshelf::Berksfile] berksfile
     # @param [Hash] options
     #
     # @option options [Array<CookbookSource>, CookbookSource] sources
-    def initialize(downloader, options = {})
-      @downloader = downloader
-      @graph = Solve::Graph.new
-      @sources = Hash.new
+    def initialize(berksfile, options = {})
+      @berksfile  = berksfile
+      @downloader = @berksfile.downloader
+      @graph      = Solve::Graph.new
+      @sources    = Hash.new
 
       # Dependencies need to be added AFTER the sources. If they are
       # not, then one of the dependencies of a source that is added
@@ -70,7 +74,7 @@ module Berkshelf
       source.cached_cookbook.dependencies.each do |name, constraint|
         next if has_source?(name)
 
-        add_source(CookbookSource.new(name, constraint: constraint))
+        add_source(CookbookSource.new(berksfile, name, constraint: constraint))
       end
     end
 

data/lib/berkshelf/test.rb

@@ -0,0 +1,37 @@
+module Berkshelf
+  # Because aruba runs in a sub-process, there's no easy way to share mocks and
+  # stubs across a run (See RiotGames/berkshelf#208). As a work-around, we pass
+  # "special" mocks and stubs into the TEST environment variable. This class
+  # parses and then requires the appropriate mocks during the run.
+  #
+  # @author Seth Vargo <sethvargo@gmail.com>
+  class Mocks
+    require 'rspec/mocks/standalone'
+
+    class << self
+      def env_keys
+        self.instance_methods(false).map { |key| key.to_s.upcase }
+      end
+    end
+
+    def initialize(keys)
+      keys.each do |key|
+        self.send(key.downcase.to_sym, ENV[key.to_s])
+      end
+    end
+
+    # Trick bundler into thinking gems are missing.
+    #
+    # @param [String] gems
+    #   a CSV list of gems to be missing
+    def missing_gems(gems)
+      gems.split(',').each do |gem|
+        Gem::Specification.stub(:find_by_name).with(gem).and_raise(Gem::LoadError)
+      end
+    end
+  end
+end
+
+unless (keys = Berkshelf::Mocks.env_keys & ENV.keys).empty?
+  Berkshelf::Mocks.new(keys)
+end

data/lib/berkshelf/version.rb

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

data/spec/spec_helper.rb

@@ -1,3 +1,7 @@
+# We set this variable to load additional test materials during cucumber
+# runs, since aruba runs in a subprocess. See lib/berkshelf/test.rb
+ENV['RUBY_ENV'] ||= 'test'
+
 require 'rubygems'
 require 'bundler'
 require 'spork'
@@ -11,7 +15,7 @@ Spork.prefork do
 
   APP_ROOT = File.expand_path('../../', __FILE__)
   ENV["BERKSHELF_PATH"] = File.join(APP_ROOT, "spec", "tmp", "berkshelf")
-  ENV["BERKSHELF_CHEF_CONFIG"] = File.join(APP_ROOT, "spec", "tmp", "knife.rb")
+  ENV["BERKSHELF_CHEF_CONFIG"] = File.join(APP_ROOT, "spec", "knife.rb")
 
   Dir[File.join(APP_ROOT, "spec/support/**/*.rb")].each {|f| require f}
 

data/spec/unit/berkshelf/community_rest_spec.rb

@@ -15,6 +15,7 @@ describe Berkshelf::CommunityREST, vcr: { record: :new_episodes, serialize_with:
 
     it 'unpacks the tar' do
       ::File.should_receive(:open).with(target, 'rb')
+      ::IO.should_receive(:binread).with(target, 2).and_return([0x1F, 0x8B].pack("C*"))
       Zlib::GzipReader.should_receive(:new).with(file)
       Archive::Tar::Minitar.should_receive(:unpack).with(gzip_reader, destination)
 

data/spec/unit/berkshelf/cookbook_source_spec.rb

@@ -1,267 +1,287 @@
 require 'spec_helper'
 
-module Berkshelf
-  describe CookbookSource do
-    let(:cookbook_name) { "nginx" }
+describe Berkshelf::CookbookSource do
+  let(:cookbook_name) { "nginx" }
+  let(:berksfile) { double('berksfile', filepath: fixtures_path.join("Berksfile").to_s) }
 
-    describe "ClassMethods" do
-      subject { CookbookSource }
+  describe "ClassMethods" do
+    subject { Berkshelf::CookbookSource }
 
-      describe "::initialize" do
-        context "given no location key (i.e. :git, :path, :site)" do
-          let(:source) { subject.new(cookbook_name) }
+    describe "::initialize" do
+      context "given no location key (i.e. :git, :path, :site)" do
+        let(:source) { subject.new(berksfile, cookbook_name) }
 
-          it "sets a nil valie for location" do
-            source.location.should be_nil
-          end
+        it "sets a nil valie for location" do
+          source.location.should be_nil
         end
+      end
 
-        context 'given no value for :locked_version' do
-          let(:source) { subject.new(cookbook_name) }
+      context 'given no value for :locked_version' do
+        let(:source) { subject.new(berksfile, cookbook_name) }
 
-          it 'returns a wildcard match for any version' do
-            expect(source.version_constraint.to_s).to eq('>= 0.0.0')
-          end
+        it 'returns a wildcard match for any version' do
+          expect(source.version_constraint.to_s).to eq('>= 0.0.0')
         end
+      end
 
-        context 'given a value for :locked_version' do
-          let(:source) { subject.new(cookbook_name, locked_version: '1.2.3') }
+      context 'given a value for :locked_version' do
+        let(:source) { subject.new(berksfile, cookbook_name, locked_version: '1.2.3') }
 
-          it 'returns the locked_version as the constraint' do
-            expect(source.version_constraint.to_s).to eq('= 1.2.3')
-          end
+        it 'returns the locked_version as the constraint' do
+          expect(source.version_constraint.to_s).to eq('= 1.2.3')
         end
+      end
 
-        context 'given no value for :constraint' do
-          let(:source) { subject.new(cookbook_name) }
+      context 'given no value for :constraint' do
+        let(:source) { subject.new(berksfile, cookbook_name) }
 
-          it 'returns a wildcard match for any version' do
-            expect(source.version_constraint.to_s).to eq('>= 0.0.0')
-          end
+        it 'returns a wildcard match for any version' do
+          expect(source.version_constraint.to_s).to eq('>= 0.0.0')
         end
+      end
 
-        context 'given a value for :constraint' do
-          let(:source) { subject.new(cookbook_name, constraint: '~> 1.0.84') }
+      context 'given a value for :constraint' do
+        let(:source) { subject.new(berksfile, cookbook_name, constraint: '~> 1.0.84') }
 
-          it 'returns a Solve::Constraint for the given version for version_constraint' do
-            expect(source.version_constraint.to_s).to eq('~> 1.0.84')
-          end
+        it 'returns a Solve::Constraint for the given version for version_constraint' do
+          expect(source.version_constraint.to_s).to eq('~> 1.0.84')
         end
+      end
 
-        context 'given a value for :locked_version and :constraint' do
-          let(:source) { subject.new(cookbook_name, constraint: '~> 1.0.84', locked_version: '1.2.3') }
+      context 'given a value for :locked_version and :constraint' do
+        let(:source) { subject.new(berksfile, cookbook_name, constraint: '~> 1.0.84', locked_version: '1.2.3') }
 
-          it 'uses the :locked_version' do
-            expect(source.version_constraint.to_s).to eq('= 1.2.3')
-          end
+        it 'uses the :locked_version' do
+          expect(source.version_constraint.to_s).to eq('= 1.2.3')
         end
+      end
 
-        context "given a location key :git" do
-          let(:url) { "git://url_to_git" }
-          let(:source) { subject.new(cookbook_name, git: url) }
+      context "given a location key :git" do
+        let(:url) { "git://url_to_git" }
+        let(:source) { subject.new(berksfile, cookbook_name, git: url) }
 
-          it "initializes a GitLocation for location" do
-            source.location.should be_a(GitLocation)
-          end
+        it "initializes a GitLocation for location" do
+          source.location.should be_a(Berkshelf::GitLocation)
+        end
 
-          it "points to the given Git URL" do
-            source.location.uri.should eql(url)
-          end
+        it "points to the given Git URL" do
+          source.location.uri.should eql(url)
         end
+      end
 
-        context "given a location key :path" do
-          context "given a value for path that contains a cookbook" do
-            let(:path) { fixtures_path.join("cookbooks", "example_cookbook").to_s }
+      context "given a location key :path" do
+        context "given a value for path that contains a cookbook" do
+          let(:path) { fixtures_path.join("cookbooks", "example_cookbook").to_s }
 
-            it "initializes a PathLocation for location" do
-              subject.new(cookbook_name, path: path).location.should be_a(PathLocation)
-            end
+          it "initializes a PathLocation for location" do
+            subject.new(berksfile, cookbook_name, path: path).location.should be_a(Berkshelf::PathLocation)
+          end
 
-            it "points to the specified path" do
-              subject.new(cookbook_name, path: path).location.path.should eql(path)
-            end
+          it "points to the specified path" do
+            subject.new(berksfile, cookbook_name, path: path).location.path.should eql(path)
           end
+        end
 
-          context "given a value for path that does not contain a cookbook" do
-            let(:path) { "/does/not/exist" }
+        context "given a value for path that does not contain a cookbook" do
+          let(:path) { "/does/not/exist" }
 
-            it "raises Berkshelf::CookbookNotFound" do
-              lambda {
-                subject.new(cookbook_name, path: path)
-              }.should raise_error(Berkshelf::CookbookNotFound)
-            end
+          it "raises Berkshelf::CookbookNotFound" do
+            lambda {
+              subject.new(berksfile, cookbook_name, path: path)
+            }.should raise_error(Berkshelf::CookbookNotFound)
           end
+        end
 
-          context "given an invalid option" do
-            it "raises BerkshelfError with a friendly message" do
-              lambda {
-                subject.new(cookbook_name, invalid_opt: "thisisnotvalid")
-              }.should raise_error(Berkshelf::BerkshelfError, "Invalid options for Cookbook Source: 'invalid_opt'.")
-            end
-
-            it "raises BerkshelfError with a messaging containing all of the invalid options" do
-              lambda {
-                subject.new(cookbook_name, invalid_one: "one", invalid_two: "two")
-              }.should raise_error(Berkshelf::BerkshelfError, "Invalid options for Cookbook Source: 'invalid_one', 'invalid_two'.")
-            end
+        context "given an invalid option" do
+          it "raises BerkshelfError with a friendly message" do
+            lambda {
+              subject.new(berksfile, cookbook_name, invalid_opt: "thisisnotvalid")
+            }.should raise_error(Berkshelf::BerkshelfError, "Invalid options for Cookbook Source: 'invalid_opt'.")
           end
 
-          describe "::add_valid_option" do
-            before(:each) do
-              @original = subject.class_variable_get :@@valid_options
-              subject.class_variable_set :@@valid_options, []
-            end
+          it "raises BerkshelfError with a messaging containing all of the invalid options" do
+            lambda {
+              subject.new(berksfile, cookbook_name, invalid_one: "one", invalid_two: "two")
+            }.should raise_error(Berkshelf::BerkshelfError, "Invalid options for Cookbook Source: 'invalid_one', 'invalid_two'.")
+          end
+        end
 
-            after(:each) do
-              subject.class_variable_set :@@valid_options, @original
-            end
+        describe "::add_valid_option" do
+          before(:each) do
+            @original = subject.class_variable_get :@@valid_options
+            subject.class_variable_set :@@valid_options, []
+          end
 
-            it "adds an option to the list of valid options" do
-              subject.add_valid_option(:one)
+          after(:each) do
+            subject.class_variable_set :@@valid_options, @original
+          end
 
-              subject.valid_options.should have(1).item
-              subject.valid_options.should include(:one)
-            end
+          it "adds an option to the list of valid options" do
+            subject.add_valid_option(:one)
 
-            it "does not add duplicate options to the list of valid options" do
-              subject.add_valid_option(:one)
-              subject.add_valid_option(:one)
+            subject.valid_options.should have(1).item
+            subject.valid_options.should include(:one)
+          end
+
+          it "does not add duplicate options to the list of valid options" do
+            subject.add_valid_option(:one)
+            subject.add_valid_option(:one)
 
-              subject.valid_options.should have(1).item
-              subject.valid_options.should include(:one)
-            end
+            subject.valid_options.should have(1).item
+            subject.valid_options.should include(:one)
           end
+        end
 
-          describe "::add_location_key" do
-            before(:each) do
-              @original = subject.class_variable_get :@@location_keys
-              subject.class_variable_set :@@location_keys, {}
-            end
+        describe "::add_location_key" do
+          before(:each) do
+            @original = subject.class_variable_get :@@location_keys
+            subject.class_variable_set :@@location_keys, {}
+          end
 
-            after(:each) do
-              subject.class_variable_set :@@location_keys, @original
-            end
+          after(:each) do
+            subject.class_variable_set :@@location_keys, @original
+          end
 
-            it "adds a location key and the associated class to the list of valid locations" do
-              subject.add_location_key(:git, subject.class)
+          it "adds a location key and the associated class to the list of valid locations" do
+            subject.add_location_key(:git, subject.class)
 
-              subject.location_keys.should have(1).item
-              subject.location_keys.should include(:git)
-              subject.location_keys[:git].should eql(subject.class)
-            end
+            subject.location_keys.should have(1).item
+            subject.location_keys.should include(:git)
+            subject.location_keys[:git].should eql(subject.class)
+          end
 
-            it "does not add duplicate location keys to the list of location keys" do
-              subject.add_location_key(:git, subject.class)
-              subject.add_location_key(:git, subject.class)
+          it "does not add duplicate location keys to the list of location keys" do
+            subject.add_location_key(:git, subject.class)
+            subject.add_location_key(:git, subject.class)
 
-              subject.location_keys.should have(1).item
-              subject.location_keys.should include(:git)
-            end
+            subject.location_keys.should have(1).item
+            subject.location_keys.should include(:git)
           end
         end
+      end
 
-        context "given a location key :site" do
-          let(:url) { "http://path_to_api/v1" }
-          let(:source) { subject.new(cookbook_name, site: url) }
+      context "given a location key :site" do
+        let(:url) { "http://path_to_api/v1" }
+        let(:source) { subject.new(berksfile, cookbook_name, site: url) }
 
-          it "initializes a SiteLocation for location" do
-            source.location.should be_a(SiteLocation)
-          end
+        it "initializes a SiteLocation for location" do
+          source.location.should be_a(Berkshelf::SiteLocation)
+        end
 
-          it "points to the specified URI" do
-            source.location.api_uri.to_s.should eql(url)
-          end
+        it "points to the specified URI" do
+          source.location.api_uri.to_s.should eql(url)
         end
+      end
 
-        context "given multiple location options" do
-          it "raises with an Berkshelf::BerkshelfError" do
-            lambda {
-              subject.new(cookbook_name, site: "something", git: "something")
-            }.should raise_error(Berkshelf::BerkshelfError)
-          end
+      context "given multiple location options" do
+        it "raises with an Berkshelf::BerkshelfError" do
+          lambda {
+            subject.new(berksfile, cookbook_name, site: "something", git: "something")
+          }.should raise_error(Berkshelf::BerkshelfError)
         end
+      end
 
-        context "given a group option containing a single group" do
-          let(:group) { :production }
-          let(:source) { subject.new(cookbook_name, group: group) }
+      context "given a group option containing a single group" do
+        let(:group) { :production }
+        let(:source) { subject.new(berksfile, cookbook_name, group: group) }
 
-          it "assigns the single group to the groups attribute" do
-            source.groups.should include(group)
-          end
+        it "assigns the single group to the groups attribute" do
+          source.groups.should include(group)
         end
+      end
 
-        context "given a group option containing an array of groups" do
-          let(:groups) { [ :development, :test ] }
-          let(:source) { subject.new(cookbook_name, group: groups) }
+      context "given a group option containing an array of groups" do
+        let(:groups) { [ :development, :test ] }
+        let(:source) { subject.new(berksfile, cookbook_name, group: groups) }
 
-          it "assigns all the groups to the group attribute" do
-            source.groups.should eql(groups)
-          end
+        it "assigns all the groups to the group attribute" do
+          source.groups.should eql(groups)
         end
+      end
 
-        context "given no group option" do
-          let(:source) { subject.new(cookbook_name) }
+      context "given no group option" do
+        let(:source) { subject.new(berksfile, cookbook_name) }
 
-          it "should have the default group assigned" do
-            source.groups.should include(:default)
-          end
+        it "should have the default group assigned" do
+          source.groups.should include(:default)
         end
       end
     end
+  end
 
-    subject { CookbookSource.new(cookbook_name) }
+  subject { Berkshelf::CookbookSource.new(berksfile, cookbook_name) }
 
-    describe '#add_group' do
-      it "should store strings as symbols" do
-        subject.add_group "foo"
-        subject.groups.should =~ [:default, :foo]
-      end
+  describe '#add_group' do
+    it "should store strings as symbols" do
+      subject.add_group "foo"
+      subject.groups.should =~ [:default, :foo]
+    end
 
-      it "should not store duplicate groups" do
-        subject.add_group "bar"
-        subject.add_group "bar"
-        subject.add_group :bar
-        subject.groups.should =~ [:default, :bar]
-      end
+    it "should not store duplicate groups" do
+      subject.add_group "bar"
+      subject.add_group "bar"
+      subject.add_group :bar
+      subject.groups.should =~ [:default, :bar]
+    end
 
-      it "should add multiple groups" do
-        subject.add_group "baz", "quux"
-        subject.groups.should =~ [:default, :baz, :quux]
-      end
+    it "should add multiple groups" do
+      subject.add_group "baz", "quux"
+      subject.groups.should =~ [:default, :baz, :quux]
+    end
 
-      it "should handle multiple groups as an array" do
-        subject.add_group ["baz", "quux"]
-        subject.groups.should =~ [:default, :baz, :quux]
-      end
+    it "should handle multiple groups as an array" do
+      subject.add_group ["baz", "quux"]
+      subject.groups.should =~ [:default, :baz, :quux]
     end
+  end
+
+  describe "#cached_and_location" do
+    let(:options) { Hash.new }
 
-    describe "#downloaded?" do
-      it "returns true if self.cached_cookbook is not nil" do
-        subject.stub(:cached_cookbook) { double('cb') }
+    before do
+      Berkshelf::CachedCookbook.stub(:from_path).and_return(double('cached_cookbook'))
+    end
 
-        subject.downloaded?.should be_true
+    context "when given a value for :path" do
+      before do
+        berksfile.stub(filepath: "/rspec/Berksfile")
+        options[:path] = "cookbooks/whatever"
       end
 
-      it "returns false if self.cached_cookbook is nil" do
-        subject.stub(:cached_cookbook) { nil }
+      it "returns a PathLocation with a path relative to the Berksfile's filepath" do
+        _, location = subject.cached_and_location(options)
 
-        subject.downloaded?.should be_false
+        location.path.should eql("/rspec/cookbooks/whatever")
       end
     end
+  end
 
-    describe "#to_s" do
-      it "contains the name, constraint, and groups" do
-        source = CookbookSource.new("artifact", constraint: "= 0.10.0")
+  describe "#downloaded?" do
+    it "returns true if self.cached_cookbook is not nil" do
+      subject.stub(:cached_cookbook) { double('cb') }
 
-        source.to_s.should eql("artifact (= 0.10.0) groups: [:default]")
-      end
+      subject.downloaded?.should be_true
+    end
 
-      context "given a CookbookSource with an explicit location" do
-        it "contains the name, constraint, groups, and location" do
-          source = CookbookSource.new("artifact", constraint: "= 0.10.0", site: "http://cookbooks.opscode.com/api/v1/cookbooks")
+    it "returns false if self.cached_cookbook is nil" do
+      subject.stub(:cached_cookbook) { nil }
 
-          source.to_s.should eql("artifact (= 0.10.0) groups: [:default] location: site: 'http://cookbooks.opscode.com/api/v1/cookbooks'")
-        end
+      subject.downloaded?.should be_false
+    end
+  end
+
+  describe "#to_s" do
+    it "contains the name, constraint, and groups" do
+      source = Berkshelf::CookbookSource.new(berksfile, "artifact", constraint: "= 0.10.0")
+
+      source.to_s.should eql("artifact (= 0.10.0) groups: [:default]")
+    end
+
+    context "given a CookbookSource with an explicit location" do
+      it "contains the name, constraint, groups, and location" do
+        source = Berkshelf::CookbookSource.new(berksfile, "artifact", constraint: "= 0.10.0", site: "http://cookbooks.opscode.com/api/v1/cookbooks")
+
+        source.to_s.should eql("artifact (= 0.10.0) groups: [:default] location: site: 'http://cookbooks.opscode.com/api/v1/cookbooks'")
       end
     end
   end