berkshelf 1.4.6 → 2.0.0.beta

data/spec/unit/berkshelf/cached_cookbook_spec.rb

@@ -1,70 +1,68 @@
 require 'spec_helper'
 
 describe Berkshelf::CachedCookbook do
-  describe "ClassMethods" do
-    subject { described_class }
+  describe '.from_store_path' do
+    let(:path) { fixtures_path.join('cookbooks', 'example_cookbook-0.5.0') }
+    let(:cached) { Berkshelf::CachedCookbook.from_path(path) }
 
-    describe "#from_store_path" do
-      before(:each) do
-        @cached_cb = subject.from_store_path(fixtures_path.join("cookbooks", "example_cookbook-0.5.0"))
-      end
-
-      it "returns an instance of CachedCookbook" do
-        @cached_cb.should be_a(described_class)
-      end
+    it 'returns a CachedCookbook' do
+      expect(cached).to be_a(Berkshelf::CachedCookbook)
+    end
 
-      it "sets a version number" do
-        @cached_cb.version.should eql("0.5.0")
-      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
-        @cached_cb.metadata.name.should eql("example_cookbook")
-      end
+    it 'sets the metadata.name value to the cookbook_name' do
+      expect(cached.metadata.name).to eq('example_cookbook')
+    end
 
-      context "given a path that does not contain a cookbook" do
-        it "returns nil" do
-          subject.from_store_path(tmp_path).should be_nil
-        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
       end
+    end
 
-      context "given a path that does not match the CachedCookbook dirname format" do
-        it "returns nil" do
-          subject.from_store_path(fixtures_path.join("cookbooks", "example_cookbook")).should be_nil
-        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
       end
     end
 
-    describe "#checksum" do
-      it "returns a checksum of the given filepath" do
-        subject.checksum(fixtures_path.join("cookbooks", "example_cookbook-0.5.0", "README.md")).should eql("6e21094b7a920e374e7261f50e9c4eef")
+    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')
       end
 
-      context "given path does not exist" do
-        it "raises an Errno::ENOENT error" do
-          lambda {
-            subject.checksum(fixtures_path.join("notexisting.file"))
-          }.should raise_error(Errno::ENOENT)
+      context 'given path does not exist' do
+        it 'raises an Errno::ENOENT error' do
+          expect {
+            Berkshelf::CachedCookbook.checksum(fixtures_path.join('notexisting.file'))
+          }.to raise_error(Errno::ENOENT)
         end
       end
     end
   end
 
-  describe "#dependencies" do
-    let(:dependencies) { { "mysql" => "= 1.2.0", "ntp" => ">= 0.0.0" } }
-    let(:recommendations) { { "database" => ">= 0.0.0" } }
 
-    let(:cb_path) do
-      generate_cookbook(Berkshelf.cookbook_store.storage_path, "sparkle", "0.1.0", dependencies: dependencies, recommendations: recommendations)
+  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 { described_class.from_store_path(cb_path) }
+    subject { Berkshelf::CachedCookbook.from_store_path(path) }
 
-    it "contains depends from the cookbook metadata" do
-      subject.dependencies.should include(dependencies)
+    it 'contains depends from the cookbook metadata' do
+      expect(subject.dependencies).to include(dependencies)
     end
 
-    it "contains recommendations from the cookbook metadata" do
-      subject.dependencies.should include(recommendations)
+    it 'contains recommendations from the cookbook metadata' do
+      expect(subject.dependencies).to include(recommendations)
     end
   end
 end

data/spec/unit/berkshelf/chef/cookbook/chefignore_spec.rb

@@ -1,23 +1,19 @@
 require 'spec_helper'
 
 describe Berkshelf::Chef::Cookbook::Chefignore do
-  describe "ClassMethods" do
-    subject { described_class }
+  describe '.find_relative_to' do
+    let(:path) { tmp_path.join('chefignore-test') }
+    before(:each) { FileUtils.mkdir_p(path) }
 
