berkshelf 1.4.6 → 2.0.0.beta

data/spec/unit/berkshelf/locations/chef_api_location_spec.rb

@@ -1,138 +1,143 @@
 require 'spec_helper'
 
 describe Berkshelf::ChefAPILocation, :chef_server do
-  let(:test_chef_api) { "https://chefserver:8081" }
-  let(:node_name) { "reset" }
-  let(:client_key) { fixtures_path.join("reset.pem").to_s }
-
-  describe "ClassMethods" do
-    subject { described_class }
-
-    let(:valid_uri) { test_chef_api }
-    let(:invalid_uri) { "notauri" }
-    let(:constraint) { double('constraint') }
-
-    describe "::initialize" do
-      before(:each) do
-        @location = subject.new("nginx",
-          constraint,
-          chef_api: test_chef_api,
-          node_name: node_name,
-          client_key: client_key
-        )
-      end
+  let(:test_chef_api) { 'https://chefserver:8081' }
+  let(:node_name) { 'reset' }
+  let(:client_key) { fixtures_path.join('reset.pem').to_s }
+
+  let(:valid_uri) { test_chef_api }
+  let(:invalid_uri) { 'notauri' }
+  let(:constraint) { double('constraint') }
+
+  describe '.initialize' do
+    subject do
+      Berkshelf::ChefAPILocation.new('nginx',
+        constraint,
+        chef_api: test_chef_api,
+        node_name: node_name,
+        client_key: client_key
+      )
+    end
 
-      it "sets the uri attribute to the value of the chef_api option" do
-        @location.uri.should eql(test_chef_api)
-      end
+    it 'sets the uri attribute to the value of the chef_api option' do
+      expect(subject.uri).to eq(test_chef_api)
+    end
 
-      it "sets the node_name attribute to the value of the node_name option" do
-        @location.node_name.should eql(node_name)
-      end
+    it 'sets the node_name attribute to the value of the node_name option' do
+      expect(subject.node_name).to eq(node_name)
+    end
 
-      it "sets the client_key attribute to the value of the client_key option" do
-        @location.client_key.should eql(client_key)
-      end
+    it 'sets the client_key attribute to the value of the client_key option' do
+      expect(subject.client_key).to eq(client_key)
+    end
 
-      it "sets the downloaded status to false" do
-        @location.should_not be_downloaded
-      end
+    it 'sets the downloaded status to false' do
+      expect(subject).to_not be_downloaded
+    end
 
-      context "when an invalid Chef API URI is given" do
-        it "raises Berkshelf::InvalidChefAPILocation" do
-          lambda {
-            subject.new("nginx", constraint, chef_api: invalid_uri, node_name: node_name, client_key: client_key)
-          }.should raise_error(Berkshelf::InvalidChefAPILocation, "'notauri' is not a valid Chef API URI.")
-        end
+    context 'when an invalid Chef API URI is given' do
+      it 'raises Berkshelf::InvalidChefAPILocation' do
+        expect {
+          Berkshelf::ChefAPILocation.new("nginx", constraint, chef_api: invalid_uri, node_name: node_name, client_key: client_key)
+        }.to raise_error(Berkshelf::InvalidChefAPILocation, "'notauri' is not a valid Chef API URI.")
       end
+    end
 
-      context "when no option for node_name is supplied" do
-        it "raises Berkshelf::InvalidChefAPILocation" do
-          lambda {
-            subject.new("nginx", constraint, chef_api: invalid_uri, client_key: client_key)
-          }.should raise_error(Berkshelf::InvalidChefAPILocation)
-        end
+    context 'when no option for node_name is supplied' do
+      it 'raises Berkshelf::InvalidChefAPILocation' do
+        expect {
+          Berkshelf::ChefAPILocation.new('nginx', constraint, chef_api: invalid_uri, client_key: client_key)
+        }.to raise_error(Berkshelf::InvalidChefAPILocation)
       end
+    end
 
-      context "when no option for client_key is supplied" do
-        it "raises Berkshelf::InvalidChefAPILocation" do
-          lambda {
-            subject.new("nginx", constraint, chef_api: invalid_uri, node_name: node_name)
-          }.should raise_error(Berkshelf::InvalidChefAPILocation)
-        end
+    context 'when no option for client_key is supplied' do
+      it 'raises Berkshelf::InvalidChefAPILocation' do
+        expect {
+          Berkshelf::ChefAPILocation.new('nginx', constraint, chef_api: invalid_uri, node_name: node_name)
+        }.to raise_error(Berkshelf::InvalidChefAPILocation)
       end
