chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/{lib/chef/monkey_patches/file.rb → spec/unit/audit/rspec_formatter_spec.rb}

@@ -1,6 +1,8 @@
 #
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Author:: Tyler Ball (<tball@chef.io>)
+# Author:: Claire McQuin (<claire@getchef.com>)
+#
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,11 +18,12 @@
 # limitations under the License.
 #
 
-if !File.respond_to?(:realpath)
-  require 'pathname'
-  class File
-    def self.realpath(path)
-      Pathname.new(path).realpath.to_s
-    end
+require 'spec_helper'
+require 'chef/audit/rspec_formatter'
+
+describe Chef::Audit::RspecFormatter do
+  let(:formatter) { Chef::Audit::RspecFormatter.new(nil) }
+  it "should respond to close" do
+    expect(formatter).to respond_to(:close)
   end
 end

data/spec/unit/audit/runner_spec.rb

@@ -0,0 +1,135 @@
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'rspec/core/sandbox'
+require 'chef/audit/runner'
+require 'chef/audit/audit_event_proxy'
+require 'chef/audit/rspec_formatter'
+require 'rspec/support/spec/in_sub_process'
+require 'rspec/support/spec/stderr_splitter'
+
+
+describe Chef::Audit::Runner do
+  include RSpec::Support::InSubProcess
+
+  let(:events) { double("events") }
+  let(:run_context) { instance_double(Chef::RunContext, :events => events) }
+  let(:runner) { Chef::Audit::Runner.new(run_context) }
+
+  around(:each) do |ex|
+    RSpec::Core::Sandbox.sandboxed { ex.run }
+  end
+
+  describe "#initialize" do
+    it "correctly sets the run_context during initialization" do
+      expect(runner.instance_variable_get(:@run_context)).to eq(run_context)
+    end
+  end
+
+  context "during #run" do
+
+    describe "#setup" do
+      let(:log_location) { File.join(Dir.tmpdir, 'audit_log') }
+      let(:color) { false }
+
+      before do
+        Chef::Config[:log_location] = log_location
+        Chef::Config[:color] = color
+      end
+
+      it "sets all the config values" do
+        # This runs the Serverspec includes - we don't want these hanging around in all subsequent tests so
+        # we run this in a forked process.  Keeps Serverspec files from getting loaded into main process.
+        in_sub_process do
+          runner.send(:setup)
+
+          expect(RSpec.configuration.output_stream).to eq(log_location)
+          expect(RSpec.configuration.error_stream).to eq(log_location)
+
+          expect(RSpec.configuration.formatters.size).to eq(2)
+          expect(RSpec.configuration.formatters).to include(instance_of(Chef::Audit::AuditEventProxy))
+          expect(RSpec.configuration.formatters).to include(instance_of(Chef::Audit::RspecFormatter))
+          expect(Chef::Audit::AuditEventProxy.class_variable_get(:@@events)).to eq(run_context.events)
+
+          expect(RSpec.configuration.expectation_frameworks).to eq([RSpec::Matchers])
+          expect(RSpec::Matchers.configuration.syntax).to eq([:expect])
+
+          expect(RSpec.configuration.color).to eq(color)
+          expect(RSpec.configuration.expose_dsl_globally?).to eq(false)
+
+          expect(Specinfra.configuration.backend).to eq(:exec)
+        end
+      end
+    end
+
+    describe "#register_control_groups" do
+      let(:audits) { [] }
+      let(:run_context) { instance_double(Chef::RunContext, :audits => audits) }
+
+      it "adds the control group aliases" do
+        runner.send(:register_control_groups)
+
+        expect(RSpec::Core::DSL.example_group_aliases).to include(:__control_group__)
+        expect(RSpec::Core::DSL.example_group_aliases).to include(:control)
+      end
+
+      context "audits exist" do
+        let(:audits) { {"audit_name" => group} }
+        let(:group) {Struct.new(:args, :block).new(["group_name"], nil)}
+
+        it "sends the audits to the world" do
+          runner.send(:register_control_groups)
+
+          expect(RSpec.world.example_groups.size).to eq(1)
+          # For whatever reason, `kind_of` is not working
+          # expect(RSpec.world.example_groups).to include(kind_of(RSpec::Core::ExampleGroup)) => FAIL
+          g = RSpec.world.example_groups[0]
+          expect(g.ancestors).to include(RSpec::Core::ExampleGroup)
+          expect(g.description).to eq("group_name")
+        end
+      end
+    end
+
+    describe "#do_run" do
+      let(:rspec_runner) { instance_double(RSpec::Core::Runner) }
+
+      it "executes the runner" do
+        expect(RSpec::Core::Runner).to receive(:new).with(nil).and_return(rspec_runner)
+        expect(rspec_runner).to receive(:run_specs).with([])
+
+        runner.send(:do_run)
+      end
+    end
+  end
+
+  describe "counters" do
+    it "correctly calculates failed?" do
+      expect(runner.failed?).to eq(false)
+    end
+
+    it "correctly calculates num_failed" do
+      expect(runner.num_failed).to eq(0)
+    end
+
+    it "correctly calculates num_total" do
+      expect(runner.num_total).to eq(0)
+    end
+  end
+
+end

data/spec/unit/chef_fs/config_spec.rb

@@ -55,4 +55,56 @@ describe Chef::ChefFS::Config do
       Chef::ChefFS::Config.new(base_config, Dir.pwd, {}, ui)
     end
   end
