berkshelf 3.1.5 → 3.2.0

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ end
 
 Spork.prefork do
   require 'rspec'
+  require 'cleanroom/rspec'
   require 'webmock/rspec'
   require 'berkshelf/api/rspec' unless windows?
 
@@ -24,7 +25,6 @@ Spork.prefork do
     end
 
     config.mock_with :rspec
-    config.treat_symbols_as_metadata_keys_with_true_values = true
     config.filter_run focus: true
     config.filter_run_excluding not_supported_on_windows: windows?
     config.run_all_when_everything_filtered = true

data/spec/support/kitchen.rb

@@ -5,7 +5,9 @@ module Berkshelf
 
       def stub_kitchen!
         generator = double('kitchen-generator', invoke_all: nil)
-        ::Kitchen::Generator::Init.stub(:new).with(any_args()).and_return(generator)
+        allow(::Kitchen::Generator::Init).to receive(:new)
+          .with(any_args())
+          .and_return(generator)
       end
     end
   end

data/spec/support/matchers/file_system_matchers.rb

@@ -107,7 +107,7 @@ module Berkshelf
           end
         end
 
-        def negative_failure_message
+        def failure_message_when_negated
           if @failure.is_a?(Array) && @failure[0] == :not
             "Structure had #{@failure}, but it shouldn't have"
           else

data/spec/support/matchers/filepath_matchers.rb

@@ -1,3 +1,4 @@
+require 'rspec/expectations'
 require 'pathname'
 
 RSpec::Matchers.define :be_relative_path do
@@ -9,11 +10,46 @@ RSpec::Matchers.define :be_relative_path do
     end
   end
 
-  failure_message_for_should do |given|
+  failure_message do |given|
     "Expected '#{given}' to be a relative path but got an absolute path."
   end
 
-  failure_message_for_should_not do |given|
+  failure_message_when_negated do |given|
     "Expected '#{given}' to not be a relative path but got an absolute path."
   end
 end
+
+# expect('/path/to/directory').to be_a_directory
+RSpec::Matchers.define :be_a_directory do
+  match do |actual|
+    File.directory?(actual)
+  end
+end
+
+# expect('/path/to/directory').to be_a_file
+RSpec::Matchers.define :be_a_file do
+  match do |actual|
+    File.file?(actual)
+  end
+end
+
+# expect('/path/to/directory').to be_a_symlink
+RSpec::Matchers.define :be_a_symlink do
+  match do |actual|
+    File.symlink?(actual)
+  end
+end
+
+# expect('/path/to/directory').to be_a_symlink_to
+RSpec::Matchers.define :be_a_symlink_to do |path|
+  match do |actual|
+    File.symlink?(actual) && File.readlink(actual) == path
+  end
+end
+
+# expect('/path/to/file').to be_an_executable
+RSpec::Matchers.define :be_an_executable do
+  match do |actual|
+    File.executable?(actual)
+  end
+end

data/spec/support/shared_examples/formatter.rb

@@ -1,11 +1,11 @@
-module Berkshelf
-  shared_examples 'a formatter object' do
-    BaseFormatter.instance_methods(false).each do |name|
-      next if name == :cleanup_hook
+require 'rspec'
 
-      it "implements ##{name}" do
-        expect(subject.method(name).owner).to eq(described_class)
-      end
+RSpec.shared_examples "a formatter object" do
+  Berkshelf::BaseFormatter.instance_methods(false).each do |name|
+    next if name == :cleanup_hook
+
+    it "implements ##{name}" do
+      expect(subject.method(name).owner).to eq(described_class)
     end
   end
 end

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -53,12 +53,12 @@ describe Berkshelf::Berksfile do
     let(:default_options) { { group: [] } }
 
     it 'sends the add_dependency message with the name, constraint, and options to the instance of the includer' do
-      subject.should_receive(:add_dependency).with(name, constraint, default_options)
+      expect(subject).to receive(:add_dependency).with(name, constraint, default_options)
       subject.cookbook(name, constraint, default_options)
     end
 
     it 'merges the default options into specified options' do