+    end
 
-      context "given the symbol :config for the value of chef_api:" do
-        before(:each) { @loc = subject.new("nginx", constraint, chef_api: :config) }
+    context 'given the symbol :config for the value of chef_api:' do
+      subject do
+        Berkshelf::ChefAPILocation.new('nginx', constraint, chef_api: :config)
+      end
 
-        it "uses the value of Berkshelf::Chef.instance.chef.chef_server_url for the uri attribute" do
-          @loc.uri.should eql(Berkshelf::Config.instance.chef.chef_server_url)
-        end
+      it 'uses the value of Berkshelf::Chef.instance.chef.chef_server_url for the uri attribute' do
+        expect(subject.uri).to eq(Berkshelf::Config.instance.chef.chef_server_url)
+      end
 
-        it "uses the value of Berkshelf::Chef.instance.chef.node_name for the node_name attribute" do
-          @loc.node_name.should eql(Berkshelf::Config.instance.chef.node_name)
-        end
+      it 'uses the value of Berkshelf::Chef.instance.chef.node_name for the node_name attribute' do
+        expect(subject.node_name).to eq(Berkshelf::Config.instance.chef.node_name)
+      end
 
-        it "uses the value of Berkshelf::Chef.instance.chef.client_key for the client_key attribute" do
-          @loc.client_key.should eql(Berkshelf::Config.instance.chef.client_key)
-        end
+      it 'uses the value of Berkshelf::Chef.instance.chef.client_key for the client_key attribute' do
+        expect(subject.client_key).to eq(Berkshelf::Config.instance.chef.client_key)
       end
     end
+  end
 
-    describe "::validate_uri" do
-      it "returns false if the given URI is invalid" do
-        subject.validate_uri(invalid_uri).should be_false
-      end
+  describe '.validate_uri' do
+    it 'returns false if the given URI is invalid' do
+      expect(Berkshelf::ChefAPILocation.validate_uri(invalid_uri)).to be_false
+    end
 
-      it "returns true if the given URI is valid" do
-        subject.validate_uri(valid_uri).should be_true
-      end
+    it 'returns true if the given URI is valid' do
+      expect(Berkshelf::ChefAPILocation.validate_uri(valid_uri)).to be_true
     end
+  end
 
-    describe "::validate_uri!" do
-      it "raises Berkshelf::InvalidChefAPILocation if the given URI is invalid" do
-        lambda {
-          subject.validate_uri!(invalid_uri)
-        }.should raise_error(Berkshelf::InvalidChefAPILocation, "'notauri' is not a valid Chef API URI.")
-      end
+  describe '.validate_uri!' do
+    it 'raises Berkshelf::InvalidChefAPILocation if the given URI is invalid' do
+      expect {
+        Berkshelf::ChefAPILocation.validate_uri!(invalid_uri)
+      }.to raise_error(Berkshelf::InvalidChefAPILocation, "'notauri' is not a valid Chef API URI.")
+    end
 
-      it "returns true if the given URI is valid" do
-        subject.validate_uri!(valid_uri).should be_true
-      end
+    it 'returns true if the given URI is valid' do
+      expect(Berkshelf::ChefAPILocation.validate_uri!(valid_uri)).to be_true
     end
   end
 
+
+
   subject do
-    described_class.new('nginx', nil, chef_api: test_chef_api, node_name: node_name, client_key: client_key)
+    Berkshelf::ChefAPILocation.new('nginx',
+      nil,
+      chef_api: test_chef_api,
+      node_name: node_name,
+      client_key: client_key
+    )
   end
 
-  describe "#target_cookbook" do
+  describe '#target_cookbook' do
     let(:cookbook_version) { double('cookbook_version') }
 
-    context "when a version constraint is present" do
+    context 'when a version constraint is present' do
       let(:constraint) { double('constraint') }
 
-      it "returns the best solution for the constraint" do
+      it 'returns the best solution for the constraint' do
         subject.stub(:version_constraint).and_return(constraint)
         subject.stub_chain(:conn, :cookbook, :satisfy).with(subject.name, constraint).and_return(cookbook_version)
-        
-        subject.target_cookbook.should eql(cookbook_version)
+
+        expect(subject.target_cookbook).to eq(cookbook_version)
       end
     end
 
-    context "when a version constraint is not present" do
-      it "returns the latest version of the cookbook" do
+    context 'when a version constraint is not present' do
+      it 'returns the latest version of the cookbook' do
         subject.stub(:version_constraint).and_return(nil)
         subject.stub_chain(:conn, :cookbook, :latest_version).with(subject.name).and_return(cookbook_version)
 
