berkshelf 1.4.6 → 2.0.0.beta

data/spec/unit/berkshelf/errors_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
-describe "berkshelf errors" do
+describe Berkshelf::BerkshelfError do
   pending
 end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Berkshelf::Formatters::Null do
+  before { Berkshelf.set_format(:null) }
+
+  [:install, :package, :foo, :bar, :bacon].each do |meth|
+    it "does not raise an error for :#{meth}" do
+      expect {
+        subject.send(meth)
+      }.to_not raise_error(Berkshelf::AbstractFunction)
+    end
+
+    it "returns nil for :#{meth}" do
+      expect(subject.send(meth)).to be_nil
+    end
+  end
+end

data/spec/unit/berkshelf/formatters_spec.rb

@@ -1,119 +1,112 @@
 require 'spec_helper'
 
-module Berkshelf
-  describe Formatters do
-    before(:each) do
-      @original = Formatters.class_variable_get :@@formatters
-      Formatters.class_variable_set :@@formatters, Hash.new
-    end
+describe Berkshelf::Formatters do
+  before do
+    @original = Berkshelf::Formatters.class_variable_get :@@formatters
+    Berkshelf::Formatters.class_variable_set :@@formatters, {}
+  end
+
+  after do
+    Berkshelf::Formatters.class_variable_set :@@formatters, @original
+  end
+
+  let(:format_id) { :rspec }
+  let(:format_klass) { Class.new { include Berkshelf::Formatters::AbstractFormatter } }
+
+  describe '.register' do
+    it 'adds the class of the includer to the list of registered formatters with the id' do
+      Berkshelf::Formatters.register(format_id, format_klass)
 
-    after(:each) do
-      Formatters.class_variable_set :@@formatters, @original
+      expect(Berkshelf::Formatters.formatters).to have_key(format_id)
+      expect(Berkshelf::Formatters.formatters[format_id]).to eq(format_klass)
     end
 
-    describe "ClassMethods" do
-      subject { Formatters }
-      let(:format_id) { :rspec }
-      let(:format_klass) { Class.new }
-
-      describe "::register" do
-        it "adds the class of the includer to the list of registered formatters with the id" do
-          subject.register(format_id, format_klass)
-
-          subject.formatters.should have_key(format_id)
-          subject.formatters[format_id].should eql(format_klass)
-        end
-
-        context "when given a string instead of a symbol as the ID" do
-          it "converts the string to a symbol and registers it" do
-            subject.register("rspec", format_klass)
-
-            subject.formatters.should have_key(:rspec)
-            subject.formatters[:rspec].should eql(format_klass)
-          end
-        end
-
-        context "when a formatter of the given ID has already been registered" do
-          it "raises an InternalError" do
-            subject.register(format_id, format_klass)
-
-            lambda {
-              subject.register(format_id, format_klass)
-            }.should raise_error(Berkshelf::InternalError)
-          end
-        end
-      end
+    context 'when given a string instead of a symbol as the ID' do
+      it 'converts the string to a symbol and registers it' do
+        Berkshelf::Formatters.register('rspec', format_klass)
 
-      describe "::formatters" do
-        before(:each) do
-          subject.register(format_id, format_klass)
-        end
-
-        it "returns a hash where formatter ID's are keys and values are formatter classes" do
-          subject.formatters.should be_a(Hash)
-          subject.formatters.should have(1).item
-          subject.formatters.keys.first.should eql(format_id)
-          subject.formatters.values.first.should eql(format_klass)
-        end
+        expect(Berkshelf::Formatters.formatters).to have_key(:rspec)
+        expect(Berkshelf::Formatters.formatters[:rspec]).to eq(format_klass)
       end
+    end
 
-      describe "::get" do
-        before(:each) do
-          subject.register(format_id, format_klass)
-        end
-
-        it "returns the class constant of the given formatter ID" do
-          subject[format_id].should eql(format_klass)
-        end
+    context 'when a formatter of the given ID has already been registered' do
+      it 'raises an InternalError' do
+        Berkshelf::Formatters.register(format_id, format_klass)
 
-        context "when the ID has not been registered" do
-          it "returns nil" do
-            subject[:not_there].should be_nil
-          end
-        end
+        expect {
+          Berkshelf::Formatters.register(format_id, format_klass)
+        }.to raise_error(Berkshelf::InternalError)
       end
     end
   end
 