-      subject.should_receive(:add_dependency)do |arg_name, arg_constraint, arg_options|
+      expect(subject).to receive(:add_dependency)do |arg_name, arg_constraint, arg_options|
         expect(arg_name).to eq(name)
         expect(arg_constraint).to eq(constraint)
         expect(arg_options[:path]).to match(%r{/Users/reset})
@@ -69,23 +69,27 @@ describe Berkshelf::Berksfile do
     end
 
     it 'converts a single specified group option into an array of groups' do
-      subject.should_receive(:add_dependency).with(name, constraint, group: [:production])
+      expect(subject).to receive(:add_dependency).with(name, constraint, group: [:production])
       subject.cookbook(name, constraint, group: :production)
     end
 
     context 'when no constraint specified' do
       it 'sends the add_dependency message with a nil value for constraint' do
-        subject.should_receive(:add_dependency).with(name, nil, default_options)
+        expect(subject).to receive(:add_dependency).with(name, nil, default_options)
         subject.cookbook(name, default_options)
       end
     end
 
     context 'when no options specified' do
       it 'sends the add_dependency message with an empty Hash for the value of options' do
-        subject.should_receive(:add_dependency).with(name, constraint, default_options)
+        expect(subject).to receive(:add_dependency).with(name, constraint, default_options)
         subject.cookbook(name, constraint)
       end
     end
+
+    it "is a DSL method" do
+      expect(subject).to have_exposed_method(:cookbook)
+    end
   end
 
   describe '#group' do
@@ -93,12 +97,16 @@ describe Berkshelf::Berksfile do
     let(:group) { 'production' }
 
     it 'sends the add_dependency message with an array of groups determined by the parameter to the group block' do
-      subject.should_receive(:add_dependency).with(name, nil, group: [group])
+      expect(subject).to receive(:add_dependency).with(name, nil, group: [group])
 
       subject.group(group) do
         subject.cookbook(name)
       end
     end
+
+    it "is a DSL method" do
+      expect(subject).to have_exposed_method(:group)
+    end
   end
 
   describe '#metadata' do
@@ -108,14 +116,22 @@ describe Berkshelf::Berksfile do
     before { Dir.chdir(path) }
 
     it 'sends the add_dependency message with an explicit version constraint and the path to the cookbook' do
-      subject.should_receive(:add_dependency).with('example_cookbook', nil, path: path.to_s, metadata: true)
+      expect(subject).to receive(:add_dependency).with('example_cookbook', nil, path: path.to_s, metadata: true)
       subject.metadata
     end
+
+    it "is a DSL method" do
+      expect(subject).to have_exposed_method(:metadata)
+    end
   end
 
   describe "#source" do
     let(:new_source) { "http://berks.riotgames.com" }
 
+    it "is a DSL method" do
+      expect(subject).to have_exposed_method(:source)
+    end
+
     it "adds a source to the sources" do
       subject.source(new_source)
       expect(subject.sources.map(&:to_s)).to include(new_source)
@@ -179,12 +195,26 @@ describe Berkshelf::Berksfile do
     it "raises a Berkshelf::Deprecated error" do
       expect { subject.site }.to raise_error(Berkshelf::DeprecatedError)
     end
+
+    it "is a DSL method" do
+      expect(subject).to have_exposed_method(:site)
+    end
   end
 
   describe "#chef_api" do
     it "raises a Berkshelf::Deprecated error" do
       expect { subject.chef_api }.to raise_error(Berkshelf::DeprecatedError)
     end
+
+    it "is a DSL method" do
+      expect(subject).to have_exposed_method(:chef_api)
+    end
+  end
+
+  describe '#extension' do
+    it "is a DSL method" do
+      expect(subject).to have_exposed_method(:extension)
+    end
   end
 
   describe '#dependencies' do
@@ -199,7 +229,7 @@ describe Berkshelf::Berksfile do
       subject.add_dependency(dependency_one.name)
       subject.add_dependency(dependency_two.name)
 
-      expect(subject.dependencies).to have(2).items
+      expect(subject.dependencies.size).to eq(2)
       expect(subject).to have_dependency(dependency_one.name)
       expect(subject).to have_dependency(dependency_two.name)
     end