-        subject.target_cookbook.should eql(cookbook_version)
+        expect(subject.target_cookbook).to eq(cookbook_version)
       end
     end
   end
 
-  describe "#to_s" do
-    it "returns a string containing the location key and the Chef API URI" do
-      subject.to_s.should eql("chef_api: '#{test_chef_api}'")
+  describe '#to_s' do
+    it 'returns a string containing the location key and the Chef API URI' do
+      expect(subject.to_s).to eq("chef_api: '#{test_chef_api}'")
     end
   end
 end

data/spec/unit/berkshelf/locations/git_location_spec.rb

@@ -3,130 +3,146 @@ require 'spec_helper'
 describe Berkshelf::GitLocation do
   let(:complacent_constraint) { double('comp-vconstraint', satisfies?: true) }
 
-  describe "ClassMethods" do
-    subject { described_class }
-
-    describe "::initialize" do
-      it "raises InvalidGitURI if given an invalid Git URI for options[:git]" do
-        lambda {
-          subject.new("nginx", complacent_constraint, git: "/something/on/disk")
-        }.should raise_error(Berkshelf::InvalidGitURI)
-      end
+  describe '.initialize' do
+    it 'raises InvalidGitURI if given an invalid Git URI for options[:git]' do
+      expect {
+        Berkshelf::GitLocation.new('berkshelf-cookbook-fixture', complacent_constraint, git: '/something/on/disk')
+      }.to raise_error(Berkshelf::InvalidGitURI)
     end
+  end
 
-    describe "::tmpdir" do
-      it "creates a temporary directory within the Berkshelf temporary directory" do
-        subject.tmpdir.should include(Berkshelf.tmp_dir)
-      end
+  describe '.tmpdir' do
+    it 'creates a temporary directory within the Berkshelf temporary directory' do
+      expect(Berkshelf::GitLocation.tmpdir).to include(Berkshelf.tmp_dir)
     end
   end
 
-  subject { described_class.new("nginx", complacent_constraint, git: "git://github.com/opscode-cookbooks/nginx.git") }
 