-  describe Formatters::AbstractFormatter do
-    before(:each) do
-      @original = Formatters.class_variable_get :@@formatters
-      Formatters.class_variable_set :@@formatters, Hash.new
+  describe '.formatters' do
+    before do
+      Berkshelf::Formatters.register(format_id, format_klass)
+    end
+
+    it "returns a hash where formatter ID's are keys and values are formatter classes" do
+      expect(Berkshelf::Formatters.formatters).to be_a(Hash)
+      expect(Berkshelf::Formatters.formatters).to have(1).item
+      expect(Berkshelf::Formatters.formatters.keys.first).to eq(format_id)
+      expect(Berkshelf::Formatters.formatters.values.first).to eq(format_klass)
     end
+  end
+
+  describe '.get' do
+    before { Berkshelf::Formatters.register(format_id, format_klass) }
 
-    after(:each) do
-      Formatters.class_variable_set :@@formatters, @original
+    it 'returns the class constant of the given formatter ID' do
+      expect(Berkshelf::Formatters[format_id]).to eq(format_klass)
     end
 
-    describe "ClassMethods" do
-      subject do
-        Class.new do
-          include Formatters::AbstractFormatter
-        end
+    context 'when the ID has not been registered' do
+      it 'returns nil' do
+        expect(Berkshelf::Formatters[:not_there]).to be_nil
       end
+    end
+  end
 
-      describe "::register_formatter" do
-        it "delegates to Formatters" do
-          Formatters.should_receive(:register).with(:rspec, subject)
+  describe Berkshelf::Formatters::AbstractFormatter do
+    describe '.register_formatter' do
+      it 'delegates to Formatters' do
+        Berkshelf::Formatters.should_receive(:register).with(:rspec, format_klass)
 
-          subject.register_formatter(:rspec)
-        end
+        format_klass.register_formatter(:rspec)
       end
     end
 
+
+
     subject do
-      Class.new do
-        include Formatters::AbstractFormatter
-      end.new
+      Class.new { include Berkshelf::Formatters::AbstractFormatter }.new
     end
 
-    it "has abstract methods for all the messaging modes" do
-      lambda { subject.install("my_coobook","1.2.3","http://community") }.should raise_error(AbstractFunction)
-      lambda { subject.use("my_coobook","1.2.3") }.should raise_error(AbstractFunction)
-      lambda { subject.use("my_coobook","1.2.3","http://community") }.should raise_error(AbstractFunction)
-      lambda { subject.upload("my_coobook","1.2.3","http://chef_server") }.should raise_error(AbstractFunction)
-      lambda { subject.msg("something you should know") }.should raise_error(AbstractFunction)
-      lambda { subject.error("whoa this is bad") }.should raise_error(AbstractFunction)
+    it 'has abstract methods for all the messaging modes' do
+      expect {
+        subject.install('my_coobook','1.2.3','http://community')
+      }.to raise_error(Berkshelf::AbstractFunction)
+
+      expect {
+        subject.use('my_coobook','1.2.3')
+      }.to raise_error(Berkshelf::AbstractFunction)
+
+      expect {
+        subject.use('my_coobook','1.2.3','http://community')
+      }.to raise_error(Berkshelf::AbstractFunction)
+
+      expect {
+        subject.upload('my_coobook','1.2.3','http://chef_server')
+      }.to raise_error(Berkshelf::AbstractFunction)
+
+      expect {
+        subject.msg('something you to know')
+      }.to raise_error(Berkshelf::AbstractFunction)
+
+      expect {
+        subject.error('whoa this is bad')
+      }.to raise_error(Berkshelf::AbstractFunction)
     end
   end
 end

data/spec/unit/berkshelf/git_spec.rb

@@ -1,299 +1,311 @@
 require 'spec_helper'
 
 describe Berkshelf::Git do
-  describe "ClassMethods" do
-    subject { Berkshelf::Git }
-    let(:git) { Berkshelf::Git }
+  let(:git) { Berkshelf::Git }
 
-    describe "::find_git" do
-      it "should find git" do
-        subject.find_git.should_not be_nil
-      end
+  describe '.find_git' do
+    it 'finds git' do
+      expect(Berkshelf::Git.find_git).to_not be_nil
+    end
 