@@ -214,7 +244,7 @@ describe Berkshelf::Berksfile do
     it 'retrieves the locked (cached) cookbook for each dependency' do
       subject.add_dependency('bacon', nil)
       subject.add_dependency('ham', nil)
-      subject.stub(:retrive_locked)
+      allow(subject).to receive(:retrive_locked)
 
       expect(subject).to receive(:retrieve_locked).twice
       subject.cookbooks
@@ -223,21 +253,21 @@ describe Berkshelf::Berksfile do
 
   describe '#groups' do
     before do
-      subject.stub(:dependencies) { [dependency_one, dependency_two] }
-      dependency_one.stub(:groups) { [:nautilus, :skarner] }
-      dependency_two.stub(:groups) { [:nautilus, :riven] }
+      allow(subject).to receive(:dependencies) { [dependency_one, dependency_two] }
+      allow(dependency_one).to receive(:groups) { [:nautilus, :skarner] }
+      allow(dependency_two).to receive(:groups) { [:nautilus, :riven] }
     end
 
     it 'returns a hash containing keys for every group a dependency is a member of' do
-      expect(subject.groups.keys).to have(3).items
+      expect(subject.groups.keys.size).to eq(3)
       expect(subject.groups).to have_key(:nautilus)
       expect(subject.groups).to have_key(:skarner)
       expect(subject.groups).to have_key(:riven)
     end
 
     it 'returns an Array of Berkshelf::Dependencys who are members of the group for value' do
-      expect(subject.groups[:nautilus]).to have(2).items
-      expect(subject.groups[:riven]).to have(1).item
+      expect(subject.groups[:nautilus].size).to eq(2)
+      expect(subject.groups[:riven].size).to eq(1)
     end
   end
 
@@ -253,7 +283,7 @@ describe Berkshelf::Berksfile do
     let(:dependency) { subject.dependencies.first }
 
     it 'adds new dependency to the list of dependencies' do
-      expect(subject.dependencies).to have(1).dependency
+      expect(subject.dependencies.size).to eq(1)
     end
 
     it "is a Berkshelf::Dependency" do
@@ -310,7 +340,7 @@ describe Berkshelf::Berksfile do
     let(:cached) { double('cached') }
 
     before do
-      subject.stub(:lockfile).and_return(lockfile)
+      allow(subject).to receive(:lockfile).and_return(lockfile)
     end
 
     it 'delegates to the lockfile' do
@@ -323,11 +353,11 @@ describe Berkshelf::Berksfile do
     let(:uploader) { double(Berkshelf::Uploader, run: nil) }
 
     before do
-      subject.stub(:validate_lockfile_present!)
-      subject.stub(:validate_lockfile_trusted!)
-      subject.stub(:validate_dependencies_installed!)
+      allow(subject).to receive(:validate_lockfile_present!)
+      allow(subject).to receive(:validate_lockfile_trusted!)
+      allow(subject).to receive(:validate_dependencies_installed!)
 
-      Berkshelf::Uploader.stub(:new).and_return(uploader)
+      allow(Berkshelf::Uploader).to receive(:new).and_return(uploader)
     end
 
     it 'validates the lockfile is present' do

data/spec/unit/berkshelf/cached_cookbook_spec.rb

@@ -88,27 +88,27 @@ describe Berkshelf::CachedCookbook do
   describe '#pretty_hash' do
     shared_examples 'a pretty_hash cookbook attribute' do |attribute, key|
       it "is not present when the `#{attribute}` attribute is nil" do
-        subject.stub(attribute.to_sym).and_return(nil)
+        allow(subject).to receive(attribute.to_sym).and_return(nil)
         expect(subject.pretty_hash).to_not have_key((key || attribute).to_sym)
       end
 
       it "is not present when the `#{attribute}` attribute is an empty string" do
-        subject.stub(attribute.to_sym).and_return('')
+        allow(subject).to receive(attribute.to_sym).and_return('')
         expect(subject.pretty_hash).to_not have_key((key || attribute).to_sym)
       end
 
       it "is not present when the `#{attribute}` attribute is an empty array" do
-        subject.stub(attribute.to_sym).and_return([])
+        allow(subject).to receive(attribute.to_sym).and_return([])
         expect(subject.pretty_hash).to_not have_key((key || attribute).to_sym)
       end
 
       it "is not present when the `#{attribute}` attribute is an empty hash" do
