berkshelf 2.0.18 → 3.0.0.beta1

data/spec/unit/berkshelf/cached_cookbook_spec.rb

@@ -1,70 +1,63 @@
 require 'spec_helper'
 
 describe Berkshelf::CachedCookbook do
-  describe '.from_store_path' do
-    let(:path) { fixtures_path.join('cookbooks', 'example_cookbook-0.5.0') }
-    let(:cached) { Berkshelf::CachedCookbook.from_path(path) }
+  describe "ClassMethods" do
+    describe '::from_store_path' do
+      let(:path) { fixtures_path.join('cookbooks', 'example_cookbook-0.5.0') }
+      let(:cached) { described_class.from_path(path) }
 
-    it 'returns a CachedCookbook' do
-      expect(cached).to be_a(Berkshelf::CachedCookbook)
-    end
-
-    it 'sets a version number' do
-      expect(cached.version).to eq('0.5.0')
-    end
-
-    it 'sets the metadata.name value to the cookbook_name' do
-      expect(cached.metadata.name).to eq('example_cookbook')
-    end
+      it 'returns a CachedCookbook' do
+        expect(cached).to be_a(described_class)
+      end
 
-    context 'given a path that does not contain a cookbook' do
-      it 'returns nil' do
-        expect(Berkshelf::CachedCookbook.from_store_path(tmp_path)).to be_nil
+      it 'sets a version number' do
+        expect(cached.version).to eq('0.5.0')
       end
-    end
 
-    context 'given a path that does not match the CachedCookbook dirname format' do
-      it 'returns nil' do
-        path = fixtures_path.join('cookbooks', 'example_cookbook')
-        expect(Berkshelf::CachedCookbook.from_store_path(path)).to be_nil
+      it 'sets the metadata.name value to the cookbook_name' do
+        expect(cached.metadata.name).to eq('example_cookbook')
       end
 
-      context 'given an already cached cookbook' do
-        let!(:cached) { described_class.from_store_path(path) }
+      context 'given a path that does not contain a cookbook' do
+        it 'returns nil' do
+          expect(described_class.from_store_path(tmp_path)).to be_nil
+        end
+      end
 
-        it 'returns the cached cookbook instance' do
-          expect(described_class.from_store_path(path)).to eq(cached)
+      context 'given a path that does not match the CachedCookbook dirname format' do
+        it 'returns nil' do
+          path = fixtures_path.join('cookbooks', 'example_cookbook')
+          expect(described_class.from_store_path(path)).to be_nil
         end
       end
     end
 
-    describe '#checksum' do
+    describe '::checksum' do
       it 'returns a checksum of the given filepath' do
         path = fixtures_path.join('cookbooks', 'example_cookbook-0.5.0', 'README.md')
-        expect(Berkshelf::CachedCookbook.checksum(path)).to eq('6e21094b7a920e374e7261f50e9c4eef')
+        expect(described_class.checksum(path)).to eq('6e21094b7a920e374e7261f50e9c4eef')
       end
 
       context 'given path does not exist' do
         it 'raises an Errno::ENOENT error' do
           expect {
-            Berkshelf::CachedCookbook.checksum(fixtures_path.join('notexisting.file'))
+            described_class.checksum(fixtures_path.join('notexisting.file'))
           }.to raise_error(Errno::ENOENT)
         end
       end
     end
   end
 
+  let(:dependencies) { { 'mysql' => '= 1.2.0', 'ntp' => '>= 0.0.0' } }
+  let(:recommendations) { { 'database' => '>= 0.0.0' } }
+  let(:path) do
+    generate_cookbook(Berkshelf.cookbook_store.storage_path,
+      'sparkle', '0.1.0', dependencies: dependencies, recommendations: recommendations)
+  end
 
-  describe '#dependencies' do
-    let(:dependencies) { { 'mysql' => '= 1.2.0', 'ntp' => '>= 0.0.0' } }
-    let(:recommendations) { { 'database' => '>= 0.0.0' } }
-
-    let(:path) do
-      generate_cookbook(Berkshelf.cookbook_store.storage_path, 'sparkle', '0.1.0', dependencies: dependencies, recommendations: recommendations)
-    end
-
-    subject { Berkshelf::CachedCookbook.from_store_path(path) }
+  subject { Berkshelf::CachedCookbook.from_store_path(path) }
 
