berkshelf 1.4.6 → 2.0.0.beta

data/spec/unit/berkshelf/init_generator_spec.rb

@@ -1,192 +1,192 @@
 require 'spec_helper'
 
 describe Berkshelf::InitGenerator, vcr: { record: :new_episodes, serialize_with: :json } do
-  subject { described_class }
-
   let(:target) { tmp_path.join("some_cookbook") }
   let(:resolver) { double('resolver') }
 
-  context "with default options" do
-    before(:each) do
+  context 'with default options' do
+    before do
       capture(:stdout) {
-        subject.new([target]).invoke_all
+        Berkshelf::InitGenerator.new([target]).invoke_all
       }
     end
 
     specify do
-      target.should have_structure {
-        file ".gitignore"
-        file "Berksfile"
-        file "Gemfile" do
+      expect(target).to have_structure {
+        file '.gitignore'
+        file 'Berksfile'
+        file 'Gemfile' do
           contains "gem 'berkshelf'"
         end
-        file "Vagrantfile" do
-          contains "recipe[some_cookbook::default]"
+        file 'Vagrantfile' do
+          contains 'recipe[some_cookbook::default]'
         end
-        no_file "chefignore"
+        no_file 'chefignore'
       }
     end
   end
 
-  context "with a chefignore" do
+  context 'with a chefignore' do
     before(:each) do
       capture(:stdout) {
-        subject.new([target], chefignore: true).invoke_all
+        Berkshelf::InitGenerator.new([target], chefignore: true).invoke_all
       }
     end
 
     specify do
-      target.should have_structure {
-        file "Berksfile"
-        file "chefignore"
+      expect(target).to have_structure {
+        file 'Berksfile'
+        file 'chefignore'
       }
     end
   end
 
-  context "with a metadata entry in the Berksfile" do
+  context 'with a metadata entry in the Berksfile' do
     before(:each) do
       Dir.mkdir target
-      File.open(target.join("metadata.rb"), 'w+') do |f|
-        f.write ""
+      File.open(target.join('metadata.rb'), 'w+') do |f|
+        f.write ''
       end
 
       capture(:stdout) {
-        subject.new([target], metadata_entry: true).invoke_all
+        Berkshelf::InitGenerator.new([target], metadata_entry: true).invoke_all
       }
     end
 
     specify do
-      target.should have_structure {
-        file "Berksfile" do
-          contains "metadata"
+      expect(target).to have_structure {
+        file 'Berksfile' do
+          contains 'metadata'
         end
       }
     end
   end
 
-  context "with the foodcritic option true" do
+  context 'with the foodcritic option true' do
     before(:each) do
       capture(:stdout) {
-        subject.new([target], foodcritic: true).invoke_all
+        Berkshelf::InitGenerator.new([target], foodcritic: true).invoke_all
       }
     end
 
     specify do
-      target.should have_structure {
-        file "Thorfile" do
+      expect(target).to have_structure {
+        file 'Thorfile' do
           contains "require 'thor/foodcritic'"
         end
-        file "Gemfile" do
+        file 'Gemfile' do
           contains "gem 'thor-foodcritic'"
         end
       }
     end
   end
 
-  context "with the scmversion option true" do
+  context 'with the scmversion option true' do
     before(:each) do
       capture(:stdout) {
-        subject.new([target], scmversion: true).invoke_all
+        Berkshelf::InitGenerator.new([target], scmversion: true).invoke_all
       }
     end
 
     specify do
-      target.should have_structure {
-        file "Thorfile" do
+      expect(target).to have_structure {
+        file 'Thorfile' do
           contains "require 'thor/scmversion'"
         end
-        file "Gemfile" do
+        file 'Gemfile' do
           contains "gem 'thor-scmversion'"
         end
       }
     end
   end
 
-  context "with the bundler option true" do
+  context 'with the bundler option true' do
     before(:each) do
       capture(:stdout) {
-        subject.new([target], no_bundler: true).invoke_all
+        Berkshelf::InitGenerator.new([target], no_bundler: true).invoke_all
       }
     end
 
     specify do
-      target.should have_structure {
-        no_file "Gemfile"
+      expect(target).to have_structure {
+        no_file 'Gemfile'
       }
     end
   end
 
-  context "given a value for the cookbook_name option" do
-    it "sets the value of cookbook_name attribute to the specified option" do
-      generator = subject.new([target], cookbook_name: "nautilus")
+  context 'given a value for the cookbook_name option' do
+    it 'sets the value of cookbook_name attribute to the specified option' do
+      generator = Berkshelf::InitGenerator.new([target], cookbook_name: 'nautilus')
+      cookbook = generator.send(:cookbook_name)
 
-      generator.send(:cookbook_name).should eql("nautilus")
+      expect(cookbook).to eq('nautilus')
     end
   end
 
-  context "when no value for cookbook_name option is specified" do
-    it "infers the name of the cookbook from the directory name" do
-      generator = subject.new([target])
+  context 'when no value for cookbook_name option is specified' do
+    it 'infers the name of the cookbook from the directory name' do
+      generator = Berkshelf::InitGenerator.new([target])
+      cookbook = generator.send(:cookbook_name)
 
-      generator.send(:cookbook_name).should eql("some_cookbook")
+      expect(cookbook).to eq('some_cookbook')
     end
   end
 
-  context "when skipping git" do
+  context 'when skipping git' do
     before(:each) do
-      generator = subject.new([target], skip_git: true)
+      generator = Berkshelf::InitGenerator.new([target], skip_git: true)
       capture(:stdout) { generator.invoke_all }
     end
 
-    it "should not have a .git directory" do
-      target.should_not have_structure {
-        directory ".git"
+    it 'does not have a .git directory' do
+      expect(target).to_not have_structure {
+        directory '.git'
       }
     end
   end
 
-  context "when skipping vagrant" do
+  context 'when skipping vagrant' do
     before(:each) do
       capture(:stdout) {
-        subject.new([target], skip_vagrant: true).invoke_all
+        Berkshelf::InitGenerator.new([target], skip_vagrant: true).invoke_all
       }
     end
 
-    it "should not have a Vagrantfile" do
-      target.should have_structure {
-        no_file "Vagrantfile"
+    it 'does not have a Vagrantfile' do
+      expect(target).to have_structure {
+        no_file 'Vagrantfile'
       }
     end
   end
 
-  context "with the chef_minitest option true" do
+  context 'with the chef_minitest option true' do
     before(:each) do
         Berkshelf::Resolver.stub(:resolve) { resolver }
-        pending "Runs fine with no mock for the HTTP call on the first pass, subsequent passes throw errors"
+        pending 'Runs fine with no mock for the HTTP call on the first pass, subsequent passes throw errors'
         capture(:stdout) {
-          subject.new([target], chef_minitest: true).invoke_all
+          Berkshelf::InitGenerator.new([target], chef_minitest: true).invoke_all
         }
     end
 
     specify do
-      target.should have_structure {
-        file "Berksfile" do
-          contains "cookbook \"minitest-handler\""
+      expect(target).to have_structure {
+        file 'Berksfile' do
+          contains "cookbook 'minitest-handler'"
         end
-        file "Vagrantfile" do
-          contains "\"recipe[minitest-handler::default]\""
+        file 'Vagrantfile' do
+          contains "'recipe[minitest-handler::default]'"
         end
-       directory "files" do
-         directory "default" do
-           directory "tests" do
-             directory "minitest" do
-               file "default_test.rb" do
+       directory 'files' do
+         directory 'default' do
+           directory 'tests' do
+             directory 'minitest' do
+               file 'default_test.rb' do
                  contains "describe 'some_cookbook::default' do"
-                 contains "include Helpers::Some_cookbook"
+                 contains 'include Helpers::Some_cookbook'
                end
-               directory "support" do
-                 file "helpers.rb" do
-                   contains "module Some_cookbook"
+               directory 'support' do
+                 file 'helpers.rb' do
+                   contains 'module Some_cookbook'
                  end
                end
              end

data/spec/unit/berkshelf/location_spec.rb

@@ -1,208 +1,189 @@
 require 'spec_helper'
 
-module Berkshelf
-  describe Location do
-    describe "ClassMethods Module" do
-      subject do
-        Class.new do
-          include Location
-        end
-      end
+describe Berkshelf::Location do
+  # Since this is a module, we need to test the implementation via a class
+  let(:klass) { Class.new { include Berkshelf::Location } }
+
+  describe '.set_location_key' do
+    before do
+      @original = Berkshelf::CookbookSource.class_variable_get :@@location_keys
+      Berkshelf::CookbookSource.class_variable_set :@@location_keys, {}
+    end
 
-      describe "::set_location_key" do
-        before(:each) do
-          @original = CookbookSource.class_variable_get :@@location_keys
-          CookbookSource.class_variable_set :@@location_keys, {}
-        end
+    after do
+      Berkshelf::CookbookSource.class_variable_set :@@location_keys, @original
+    end
 
-        after(:each) do
-          CookbookSource.class_variable_set :@@location_keys, @original
-        end
+    it 'adds the given location key CookbookSource.location_keys' do
+      klass.set_location_key(:reset)
 
-        it "adds the given location key with the includer's Class to CookbookSource.location_keys" do
-          subject.set_location_key(:reset)
+      expect(Berkshelf::CookbookSource.location_keys).to have(1).item
+      expect(Berkshelf::CookbookSource.location_keys).to include(:reset)
+      expect(Berkshelf::CookbookSource.location_keys[:reset]).to eq(klass)
+    end
+  end
 
-          CookbookSource.location_keys.should have(1).item
-          CookbookSource.location_keys.should include(:reset)
-          CookbookSource.location_keys[:reset].should eql(subject)
-        end
-      end
+  describe '.location_key' do
+    before do
+      @original = Berkshelf::CookbookSource.class_variable_get :@@location_keys
+      Berkshelf::CookbookSource.class_variable_set :@@location_keys, {}
+    end
 
-      describe "::location_key" do
-        before(:each) do
-          @original = CookbookSource.class_variable_get :@@location_keys
-          CookbookSource.class_variable_set :@@location_keys, {}
-        end
+    after do
+      Berkshelf::CookbookSource.class_variable_set :@@location_keys, @original
+    end
 
-        after(:each) do
-          CookbookSource.class_variable_set :@@location_keys, @original
-        end
+    it "returns the class' registered location key" do
+      klass.set_location_key(:reset)
+      expect(klass.location_key).to eq(:reset)
+    end
+  end
 
-        it "returns the class' registered location key" do
-          subject.set_location_key(:reset)
+  describe '.set_valid_options' do
+    before do
+      @original = Berkshelf::CookbookSource.class_variable_get :@@valid_options
+      Berkshelf::CookbookSource.class_variable_set :@@valid_options, []
+    end
 
-          subject.location_key.should eql(:reset)
-        end
-      end
+    after do
+      Berkshelf::CookbookSource.class_variable_set :@@valid_options, @original
+    end
 
-      describe "::set_valid_options" do
-        before(:each) do
-          @original = CookbookSource.class_variable_get :@@valid_options
-          CookbookSource.class_variable_set :@@valid_options, []
-        end
+    it 'adds the given symbol to the list of valid options on CookbookSource' do
+      klass.set_valid_options(:mundo)
 
-        after(:each) do
-          CookbookSource.class_variable_set :@@valid_options, @original
-        end
+      expect(Berkshelf::CookbookSource.valid_options).to have(1).item
+      expect(Berkshelf::CookbookSource.valid_options).to include(:mundo)
+    end
 
-        it "adds the given symbol to the list of valid options on CookbookSource" do
-          subject.set_valid_options(:mundo)
+    it 'adds parameters to the list of valid options on the CookbookSource' do
+      klass.set_valid_options(:riot, :arenanet)
 
-          CookbookSource.valid_options.should have(1).item
-          CookbookSource.valid_options.should include(:mundo)
-        end
+      expect(Berkshelf::CookbookSource.valid_options).to have(2).items
+      expect(Berkshelf::CookbookSource.valid_options).to include(:riot)
+      expect(Berkshelf::CookbookSource.valid_options).to include(:arenanet)
+    end
+  end
 
-        it "adds parameters to the list of valid options on the CookbookSource" do
-          subject.set_valid_options(:riot, :arenanet)
+  describe '.solve_for_constraint' do
+    let(:constraint) { '~> 0.101.2' }
+    let(:versions) do
+      {
+        '0.101.2' => 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2',
+        '0.101.0' => 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_0',
+        '0.100.2' => 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_100_2',
+        '0.100.0' => 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_100_0'
+      }
+    end
 
-          CookbookSource.valid_options.should have(2).items
-          CookbookSource.valid_options.should include(:riot)
-          CookbookSource.valid_options.should include(:arenanet)
-        end
-      end
+    it 'returns an array with a string containing the version of the solution at index 0' do
+      result = klass.solve_for_constraint(constraint, versions)
+      expect(result[0]).to eq('0.101.2')
+    end
 
-      describe "::solve_for_constraint" do
-        let(:constraint) { "~> 0.101.2" }
-        let(:versions) do
-          {
-            "0.101.2" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2",
-            "0.101.0" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_0",
-            "0.100.2" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_100_2",
-            "0.100.0" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_100_0"
-          }
-        end
-
-        it "returns an array with a string containing the version of the solution at index 0" do
-          result = subject.solve_for_constraint(constraint, versions)
-
-          result[0].should eql("0.101.2")
-        end
-
-        it "returns an array containing a URI at index 0" do
-          result = subject.solve_for_constraint(constraint, versions)
-
-          result[1].should match(URI.regexp)
-        end
-
-        it "should return the best match for the constraint and versions given" do
-          subject.solve_for_constraint(constraint, versions)[0].to_s.should eql("0.101.2")
-        end
-
-        context "given a solution can not be found for constraint" do
-          it "returns nil" do
-            subject.solve_for_constraint(Solve::Constraint.new(">= 1.0"), versions).should be_nil
-          end
-        end
-      end
+    it 'returns an array containing a URI at index 0' do
+      result = klass.solve_for_constraint(constraint, versions)
+      expect(result[1]).to match(URI.regexp)
     end
 
-    describe "ModuleFunctions" do
-      subject { Location }
+    it 'returns the best match for the constraint and versions given' do
+      expect(klass.solve_for_constraint(constraint, versions)[0].to_s).to eql('0.101.2')
+    end
 
-      describe "::init" do
-        let(:name) { "artifact" }
-        let(:constraint) { double("constraint") }
+    context 'given a solution can not be found for constraint' do
+      it 'returns nil' do
+        result = klass.solve_for_constraint(Solve::Constraint.new('>= 1.0'), versions)
+        expect(result).to be_nil
+      end
+    end
+  end
 
-        it "returns an instance of SiteLocation given a site: option key" do
-          result = subject.init(name, constraint, site: "http://site/value")
+  describe ';init' do
+    let(:name) { 'artifact' }
+    let(:constraint) { double('constraint') }
 
-          result.should be_a(SiteLocation)
-        end
+    it 'returns an instance of SiteLocation given a site: option key' do
+      result = Berkshelf::Location.init(name, constraint, site: 'http://site/value')
+      expect(result).to be_a(Berkshelf::SiteLocation)
+    end
 
-        it "returns an instance of PathLocation given a path: option key" do
-          result = subject.init(name, constraint, path: "/Users/reset/code")
+    it 'returns an instance of PathLocation given a path: option key' do
+      result = Berkshelf::Location.init(name, constraint, path: '/Users/reset/code')
+      expect(result).to be_a(Berkshelf::PathLocation)
+    end
 
-          result.should be_a(PathLocation)
-        end
+    it 'returns an instance of GitLocation given a git: option key' do
+      result = Berkshelf::Location.init(name, constraint, git: 'git://github.com/something.git')
+      expect(result).to be_a(Berkshelf::GitLocation)
+    end
 
-        it "returns an instance of GitLocation given a git: option key" do
-          result = subject.init(name, constraint, git: "git://github.com/something.git")
+    it 'returns an instance of SiteLocation when no option key is given that matches a registered location_key' do
+      result = Berkshelf::Location.init(name, constraint)
+      expect(result).to be_a(Berkshelf::SiteLocation)
+    end
 
-          result.should be_a(GitLocation)
-        end
+    context 'given two location_keys' do
+      it 'raises an InternalError' do
+        expect {
+          Berkshelf::Location.init(name, constraint, git: :value, path: :value)
+        }.to raise_error(Berkshelf::InternalError)
+      end
+    end
+  end
 
-        it "returns an instance of SiteLocation when no option key is given that matches a registered location_key" do
-          result = subject.init(name, constraint)
 
-          result.should be_a(SiteLocation)
-        end
 
-        context "given two location_keys" do
-          it "raises an InternalError" do
-            lambda {
-              subject.init(name, constraint, git: :value, path: :value)
-            }.should raise_error(InternalError)
-          end
-        end
-      end
-    end
+  let(:name) { 'nginx' }
+  let(:constraint) { double('constraint') }
 
-    let(:name) { "nginx" }
-    let(:constraint) { double('constraint') }
+  subject do
+    Class.new { include Berkshelf::Location }.new(name, constraint)
+  end
 
-    subject do
-      Class.new do
-        include Location
-      end.new(name, constraint)
+  describe 'downloaded?' do
+    it 'starts as false' do
+      expect(subject.downloaded?).to be_false
     end
+  end
 
-    it "sets the downloaded? state to false" do
-      subject.downloaded?.should be_false
+  describe '#download' do
+    it 'raises a AbstractFunction if not defined' do
+      expect {
+        subject.download(double('destination'))
+      }.to raise_error(Berkshelf::AbstractFunction)
     end
+  end
 
-    describe "#download" do
-      it "raises a AbstractFunction if not defined" do
-        lambda {
-          subject.download(double('destination'))
-        }.should raise_error(AbstractFunction)
-      end
-    end
+  describe '#validate_cached' do
+    let(:cached) { double('cached-cb', cookbook_name: name, version: '0.1.0') }
 
-    describe "#validate_cached" do
-      let(:cached) { double('cached-cb', cookbook_name: name, version: "0.1.0") }
+    it 'raises a CookbookValidationFailure error if the version constraint does not satisfy the cached version' do
+      constraint.should_receive(:satisfies?).with(cached.version).and_return(false)
 
-      it "raises a CookbookValidationFailure error if the version constraint does not satisfy the cached version" do
-        constraint.should_receive(:satisfies?).with(cached.version).and_return(false)
+      expect {
+        subject.validate_cached(cached)
+      }.to raise_error(Berkshelf::CookbookValidationFailure)
+    end
 
-        lambda {
-          subject.validate_cached(cached)
-        }.should raise_error(CookbookValidationFailure)
-      end
+    it 'returns true if cached_cookbooks satisfies the version constraint' do
+      constraint.should_receive(:satisfies?).with(cached.version).and_return(true)
+      expect(subject.validate_cached(cached)).to be_true
+    end
 
-      it "returns true if cached_cookbooks satisfies the version constraint" do
+    context "when the cached_cookbooks satisfies the version constraint" do
+      it "returns true if the name of the cached_cookbook matches the name of the location" do
         constraint.should_receive(:satisfies?).with(cached.version).and_return(true)
-
-        subject.validate_cached(cached).should be_true
+        cached.stub(:name) { name }
+        expect(subject.validate_cached(cached)).to be_true
       end
 
-      context "when the cached_cookbooks satisfies the version constraint" do
-        it "returns true if the name of the cached_cookbook matches the name of the location" do
-          constraint.should_receive(:satisfies?).with(cached.version).and_return(true)
-          cached.stub(:name) { name }
-
-          subject.validate_cached(cached).should be_true
-        end
-
-        it "raises an AmbiguousCookbookName error if the cached_cookbook's name does not match the location's" do
-          pending "Implement when Opscode makes the 'name' a required attribute in Cookbook metadata"
-
-          constraint.should_receive(:satisfies?).with(cached.version).and_return(true)
-          cached.stub(:cookbook_name) { "artifact" }
+      it "warns about the MismatchedCookbookName if the cached_cookbook's name does not match the location's" do
+        constraint.should_receive(:satisfies?).with(cached.version).and_return(true)
+        cached.stub(:cookbook_name) { "artifact" }
+        msg = Berkshelf::MismatchedCookbookName.new(subject, cached).to_s
 
-          lambda {
-            subject.validate_cached(cached)
-          }.should raise_error(AmbiguousCookbookName)
-        end
+        Berkshelf.ui.should_receive(:warn).with(msg)
+        subject.validate_cached(cached)
       end
     end
   end