-  describe "#download" do
-    context "when a local revision is present" do
+
+  subject { Berkshelf::GitLocation.new('berkshelf-cookbook-fixture', complacent_constraint, git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git') }
+
+  describe '#download' do
+    context 'when a local revision is present' do
       let(:cached) { double('cached') }
 
       before do
+        Berkshelf::Git.stub(:rev_parse).and_return('abcd1234')
         Berkshelf::GitLocation.any_instance.stub(:cached?).and_return(true)
         Berkshelf::GitLocation.any_instance.stub(:validate_cached).with(cached).and_return(cached)
         Berkshelf::CachedCookbook.stub(:from_store_path).with(any_args()).and_return(cached)
       end
 
-      it "returns the cached cookbook" do
+      it 'returns the cached cookbook' do
         expect(subject.download(tmp_path)).to eq(cached)
       end
     end
 
-    it "returns an instance of Berkshelf::CachedCookbook" do
-      subject.download(tmp_path).should be_a(Berkshelf::CachedCookbook)
+    it 'returns an instance of Berkshelf::CachedCookbook' do
+      expect(subject.download(tmp_path)).to be_a(Berkshelf::CachedCookbook)
     end
 
-    it "downloads the cookbook to the given destination" do
+    it 'downloads the cookbook to the given destination' do
       cached_cookbook = subject.download(tmp_path)
-      branch_name = subject.branch_name
+      ref = subject.ref
 
-      tmp_path.should have_structure {
-        directory "#{cached_cookbook.cookbook_name}-#{branch_name}" do
-          file "metadata.rb"
+      expect(tmp_path).to have_structure {
+        directory "#{cached_cookbook.cookbook_name}-#{ref}" do
+          file 'metadata.rb'
         end
       }
     end
 
-    it "sets the downloaded status to true" do
+    it 'sets the downloaded status to true' do
       subject.download(tmp_path)
-
-      subject.should be_downloaded
+      expect(subject).to be_downloaded
     end
 
-    context "given no ref/branch/tag options is given" do
-      subject { described_class.new("nginx", complacent_constraint, git: "git://github.com/opscode-cookbooks/nginx.git") }
+    context 'given no ref/branch/tag options is given' do
+      subject { Berkshelf::GitLocation.new('berkshelf-cookbook-fixture', complacent_constraint, git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git') }
 
-      it "sets the branch attribute to the HEAD revision of the cloned repo" do
+      it 'sets the branch attribute to the HEAD revision of the cloned repo' do
         subject.download(tmp_path)
-
-        subject.branch.should_not be_nil
+        expect(subject.branch).to_not be_nil
       end
     end
 
-    context "given a git repo that does not exist" do
-      subject { described_class.new("doesnot_exist", complacent_constraint, git: "git://github.com/RiotGames/thisrepo_does_not_exist.git") }
+    context 'given a git repo that does not exist' do
+      subject { Berkshelf::GitLocation.new('doesnot_exist', complacent_constraint, git: 'git://github.com/RiotGames/thisrepo_does_not_exist.git') }
 
-      it "raises a GitError" do
+      it 'raises a GitError' do
         Berkshelf::Git.stub(:git).and_raise(Berkshelf::GitError.new(''))
-        lambda {
+        expect {
           subject.download(tmp_path)
-        }.should raise_error(Berkshelf::GitError)
+        }.to raise_error(Berkshelf::GitError)
       end
     end
 
-    context "given a git repo that does not contain a cookbook" do
+    context 'given a git repo that does not contain a cookbook' do
       let(:fake_remote) { local_git_origin_path_for('not_a_cookbook') }
-      subject { described_class.new("doesnot_exist", complacent_constraint, git: "file://#{fake_remote}.git") }
+      subject { Berkshelf::GitLocation.new('doesnot_exist', complacent_constraint, git: "file://#{fake_remote}.git") }
 
-      it "raises a CookbookNotFound error" do
+      it 'raises a CookbookNotFound error' do
         subject.stub(:clone).and_return {
           FileUtils.mkdir_p(fake_remote)
-          Dir.chdir(fake_remote) { |dir| `git init; echo hi > README; git add README; git commit README -m "README"`; dir }
+          Dir.chdir(fake_remote) { |dir| `git init; echo hi > README; git add README; git commit README -m 'README'`; dir }
         }
 
-        lambda {
+        expect {
           subject.download(tmp_path)
-        }.should raise_error(Berkshelf::CookbookNotFound)
+        }.to raise_error(Berkshelf::CookbookNotFound)
       end
     end
 
-    context "given the content at the Git repo does not satisfy the version constraint" do
+    context 'given the content at the Git repo does not satisfy the version constraint' do
       subject do
-        described_class.new("nginx",
+        Berkshelf::GitLocation.new('berkshelf-cookbook-fixture',
           double('constraint', satisfies?: false),
-          git: "git://github.com/opscode-cookbooks/nginx.git"
+          git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git'
         )
       end
 
-      it "raises a CookbookValidationFailure error" do
-        lambda {
+      it 'raises a CookbookValidationFailure error' do
+        expect {
           subject.download(tmp_path)
-        }.should raise_error(Berkshelf::CookbookValidationFailure)
+        }.to raise_error(Berkshelf::CookbookValidationFailure)
+      end
+    end
+
+    context 'given a value for tag' do
+      let(:tag) { '1.0.0' }
+
+      subject do
+        Berkshelf::GitLocation.new('berkshelf-cookbook-fixture',
+          complacent_constraint,
+          git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git',
+          tag: tag
+        )
+      end
+      let(:cached) { subject.download(tmp_path) }
+      let(:sha) { subject.ref }
+      let(:expected_path) { tmp_path.join("#{cached.cookbook_name}-#{sha}") }
+
+      it 'returns a cached cookbook with a path that contains the ref' do
+        expect(cached.path).to eq(expected_path)
       end
     end
 
-    context "given a value for ref that is a tag or branch and not a commit hash" do
-      let(:ref) { "0.9.8" }
+    context 'give a value for branch' do
+      let(:branch) { 'master' }
 
       subject do
-        described_class.new("nginx",
+        Berkshelf::GitLocation.new('berkshelf-cookbook-fixture',
           complacent_constraint,
-          git: "git://github.com/opscode-cookbooks/nginx.git",
-          ref: ref
+          git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git',
+          branch: branch
         )
       end
-      let(:cached_cookbook) { subject.download(tmp_path) }
-      let(:commit_hash) { "d7be334b094f497f5cce4169a8b3012bf7b27bc3" }
-      let(:expected_path) { tmp_path.join("#{cached_cookbook.cookbook_name}-#{ref}") }
+      let(:cached) { subject.download(tmp_path) }
+      let(:sha) { subject.ref }
+      let(:expected_path) { tmp_path.join("#{cached.cookbook_name}-#{sha}") }
 
-      it "returns a cached cookbook with a path that contains the ref and not the commit hash it is pointing to" do
-        cached_cookbook.path.should eql(expected_path)
+      it 'returns a cached cookbook with a path that contains the ref' do
+        expect(cached.path).to eq(expected_path)
       end
     end
   end

data/spec/unit/berkshelf/locations/path_location_spec.rb

@@ -2,58 +2,74 @@ require 'spec_helper'
 
 describe Berkshelf::PathLocation do
   let(:complacent_constraint) { double('comp-vconstraint', satisfies?: true) }
-  let(:path) { fixtures_path.join("cookbooks", "example_cookbook").to_s }
+  let(:path) { fixtures_path.join('cookbooks', 'example_cookbook').to_s }
 
-  describe "ClassMethods" do
-    describe "::new" do
-      it "assigns the value of :path to @path" do
-        obj = described_class.new("nginx", complacent_constraint, path: path)
-
-        obj.path.should eql(path)
-      end
+  describe '.new' do
+    it 'assigns the value of :path to @path' do
+      location = Berkshelf::PathLocation.new('nginx', complacent_constraint, path: path)
+      expect(location.path).to eq(path)
     end
   end
 
-  subject { described_class.new("nginx", complacent_constraint, path: path) }
 
-  describe "#download" do
-    it "returns an instance of CachedCookbook" do
-      subject.download(tmp_path).should be_a(Berkshelf::CachedCookbook)
+
+  subject { Berkshelf::PathLocation.new('nginx', complacent_constraint, path: path) }
+
+  describe '#download' do
+    it 'returns an instance of CachedCookbook' do
+      expect(subject.download(tmp_path)).to be_a(Berkshelf::CachedCookbook)
     end
 
-    it "sets the downloaded status to true" do
+    it 'sets the downloaded status to true' do
       subject.download(tmp_path)
-
-      subject.should be_downloaded
+      expect(subject).to be_downloaded
     end
 
-    context "given a path that does not exist" do
-      subject { described_class.new("doesnot_exist", complacent_constraint, path: tmp_path.join("doesntexist_noway")) }
+    context 'given a path that does not exist' do
+      subject { Berkshelf::PathLocation.new('doesnot_exist', complacent_constraint, path: tmp_path.join('doesntexist_noway')) }
 
-      it "raises a CookbookNotFound error" do
-        lambda {
+      it 'raises a CookbookNotFound error' do
+        expect {
           subject.download(tmp_path)
-        }.should raise_error(Berkshelf::CookbookNotFound)
+        }.to raise_error(Berkshelf::CookbookNotFound)
       end
     end
 
-    context "given a path that does not contain a cookbook" do
-      subject { described_class.new("doesnot_exist", complacent_constraint, path: fixtures_path) }
+    context 'given a path that does not contain a cookbook' do
+      subject { Berkshelf::PathLocation.new('doesnot_exist', complacent_constraint, path: fixtures_path) }
 
-      it "raises a CookbookNotFound error" do
-        lambda {
+      it 'raises a CookbookNotFound error' do
+        expect {
           subject.download(tmp_path)
-        }.should raise_error(Berkshelf::CookbookNotFound)
+        }.to raise_error(Berkshelf::CookbookNotFound)
       end
     end
 
-    context "given the content at path does not satisfy the version constraint" do
-      subject { described_class.new("nginx", double('constraint', satisfies?: false), path: path) }
+    context 'given the content at path does not satisfy the version constraint' do
+      subject { Berkshelf::PathLocation.new('nginx', double('constraint', satisfies?: false), path: path) }
 
-      it "raises a CookbookValidationFailure error" do
-        lambda {
+      it 'raises a CookbookValidationFailure error' do
+        expect {
           subject.download(double('path'))
-        }.should raise_error(Berkshelf::CookbookValidationFailure)
+        }.to raise_error(Berkshelf::CookbookValidationFailure)
+      end
+    end
+  end
+
+  describe '#to_s' do
+    context 'for a remote path' do
+      subject { Berkshelf::PathLocation.new('nginx', complacent_constraint, path: path) }
+
+      it 'includes the path information' do
+        expect(subject.to_s).to match(/path\:.+example_cookbook/)
+      end
+    end
+
+    context 'for a store path' do
+      subject { Berkshelf::PathLocation.new('nginx', complacent_constraint, path: File.join(Berkshelf.berkshelf_path, 'cookbooks/example_cookbook')) }
+
+      it 'does not include the path information' do
+        expect(subject.to_s).to_not match(/path\:.+/)
       end
     end
   end