+
+  describe "local FS configuration" do
+
+    let(:chef_config) do
+      Mash.new({
+        client_path: "/base_path/clients",
+        cookbook_path: "/base_path/cookbooks",
+        data_bag_path: "/base_path/data_bags",
+        environment_path: "/base_path/environments",
+        node_path: "/base_path/nodes",
+        role_path: "/base_path/roles",
+        user_path: "/base_path/users",
+        policy_path: "/base_path/policies"
+      })
+    end
+
+    let(:chef_fs_config)  { Chef::ChefFS::Config.new(chef_config, Dir.pwd) }
+
+    subject(:local_fs) { chef_fs_config.local_fs }
+
+    def platform_path(*args)
+      File.expand_path(*args)
+    end
+
+    it "sets the correct nodes path on the local FS object" do
+      expect(local_fs.child_paths["nodes"]).to eq([platform_path("/base_path/nodes")])
+    end
+
+    it "sets the correct cookbook path on the local FS object" do
+      expect(local_fs.child_paths["cookbooks"]).to eq([platform_path("/base_path/cookbooks")])
+    end
+
+    it "sets the correct data bag path on the local FS object" do
+      expect(local_fs.child_paths["data_bags"]).to eq([platform_path("/base_path/data_bags")])
+    end
+
+    it "sets the correct environment path on the local FS object" do
+      expect(local_fs.child_paths["environments"]).to eq([platform_path("/base_path/environments")])
+    end
+
+    it "sets the correct role path on the local FS object" do
+      expect(local_fs.child_paths["roles"]).to eq([platform_path("/base_path/roles")])
+    end
+
+    it "sets the correct user path on the local FS object" do
+      expect(local_fs.child_paths["users"]).to eq([platform_path("/base_path/users")])
+    end
+
+    it "sets the correct policy path on the local FS object" do
+      expect(local_fs.child_paths["policies"]).to eq([platform_path("/base_path/policies")])
+    end
+  end
 end

data/spec/unit/chef_fs/diff_spec.rb

@@ -91,7 +91,7 @@ describe 'diff', :uses_diff => true do
       Chef::ChefFS::CommandLine.diff_print(pattern('/'), a, b, nil, nil) do |diff|
         results << remove_os_differences(diff)
       end