+  describe '#dependencies' do
     it 'contains depends from the cookbook metadata' do
       expect(subject.dependencies).to include(dependencies)
     end
@@ -72,5 +65,47 @@ describe Berkshelf::CachedCookbook do
     it 'contains recommendations from the cookbook metadata' do
       expect(subject.dependencies).to include(recommendations)
     end
+
+    it 'returns a hash' do
+      expect(subject.dependencies).to be_a(Hash)
+    end
+  end
+
+  describe '#pretty_hash' do
+    shared_examples 'a pretty_hash cookbook attribute' do |attribute, key|
+      it "is not present when the `#{attribute}` attribute is nil" do
+        subject.stub(attribute.to_sym).and_return(nil)
+        expect(subject.pretty_hash).to_not have_key((key || attribute).to_sym)
+      end
+
+      it "is not present when the `#{attribute}` attribute is an empty string" do
+        subject.stub(attribute.to_sym).and_return('')
+        expect(subject.pretty_hash).to_not have_key((key || attribute).to_sym)
+      end
+
+      it "is not present when the `#{attribute}` attribute is an empty array" do
+        subject.stub(attribute.to_sym).and_return([])
+        expect(subject.pretty_hash).to_not have_key((key || attribute).to_sym)
+      end
+
+      it "is not present when the `#{attribute}` attribute is an empty hash" do
+        subject.stub(attribute.to_sym).and_return([])
+        expect(subject.pretty_hash).to_not have_key((key || attribute).to_sym)
+      end
+
+      it "is present when the `#{attribute}` attribute has a Hash value" do
+        subject.stub(attribute.to_sym).and_return(foo: 'bar')
+        expect(subject.pretty_hash).to have_key((key || attribute).to_sym)
+      end
+    end
+
+    it_behaves_like 'a pretty_hash cookbook attribute', 'cookbook_name', 'name'
+    it_behaves_like 'a pretty_hash cookbook attribute', 'version'
+    it_behaves_like 'a pretty_hash cookbook attribute', 'description'
+    it_behaves_like 'a pretty_hash cookbook attribute', 'maintainer', 'author'
+    it_behaves_like 'a pretty_hash cookbook attribute', 'maintainer_email', 'email'
+    it_behaves_like 'a pretty_hash cookbook attribute', 'license'
+    it_behaves_like 'a pretty_hash cookbook attribute', 'platforms'
+    it_behaves_like 'a pretty_hash cookbook attribute', 'dependencies'
   end
 end

data/spec/unit/berkshelf/community_rest_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
 describe Berkshelf::CommunityREST, vcr: { record: :new_episodes, serialize_with: :json } do
-  describe '.unpack' do
-    let(:target) { '/foo/bar' }
-    let(:destination) { '/destination/bar' }
-    let(:file) { double('file') }
-
-    describe 'a tar.gz file' do
+  describe "ClassMethods" do
+    describe "::unpack" do
+      let(:target) { '/foo/bar' }
+      let(:destination) { '/destination/bar' }
+      let(:file) { double('file') }
       let(:gzip_reader) { double('gzip_reader') }
 
       before do