-    describe "::find_relative_to" do
-      let(:path) { tmp_path.join('chefignore-test') }
-      before(:each) { FileUtils.mkdir_p(path) }
-
-      it "finds a chefignore file in a 'cookbooks' directory relative to the given path" do
-        FileUtils.touch(path.join('chefignore'))
-        subject.find_relative_to(path)
-      end
+    it "finds a chefignore file in a 'cookbooks' directory relative to the given path" do
+      FileUtils.touch(path.join('chefignore'))
+      Berkshelf::Chef::Cookbook::Chefignore.find_relative_to(path)
+    end
 
-      it "finds a chefignore file relative to the given path" do
-        FileUtils.mkdir_p(path.join('cookbooks'))
-        FileUtils.touch(path.join('cookbooks', 'chefignore'))
-        subject.find_relative_to(path)
-      end
+    it 'finds a chefignore file relative to the given path' do
+      FileUtils.mkdir_p(path.join('cookbooks'))
+      FileUtils.touch(path.join('cookbooks', 'chefignore'))
+      Berkshelf::Chef::Cookbook::Chefignore.find_relative_to(path)
     end
   end
 end

data/spec/unit/berkshelf/community_rest_spec.rb

@@ -19,50 +19,52 @@ describe Berkshelf::CommunityREST, vcr: { record: :new_episodes, serialize_with:
       Zlib::GzipReader.should_receive(:new).with(file)
       Archive::Tar::Minitar.should_receive(:unpack).with(gzip_reader, destination)
 
-      expect(described_class.unpack(target, destination)).to eq(destination)
+      expect(Berkshelf::CommunityREST.unpack(target, destination)).to eq(destination)
     end
   end
 
   describe '.uri_escape_version' do
     it 'returns a string' do
-      expect(described_class.uri_escape_version(nil)).to be_a(String)
+      expect(Berkshelf::CommunityREST.uri_escape_version(nil)).to be_a(String)
     end
 
     it 'converts a version to it\'s underscored version' do
-      expect(described_class.uri_escape_version('1.1.2')).to eq('1_1_2')
+      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(described_class.uri_escape_version('1.1.1.2')).to eq('1_1_1_2')
+      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(described_class.uri_escape_version('1.2')).to eq('1_2')
+      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(described_class.version_from_uri(nil)).to be_a(String)
+      expect(Berkshelf::CommunityREST.version_from_uri(nil)).to be_a(String)
     end
 
     it 'extracts the version from the URL' do
-      expect(described_class.version_from_uri('/api/v1/cookbooks/nginx/versions/1_1_2')).to eq('1.1.2')
+      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(described_class.version_from_uri('/api/v1/cookbooks/nginx/versions/1_1_1_2')).to eq('1.1.1.2')
+      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(described_class.version_from_uri('/api/v1/cookbooks/nginx/versions/1_2')).to eq('1.2')
+      expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_2')).to eq('1.2')
     end
   end
 
-  let(:api_uri) { described_class::V1_API }
+
+
+  let(:api_uri) { Berkshelf::CommunityREST::V1_API }
 
   subject do
-    described_class.new(api_uri)
+    Berkshelf::CommunityREST.new(api_uri)
   end
 
   describe '#download' do
@@ -112,7 +114,7 @@ describe Berkshelf::CommunityREST, vcr: { record: :new_episodes, serialize_with:
 
   describe '#latest_version' do
     it 'returns the version number of the latest version of the cookbook' do
-      subject.latest_version('nginx').should eql('1.4.0')
+      expect(subject.latest_version('nginx')).to eq('1.4.0')
     end
 
     it 'raises a CookbookNotFound error on a 404 response' do
@@ -132,7 +134,7 @@ describe Berkshelf::CommunityREST, vcr: { record: :new_episodes, serialize_with:
 
   describe '#versions' do
     it 'returns an array containing an item for each version' do
-      subject.versions('nginx').should have(24).versions
+      expect(subject.versions('nginx')).to have(24).versions
     end
 
     it 'raises a CookbookNotFound error on a 404 response' do
@@ -152,7 +154,7 @@ describe Berkshelf::CommunityREST, vcr: { record: :new_episodes, serialize_with:
 
   describe '#satisfy' do
     it 'returns the version number of the best solution' do
-      subject.satisfy('nginx', '= 1.1.0').should eql('1.1.0')
+      expect(subject.satisfy('nginx', '= 1.1.0')).to eq('1.1.0')
     end
   end
 

data/spec/unit/berkshelf/config_spec.rb

@@ -1,38 +1,54 @@
 require 'spec_helper'
 
 describe Berkshelf::Config do
-  let(:klass) { described_class }
+  describe '.file' do
+    context 'when the file does not exist' do
+      before { File.stub(:exists?).and_return(false) }
 
-  describe "ClassMethods" do
-    subject { klass }
-
-    describe "::file" do
-      subject { klass.file }
+      it 'is nil' do
+        expect(Berkshelf::Config.file).to be_nil
+      end
+    end
+  end
 
-      context "when the file does not exist" do
-        before :each do
-          File.stub exists?: false
-        end
+  describe '.instance' do
+    it 'should be a Berkshelf::Config' do
+      expect(Berkshelf::Config.instance).to be_an_instance_of(Berkshelf::Config)
+    end
+  end
 
-        it { should be_nil }
-      end
+  describe '.path' do
+    it 'is a string' do
+      expect(Berkshelf::Config.path).to be_a(String)
     end
 
-    describe "::instance" do
-      subject { klass.instance }
+    before do
+      File.stub(:exists?).and_return(false)
+    end
 
-      it { should be_a klass }
+    after do
+      Berkshelf::Config.instance_variable_set(:@path, nil)
     end
 
-    describe "::path" do
-      subject { klass.path }
+    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 { should be_a String }
+        it "returns '#{location}' as the path" do
+          expect(Berkshelf::Config.path).to eq(path)
+        end
+      end
+    end
 
-      it "points to a location within ENV['BERKSHELF_PATH']" do
+    context "when ENV['BERKSHELF_PATH'] is used" do
+      before do
         ENV.stub(:[]).with('BERKSHELF_PATH').and_return('/tmp')
+        File.stub(:exists?).with('/tmp').and_return(true)
+      end
 
-        subject.should eql("/tmp/config.json")
+      it "points to a location within it" do
+        expect(Berkshelf::Config.path).to eq('/tmp/config.json')
       end
     end
   end

data/spec/unit/berkshelf/cookbook_generator_spec.rb

@@ -1,14 +1,12 @@
 require 'spec_helper'
 
 describe Berkshelf::CookbookGenerator do
-  subject { described_class }
-
-  let(:name) { "sparkle_motion" }
+  let(:name) { 'sparkle_motion' }
   let(:target) { tmp_path.join(name) }
 
-  context "with default options" do
+  context 'with default options' do
     before do
-      capture(:stdout) { subject.new([target, name]).invoke_all }
+      capture(:stdout) { Berkshelf::CookbookGenerator.new([target, name]).invoke_all }
     end
 
     specify do
@@ -59,18 +57,16 @@ describe Berkshelf::CookbookGenerator do
 
   context "given a 'maintainer_email' option" do
     before do
-      @email = "jamie@vialstudios.com"
       capture(:stdout) {
-        described_class.new([target, name], maintainer_email: @email).invoke_all
+        Berkshelf::CookbookGenerator.new([target, name], maintainer_email: 'jamie@vialstudios.com').invoke_all
       }
     end
 
     it "generates a metadata.rb with the 'maintainer_email' value set" do
-      email = @email
-
+      email = email
       expect(target).to have_structure {
         file 'metadata.rb' do
-          contains "maintainer_email \"#{email}\""
+          contains 'maintainer_email "jamie@vialstudios.com"'
         end
       }
     end

data/spec/unit/berkshelf/cookbook_source_spec.rb

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