berkshelf 3.0.0.beta1 → 3.0.0.beta2

data/spec/support/path_helpers.rb

@@ -40,7 +40,7 @@ module Berkshelf
       #
       # @return [Bershelf::Chef::Config]
       def chef_config
-        Berkshelf::Chef::Config.from_file(chef_config_path)
+        Ridley::Chef::Config.from_file(chef_config_path)
       end
 
       def clean_tmp_path
@@ -58,7 +58,7 @@ module Berkshelf
           Berkshelf.chef_config = chef_config
 
           # This fucking sucks...
-          load 'berkshelf/chef/config.rb'
+          # load 'berkshelf/chef/config.rb'
           load 'berkshelf/config.rb'
 
           Berkshelf.config = Berkshelf::Config.new

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -269,10 +269,6 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe "#install" do
-    pending
-  end
-
   describe '#add_dependency' do
     let(:name) { 'cookbook_one' }
     let(:constraint) { '= 1.2.0' }
@@ -335,6 +331,36 @@ describe Berkshelf::Berksfile do
     end
   end
 
+  describe '#retrieve_locked' do
+    let(:lockfile) { double('lockfile', find: locked) }
+    let(:locked) { double('locked', cached_cookbook: cached, locked_version: '1.0.0') }
+    let(:cached) { double('cached') }
+
+    before do
+      subject.stub(:validate_cookbook_names!)
+      subject.stub(:lockfile).and_return(lockfile)
+    end
+
+    it 'validates cookbook names' do
+      expect(subject).to receive(:validate_cookbook_names!).once
+      subject.retrieve_locked('bacon')
+    end
+
+    it 'raises an error when the lockfile does not exist' do
+      lockfile.stub(:find)
+      expect {
+        subject.retrieve_locked('bacon')
+      }.to raise_error(Berkshelf::LockfileNotFound)
+    end
+
+    it 'raises an error when the cookbook is not downloaded' do
+      locked.stub(:cached_cookbook)
+      expect {
+        subject.retrieve_locked('bacon')
+      }.to raise_error(Berkshelf::CookbookNotFound)
+    end
+  end
+
   describe '#upload' do
     let(:options) { Hash.new }
     let(:chef_config) do
@@ -428,8 +454,8 @@ describe Berkshelf::Berksfile do
   describe "#apply" do
     let(:env_name)    { 'berkshelf-test' }
     let(:server_url)  { Berkshelf::RSpec::ChefServer.server_url }
-    let(:client_name) { 'reset' }
-    let(:client_key)  { fixtures_path.join('reset.pem').to_s }
+    let(:client_name) { 'berkshelf' }
+    let(:client_key)  { fixtures_path.join('../config/berkshelf.pem').to_s }
     let(:ridley)      { Ridley.new(server_url: server_url, client_name: client_name, client_key: client_key) }
 
     before do
@@ -525,14 +551,14 @@ describe Berkshelf::Berksfile do
       Dir.stub(:glob).and_return(['/there are/spaces/in this/recipes/default.rb'])
       expect {
         subject.validate_files!(cookbook)
-      }.to raise_error(Berkshelf::InvalidCookbookFiles)
+      }.to raise_error
     end
 
     it 'does not raise an error when the cookbook is valid' do
       Dir.stub(:glob).and_return(['/there-are/no-spaces/in-this/recipes/default.rb'])
       expect {
         subject.validate_files!(cookbook)
-      }.to_not raise_error(Berkshelf::InvalidCookbookFiles)
+      }.to_not raise_error
     end
 
     it 'does not raise an exception with spaces in the path' do

data/spec/unit/berkshelf/dependency_spec.rb

@@ -214,13 +214,6 @@ describe Berkshelf::Dependency do
       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'))
 

data/spec/unit/berkshelf/formatters/null_spec.rb