-      it "should raise if it can't find git" do
-        ENV.should_receive(:[]).with("PATH").and_return(String.new)
+    it 'raises an error if git cannot be not found' do
+      ENV.should_receive(:[]).with('PATH').and_return(String.new)
 
-        lambda {
-          subject.find_git
-        }.should raise_error(Berkshelf::GitNotFound)
-      end
+      expect {
+        Berkshelf::Git.find_git
+      }.to raise_error(Berkshelf::GitNotFound)
     end
+  end
 
-    describe "::clone" do
-      let(:target) { clone_target_for('nginx') }
+  describe '.clone' do
+    let(:target) { clone_target_for('nginx') }
 
-      it "clones the repository to the target path" do
-        origin_uri = git_origin_for("nginx")
-        subject.clone(origin_uri, target)
+    it 'clones the repository to the target path' do
+      origin_uri = git_origin_for('nginx')
+      Berkshelf::Git.clone(origin_uri, target)
 
-        expect(target).to exist
-        expect(target).to be_directory
-      end
+      expect(target).to exist
+      expect(target).to be_directory
     end
+  end
 
-    describe "::checkout" do
-      let(:repo_path) { clone_target_for('nginx') }
-      let(:repo) { 
-        origin_uri = git_origin_for('nginx', tags: ['1.0.1', '1.0.2'], branches: ['topic', 'next_topic'])
-        git.clone(origin_uri, repo_path)
-      }
+  describe '.checkout' do
+    let(:repo_path) { clone_target_for('nginx') }
+    let(:repo) {
+      origin_uri = git_origin_for('nginx', tags: ['1.0.1', '1.0.2'], branches: ['topic', 'next_topic'])
+      git.clone(origin_uri, repo_path)
+    }
 
-      shared_examples "able to checkout git ref" do |test_ref|
-        it "checks out the specified ref of the given repository" do
-          git.checkout(repo, ref)
+    shared_examples 'able to checkout git ref' do |test_ref|
+      it 'checks out the specified ref of the given repository' do
+        git.checkout(repo, ref)
 