-        subject.stub(attribute.to_sym).and_return([])
+        allow(subject).to receive(attribute.to_sym).and_return([])
         expect(subject.pretty_hash).to_not have_key((key || attribute).to_sym)
       end
 
       it "is present when the `#{attribute}` attribute has a Hash value" do
-        subject.stub(attribute.to_sym).and_return(foo: 'bar')
+        allow(subject).to receive(attribute.to_sym).and_return(foo: 'bar')
         expect(subject.pretty_hash).to have_key((key || attribute).to_sym)
       end
     end

data/spec/unit/berkshelf/cli_spec.rb

@@ -7,7 +7,7 @@ module Berkshelf
     let(:cookbooks) { ['mysql'] }
 
     before do
-      Berksfile.stub(:from_options).and_return(berksfile)
+      allow(Berksfile).to receive(:from_options).and_return(berksfile)
     end
 
     describe '#upload' do

data/spec/unit/berkshelf/community_rest_spec.rb

@@ -9,16 +9,16 @@ describe Berkshelf::CommunityREST do
       let(:gzip_reader) { double('gzip_reader') }
 
       before do
-        File.stub(:open).with(target, 'rb').and_return(file)
-        Zlib::GzipReader.stub(:new).with(file).and_return(gzip_reader)
-        Archive::Tar::Minitar.stub(:unpack).with(gzip_reader, destination)
+        allow(File).to receive(:open).with(target, 'rb').and_return(file)
+        allow(Zlib::GzipReader).to receive(:new).with(file).and_return(gzip_reader)
+        allow(Archive::Tar::Minitar).to receive(:unpack).with(gzip_reader, destination)
       end
 
       it 'unpacks the tar' do
-        File.should_receive(:open).with(target, 'rb')
-        ::IO.should_receive(:binread).with(target, 2).and_return([0x1F, 0x8B].pack("C*"))
-        Zlib::GzipReader.should_receive(:new).with(file)
-        Archive::Tar::Minitar.should_receive(:unpack).with(gzip_reader, destination)
+        expect(File).to receive(:open).with(target, 'rb')
+        expect(::IO).to receive(:binread).with(target, 2).and_return([0x1F, 0x8B].pack("C*"))
+        expect(Zlib::GzipReader).to receive(:new).with(file)
+        expect(Archive::Tar::Minitar).to receive(:unpack).with(gzip_reader, destination)
 
         expect(Berkshelf::CommunityREST.unpack(target, destination)).to eq(destination)
       end
@@ -76,8 +76,8 @@ describe Berkshelf::CommunityREST do
     let(:archive) { double('archive', path: '/foo/bar', unlink: true) }
 
     before do
-      subject.stub(:stream).with(any_args()).and_return(archive)
-      Berkshelf::CommunityREST.stub(:unpack)
+      allow(subject).to receive(:stream).with(any_args()).and_return(archive)
+      allow(Berkshelf::CommunityREST).to receive(:unpack)
     end
 
     it 'unpacks the archive' do
@@ -87,8 +87,8 @@ describe Berkshelf::CommunityREST do
         headers: { 'Content-Type' => 'application/json' },
       )
 
-      Berkshelf::CommunityREST.should_receive(:unpack).with('/foo/bar').once.and_return('/foo/nginx')
-      archive.should_receive(:unlink).once
+      expect(Berkshelf::CommunityREST).to receive(:unpack).with('/foo/bar').once.and_return('/foo/nginx')
+      expect(archive).to receive(:unlink).once
 
       subject.download('bacon', '1.0.0')
     end
@@ -215,6 +215,6 @@ describe Berkshelf::CommunityREST do
   end
 
   describe '#stream' do
-    pending
+    skip
   end
 end

data/spec/unit/berkshelf/config_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Berkshelf::Config do
   describe '::file' do
     context 'when the file does not exist' do
-      before { File.stub(:exists?).and_return(false) }
+      before { allow(File).to receive(:exists?).and_return(false) }
 
       it 'is nil' do
         expect(Berkshelf::Config.file).to be_nil