-      results.should =~ [
+      expect(results).to match_array([
         'diff --knife a/both_dirs/sub_both_files_different b/both_dirs/sub_both_files_different
 --- a/both_dirs/sub_both_files_different DATE
 +++ b/both_dirs/sub_both_files_different DATE
@@ -160,14 +160,14 @@ new file
 +++ b/b_only_file DATE
 CONTEXT_LINE_NUMBERS
 +b_only_file
-' ]
+' ])
     end
     it 'Chef::ChefFS::CommandLine.diff_print(/both_dirs)' do
       results = []
       Chef::ChefFS::CommandLine.diff_print(pattern('/both_dirs'), a, b, nil, nil) do |diff|
         results << remove_os_differences(diff)
       end
-      results.should =~ [
+      expect(results).to match_array([
         'diff --knife a/both_dirs/sub_both_files_different b/both_dirs/sub_both_files_different
 --- a/both_dirs/sub_both_files_different DATE
 +++ b/both_dirs/sub_both_files_different DATE
@@ -202,14 +202,14 @@ new file
 +++ b/both_dirs/sub_b_only_file DATE
 CONTEXT_LINE_NUMBERS
 +sub_b_only_file
-' ]
+' ])
     end
     it 'Chef::ChefFS::CommandLine.diff_print(/) with depth 1' do
       results = []
       Chef::ChefFS::CommandLine.diff_print(pattern('/'), a, b, 1, nil) do |diff|
         results << remove_os_differences(diff)
       end
-      results.should =~ [
+      expect(results).to match_array([
 'Common subdirectories: b/both_dirs
 ','diff --knife a/both_files_different b/both_files_different
 --- a/both_files_different DATE
@@ -236,14 +236,14 @@ new file
 +++ b/b_only_file DATE
 CONTEXT_LINE_NUMBERS
 +b_only_file
-' ]
+' ])
     end
     it 'Chef::ChefFS::CommandLine.diff_print(/*_*) with depth 0' do
       results = []
       Chef::ChefFS::CommandLine.diff_print(pattern('/*_*'), a, b, 0, nil) do |diff|
         results << remove_os_differences(diff)
       end
-      results.should =~ [
+      expect(results).to match_array([
 'Common subdirectories: b/both_dirs
 ','diff --knife a/both_files_different b/both_files_different
 --- a/both_files_different DATE
@@ -270,14 +270,14 @@ new file
 +++ b/b_only_file DATE
 CONTEXT_LINE_NUMBERS
 +b_only_file
-' ]
+' ])
     end
     it 'Chef::ChefFS::CommandLine.diff_print(/) in name-only mode' do
       results = []
       Chef::ChefFS::CommandLine.diff_print(pattern('/'), a, b, nil, :name_only) do |diff|
         results << remove_os_differences(diff)
       end
-      results.should =~ [
+      expect(results).to match_array([
           "b/both_dirs/sub_both_files_different\n",
           "b/both_dirs/sub_dirs_empty_in_b_filled_in_a/subsub\n",
           "b/both_dirs/sub_dirs_empty_in_a_filled_in_b/subsub\n",
@@ -296,14 +296,14 @@ CONTEXT_LINE_NUMBERS
           "b/b_only_file\n",
           "b/dir_in_a_file_in_b\n",
           "b/file_in_a_dir_in_b\n"
-      ]
+      ])
     end
     it 'Chef::ChefFS::CommandLine.diff_print(/) in name-status mode' do
       results = []
       Chef::ChefFS::CommandLine.diff_print(pattern('/'), a, b, nil, :name_status) do |diff|
         results << remove_os_differences(diff)
       end
-      results.should =~ [
+      expect(results).to match_array([
           "M\tb/both_dirs/sub_both_files_different\n",
           "D\tb/both_dirs/sub_dirs_empty_in_b_filled_in_a/subsub\n",
           "A\tb/both_dirs/sub_dirs_empty_in_a_filled_in_b/subsub\n",
@@ -322,7 +322,7 @@ CONTEXT_LINE_NUMBERS
           "A\tb/b_only_file\n",
           "T\tb/dir_in_a_file_in_b\n",
           "T\tb/file_in_a_dir_in_b\n"
-      ]
+      ])
     end
   end
 end

data/spec/unit/chef_fs/file_pattern_spec.rb

@@ -28,466 +28,465 @@ describe Chef::ChefFS::FilePattern do
   context 'with empty pattern ""' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('') }
     it 'match?' do
-      pattern.match?('').should be_true
-      pattern.match?('/').should be_false
-      pattern.match?('a').should be_false
-      pattern.match?('a/b').should be_false
+      expect(pattern.match?('')).to be_truthy
+      expect(pattern.match?('/')).to be_falsey
+      expect(pattern.match?('a')).to be_falsey
+      expect(pattern.match?('a/b')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should == ''
+      expect(pattern.exact_path).to eq('')
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('').should be_false
-      pattern.could_match_children?('a/b').should be_false
+      expect(pattern.could_match_children?('')).to be_falsey
+      expect(pattern.could_match_children?('a/b')).to be_falsey
     end
   end
 
   context 'with root pattern "/"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('/') }
     it 'match?' do
-      pattern.match?('/').should be_true
-      pattern.match?('').should be_false
-      pattern.match?('a').should be_false
-      pattern.match?('/a').should be_false
+      expect(pattern.match?('/')).to be_truthy
+      expect(pattern.match?('')).to be_falsey
+      expect(pattern.match?('a')).to be_falsey
+      expect(pattern.match?('/a')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should == '/'
+      expect(pattern.exact_path).to eq('/')
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('').should be_false
-      pattern.could_match_children?('/').should be_false
-      pattern.could_match_children?('a').should be_false
-      pattern.could_match_children?('a/b').should be_false
-      pattern.could_match_children?('/a').should be_false
+      expect(pattern.could_match_children?('')).to be_falsey
+      expect(pattern.could_match_children?('/')).to be_falsey
+      expect(pattern.could_match_children?('a')).to be_falsey
+      expect(pattern.could_match_children?('a/b')).to be_falsey
+      expect(pattern.could_match_children?('/a')).to be_falsey
     end
   end
 
   context 'with simple pattern "abc"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('abc') }
     it 'match?' do
-      pattern.match?('abc').should be_true
-      pattern.match?('a').should be_false
-      pattern.match?('abcd').should be_false
-      pattern.match?('/abc').should be_false
-      pattern.match?('').should be_false
-      pattern.match?('/').should be_false
+      expect(pattern.match?('abc')).to be_truthy
+      expect(pattern.match?('a')).to be_falsey
+      expect(pattern.match?('abcd')).to be_falsey
+      expect(pattern.match?('/abc')).to be_falsey
+      expect(pattern.match?('')).to be_falsey
+      expect(pattern.match?('/')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should == 'abc'
+      expect(pattern.exact_path).to eq('abc')
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('').should be_false
-      pattern.could_match_children?('abc').should be_false
-      pattern.could_match_children?('/abc').should be_false
+      expect(pattern.could_match_children?('')).to be_falsey
+      expect(pattern.could_match_children?('abc')).to be_falsey
+      expect(pattern.could_match_children?('/abc')).to be_falsey
     end
   end
 
   context 'with simple pattern "/abc"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('/abc') }
     it 'match?' do
-      pattern.match?('/abc').should be_true
-      pattern.match?('abc').should be_false
-      pattern.match?('a').should be_false
-      pattern.match?('abcd').should be_false
-      pattern.match?('').should be_false
-      pattern.match?('/').should be_false
+      expect(pattern.match?('/abc')).to be_truthy
+      expect(pattern.match?('abc')).to be_falsey
+      expect(pattern.match?('a')).to be_falsey
+      expect(pattern.match?('abcd')).to be_falsey
+      expect(pattern.match?('')).to be_falsey
+      expect(pattern.match?('/')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should == '/abc'
+      expect(pattern.exact_path).to eq('/abc')
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('abc').should be_false
-      pattern.could_match_children?('/abc').should be_false
-      pattern.could_match_children?('/').should be_true
-      pattern.could_match_children?('').should be_false
+      expect(pattern.could_match_children?('abc')).to be_falsey
+      expect(pattern.could_match_children?('/abc')).to be_falsey
+      expect(pattern.could_match_children?('/')).to be_truthy
+      expect(pattern.could_match_children?('')).to be_falsey
     end
     it 'exact_child_name_under' do
-      pattern.exact_child_name_under('/').should == 'abc'
+      expect(pattern.exact_child_name_under('/')).to eq('abc')
     end
   end
 
   context 'with simple pattern "abc/def/ghi"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('abc/def/ghi') }
     it 'match?' do
-      pattern.match?('abc/def/ghi').should be_true
-      pattern.match?('/abc/def/ghi').should be_false
-      pattern.match?('abc').should be_false
-      pattern.match?('abc/def').should be_false
+      expect(pattern.match?('abc/def/ghi')).to be_truthy
+      expect(pattern.match?('/abc/def/ghi')).to be_falsey
+      expect(pattern.match?('abc')).to be_falsey
+      expect(pattern.match?('abc/def')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should == 'abc/def/ghi'
+      expect(pattern.exact_path).to eq('abc/def/ghi')
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('abc').should be_true
-      pattern.could_match_children?('xyz').should be_false
-      pattern.could_match_children?('/abc').should be_false
-      pattern.could_match_children?('abc/def').should be_true
-      pattern.could_match_children?('abc/xyz').should be_false
-      pattern.could_match_children?('abc/def/ghi').should be_false
+      expect(pattern.could_match_children?('abc')).to be_truthy
+      expect(pattern.could_match_children?('xyz')).to be_falsey
+      expect(pattern.could_match_children?('/abc')).to be_falsey
+      expect(pattern.could_match_children?('abc/def')).to be_truthy
+      expect(pattern.could_match_children?('abc/xyz')).to be_falsey
+      expect(pattern.could_match_children?('abc/def/ghi')).to be_falsey
     end
     it 'exact_child_name_under' do
-      pattern.exact_child_name_under('abc').should == 'def'
-      pattern.exact_child_name_under('abc/def').should == 'ghi'
+      expect(pattern.exact_child_name_under('abc')).to eq('def')
+      expect(pattern.exact_child_name_under('abc/def')).to eq('ghi')
     end
   end
 
   context 'with simple pattern "/abc/def/ghi"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('/abc/def/ghi') }
     it 'match?' do
-      pattern.match?('/abc/def/ghi').should be_true
-      pattern.match?('abc/def/ghi').should be_false
-      pattern.match?('/abc').should be_false
-      pattern.match?('/abc/def').should be_false
+      expect(pattern.match?('/abc/def/ghi')).to be_truthy
+      expect(pattern.match?('abc/def/ghi')).to be_falsey
+      expect(pattern.match?('/abc')).to be_falsey
+      expect(pattern.match?('/abc/def')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should == '/abc/def/ghi'
+      expect(pattern.exact_path).to eq('/abc/def/ghi')
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('/abc').should be_true
-      pattern.could_match_children?('/xyz').should be_false
-      pattern.could_match_children?('abc').should be_false
-      pattern.could_match_children?('/abc/def').should be_true
-      pattern.could_match_children?('/abc/xyz').should be_false
-      pattern.could_match_children?('/abc/def/ghi').should be_false
+      expect(pattern.could_match_children?('/abc')).to be_truthy
+      expect(pattern.could_match_children?('/xyz')).to be_falsey
+      expect(pattern.could_match_children?('abc')).to be_falsey
+      expect(pattern.could_match_children?('/abc/def')).to be_truthy
+      expect(pattern.could_match_children?('/abc/xyz')).to be_falsey
+      expect(pattern.could_match_children?('/abc/def/ghi')).to be_falsey
     end
     it 'exact_child_name_under' do
-      pattern.exact_child_name_under('/').should == 'abc'
-      pattern.exact_child_name_under('/abc').should == 'def'
-      pattern.exact_child_name_under('/abc/def').should == 'ghi'
+      expect(pattern.exact_child_name_under('/')).to eq('abc')
+      expect(pattern.exact_child_name_under('/abc')).to eq('def')
+      expect(pattern.exact_child_name_under('/abc/def')).to eq('ghi')
     end
   end
 
   context 'with simple pattern "a\*\b"', :pending => (Chef::Platform.windows?) do
     let(:pattern) { Chef::ChefFS::FilePattern.new('a\*\b') }
     it 'match?' do
-      pattern.match?('a*b').should be_true
-      pattern.match?('ab').should be_false
-      pattern.match?('acb').should be_false
-      pattern.match?('ab').should be_false
+      expect(pattern.match?('a*b')).to be_truthy
+      expect(pattern.match?('ab')).to be_falsey
+      expect(pattern.match?('acb')).to be_falsey
+      expect(pattern.match?('ab')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should == 'a*b'
+      expect(pattern.exact_path).to eq('a*b')
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('a/*b').should be_false
+      expect(pattern.could_match_children?('a/*b')).to be_falsey
     end
   end
 
   context 'with star pattern "/abc/*/ghi"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('/abc/*/ghi') }
     it 'match?' do
-      pattern.match?('/abc/def/ghi').should be_true
-      pattern.match?('/abc/ghi').should be_false
+      expect(pattern.match?('/abc/def/ghi')).to be_truthy
+      expect(pattern.match?('/abc/ghi')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should be_nil
+      expect(pattern.exact_path).to be_nil
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('/abc').should be_true
-      pattern.could_match_children?('/xyz').should be_false
-      pattern.could_match_children?('abc').should be_false
-      pattern.could_match_children?('/abc/def').should be_true
-      pattern.could_match_children?('/abc/xyz').should be_true
-      pattern.could_match_children?('/abc/def/ghi').should be_false
+      expect(pattern.could_match_children?('/abc')).to be_truthy
+      expect(pattern.could_match_children?('/xyz')).to be_falsey
+      expect(pattern.could_match_children?('abc')).to be_falsey
+      expect(pattern.could_match_children?('/abc/def')).to be_truthy
+      expect(pattern.could_match_children?('/abc/xyz')).to be_truthy
+      expect(pattern.could_match_children?('/abc/def/ghi')).to be_falsey
     end
     it 'exact_child_name_under' do
-      pattern.exact_child_name_under('/').should == 'abc'
-      pattern.exact_child_name_under('/abc').should == nil
-      pattern.exact_child_name_under('/abc/def').should == 'ghi'
+      expect(pattern.exact_child_name_under('/')).to eq('abc')
+      expect(pattern.exact_child_name_under('/abc')).to eq(nil)
+      expect(pattern.exact_child_name_under('/abc/def')).to eq('ghi')
     end
   end
 
   context 'with star pattern "/abc/d*f/ghi"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('/abc/d*f/ghi') }
     it 'match?' do
-      pattern.match?('/abc/def/ghi').should be_true
-      pattern.match?('/abc/dxf/ghi').should be_true
-      pattern.match?('/abc/df/ghi').should be_true
-      pattern.match?('/abc/dxyzf/ghi').should be_true
-      pattern.match?('/abc/d/ghi').should be_false
-      pattern.match?('/abc/f/ghi').should be_false
-      pattern.match?('/abc/ghi').should be_false
-      pattern.match?('/abc/xyz/ghi').should be_false
+      expect(pattern.match?('/abc/def/ghi')).to be_truthy
+      expect(pattern.match?('/abc/dxf/ghi')).to be_truthy
+      expect(pattern.match?('/abc/df/ghi')).to be_truthy
+      expect(pattern.match?('/abc/dxyzf/ghi')).to be_truthy
+      expect(pattern.match?('/abc/d/ghi')).to be_falsey
+      expect(pattern.match?('/abc/f/ghi')).to be_falsey
+      expect(pattern.match?('/abc/ghi')).to be_falsey
+      expect(pattern.match?('/abc/xyz/ghi')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should be_nil
+      expect(pattern.exact_path).to be_nil
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('/abc').should be_true
-      pattern.could_match_children?('/xyz').should be_false
-      pattern.could_match_children?('abc').should be_false
-      pattern.could_match_children?('/abc/def').should be_true
-      pattern.could_match_children?('/abc/xyz').should be_false
-      pattern.could_match_children?('/abc/dxyzf').should be_true
-      pattern.could_match_children?('/abc/df').should be_true
-      pattern.could_match_children?('/abc/d').should be_false
-      pattern.could_match_children?('/abc/f').should be_false
-      pattern.could_match_children?('/abc/def/ghi').should be_false
+      expect(pattern.could_match_children?('/abc')).to be_truthy
+      expect(pattern.could_match_children?('/xyz')).to be_falsey
+      expect(pattern.could_match_children?('abc')).to be_falsey
+      expect(pattern.could_match_children?('/abc/def')).to be_truthy
+      expect(pattern.could_match_children?('/abc/xyz')).to be_falsey
+      expect(pattern.could_match_children?('/abc/dxyzf')).to be_truthy
+      expect(pattern.could_match_children?('/abc/df')).to be_truthy
+      expect(pattern.could_match_children?('/abc/d')).to be_falsey
+      expect(pattern.could_match_children?('/abc/f')).to be_falsey
+      expect(pattern.could_match_children?('/abc/def/ghi')).to be_falsey
     end
     it 'exact_child_name_under' do
-      pattern.exact_child_name_under('/').should == 'abc'
-      pattern.exact_child_name_under('/abc').should == nil
-      pattern.exact_child_name_under('/abc/def').should == 'ghi'
+      expect(pattern.exact_child_name_under('/')).to eq('abc')
+      expect(pattern.exact_child_name_under('/abc')).to eq(nil)
+      expect(pattern.exact_child_name_under('/abc/def')).to eq('ghi')
     end
   end
 
   context 'with star pattern "/abc/d??f/ghi"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('/abc/d??f/ghi') }
     it 'match?' do
-      pattern.match?('/abc/deef/ghi').should be_true
-      pattern.match?('/abc/deeef/ghi').should be_false
-      pattern.match?('/abc/def/ghi').should be_false
-      pattern.match?('/abc/df/ghi').should be_false
-      pattern.match?('/abc/d/ghi').should be_false
-      pattern.match?('/abc/f/ghi').should be_false
-      pattern.match?('/abc/ghi').should be_false
+      expect(pattern.match?('/abc/deef/ghi')).to be_truthy
+      expect(pattern.match?('/abc/deeef/ghi')).to be_falsey
+      expect(pattern.match?('/abc/def/ghi')).to be_falsey
+      expect(pattern.match?('/abc/df/ghi')).to be_falsey
+      expect(pattern.match?('/abc/d/ghi')).to be_falsey
+      expect(pattern.match?('/abc/f/ghi')).to be_falsey
+      expect(pattern.match?('/abc/ghi')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should be_nil
+      expect(pattern.exact_path).to be_nil
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('/abc').should be_true
-      pattern.could_match_children?('/xyz').should be_false
-      pattern.could_match_children?('abc').should be_false
-      pattern.could_match_children?('/abc/deef').should be_true
-      pattern.could_match_children?('/abc/deeef').should be_false
-      pattern.could_match_children?('/abc/def').should be_false
-      pattern.could_match_children?('/abc/df').should be_false
-      pattern.could_match_children?('/abc/d').should be_false
-      pattern.could_match_children?('/abc/f').should be_false
-      pattern.could_match_children?('/abc/deef/ghi').should be_false
+      expect(pattern.could_match_children?('/abc')).to be_truthy
+      expect(pattern.could_match_children?('/xyz')).to be_falsey
+      expect(pattern.could_match_children?('abc')).to be_falsey
+      expect(pattern.could_match_children?('/abc/deef')).to be_truthy
+      expect(pattern.could_match_children?('/abc/deeef')).to be_falsey
+      expect(pattern.could_match_children?('/abc/def')).to be_falsey
+      expect(pattern.could_match_children?('/abc/df')).to be_falsey
+      expect(pattern.could_match_children?('/abc/d')).to be_falsey
+      expect(pattern.could_match_children?('/abc/f')).to be_falsey
+      expect(pattern.could_match_children?('/abc/deef/ghi')).to be_falsey
     end
     it 'exact_child_name_under' do
-      pattern.exact_child_name_under('/').should == 'abc'
-      pattern.exact_child_name_under('/abc').should == nil
-      pattern.exact_child_name_under('/abc/deef').should == 'ghi'
+      expect(pattern.exact_child_name_under('/')).to eq('abc')
+      expect(pattern.exact_child_name_under('/abc')).to eq(nil)
+      expect(pattern.exact_child_name_under('/abc/deef')).to eq('ghi')
     end
   end
 
   context 'with star pattern "/abc/d[a-z][0-9]f/ghi"', :pending => (Chef::Platform.windows?) do
     let(:pattern) { Chef::ChefFS::FilePattern.new('/abc/d[a-z][0-9]f/ghi') }
     it 'match?' do
-      pattern.match?('/abc/de1f/ghi').should be_true
-      pattern.match?('/abc/deef/ghi').should be_false
-      pattern.match?('/abc/d11f/ghi').should be_false
-      pattern.match?('/abc/de11f/ghi').should be_false
-      pattern.match?('/abc/dee1f/ghi').should be_false
-      pattern.match?('/abc/df/ghi').should be_false
-      pattern.match?('/abc/d/ghi').should be_false
-      pattern.match?('/abc/f/ghi').should be_false
-      pattern.match?('/abc/ghi').should be_false
+      expect(pattern.match?('/abc/de1f/ghi')).to be_truthy
+      expect(pattern.match?('/abc/deef/ghi')).to be_falsey
+      expect(pattern.match?('/abc/d11f/ghi')).to be_falsey
+      expect(pattern.match?('/abc/de11f/ghi')).to be_falsey
+      expect(pattern.match?('/abc/dee1f/ghi')).to be_falsey
+      expect(pattern.match?('/abc/df/ghi')).to be_falsey
+      expect(pattern.match?('/abc/d/ghi')).to be_falsey
+      expect(pattern.match?('/abc/f/ghi')).to be_falsey
+      expect(pattern.match?('/abc/ghi')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should be_nil
+      expect(pattern.exact_path).to be_nil
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('/abc').should be_true
-      pattern.could_match_children?('/xyz').should be_false
-      pattern.could_match_children?('abc').should be_false
-      pattern.could_match_children?('/abc/de1f').should be_true
-      pattern.could_match_children?('/abc/deef').should be_false
-      pattern.could_match_children?('/abc/d11f').should be_false
-      pattern.could_match_children?('/abc/de11f').should be_false
-      pattern.could_match_children?('/abc/dee1f').should be_false
-      pattern.could_match_children?('/abc/def').should be_false
-      pattern.could_match_children?('/abc/df').should be_false
-      pattern.could_match_children?('/abc/d').should be_false
-      pattern.could_match_children?('/abc/f').should be_false
-      pattern.could_match_children?('/abc/de1f/ghi').should be_false
+      expect(pattern.could_match_children?('/abc')).to be_truthy
+      expect(pattern.could_match_children?('/xyz')).to be_falsey
+      expect(pattern.could_match_children?('abc')).to be_falsey
+      expect(pattern.could_match_children?('/abc/de1f')).to be_truthy
+      expect(pattern.could_match_children?('/abc/deef')).to be_falsey
+      expect(pattern.could_match_children?('/abc/d11f')).to be_falsey
+      expect(pattern.could_match_children?('/abc/de11f')).to be_falsey
+      expect(pattern.could_match_children?('/abc/dee1f')).to be_falsey
+      expect(pattern.could_match_children?('/abc/def')).to be_falsey
+      expect(pattern.could_match_children?('/abc/df')).to be_falsey
+      expect(pattern.could_match_children?('/abc/d')).to be_falsey
+      expect(pattern.could_match_children?('/abc/f')).to be_falsey
+      expect(pattern.could_match_children?('/abc/de1f/ghi')).to be_falsey
     end
     it 'exact_child_name_under' do
-      pattern.exact_child_name_under('/').should == 'abc'
-      pattern.exact_child_name_under('/abc').should == nil
-      pattern.exact_child_name_under('/abc/de1f').should == 'ghi'
+      expect(pattern.exact_child_name_under('/')).to eq('abc')
+      expect(pattern.exact_child_name_under('/abc')).to eq(nil)
+      expect(pattern.exact_child_name_under('/abc/de1f')).to eq('ghi')
     end
   end
 
   context 'with star pattern "/abc/**/ghi"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('/abc/**/ghi') }
     it 'match?' do
-      pattern.match?('/abc/def/ghi').should be_true
-      pattern.match?('/abc/d/e/f/ghi').should be_true
-      pattern.match?('/abc/ghi').should be_false
-      pattern.match?('/abcdef/d/ghi').should be_false
-      pattern.match?('/abc/d/defghi').should be_false
-      pattern.match?('/xyz').should be_false
+      expect(pattern.match?('/abc/def/ghi')).to be_truthy
+      expect(pattern.match?('/abc/d/e/f/ghi')).to be_truthy
+      expect(pattern.match?('/abc/ghi')).to be_falsey
+      expect(pattern.match?('/abcdef/d/ghi')).to be_falsey
+      expect(pattern.match?('/abc/d/defghi')).to be_falsey
+      expect(pattern.match?('/xyz')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should be_nil
+      expect(pattern.exact_path).to be_nil
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('/abc').should be_true
-      pattern.could_match_children?('/abc/d').should be_true
-      pattern.could_match_children?('/abc/d/e').should be_true
-      pattern.could_match_children?('/abc/d/e/f').should be_true
-      pattern.could_match_children?('/abc/def/ghi').should be_true
-      pattern.could_match_children?('abc').should be_false
-      pattern.could_match_children?('/xyz').should be_false
+      expect(pattern.could_match_children?('/abc')).to be_truthy
+      expect(pattern.could_match_children?('/abc/d')).to be_truthy
+      expect(pattern.could_match_children?('/abc/d/e')).to be_truthy
+      expect(pattern.could_match_children?('/abc/d/e/f')).to be_truthy
+      expect(pattern.could_match_children?('/abc/def/ghi')).to be_truthy
+      expect(pattern.could_match_children?('abc')).to be_falsey
+      expect(pattern.could_match_children?('/xyz')).to be_falsey
     end
     it 'exact_child_name_under' do
-      pattern.exact_child_name_under('/').should == 'abc'
-      pattern.exact_child_name_under('/abc').should == nil
-      pattern.exact_child_name_under('/abc/def').should == nil
+      expect(pattern.exact_child_name_under('/')).to eq('abc')
+      expect(pattern.exact_child_name_under('/abc')).to eq(nil)
+      expect(pattern.exact_child_name_under('/abc/def')).to eq(nil)
     end
   end
 
   context 'with star pattern "/abc**/ghi"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('/abc**/ghi') }
     it 'match?' do
-      pattern.match?('/abc/def/ghi').should be_true
-      pattern.match?('/abc/d/e/f/ghi').should be_true
-      pattern.match?('/abc/ghi').should be_true
-      pattern.match?('/abcdef/ghi').should be_true
-      pattern.match?('/abc/defghi').should be_false
-      pattern.match?('/xyz').should be_false
+      expect(pattern.match?('/abc/def/ghi')).to be_truthy
+      expect(pattern.match?('/abc/d/e/f/ghi')).to be_truthy
+      expect(pattern.match?('/abc/ghi')).to be_truthy
+      expect(pattern.match?('/abcdef/ghi')).to be_truthy
+      expect(pattern.match?('/abc/defghi')).to be_falsey
+      expect(pattern.match?('/xyz')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should be_nil
+      expect(pattern.exact_path).to be_nil
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('/abc').should be_true
-      pattern.could_match_children?('/abcdef').should be_true
-      pattern.could_match_children?('/abc/d/e').should be_true
-      pattern.could_match_children?('/abc/d/e/f').should be_true
-      pattern.could_match_children?('/abc/def/ghi').should be_true
-      pattern.could_match_children?('abc').should be_false
+      expect(pattern.could_match_children?('/abc')).to be_truthy
+      expect(pattern.could_match_children?('/abcdef')).to be_truthy
+      expect(pattern.could_match_children?('/abc/d/e')).to be_truthy
+      expect(pattern.could_match_children?('/abc/d/e/f')).to be_truthy
+      expect(pattern.could_match_children?('/abc/def/ghi')).to be_truthy
+      expect(pattern.could_match_children?('abc')).to be_falsey
     end
     it 'could_match_children? /abc** returns false for /xyz' do
-      pending 'Make could_match_children? more rigorous' do
-        # At the moment, we return false for this, but in the end it would be nice to return true:
-        pattern.could_match_children?('/xyz').should be_false
-      end
+      pending 'Make could_match_children? more rigorous'
+      # At the moment, we return false for this, but in the end it would be nice to return true:
+      expect(pattern.could_match_children?('/xyz')).to be_falsey
     end
     it 'exact_child_name_under' do
-      pattern.exact_child_name_under('/').should == nil
-      pattern.exact_child_name_under('/abc').should == nil
-      pattern.exact_child_name_under('/abc/def').should == nil
+      expect(pattern.exact_child_name_under('/')).to eq(nil)
+      expect(pattern.exact_child_name_under('/abc')).to eq(nil)
+      expect(pattern.exact_child_name_under('/abc/def')).to eq(nil)
     end
   end
 
   context 'with star pattern "/abc/**ghi"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('/abc/**ghi') }
     it 'match?' do
-      pattern.match?('/abc/def/ghi').should be_true
-      pattern.match?('/abc/def/ghi/ghi').should be_true
-      pattern.match?('/abc/def/ghi/jkl').should be_false
-      pattern.match?('/abc/d/e/f/ghi').should be_true
-      pattern.match?('/abc/ghi').should be_true
-      pattern.match?('/abcdef/ghi').should be_false
-      pattern.match?('/abc/defghi').should be_true
-      pattern.match?('/xyz').should be_false
+      expect(pattern.match?('/abc/def/ghi')).to be_truthy
+      expect(pattern.match?('/abc/def/ghi/ghi')).to be_truthy
+      expect(pattern.match?('/abc/def/ghi/jkl')).to be_falsey
+      expect(pattern.match?('/abc/d/e/f/ghi')).to be_truthy
+      expect(pattern.match?('/abc/ghi')).to be_truthy
+      expect(pattern.match?('/abcdef/ghi')).to be_falsey
+      expect(pattern.match?('/abc/defghi')).to be_truthy
+      expect(pattern.match?('/xyz')).to be_falsey
     end
     it 'exact_path' do
-      pattern.exact_path.should be_nil
+      expect(pattern.exact_path).to be_nil
     end
     it 'could_match_children?' do
-      pattern.could_match_children?('/abc').should be_true
-      pattern.could_match_children?('/abcdef').should be_false
-      pattern.could_match_children?('/abc/d/e').should be_true
-      pattern.could_match_children?('/abc/d/e/f').should be_true
-      pattern.could_match_children?('/abc/def/ghi').should be_true
-      pattern.could_match_children?('abc').should be_false
-      pattern.could_match_children?('/xyz').should be_false
+      expect(pattern.could_match_children?('/abc')).to be_truthy
+      expect(pattern.could_match_children?('/abcdef')).to be_falsey
+      expect(pattern.could_match_children?('/abc/d/e')).to be_truthy
+      expect(pattern.could_match_children?('/abc/d/e/f')).to be_truthy
+      expect(pattern.could_match_children?('/abc/def/ghi')).to be_truthy
+      expect(pattern.could_match_children?('abc')).to be_falsey
+      expect(pattern.could_match_children?('/xyz')).to be_falsey
     end
     it 'exact_child_name_under' do
-      pattern.exact_child_name_under('/').should == 'abc'
-      pattern.exact_child_name_under('/abc').should == nil
-      pattern.exact_child_name_under('/abc/def').should == nil
+      expect(pattern.exact_child_name_under('/')).to eq('abc')
+      expect(pattern.exact_child_name_under('/abc')).to eq(nil)
+      expect(pattern.exact_child_name_under('/abc/def')).to eq(nil)
     end
   end
 
   context 'with star pattern "a**b**c"' do
     let(:pattern) { Chef::ChefFS::FilePattern.new('a**b**c') }
     it 'match?' do
-      pattern.match?('axybzwc').should be_true
-      pattern.match?('abc').should be_true
-      pattern.match?('axyzwc').should be_false
-      pattern.match?('ac').should be_false
-      pattern.match?('a/x/y/b/z/w/c').should be_true
+      expect(pattern.match?('axybzwc')).to be_truthy
+      expect(pattern.match?('abc')).to be_truthy
+      expect(pattern.match?('axyzwc')).to be_falsey
+      expect(pattern.match?('ac')).to be_falsey
+      expect(pattern.match?('a/x/y/b/z/w/c')).to be_truthy
     end
     it 'exact_path' do
-      pattern.exact_path.should be_nil
+      expect(pattern.exact_path).to be_nil
     end
   end
 
   context 'normalization tests' do
     it 'handles trailing slashes' do
-      p('abc/').normalized_pattern.should == 'abc'
-      p('abc/').exact_path.should == 'abc'
-      p('abc/').match?('abc').should be_true
-      p('//').normalized_pattern.should == '/'
-      p('//').exact_path.should == '/'
-      p('//').match?('/').should be_true
-      p('/./').normalized_pattern.should == '/'
-      p('/./').exact_path.should == '/'
-      p('/./').match?('/').should be_true
+      expect(p('abc/').normalized_pattern).to eq('abc')
+      expect(p('abc/').exact_path).to eq('abc')
+      expect(p('abc/').match?('abc')).to be_truthy
+      expect(p('//').normalized_pattern).to eq('/')
+      expect(p('//').exact_path).to eq('/')
+      expect(p('//').match?('/')).to be_truthy
+      expect(p('/./').normalized_pattern).to eq('/')
+      expect(p('/./').exact_path).to eq('/')
+      expect(p('/./').match?('/')).to be_truthy
     end
     it 'handles multiple slashes' do
-      p('abc//def').normalized_pattern.should == 'abc/def'
-      p('abc//def').exact_path.should == 'abc/def'
-      p('abc//def').match?('abc/def').should be_true
-      p('abc//').normalized_pattern.should == 'abc'
-      p('abc//').exact_path.should == 'abc'
-      p('abc//').match?('abc').should be_true
+      expect(p('abc//def').normalized_pattern).to eq('abc/def')
+      expect(p('abc//def').exact_path).to eq('abc/def')
+      expect(p('abc//def').match?('abc/def')).to be_truthy
+      expect(p('abc//').normalized_pattern).to eq('abc')
+      expect(p('abc//').exact_path).to eq('abc')
+      expect(p('abc//').match?('abc')).to be_truthy
     end
     it 'handles dot' do
-      p('abc/./def').normalized_pattern.should == 'abc/def'
-      p('abc/./def').exact_path.should == 'abc/def'
-      p('abc/./def').match?('abc/def').should be_true
-      p('./abc/def').normalized_pattern.should == 'abc/def'
-      p('./abc/def').exact_path.should == 'abc/def'
-      p('./abc/def').match?('abc/def').should be_true
-      p('/.').normalized_pattern.should == '/'
-      p('/.').exact_path.should == '/'
-      p('/.').match?('/').should be_true
+      expect(p('abc/./def').normalized_pattern).to eq('abc/def')
+      expect(p('abc/./def').exact_path).to eq('abc/def')
+      expect(p('abc/./def').match?('abc/def')).to be_truthy
+      expect(p('./abc/def').normalized_pattern).to eq('abc/def')
+      expect(p('./abc/def').exact_path).to eq('abc/def')
+      expect(p('./abc/def').match?('abc/def')).to be_truthy
+      expect(p('/.').normalized_pattern).to eq('/')
+      expect(p('/.').exact_path).to eq('/')
+      expect(p('/.').match?('/')).to be_truthy
     end
     it 'handles dot by itself', :pending => "decide what to do with dot by itself" do
-      p('.').normalized_pattern.should == '.'
-      p('.').exact_path.should == '.'
-      p('.').match?('.').should be_true
-      p('./').normalized_pattern.should == '.'
-      p('./').exact_path.should == '.'
-      p('./').match?('.').should be_true
+      expect(p('.').normalized_pattern).to eq('.')
+      expect(p('.').exact_path).to eq('.')
+      expect(p('.').match?('.')).to be_truthy
+      expect(p('./').normalized_pattern).to eq('.')
+      expect(p('./').exact_path).to eq('.')
+      expect(p('./').match?('.')).to be_truthy
     end
     it 'handles dotdot' do
-      p('abc/../def').normalized_pattern.should == 'def'
-      p('abc/../def').exact_path.should == 'def'
-      p('abc/../def').match?('def').should be_true
-      p('abc/def/../..').normalized_pattern.should == ''
-      p('abc/def/../..').exact_path.should == ''
-      p('abc/def/../..').match?('').should be_true
-      p('/*/../def').normalized_pattern.should == '/def'
-      p('/*/../def').exact_path.should == '/def'
-      p('/*/../def').match?('/def').should be_true
-      p('/*/*/../def').normalized_pattern.should == '/*/def'
-      p('/*/*/../def').exact_path.should be_nil
-      p('/*/*/../def').match?('/abc/def').should be_true
-      p('/abc/def/../..').normalized_pattern.should == '/'
-      p('/abc/def/../..').exact_path.should == '/'
-      p('/abc/def/../..').match?('/').should be_true
-      p('abc/../../def').normalized_pattern.should == '../def'
-      p('abc/../../def').exact_path.should == '../def'
-      p('abc/../../def').match?('../def').should be_true
+      expect(p('abc/../def').normalized_pattern).to eq('def')
+      expect(p('abc/../def').exact_path).to eq('def')
+      expect(p('abc/../def').match?('def')).to be_truthy
+      expect(p('abc/def/../..').normalized_pattern).to eq('')
+      expect(p('abc/def/../..').exact_path).to eq('')
+      expect(p('abc/def/../..').match?('')).to be_truthy
+      expect(p('/*/../def').normalized_pattern).to eq('/def')
+      expect(p('/*/../def').exact_path).to eq('/def')
+      expect(p('/*/../def').match?('/def')).to be_truthy
+      expect(p('/*/*/../def').normalized_pattern).to eq('/*/def')
+      expect(p('/*/*/../def').exact_path).to be_nil
+      expect(p('/*/*/../def').match?('/abc/def')).to be_truthy
+      expect(p('/abc/def/../..').normalized_pattern).to eq('/')
+      expect(p('/abc/def/../..').exact_path).to eq('/')
+      expect(p('/abc/def/../..').match?('/')).to be_truthy
+      expect(p('abc/../../def').normalized_pattern).to eq('../def')
+      expect(p('abc/../../def').exact_path).to eq('../def')
+      expect(p('abc/../../def').match?('../def')).to be_truthy
     end
     it 'handles dotdot with double star' do
-      p('abc**/def/../ghi').exact_path.should be_nil
-      p('abc**/def/../ghi').match?('abc/ghi').should be_true
-      p('abc**/def/../ghi').match?('abc/x/y/z/ghi').should be_true
-      p('abc**/def/../ghi').match?('ghi').should be_false
+      expect(p('abc**/def/../ghi').exact_path).to be_nil
+      expect(p('abc**/def/../ghi').match?('abc/ghi')).to be_truthy
+      expect(p('abc**/def/../ghi').match?('abc/x/y/z/ghi')).to be_truthy
+      expect(p('abc**/def/../ghi').match?('ghi')).to be_falsey
     end
     it 'raises error on dotdot with overlapping double star' do
-      lambda { Chef::ChefFS::FilePattern.new('abc/**/../def').exact_path }.should raise_error(ArgumentError)
-      lambda { Chef::ChefFS::FilePattern.new('abc/**/abc/../../def').exact_path }.should raise_error(ArgumentError)
+      expect { Chef::ChefFS::FilePattern.new('abc/**/../def').exact_path }.to raise_error(ArgumentError)
+      expect { Chef::ChefFS::FilePattern.new('abc/**/abc/../../def').exact_path }.to raise_error(ArgumentError)
     end
     it 'handles leading dotdot' do
-      p('../abc/def').exact_path.should == '../abc/def'
-      p('../abc/def').match?('../abc/def').should be_true
-      p('/../abc/def').exact_path.should == '/abc/def'
-      p('/../abc/def').match?('/abc/def').should be_true
-      p('..').exact_path.should == '..'
-      p('..').match?('..').should be_true
-      p('/..').exact_path.should == '/'
-      p('/..').match?('/').should be_true
+      expect(p('../abc/def').exact_path).to eq('../abc/def')
+      expect(p('../abc/def').match?('../abc/def')).to be_truthy
+      expect(p('/../abc/def').exact_path).to eq('/abc/def')
+      expect(p('/../abc/def').match?('/abc/def')).to be_truthy
+      expect(p('..').exact_path).to eq('..')
+      expect(p('..').match?('..')).to be_truthy
+      expect(p('/..').exact_path).to eq('/')
+      expect(p('/..').match?('/')).to be_truthy
     end
   end