-          Dir.chdir repo_path do
-            test_ref ||= ref
-            %x[git rev-parse #{test_ref}].should == %x[git rev-parse HEAD]
-          end
+        Dir.chdir repo_path do
+          test_ref ||= ref
+          expect(%x[git rev-parse #{test_ref}]).to eq(%x[git rev-parse HEAD])
         end
       end
+    end
 
-      context 'with sha commit id' do
-        let(:ref) { git_sha_for_ref('nginx', '1.0.1') }
+    context 'with sha commit id' do
+      let(:ref) { git_sha_for_ref('nginx', '1.0.1') }
 
-        it_behaves_like 'able to checkout git ref'
-      end
+      it_behaves_like 'able to checkout git ref'
+    end
 
-      context 'with tags' do
-        let(:ref) { "1.0.1" }
+    context 'with tags' do
+      let(:ref) { '1.0.1' }
 
-        it_behaves_like 'able to checkout git ref'
+      it_behaves_like 'able to checkout git ref'
 
-        context 'after checking out another tag' do
-          let(:other_tag) { '1.0.2' }
-          before do
-            git.checkout(repo, other_tag)
-            Dir.chdir repo_path do
-              run! "echo 'uncommitted change' >> content_file"
-            end
+      context 'after checking out another tag' do
+        let(:other_tag) { '1.0.2' }
+        before do
+          git.checkout(repo, other_tag)
+          Dir.chdir repo_path do
+            run! "echo 'uncommitted change' >> content_file"
           end
-
-          it_behaves_like 'able to checkout git ref'
         end
+
+        it_behaves_like 'able to checkout git ref'
       end
+    end
 
-      context 'with branches' do
-        let(:ref) { 'topic' }
+    context 'with branches' do
+      let(:ref) { 'topic' }
 
-        it_behaves_like 'able to checkout git ref', 'origin/topic'
+      it_behaves_like 'able to checkout git ref', 'origin/topic'
 
-        context 'after checking out another branch' do
-          let(:other_branch) { 'next_topic' }
-          before do
-            git.checkout(repo, other_branch)
-            Dir.chdir repo_path do
-              run! "echo 'uncommitted change' >> content_file"
-            end
+      context 'after checking out another branch' do
+        let(:other_branch) { 'next_topic' }
+        before do
+          git.checkout(repo, other_branch)
+          Dir.chdir repo_path do
+            run! "echo 'uncommitted change' >> content_file"
           end
-
-          it_behaves_like 'able to checkout git ref', 'origin/topic'
         end
+
+        it_behaves_like 'able to checkout git ref', 'origin/topic'
       end
     end
+  end
 
-    describe "::rev_parse" do
-      let(:repo_path) { clone_target_for('nginx') }
-      before(:each) do |example|
-        origin_uri = git_origin_for('nginx', tags: ['1.1.1'])
-        subject.clone(origin_uri, repo_path)
-        subject.checkout(repo_path, git_sha_for_ref('nginx', '1.1.1'))
-      end
+  describe '.rev_parse' do
+    let(:repo_path) { clone_target_for('nginx') }
+    before(:each) do |example|
+      origin_uri = git_origin_for('nginx', tags: ['1.1.1'])
+      Berkshelf::Git.clone(origin_uri, repo_path)
+      Berkshelf::Git.checkout(repo_path, git_sha_for_ref('nginx', '1.1.1'))
+    end
 
-      it "returns the ref for HEAD" do
-        expect(subject.rev_parse(repo_path)).to eql(git_sha_for_ref('nginx', '1.1.1'))
-      end
+    it 'returns the ref for HEAD' do
+      rev = Berkshelf::Git.rev_parse(repo_path)
+      ref = git_sha_for_ref('nginx', '1.1.1')
+
+      expect(rev).to eql(ref)
     end
+  end
 
-    describe "::show_ref" do
-      let(:repo_path) { clone_target_for('nginx') }
-      let(:tags) { ['1.0.1'] }
-      let(:branches) { ['topic'] }
-      let!(:repo) {
-        origin_uri = git_origin_for('nginx', tags: tags, branches: branches)
-        git.clone(origin_uri, repo_path)
-      }
+  describe '.show_ref' do
+    let(:repo_path) { clone_target_for('nginx') }
+    let(:tags) { ['1.0.1'] }
+    let(:branches) { ['topic'] }
+    let!(:repo) {
+      origin_uri = git_origin_for('nginx', tags: tags, branches: branches)
+      git.clone(origin_uri, repo_path)
+    }
 
-      it 'returns the commit id for the given tag' do
-        git.show_ref(repo_path, '1.0.1').should == git_sha_for_ref('nginx', '1.0.1')
-      end
+    it 'returns the commit id for the given tag' do
+      show = git.show_ref(repo_path, '1.0.1')
+      ref = git_sha_for_ref('nginx', '1.0.1')
 
-      it 'returns the commit id for the given branch' do
-        git.show_ref(repo_path, 'topic').should == git_sha_for_ref('nginx', 'topic')
-      end
+      expect(show).to eq(ref)
+    end
 
-      context 'with an ambiguous ref' do
-        let(:tags) { ['topic'] }
-        let(:branches) { ['topic'] }
+    it 'returns the commit id for the given branch' do
+      show = git.show_ref(repo_path, 'topic')
+      ref = git_sha_for_ref('nginx', 'topic')
+      expect(show).to eq(ref)
+    end
 
-        it 'raises an error' do
-          expect {git.show_ref(repo_path, 'topic')}.to raise_error(Berkshelf::AmbiguousGitRef)
-        end
+    context 'with an ambiguous ref' do
+      let(:tags) { ['topic'] }
+      let(:branches) { ['topic'] }
+
+      it 'raises an error' do
+        expect {
+          git.show_ref(repo_path, 'topic')
+        }.to raise_error(Berkshelf::AmbiguousGitRef)
       end
     end
+  end
 
-    describe '::revision_from_ref' do
-      let(:repo_path) { clone_target_for('nginx') }
-      let(:tags) { ['1.0.1'] }
-      let(:branches) { ['topic'] }
-      let!(:repo) {
-        origin_uri = git_origin_for('nginx', tags: tags, branches: branches)
-        git.clone(origin_uri, repo_path)
-      }
-
-      context 'with sha commit id' do
-        let(:revision) { git_sha_for_ref('nginx', '1.0.1') }
-        it 'returns the passed revision' do
-          git.revision_from_ref(repo_path, revision).should == revision
-        end
+  describe '.revision_from_ref' do
+    let(:repo_path) { clone_target_for('nginx') }
+    let(:tags) { ['1.0.1'] }
+    let(:branches) { ['topic'] }
+    let!(:repo) {
+      origin_uri = git_origin_for('nginx', tags: tags, branches: branches)
+      git.clone(origin_uri, repo_path)
+    }
+
+    context 'with sha commit id' do
+      let(:revision) { git_sha_for_ref('nginx', '1.0.1') }
+      it 'returns the passed revision' do
+        rev = git.revision_from_ref(repo_path, revision)
+        expect(rev).to eq(revision)
       end
+    end
 
-      context 'with tag' do
-        let(:revision) { git_sha_for_ref('nginx', '1.0.1') }
-        it 'returns the revision' do
-          git.revision_from_ref(repo_path, '1.0.1').should == revision
-        end
+    context 'with tag' do
+      let(:revision) { git_sha_for_ref('nginx', '1.0.1') }
+      it 'returns the revision' do
+        rev = git.revision_from_ref(repo_path, '1.0.1')
+        expect(rev).to eq(revision)
       end
+    end
 
-      context 'with branch' do
-        let(:revision) { git_sha_for_ref('nginx', 'topic') }
-        it 'returns the revision' do
-          git.revision_from_ref(repo_path, 'topic').should == revision
-        end
+    context 'with branch' do
+      let(:revision) { git_sha_for_ref('nginx', 'topic') }
+      it 'returns the revision' do
+        rev = git.revision_from_ref(repo_path, 'topic')
+        expect(rev).to eq(revision)
       end
+    end
 
-      context 'with an invalid ref' do
-        let(:ref) { 'foobar' }
-        it 'raises an error' do
-          expect { git.revision_from_ref(repo_path, ref) }.to raise_error(Berkshelf::InvalidGitRef)
-        end
+    context 'with an invalid ref' do
+      let(:ref) { 'foobar' }
+      it 'raises an error' do
+        expect {
+          git.revision_from_ref(repo_path, ref)
+        }.to raise_error(Berkshelf::InvalidGitRef)
       end
     end
+  end
 
-    let(:readonly_uri) { "git://github.com/reset/thor-foodcritic.git" }
-    let(:https_uri) { "https://github.com/reset/solve.git" }
-    let(:http_uri) { "http://github.com/reset/solve.git" }
-    let(:invalid_uri) { "/something/on/disk" }
+  let(:readonly_uri) { 'git://github.com/reset/thor-foodcritic.git' }
+  let(:https_uri) { 'https://github.com/reset/solve.git' }
+  let(:http_uri) { 'http://github.com/reset/solve.git' }
+  let(:invalid_uri) { '/something/on/disk' }
 
-    describe "::validate_uri" do
-      context "given a valid Git read-only URI" do
-        it "returns true" do
-          subject.validate_uri(readonly_uri).should be_true
-        end
+  describe '.validate_uri' do
+    context 'given a valid Git read-only URI' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri(readonly_uri)).to be_true
       end
+    end
 
-      context "given a valid Git HTTPS URI" do
-        it "returns true" do
-          subject.validate_uri(https_uri).should be_true
-        end
+    context 'given a valid Git HTTPS URI' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri(https_uri)).to be_true
       end
+    end
 
-      context "given a valid Github SSH URI" do
-        it "returns true" do
-          subject.validate_uri("git@github.com:reset/solve.git").should be_true
-        end
+    context 'given a valid Github SSH URI' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri('git@github.com:reset/solve.git')).to be_true
       end