@@ -23,7 +23,7 @@ describe Berkshelf::Config do
     end
 
     before do
-      File.stub(:exists?).and_return(false)
+      allow(File).to receive(:exists?).and_return(false)
     end
 
     after do
@@ -32,8 +32,8 @@ describe Berkshelf::Config do
 
     context "when ENV['BERKSHELF_CONFIG'] is used" do
       before do
-        ENV.stub(:[]).with('BERKSHELF_CONFIG').and_return('/tmp/config.json')
-        File.stub(:exists?).with('/tmp/config.json').and_return(true)
+        allow(ENV).to receive(:[]).with('BERKSHELF_CONFIG').and_return('/tmp/config.json')
+        allow(File).to receive(:exists?).with('/tmp/config.json').and_return(true)
       end
 
       it "points to a location within it" do

data/spec/unit/berkshelf/cookbook_generator_spec.rb

@@ -6,7 +6,7 @@ describe Berkshelf::CookbookGenerator do
   let(:kitchen_generator) { double('kitchen-generator', invoke_all: nil) }
 
   before do
-    Kitchen::Generator::Init.stub(:new).with(any_args()).and_return(kitchen_generator)
+    allow(Kitchen::Generator::Init).to receive(:new).with(any_args()).and_return(kitchen_generator)
   end
 
   context 'with default options' do
@@ -69,7 +69,7 @@ describe Berkshelf::CookbookGenerator do
 
   context "given a 'maintainer_email' option" do
     before do
-      Kitchen::Generator::Init.stub(:new).with(any_args()).and_return(kitchen_generator)
+      allow(Kitchen::Generator::Init).to receive(:new).with(any_args()).and_return(kitchen_generator)
       capture(:stdout) {
         Berkshelf::CookbookGenerator.new([target, name], maintainer_email: 'jamie@vialstudios.com').invoke_all
       }

data/spec/unit/berkshelf/cookbook_store_spec.rb

@@ -42,17 +42,17 @@ describe Berkshelf::CookbookStore do
     let(:cached_one) { double('cached-one', name: name, version: Semverse::Version.new(version)) }
     let(:cached_two) { double('cached-two', name: 'mysql', version: Semverse::Version.new('1.2.6')) }
 
-    before { subject.stub(:cookbooks).and_return([cached_one, cached_two]) }
+    before { allow(subject).to receive(:cookbooks).and_return([cached_one, cached_two]) }
 
     it 'gets and returns the the CachedCookbook best matching the name and constraint' do
-      subject.should_receive(:cookbook).with(name, version).and_return(cached_one)
+      expect(subject).to receive(:cookbook).with(name, version).and_return(cached_one)
       result = subject.satisfy(name, constraint)
 
       expect(result).to eq(cached_one)
     end
 
     context 'when there are no cookbooks in the cookbook store' do
-      before { subject.stub(:cookbooks).and_return([]) }
+      before { allow(subject).to receive(:cookbooks).and_return([]) }
 
       it 'returns nil' do
         result = subject.satisfy(name, constraint)
@@ -64,7 +64,7 @@ describe Berkshelf::CookbookStore do
       let(:version) { Semverse::Version.new('1.0.0') }
       let(:constraint) { Semverse::Constraint.new('= 0.1.0') }
 
-      before { subject.stub(:cookbooks).and_return([ double('badcache', name: 'none', version: version) ]) }
+      before { allow(subject).to receive(:cookbooks).and_return([ double('badcache', name: 'none', version: version) ]) }
 
       it 'returns nil if there is no matching cookbook for the name and constraint' do
         result = subject.satisfy(name, constraint)
@@ -98,12 +98,12 @@ describe Berkshelf::CookbookStore do
     end
 
     it 'contains a CachedCookbook for every cookbook in the storage path' do
-      expect(subject.cookbooks).to have(2).items
+      expect(subject.cookbooks.size).to eq(2)
     end
 
     context 'given a value for the filter parameter' do
       it 'returns only the CachedCookbooks whose name match the filter' do
-        expect(subject.cookbooks('mysql')).to have(1).item
+        expect(subject.cookbooks('mysql').size).to eq(1)
       end
     end