@@ -7,7 +7,7 @@ describe Berkshelf::Formatters::Null do
     it "does not raise an error for :#{meth}" do
       expect {
         subject.send(meth)
-      }.to_not raise_error(Berkshelf::AbstractFunction)
+      }.to_not raise_error
     end
 
     it "returns nil for :#{meth}" do

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

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe Berkshelf::MercurialLocation do
+
+  include Berkshelf::RSpec::Mercurial
+
+  let(:cookbook_uri) { mercurial_origin_for('fake_cookbook', is_cookbook: true, tags: ["1.0.0"], branches: ["mybranch"]) }
+  let(:constraint) { double('comp-vconstraint', satisfies?: true) }
+  let(:dependency) { double('dep', name: "berkshelf-cookbook-fixture", version_constraint: constraint) }
+  let(:storage_path) { Berkshelf::CookbookStore.instance.storage_path }
+
+  describe '.initialize' do
+    it 'raises InvalidHgURI if given an invalid URI for options[:hg]' do
+      expect {
+        described_class.new(dependency, hg: '/something/on/disk')
+      }.to raise_error(Berkshelf::InvalidHgURI)
+    end
+  end
+
+  describe '.tmpdir' do
+    it 'creates a temporary directory within the Berkshelf temporary directory' do
+      expect(described_class.tmpdir).to include(Berkshelf.tmp_dir)
+    end
+  end
+
+  subject { described_class.new(dependency, hg: cookbook_uri) }
+
+  describe '#download' do
+
+    before() do
+      # recreate the fake repo
+      clean_tmp_path
+      FileUtils.mkdir_p(storage_path)
+      cookbook_uri
+    end
+
+    context 'when a local revision is present' do
+      let(:cached) { double('cached') }
+
+      before do
+        Berkshelf::Mercurial.stub(:rev_parse).and_return('abcd1234')
+        described_class.any_instance.stub(:cached?).and_return(true)
+        described_class.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
+        expect(subject.download).to eq(cached)
+      end
+    end
+
+    it 'returns an instance of Berkshelf::CachedCookbook' do
+      expect(subject.download).to be_a(Berkshelf::CachedCookbook)
+    end
+
+    it 'downloads the cookbook to the given destination' do
+      cached_cookbook = subject.download
+      rev = subject.rev
+
+      expect(storage_path).to have_structure {
+        directory "#{cached_cookbook.cookbook_name}-#{rev}" do
+          file 'metadata.rb'
+        end
+      }
+    end
+
+    context 'given no ref/branch/tag options is given' do
+      subject { described_class.new(dependency, hg: cookbook_uri) }
+
+      it 'sets the branch attribute to the default revision of the cloned repo' do
+        subject.download
+        expect(subject.branch).to_not be_nil
+      end
+    end
+
+    context 'given a repo that does not exist' do
+      before { dependency.stub(name: "doesnot_exist") }
+      subject { described_class.new(dependency, hg: 'http://thisdoesntexist.org/notarepo') }
+
+      it 'raises a MercurailError' do
+        Berkshelf::Mercurial.stub(:hg).and_raise(Berkshelf::MercurialError.new(''))
+        expect {
+          subject.download
+        }.to raise_error(Berkshelf::MercurialError)
+      end
+    end
+
+    context 'given a hg repo that does not contain a cookbook' do
+      let(:fake_remote) { mercurial_origin_for('not_a_cookbook', is_cookbook: false) }
+      subject { described_class.new(dependency, hg: fake_remote) }
+
+      it 'raises a CookbookNotFound error' do
+        expect {
+          subject.download
+        }.to raise_error(Berkshelf::CookbookNotFound)
+      end
+    end
+
+    context 'given the content at the repo does not satisfy the version constraint' do
+      before { constraint.stub(satisfies?: false) }
+      subject do
+        described_class.new(dependency,
+                                   hg: cookbook_uri
+        )
+      end
+
+      it 'raises a CookbookValidationFailure error' do
+        expect {
+          subject.download
+        }.to raise_error(Berkshelf::CookbookValidationFailure)
+      end
+    end
+
+    context 'given a value for tag' do
+      let(:tag) { '1.0.0' }
+
+      subject do
+        described_class.new(dependency,
+                                   hg: cookbook_uri,
+                                   tag: tag
+        )
+      end
+      let(:cached) { subject.download }
+      let(:sha) { subject.rev }
+      let(:expected_path) { storage_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 'give a value for branch' do
+      let(:branch) { 'mybranch' }
+
+      subject do
+        described_class.new(dependency,
+                                   hg: cookbook_uri,
+                                   branch: branch
+        )
+      end
+      let(:cached) { subject.download }
+      let(:sha) { subject.rev }
+      let(:expected_path) { storage_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
+  end
+end

data/spec/unit/berkshelf/lockfile_spec.rb

@@ -100,18 +100,6 @@ describe Berkshelf::Lockfile do
     end
   end
 
-  describe '#to_s' do
-    it 'returns a pretty-formatted string' do
-      expect(subject.to_s).to eq '#<Berkshelf::Lockfile Berksfile.lock>'
-    end
-  end
-
-  describe '#inspect' do
-    it 'returns a pretty-formatted, detailed string' do
-      expect(subject.inspect).to eq("#<#{described_class} Berksfile.lock, dependencies: [#<Berkshelf::Dependency: build-essential (>= 0.0.0), locked_version: 1.1.2, groups: [:default], location: default>, #<Berkshelf::Dependency: chef-client (>= 0.0.0), locked_version: 2.1.4, groups: [:default], location: default>]>")
-    end
-  end
-
   describe '#to_hash' do
     let(:hash) { subject.to_hash }
 

data/spec/unit/berkshelf/mercurial_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe Berkshelf::Mercurial do
+
+  include Berkshelf::RSpec::Mercurial
+
+  let(:hg) { Berkshelf::Mercurial }
+
+  describe '.find_hg' do
+    it 'finds hg' do
+      expect(described_class.find_hg).to_not be_nil
+    end
+
+    it 'raises an error if mercurial cannot be not found' do
+      ENV.should_receive(:[]).with('PATH').and_return(String.new)
+
+      expect {
+        described_class.find_hg
+      }.to raise_error(Berkshelf::MercurialNotFound)
+    end
+  end
+
+  describe '.clone' do
+    let(:target) { clone_path('nginx') }
+
+    it 'clones the repository to the target path' do
+      origin_uri = mercurial_origin_for('nginx')
+
+      described_class.clone(origin_uri, target)
+
+      expect(target).to exist
+      expect(target).to be_directory
+    end
+  end
+
+  describe '.checkout' do
+    let(:repo_path) { clone_path('nginx') }
+    let(:repo) {
+      origin_uri = mercurial_origin_for('nginx', tags: ['1.0.1', '1.0.2'], branches: ['topic', 'next_topic'])
+      hg.clone(origin_uri, repo_path)
+    }
+
+    shared_examples 'able to checkout hg rev' do |test_rev|
+      it 'checks out the specified rev of the given repository' do
+        hg.checkout(repo, rev)
+
+        Dir.chdir repo_path do
+          test_rev ||= rev
+          expect(%x[hg id -r #{test_rev}].split(' ').first).to eq(%x[hg id -i].strip)
+        end
+      end
+    end
+
+    context 'with sha commit id' do
+      let(:rev) { id_for_rev('nginx', '1.0.1') }
+
+      it_behaves_like 'able to checkout hg rev'
+    end
+
+    context 'with tags' do
+      let(:rev) { '1.0.1' }
+
+      it_behaves_like 'able to checkout hg rev'
+
+      context 'after checking out another tag' do
+        let(:other_tag) { '1.0.2' }
+        before do
+          hg.checkout(repo, other_tag)
+          Dir.chdir repo_path do
+            shell_out "echo 'uncommitted change' >> content_file"
+          end
+        end
+
+        it_behaves_like 'able to checkout hg rev'
+      end
+    end
+
+    context 'with branches' do
+      let(:rev) { 'topic' }
+
+      it_behaves_like 'able to checkout hg rev', 'topic'
+
+      context 'after checking out another branch' do
+        let(:other_branch) { 'next_topic' }
+        before do
+          hg.checkout(repo, other_branch)
+          Dir.chdir repo_path do
+            shell_out "echo 'uncommitted change' >> content_file"
+          end
+        end
+
+        it_behaves_like 'able to checkout hg rev', 'topic'
+      end
+    end
+  end
+
+  describe '.rev_parse' do
+    let(:repo_path) { clone_path('nginx') }
+
+    before(:each) do
+      origin_uri = mercurial_origin_for('nginx', tags: ['1.1.1'])
+      described_class.clone(origin_uri, repo_path)
+      described_class.checkout(repo_path, id_for_rev('nginx', '1.1.1'))
+    end
+
+    it 'returns the ref for HEAD' do
+      rev = described_class.rev_parse(repo_path)
+      ref = id_for_rev('nginx', '1.1.1')
+
+      expect(rev).to eql(ref)
+    end
+  end
+
+  let(:https_uri) { 'https://hghub.com/reset/' }
+  let(:http_uri) { 'http://hghub.com/reset/' }
+  let(:invalid_uri) { '/something/on/disk' }
+
+  describe '.validate_uri' do
+    context 'given an invalid URI' do
+      it 'returns false' do
+        expect(described_class.validate_uri(invalid_uri)).to be_false
+      end
+    end
+
+    context 'given a HTTP URI' do
+      it 'returns true' do
+        expect(described_class.validate_uri(http_uri)).to be_true
+      end
+    end
+
+    context 'given a valid HTTPS URI' do
+      it 'returns true' do
+        expect(described_class.validate_uri(https_uri)).to be_true
+      end
+    end
+
+    context 'given an integer' do
+      it 'returns false' do
+        expect(described_class.validate_uri(123)).to be_false
+      end
+    end
+  end
+
+  describe '.validate_uri!' do
+    context 'given an invalid URI' do
+      it 'raises InvalidHgURI' do
+        expect {
+          described_class.validate_uri!(invalid_uri)
+        }.to raise_error(Berkshelf::InvalidHgURI)
+      end
+    end
+
+    context 'given a HTTP URI' do
+      it 'raises InvalidHgURI' do
+        expect(described_class.validate_uri!(http_uri)).to be_true
+      end
+    end
+
+    context 'given a valid HTTPS URI' do
+      it 'returns true' do
+        expect(described_class.validate_uri!(https_uri)).to be_true
+      end
+    end
+
+    context 'given an integer' do
+      it 'raises InvalidHgURI' do
+        expect {
+          described_class.validate_uri!(123)
+        }.to raise_error(Berkshelf::InvalidHgURI)
+      end
+    end
+  end
+end