+    end
 
-      context "given a valid SSH URI without an 'organization'" do
-        it "returns true" do
-          subject.validate_uri("gituser@githost:solve.git").should be_true
-        end
+    context "given a valid SSH URI without an 'organization'" do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri('gituser@githost:solve.git')).to be_true
       end
+    end
 
-      context "given a valid git+ssh URI without an username" do
-        it "returns true" do
-          subject.validate_uri("git+ssh://host.com/repo").should be_true
-        end
+    context 'given a valid git+ssh URI without an username' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri('git+ssh://host.com/repo')).to be_true
       end
+    end
 
-      context "given a valid git+ssh URI with an username" do
-        it "returns true" do
-          subject.validate_uri("git+ssh://user@host.com/repo").should be_true
-        end
+    context 'given a valid git+ssh URI with an username' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri('git+ssh://user@host.com/repo')).to be_true
       end
+    end
 
-      context "given a valid URI with a dash in the hostname" do
-        it "returns true" do
-          subject.validate_uri("git://user@git-host.com/repo").should be_true
-        end
+    context 'given a valid URI with a dash in the hostname' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri('git://user@git-host.com/repo')).to be_true
       end
+    end
 
-      context "given a valid URI with host being a subdomain" do
-        it "returns true" do
-          subject.validate_uri("git://user@git.host.com/repo").should be_true
-        end
+    context 'given a valid URI with host being a subdomain' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri('git://user@git.host.com/repo')).to be_true
       end