@@ -15,7 +14,7 @@ describe Berkshelf::CommunityREST, vcr: { record: :new_episodes, serialize_with:
         Archive::Tar::Minitar.stub(:unpack).with(gzip_reader, destination)
       end
 
-      it 'unpacks the file' do
+      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)
@@ -25,85 +24,45 @@ describe Berkshelf::CommunityREST, vcr: { record: :new_episodes, serialize_with:
       end
     end
 
-    describe 'a tar file' do
-      before do
-        File.stub(:open).with(target, 'rb').and_return(file)
-        Archive::Tar::Minitar.stub(:unpack).with(target, destination)
+    describe "::uri_escape_version" do
+      it 'returns a string' do
+        expect(Berkshelf::CommunityREST.uri_escape_version(nil)).to be_a(String)
       end
 
-      it 'unpacks the file' do
-        ::IO.should_receive(:binread).once
-        ::IO.should_receive(:binread).with(target, 8, 257).and_return("ustar\x0000")
-        Archive::Tar::Minitar.should_receive(:unpack).with(target, destination)
-
-        expect(Berkshelf::CommunityREST.unpack(target, destination)).to eq(destination)
+      it 'converts a version to it\'s underscored version' do
+        expect(Berkshelf::CommunityREST.uri_escape_version('1.1.2')).to eq('1_1_2')
       end
-    end
-
-    describe 'a tar.bz2 file' do
-      let(:bzip2_reader) { double('bzip2_reader') }
 
-      before do
-        File.stub(:open).with(target, 'rb').and_return(file)
-        RBzip2::Decompressor.stub(:new).with(file).and_return(bzip2_reader)
-        Archive::Tar::Minitar.stub(:unpack).with(bzip2_reader, destination)
+      it 'works when the version has more than three points' do
+        expect(Berkshelf::CommunityREST.uri_escape_version('1.1.1.2')).to eq('1_1_1_2')
       end
 
-      it 'unpacks the file' do
-        File.should_receive(:open).with(target, 'rb')
-        ::IO.should_receive(:binread).twice
-        ::IO.should_receive(:binread).with(target, 3).and_return('BZh')
-        RBzip2::Decompressor.should_receive(:new).with(file)
-        Archive::Tar::Minitar.should_receive(:unpack).with(bzip2_reader, destination)
-
-        expect(Berkshelf::CommunityREST.unpack(target, destination)).to eq(destination)
+      it 'works when the version has less than three points' do
+        expect(Berkshelf::CommunityREST.uri_escape_version('1.2')).to eq('1_2')
       end
     end
-  end
-
-  describe '.uri_escape_version' do
-    it 'returns a string' do
-      expect(Berkshelf::CommunityREST.uri_escape_version(nil)).to be_a(String)
-    end
-
-    it 'converts a version to it\'s underscored version' do
-      expect(Berkshelf::CommunityREST.uri_escape_version('1.1.2')).to eq('1_1_2')
-    end
 
-    it 'works when the version has more than three points' do
-      expect(Berkshelf::CommunityREST.uri_escape_version('1.1.1.2')).to eq('1_1_1_2')
-    end
-
-    it 'works when the version has less than three points' do
-      expect(Berkshelf::CommunityREST.uri_escape_version('1.2')).to eq('1_2')
-    end
-  end
-
-  describe '.version_from_uri' do
-    it 'returns a string' do
-      expect(Berkshelf::CommunityREST.version_from_uri(nil)).to be_a(String)
-    end
+    describe "::version_from_uri" do
+      it 'returns a string' do
+        expect(Berkshelf::CommunityREST.version_from_uri(nil)).to be_a(String)
+      end
 
-    it 'extracts the version from the URL' do
-      expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_1_2')).to eq('1.1.2')
-    end
+      it 'extracts the version from the URL' do
+        expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_1_2')).to eq('1.1.2')
+      end
 
-    it 'works when the version has more than three points' do
-      expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_1_1_2')).to eq('1.1.1.2')
-    end
+      it 'works when the version has more than three points' do
+        expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_1_1_2')).to eq('1.1.1.2')
+      end
 
-    it 'works when the version has less than three points' do
-      expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_2')).to eq('1.2')
+      it 'works when the version has less than three points' do
+        expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_2')).to eq('1.2')
+      end
     end
   end
 
-
-
   let(:api_uri) { Berkshelf::CommunityREST::V1_API }
-
-  subject do
-    Berkshelf::CommunityREST.new(api_uri)
-  end
+  subject { Berkshelf::CommunityREST.new(api_uri) }
 
   describe '#download' do
     let(:archive) { double('archive', path: '/foo/bar', unlink: true) }
@@ -114,7 +73,7 @@ describe Berkshelf::CommunityREST, vcr: { record: :new_episodes, serialize_with:
     end
 
     it 'unpacks the archive' do
-      Berkshelf::CommunityREST.should_receive(:unpack).with('/foo/bar').once
+      Berkshelf::CommunityREST.should_receive(:unpack).with('/foo/bar').once.and_return('/foo/nginx')
       archive.should_receive(:unlink).once
 
       subject.download('nginx', '1.4.0')

data/spec/unit/berkshelf/config_spec.rb

@@ -30,21 +30,10 @@ describe Berkshelf::Config do
       Berkshelf::Config.instance_variable_set(:@path, nil)
     end
 
-    Berkshelf::Config::LOCATIONS.each do |location|
-      context "with '#{location}' as the config file" do
-        let(:path) { File.expand_path(location) }
-        before { File.stub(:exists?).with(path).and_return(true) }
-
-        it "returns '#{location}' as the path" do
-          expect(Berkshelf::Config.path).to eq(path)
-        end
-      end
-    end
-
-    context "when ENV['BERKSHELF_PATH'] is used" do
+    context "when ENV['BERKSHELF_CONFIG'] is used" do
       before do
-        ENV.stub(:[]).with('BERKSHELF_PATH').and_return('/tmp')
-        File.stub(:exists?).with('/tmp').and_return(true)
+        ENV.stub(:[]).with('BERKSHELF_CONFIG').and_return('/tmp/config.json')
+        File.stub(:exists?).with('/tmp/config.json').and_return(true)
       end
 
       it "points to a location within it" do

data/spec/unit/berkshelf/cookbook_generator_spec.rb

@@ -17,7 +17,6 @@ describe Berkshelf::CookbookGenerator do
     specify do
       expect(target).to have_structure {
         directory 'attributes'
-        directory 'definitions'
         directory 'files' do
           directory 'default'
         end
@@ -51,7 +50,7 @@ describe Berkshelf::CookbookGenerator do
           contains "description      'Installs/Configures sparkle_motion'"
         end
         file 'Berksfile' do
-          contains 'site :opscode'
+          contains 'source "http://api.berkshelf.com"'
           contains 'metadata'
         end
         file 'Gemfile'

data/spec/unit/berkshelf/cookbook_store_spec.rb

@@ -1,17 +1,20 @@
 require 'spec_helper'
 
 describe Berkshelf::CookbookStore do
-  describe '#initialize' do
-    it 'creates the storage_path' do
-      storage_path = tmp_path.join('random_storage')
-      Berkshelf::CookbookStore.new(storage_path)
+  describe "ClassMethods" do
+    describe "::instance"
+    describe "::import"
 
-      expect(storage_path).to exist
+    describe "::new" do
+      it 'creates the storage_path' do
+        storage_path = tmp_path.join('random_storage')
+        Berkshelf::CookbookStore.new(storage_path)
+
+        expect(storage_path).to exist
+      end
     end
   end
 
-
-
   subject { Berkshelf::CookbookStore.new(tmp_path.join("cbstore_rspec")) }
 
   describe '#cookbook_path' do
@@ -104,4 +107,6 @@ describe Berkshelf::CookbookStore do
       end
     end
   end
+
+  describe "#import"
 end

data/spec/unit/berkshelf/dependency_spec.rb

@@ -0,0 +1,285 @@
+require 'spec_helper'
+
+describe Berkshelf::Dependency do
+  let(:cookbook_name) { 'nginx' }
+  let(:berksfile) { double('berksfile', filepath: fixtures_path.join('Berksfile').to_s) }
+
+  describe "ClassMethods" do
+    describe "::new" do
+      let(:source) { described_class.new(berksfile, cookbook_name) }
+
+      context 'given no location key (i.e. :git, :path, :site)' do
+        it 'sets a nil valie for location' do
+          expect(source.location).to be_nil
+        end
+      end
+
+      context 'given no value for :locked_version' do
+        it 'returns a wildcard match for any version' do
+          expect(source.locked_version).to be_nil
+        end
+      end
+
+      context 'given no value for :constraint' do
+        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) { described_class.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
+      end
+
+      context 'given a location key :git' do
+        let(:url) { 'git://url_to_git' }
+        let(:source) { described_class.new(berksfile, cookbook_name, git: url) }
+
+        it 'initializes a GitLocation for location' do
+          expect(source.location).to be_a(Berkshelf::GitLocation)
+        end
+
+        it 'points to the given Git URL' do
+          expect(source.location.uri).to eq(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 }
+          let(:location) { described_class.new(berksfile, cookbook_name, path: path).location }
+
+          it 'initializes a PathLocation for location' do
+            expect(location).to be_a(Berkshelf::PathLocation)
+          end
+
+          it 'points to the specified path' do
+            expect(location.path).to eq(path)
+          end
+        end
+
+        context 'given an invalid option' do
+          it 'raises BerkshelfError with a friendly message' do
+            expect {
+              described_class.new(berksfile, cookbook_name, invalid_opt: 'thisisnotvalid')
+            }.to raise_error(Berkshelf::BerkshelfError, "Invalid options for dependency: 'invalid_opt'.")
+          end
+
+          it 'raises BerkshelfError with a messaging containing all of the invalid options' do
+            expect {
+              described_class.new(berksfile, cookbook_name, invalid_one: 'one', invalid_two: 'two')
+            }.to raise_error(Berkshelf::BerkshelfError, "Invalid options for dependency: 'invalid_one', 'invalid_two'.")
+          end
+        end
+
+        context 'given multiple location options' do
+          it 'raises with an Berkshelf::BerkshelfError' do
+            expect {
+              described_class.new(berksfile, cookbook_name, path: '/something', git: 'something')
+            }.to raise_error(Berkshelf::BerkshelfError)
+          end
+        end
+
+        context 'given a group option containing a single group' do
+          let(:group) { :production }
+          let(:source) { described_class.new(berksfile, cookbook_name, group: group) }
+
+          it 'assigns the single group to the groups attribute' do
+            expect(source.groups).to include(group)
+          end
+        end
+
+        context 'given a group option containing an array of groups' do
+          let(:groups) { [ :development, :test ] }
+          let(:source) { described_class.new(berksfile, cookbook_name, group: groups) }
+
+          it 'assigns all the groups to the group attribute' do
+            expect(source.groups).to eq(groups)
+          end
+        end
+
+        context 'given no group option' do
+          let(:source) { described_class.new(berksfile, cookbook_name) }
+
+          it 'has the default group assigned' do
+            expect(source.groups).to include(:default)
+          end
+        end
+      end
+    end
+
+    describe "::add_valid_option" do
+      before do
+        @original = described_class.class_variable_get :@@valid_options
+        described_class.class_variable_set :@@valid_options, []
+      end
+
+      after do
+        described_class.class_variable_set :@@valid_options, @original
+      end
+
+      it 'adds an option to the list of valid options' do
+        described_class.add_valid_option(:one)
+
+        expect(described_class.valid_options).to have(1).item
+        expect(described_class.valid_options).to include(:one)
+      end
+
+      it 'does not add duplicate options to the list of valid options' do
+        described_class.add_valid_option(:one)
+        described_class.add_valid_option(:one)
+
+        expect(described_class.valid_options).to have(1).item
+      end
+    end
+
+    describe "::add_location_key" do
+      before do
+        @original = described_class.class_variable_get :@@location_keys
+        described_class.class_variable_set :@@location_keys, {}
+      end
+
+      after do
+        described_class.class_variable_set :@@location_keys, @original
+      end
+
+      it 'adds a location key and the associated class to the list of valid locations' do
+        described_class.add_location_key(:git, described_class)
+
+        expect(described_class.location_keys).to have(1).item
+        expect(described_class.location_keys).to include(:git)
+        expect(described_class.location_keys[:git]).to eq(described_class)
+      end
+
+      it 'does not add duplicate location keys to the list of location keys' do
+        described_class.add_location_key(:git, described_class)
+        described_class.add_location_key(:git, described_class)
+
+        expect(described_class.location_keys).to have(1).item
+        expect(described_class.location_keys).to include(:git)
+      end
+    end
+  end
+
+  subject { described_class.new(berksfile, cookbook_name) }
+
+  describe '#add_group' do
+    it 'stores strings as symbols' do
+      subject.add_group 'foo'
+      expect(subject.groups).to eq([:default, :foo])
+    end
+
+    it 'does not store duplicate groups' do
+      subject.add_group 'bar'
+      subject.add_group 'bar'
+      subject.add_group :bar
+      expect(subject.groups).to eq([:default, :bar])
+    end
+
+    it 'adds multiple groups' do
+      subject.add_group 'baz', 'quux'
+      expect(subject.groups).to eq([:default, :baz, :quux])
+    end
+
+    it 'handles multiple groups as an array' do
+      subject.add_group ['baz', 'quux']
+      expect(subject.groups).to eq([:default, :baz, :quux])
+    end
+  end
+
+  describe "#cached_cookbook"
+  describe "#download"
+
+  describe '#downloaded?' do
+    it 'returns true if self.cached_cookbook is not nil' do
+      subject.stub(:cached_cookbook) { double('cb') }
+      expect(subject.downloaded?).to be_true
+    end
+
+    it 'returns false if self.cached_cookbook is nil' do
+      subject.stub(:cached_cookbook) { nil }
+      expect(subject.downloaded?).to be_false
+    end
+  end
+
+  describe '#to_hash' do
+    let(:hash) { subject.to_hash }
+
+    it 'does not include default values' do
+      [:constraint, :locked_version, :site, :git, :ref, :path].each do |key|
+        expect(hash).to_not have_key(key)
+      end
+    end
+
+    it 'includes the constraint' do
+      subject.version_constraint = '~> 1.0.0'
+
+      expect(hash).to have_key(:constraint)
+      expect(hash[:constraint]).to eq('~> 1.0.0')
+    end
+
+    it 'includes the locked version' do
+      subject.stub(cached_cookbook: double('cached', version: '1.2.3'))
+
+      expect(hash).to have_key(:locked_version)
+      expect(hash[:locked_version]).to eq('1.2.3')
+    end
+
+    it 'includes the git url and ref' do
+      location = double('git', uri: 'git://github.com/foo/bar.git', ref: 'abcd1234', rel: nil, download: nil)
+      location.stub(:kind_of?).and_return(false)
+      location.stub(:kind_of?).with(Berkshelf::GitLocation).and_return(true)
+      subject.stub(:location).and_return(location)
+
+      expect(hash).to have_key(:git)
+      expect(hash[:git]).to eq('git://github.com/foo/bar.git')
+      expect(hash).to have_key(:ref)
+      expect(hash[:ref]).to eq('abcd1234')
+    end
+
+    it 'includes the git url and rel' do
+      location = double('git', uri: 'git://github.com/foo/bar.git', ref: nil, rel: 'cookbooks/foo', download: nil)
+      location.stub(:kind_of?).and_return(false)
+      location.stub(:kind_of?).with(Berkshelf::GitLocation).and_return(true)
+      subject.stub(:location).and_return(location)
+
+      expect(hash).to have_key(:git)
+      expect(hash[:git]).to eq('git://github.com/foo/bar.git')
+      expect(hash).to have_key(:rel)
+      expect(hash[:rel]).to eq('cookbooks/foo')
+    end
+
+    it 'includes a relative path' do
+      location = double('path', relative_path: '../dev/foo')
+      location.stub(:kind_of?).and_return(false)
+      location.stub(:kind_of?).with(Berkshelf::PathLocation).and_return(true)
+      subject.stub(:location).and_return(location)
+
+      expect(hash).to have_key(:path)
+      expect(hash[:path]).to eq('../dev/foo')
+    end
+  end
+
+  describe "#scm_location?" do
+    let(:options) { Hash.new }
+    subject { described_class.new(berksfile, cookbook_name, options).scm_location? }
+
+    context "when the location is a GitLocation" do
+      let(:options) { { git: "git@github.com:RiotGames/berkshelf.git" } }
+      it { should be_true }
+    end
+
+    context "when the location is a GithubLocation" do
+      let(:options) { { github: "RiotGames/berkshelf" } }
+      it { should be_true }
+    end
+
+    context "when the location is a PathLocation" do
+      let(:options) { { path: fixtures_path.join('cookbooks', 'example_cookbook') } }
+      it { should be_false }
+    end
+  end
+end