+    end
 
-      context "given a valid git+ssh URI with home directory expansion" do
-        it "returns true" do
-          subject.validate_uri("git+ssh://user@host.com/~repo").should be_true
-        end
+    context 'given a valid git+ssh URI with home directory expansion' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri('git+ssh://user@host.com/~repo')).to be_true
       end
+    end
 
-      context "given an invalid URI" do
-        it "returns false" do
-          subject.validate_uri(invalid_uri).should be_false
-        end
+    context 'given an invalid URI' do
+      it 'returns false' do
+        expect(Berkshelf::Git.validate_uri(invalid_uri)).to be_false
       end
+    end
 
-      context "given a HTTP URI" do
-        it "returns true" do
-          subject.validate_uri(http_uri).should be_true
-        end
+    context 'given a HTTP URI' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri(http_uri)).to be_true
       end
+    end
 
-      context "given an integer" do
-        it "returns false" do
-          subject.validate_uri(123).should be_false
-        end
+    context 'given an integer' do
+      it 'returns false' do
+        expect(Berkshelf::Git.validate_uri(123)).to be_false
       end
     end
+  end
 
-    describe "::validate_uri!" do
-      context "given a valid Git read-only URI" do
-        it "returns true" do
-          subject.validate_uri!(readonly_uri).should be_true
-        end
+  describe '.validate_uri!' do
+    context 'given a valid Git read-only URI' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri!(readonly_uri)).to be_true
       end
+    end
 
-      context "given a valid Git HTTPS URI" do
-        it "returns true" do
-          subject.validate_uri!(https_uri).should be_true
-        end
+    context 'given a valid Git HTTPS URI' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri!(https_uri)).to be_true
       end
+    end
 
-      context "given a valid Git SSH URI" do
-        it "returns true" do
-          subject.validate_uri!("git@github.com:reset/solve.git").should be_true
-        end
+    context 'given a valid Git SSH URI' do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri!('git@github.com:reset/solve.git')).to be_true
       end
+    end
 
-      context "given a valid SSH URI without an 'organization'" do
-        it "returns true" do
-          subject.validate_uri("gituser@githost:solve.git").should be_true
-        end
+    context "given a valid SSH URI without an 'organization'" do
+      it 'returns true' do
+        expect(Berkshelf::Git.validate_uri('gituser@githost:solve.git')).to be_true
       end
+    end
 
-      context "given an invalid URI" do
-        it "raises InvalidGitURI" do
-          lambda {
-            subject.validate_uri!(invalid_uri)
-          }.should raise_error(Berkshelf::InvalidGitURI)
-        end
+    context 'given an invalid URI' do
+      it 'raises InvalidGitURI' do
+        expect {
+          Berkshelf::Git.validate_uri!(invalid_uri)
+        }.to raise_error(Berkshelf::InvalidGitURI)
       end
+    end
 
-      context "given a HTTP URI" do
-        it "raises InvalidGitURI" do
-          subject.validate_uri!(http_uri).should be_true
-        end
+    context 'given a HTTP URI' do
+      it 'raises InvalidGitURI' do
+        expect(Berkshelf::Git.validate_uri!(http_uri)).to be_true
       end
+    end
 
-      context "given an integer" do
-        it "raises InvalidGitURI" do
-          lambda {
-            subject.validate_uri!(123)
-          }.should raise_error(Berkshelf::InvalidGitURI)
-        end
+    context 'given an integer' do
+      it 'raises InvalidGitURI' do
+        expect {
+          Berkshelf::Git.validate_uri!(123)
+        }.to raise_error(Berkshelf::InvalidGitURI)
       end
     end
   end