chef 12.0.3 → 12.1.0.rc.0

data/spec/unit/util/dsc/lcm_output_parser_spec.rb

@@ -20,24 +20,19 @@ require 'chef/util/dsc/lcm_output_parser'
 
 describe Chef::Util::DSC::LocalConfigurationManager::Parser do
   context 'empty input parameter' do
-    it 'returns an empty array for a 0 length string' do
-      Chef::Util::DSC::LocalConfigurationManager::Parser::parse('').should be_empty
+    it 'raises an exception when there are no valid lines' do
+      str = <<-EOF
+                
+      EOF
+      expect {Chef::Util::DSC::LocalConfigurationManager::Parser::parse(str)}.to raise_error(Chef::Exceptions::LCMParser)
     end
 
-    it 'returns an empty array for a nil input' do
-      Chef::Util::DSC::LocalConfigurationManager::Parser::parse('').should be_empty
+    it 'raises an exception for a nil input' do
+      expect {Chef::Util::DSC::LocalConfigurationManager::Parser::parse(nil)}.to raise_error(Chef::Exceptions::LCMParser)
     end
   end
 
   context 'correctly formatted output from lcm' do
-    it 'returns an empty array for a log with no resources' do
-      str = <<EOF
-logtype: [machinename]: LCM:  [ Start  Set      ]
-logtype: [machinename]: LCM:  [ End    Set      ]
-EOF
-      Chef::Util::DSC::LocalConfigurationManager::Parser::parse(str).should be_empty
-    end
-
     it 'returns a single resource when only 1 logged with the correct name' do
       str = <<EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
@@ -46,8 +41,8 @@ logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
       resources = Chef::Util::DSC::LocalConfigurationManager::Parser::parse(str)
-      resources.length.should eq(1)
-      resources[0].name.should eq('[name]')
+      expect(resources.length).to eq(1)
+      expect(resources[0].name).to eq('[name]')
     end
 
     it 'identifies when a resource changes the state of the system' do
@@ -60,7 +55,7 @@ logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
       resources = Chef::Util::DSC::LocalConfigurationManager::Parser::parse(str)
-      resources[0].changes_state?.should be_true
+      expect(resources[0].changes_state?).to be_truthy
     end
 
     it 'preserves the log provided for how the system changed the state' do
@@ -74,7 +69,7 @@ logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
       resources = Chef::Util::DSC::LocalConfigurationManager::Parser::parse(str)
-      resources[0].change_log.should match_array(["[name]","[message]","[name]"])
+      expect(resources[0].change_log).to match_array(["[name]","[message]","[name]"])
     end
 
     it 'should return false for changes_state?' do
@@ -86,7 +81,7 @@ logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
       resources = Chef::Util::DSC::LocalConfigurationManager::Parser::parse(str)
-      resources[0].changes_state?.should be_false
+      expect(resources[0].changes_state?).to be_falsey
     end
 
     it 'should return an empty array for change_log if changes_state? is false' do
@@ -98,7 +93,7 @@ logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
       resources = Chef::Util::DSC::LocalConfigurationManager::Parser::parse(str)
-      resources[0].change_log.should be_empty
+      expect(resources[0].change_log).to be_empty
     end
   end
 
@@ -120,8 +115,8 @@ logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
 
       resources = Chef::Util::DSC::LocalConfigurationManager::Parser::parse(str)
-      resources[0].changes_state?.should be_false
-      resources[1].changes_state?.should be_true
+      expect(resources[0].changes_state?).to be_falsey
+      expect(resources[1].changes_state?).to be_truthy
     end
 
     it 'should allow missing a [End Resource] when its the first one and still find all the resource' do
@@ -141,8 +136,8 @@ logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
 
       resources = Chef::Util::DSC::LocalConfigurationManager::Parser::parse(str)
-      resources[0].changes_state?.should be_false
-      resources[1].changes_state?.should be_true
+      expect(resources[0].changes_state?).to be_falsey
+      expect(resources[1].changes_state?).to be_truthy
     end
 
     it 'should allow missing set and end resource and assume an unconverged resource in this case' do
@@ -160,10 +155,10 @@ logtype: [machinename]: LCM:  [ End    Resource ]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
       resources = Chef::Util::DSC::LocalConfigurationManager::Parser::parse(str)
-      resources[0].changes_state?.should be_true
-      resources[0].name.should eql('[name]')
-      resources[1].changes_state?.should be_true
-      resources[1].name.should eql('[name2]')
+      expect(resources[0].changes_state?).to be_truthy
+      expect(resources[0].name).to eql('[name]')
+      expect(resources[1].changes_state?).to be_truthy
+      expect(resources[1].name).to eql('[name2]')
     end
   end
 end

data/spec/unit/util/dsc/local_configuration_manager_spec.rb

@@ -65,7 +65,7 @@ EOH
         let(:lcm_cmdlet_success) { true }
 
         it 'should successfully return resource information for normally formatted output when cmdlet the cmdlet succeeds' do
-          test_configuration_result = lcm.test_configuration('config')
+          test_configuration_result = lcm.test_configuration('config', {})
           expect(test_configuration_result.class).to be(Array)
           expect(test_configuration_result.length).to be > 0
           expect(Chef::Log).not_to receive(:warn)
@@ -78,14 +78,14 @@ EOH
         let(:lcm_cmdlet_success) { false }
 
         it 'returns true when passed to #whatif_not_supported?' do
-          expect(lcm.send(:whatif_not_supported?, no_whatif_lcm_output)).to be_true
+          expect(lcm.send(:whatif_not_supported?, no_whatif_lcm_output)).to be_truthy
         end
 
         it 'should should return a (possibly empty) array of ResourceInfo instances' do
-          expect(Chef::Log).to receive(:warn)
+          expect(Chef::Log).to receive(:warn).at_least(:once)
           expect(lcm).to receive(:whatif_not_supported?).and_call_original
           test_configuration_result = nil
-          expect {test_configuration_result = lcm.test_configuration('config')}.not_to raise_error
+          expect {test_configuration_result = lcm.test_configuration('config', {})}.not_to raise_error
           expect(test_configuration_result.class).to be(Array)
         end
       end
@@ -96,16 +96,16 @@ EOH
         let(:lcm_cmdlet_success) { false }
 
         it 'should log a warning if the message is formatted as expected when a resource import failure occurs' do
-          expect(Chef::Log).to receive(:warn)
+          expect(Chef::Log).to receive(:warn).at_least(:once)
           expect(lcm).to receive(:dsc_module_import_failure?).and_call_original
           test_configuration_result = nil
-          expect {test_configuration_result = lcm.test_configuration('config')}.not_to raise_error
+          expect {test_configuration_result = lcm.test_configuration('config', {})}.not_to raise_error
         end
 
         it 'should return a (possibly empty) array of ResourceInfo instances' do
-          expect(Chef::Log).to receive(:warn)
+          expect(Chef::Log).to receive(:warn).at_least(:once)
           test_configuration_result = nil
-          expect {test_configuration_result = lcm.test_configuration('config')}.not_to raise_error
+          expect {test_configuration_result = lcm.test_configuration('config', {})}.not_to raise_error
           expect(test_configuration_result.class).to be(Array)
         end
       end
@@ -116,9 +116,9 @@ EOH
         let(:lcm_cmdlet_success) { false }
 
         it 'should log a warning' do
-          expect(Chef::Log).to receive(:warn)
+          expect(Chef::Log).to receive(:warn).at_least(:once)
           expect(lcm).to receive(:dsc_module_import_failure?).and_call_original
-          expect {lcm.test_configuration('config')}.not_to raise_error
+          expect {lcm.test_configuration('config', {})}.not_to raise_error
         end
       end
     end

data/spec/unit/util/editor_spec.rb

@@ -22,7 +22,7 @@ describe Chef::Util::Editor do
     context 'when there is no match' do
       subject(:execute) { editor.append_line_after('missing', 'new') }
 
-      it('returns the number of added lines') { should be == 0 }
+      it('returns the number of added lines') { is_expected.to eq(0) }
       it 'does not add any lines' do
         expect { execute }.to_not change { editor.lines }
       end
@@ -31,7 +31,7 @@ describe Chef::Util::Editor do
     context 'when there is a match' do
       subject(:execute) { editor.append_line_after('two', 'new') }
 
-      it('returns the number of added lines') { should be == 2 }
+      it('returns the number of added lines') { is_expected.to eq(2) }
       it 'adds a line after each match' do
         execute
         expect(editor.lines).to be == ['one', 'two', 'new', 'two', 'new', 'three']
@@ -48,7 +48,7 @@ describe Chef::Util::Editor do
     context 'when there is no match' do
       subject(:execute) { editor.append_line_if_missing('missing', 'new') }
 
-      it('returns the number of added lines') { should be == 1 }
+      it('returns the number of added lines') { is_expected.to eq(1) }
       it 'adds a line to the end' do
         execute
         expect(editor.lines).to be == ['one', 'two', 'two', 'three', 'new']
@@ -58,7 +58,7 @@ describe Chef::Util::Editor do
     context 'when there is a match' do
       subject(:execute) { editor.append_line_if_missing('one', 'new') }
 
-      it('returns the number of added lines') { should be == 0 }
+      it('returns the number of added lines') { is_expected.to eq(0) }
       it 'does not add any lines' do
         expect { execute }.to_not change { editor.lines }
       end
@@ -74,7 +74,7 @@ describe Chef::Util::Editor do
     context 'when there is no match' do
       subject(:execute) { editor.remove_lines('missing') }
 
-      it('returns the number of removed lines') { should be == 0 }
+      it('returns the number of removed lines') { is_expected.to eq(0) }
       it 'does not remove any lines' do
         expect { execute }.to_not change { editor.lines }
       end
@@ -83,7 +83,7 @@ describe Chef::Util::Editor do
     context 'when there is a match' do
       subject(:execute) { editor.remove_lines('two') }
 
-      it('returns the number of removed lines') { should be == 2 }
+      it('returns the number of removed lines') { is_expected.to eq(2) }
       it 'removes the matching lines' do
         execute
         expect(editor.lines).to be == ['one', 'three']
@@ -100,7 +100,7 @@ describe Chef::Util::Editor do
     context 'when there is no match' do
       subject(:execute) { editor.replace('missing', 'new') }
 
-      it('returns the number of changed lines') { should be == 0 }
+      it('returns the number of changed lines') { is_expected.to eq(0) }
       it 'does not change any lines' do
         expect { execute }.to_not change { editor.lines }
       end
@@ -109,7 +109,7 @@ describe Chef::Util::Editor do
     context 'when there is a match' do
       subject(:execute) { editor.replace('two', 'new') }
 
-      it('returns the number of changed lines') { should be == 2 }
+      it('returns the number of changed lines') { is_expected.to eq(2) }
       it 'replaces the matching portions' do
         execute
         expect(editor.lines).to be == ['one', 'new', 'new', 'three']
@@ -127,7 +127,7 @@ describe Chef::Util::Editor do
     context 'when there is no match' do
       subject(:execute) { editor.replace_lines('missing', 'new') }
 
-      it('returns the number of changed lines') { should be == 0 }
+      it('returns the number of changed lines') { is_expected.to eq(0) }
       it 'does not change any lines' do
         expect { execute }.to_not change { editor.lines }
       end
@@ -136,7 +136,7 @@ describe Chef::Util::Editor do
     context 'when there is a match' do
       subject(:execute) { editor.replace_lines('two', 'new') }
 
-      it('returns the number of replaced lines') { should be == 2 }
+      it('returns the number of replaced lines') { is_expected.to eq(2) }
       it 'replaces the matching line' do
         execute
         expect(editor.lines).to be == ['one', 'new', 'new', 'three']

data/spec/unit/util/file_edit_spec.rb

@@ -135,21 +135,21 @@ twice
   describe "search_file_replace" do
     it "should accept regex passed in as a string (not Regexp object) and replace the match if there is one" do
       fedit.search_file_replace("localhost", "replacement")
-      fedit.unwritten_changes?.should be_true
+      expect(fedit.unwritten_changes?).to be_truthy
       fedit.write_file
       expect(edited_file_contents).to eq(localhost_replaced)
     end
 
     it "should accept regex passed in as a Regexp object and replace the match if there is one" do
       fedit.search_file_replace(/localhost/, "replacement")
-      fedit.unwritten_changes?.should be_true
+      expect(fedit.unwritten_changes?).to be_truthy
       fedit.write_file
       expect(edited_file_contents).to eq(localhost_replaced)
     end
 
     it "should do nothing if there isn't a match" do
       fedit.search_file_replace(/pattern/, "replacement")
-      fedit.unwritten_changes?.should be_false
+      expect(fedit.unwritten_changes?).to be_falsey
       fedit.write_file
       expect(edited_file_contents).to eq(starting_content)
     end
@@ -158,7 +158,7 @@ twice
   describe "search_file_replace_line" do
     it "should search for match and replace the whole line" do
       fedit.search_file_replace_line(/localhost/, "replacement line")
-      fedit.unwritten_changes?.should be_true
+      expect(fedit.unwritten_changes?).to be_truthy
       fedit.write_file
       expect(edited_file_contents).to eq(localhost_line_replaced)
     end
@@ -167,7 +167,7 @@ twice
   describe "search_file_delete" do
     it "should search for match and delete the match" do
       fedit.search_file_delete(/localhost/)
-      fedit.unwritten_changes?.should be_true
+      expect(fedit.unwritten_changes?).to be_truthy
       fedit.write_file
       expect(edited_file_contents).to eq(localhost_deleted)
     end
@@ -176,7 +176,7 @@ twice
   describe "search_file_delete_line" do
     it "should search for match and delete the matching line" do
       fedit.search_file_delete_line(/localhost/)
-      fedit.unwritten_changes?.should be_true
+      expect(fedit.unwritten_changes?).to be_truthy
       fedit.write_file
       expect(edited_file_contents).to eq(localhost_line_deleted)
     end
@@ -185,7 +185,7 @@ twice
   describe "insert_line_after_match" do
     it "should search for match and insert the given line after the matching line" do
       fedit.insert_line_after_match(/localhost/, "new line inserted")
-      fedit.unwritten_changes?.should be_true
+      expect(fedit.unwritten_changes?).to be_truthy
       fedit.write_file
       expect(edited_file_contents).to eq(append_after_all_localhost)
     end
@@ -194,14 +194,14 @@ twice
   describe "insert_line_if_no_match" do
     it "should search for match and insert the given line if no line match" do
       fedit.insert_line_if_no_match(/pattern/, "new line inserted")
-      fedit.unwritten_changes?.should be_true
+      expect(fedit.unwritten_changes?).to be_truthy
       fedit.write_file
       expect(edited_file_contents).to eq(append_after_content)
     end
 
     it "should do nothing if there is a match" do
       fedit.insert_line_if_no_match(/localhost/, "replacement")
-      fedit.unwritten_changes?.should be_false
+      expect(fedit.unwritten_changes?).to be_falsey
       fedit.write_file
       expect(edited_file_contents).to eq(starting_content)
     end
@@ -218,7 +218,7 @@ twice
     it "should return true if a file got edited" do
       fedit.insert_line_if_no_match(/pattern/, "new line inserted")
       fedit.write_file
-      expect(fedit.file_edited?).to be_true
+      expect(fedit.file_edited?).to be_truthy
     end
   end
 end

data/spec/unit/util/path_helper_spec.rb

@@ -25,81 +25,81 @@ describe Chef::Util::PathHelper do
   [ false, true ].each do |is_windows|
     context "on #{is_windows ? "windows" : "unix"}" do
       before(:each) do
-        Chef::Platform.stub(:windows?).and_return(is_windows)
+        allow(Chef::Platform).to receive(:windows?).and_return(is_windows)
       end
 
       describe "join" do
         it "joins components when some end with separators" do
           expected = PathHelper.cleanpath("/foo/bar/baz")
           expected = "C:#{expected}" if is_windows
-          PathHelper.join(is_windows ? 'C:\\foo\\' : "/foo/", "bar", "baz").should == expected
+          expect(PathHelper.join(is_windows ? 'C:\\foo\\' : "/foo/", "bar", "baz")).to eq(expected)
         end
 
         it "joins components when some end and start with separators" do
           expected = PathHelper.cleanpath("/foo/bar/baz")
           expected = "C:#{expected}" if is_windows
-          PathHelper.join(is_windows ? 'C:\\foo\\' : "/foo/", "bar/", "/baz").should == expected
+          expect(PathHelper.join(is_windows ? 'C:\\foo\\' : "/foo/", "bar/", "/baz")).to eq(expected)
         end
 
         it "joins components that don't end in separators" do
           expected = PathHelper.cleanpath("/foo/bar/baz")
           expected = "C:#{expected}" if is_windows
-          PathHelper.join(is_windows ? 'C:\\foo' : "/foo", "bar", "baz").should == expected
+          expect(PathHelper.join(is_windows ? 'C:\\foo' : "/foo", "bar", "baz")).to eq(expected)
         end
 
         it "joins starting with '' resolve to absolute paths" do
-          PathHelper.join('', 'a', 'b').should == "#{PathHelper.path_separator}a#{PathHelper.path_separator}b"
+          expect(PathHelper.join('', 'a', 'b')).to eq("#{PathHelper.path_separator}a#{PathHelper.path_separator}b")
         end
 
         it "joins ending with '' add a / to the end" do
-          PathHelper.join('a', 'b', '').should == "a#{PathHelper.path_separator}b#{PathHelper.path_separator}"
+          expect(PathHelper.join('a', 'b', '')).to eq("a#{PathHelper.path_separator}b#{PathHelper.path_separator}")
         end
 
         if is_windows
           it "joins components on Windows when some end with unix separators" do
-            PathHelper.join('C:\\foo/', "bar", "baz").should == 'C:\\foo\\bar\\baz'
+            expect(PathHelper.join('C:\\foo/', "bar", "baz")).to eq('C:\\foo\\bar\\baz')
           end
         end
       end
 
       if is_windows
         it "path_separator is \\" do
-          PathHelper.path_separator.should == '\\'
+          expect(PathHelper.path_separator).to eq('\\')
         end
       else
         it "path_separator is /" do
-          PathHelper.path_separator.should == '/'
+          expect(PathHelper.path_separator).to eq('/')
         end
       end
 
       if is_windows
         it "cleanpath changes slashes into backslashes and leaves backslashes alone" do
-          PathHelper.cleanpath('/a/b\\c/d/').should == '\\a\\b\\c\\d'
+          expect(PathHelper.cleanpath('/a/b\\c/d/')).to eq('\\a\\b\\c\\d')
         end
         it "cleanpath does not remove leading double backslash" do
-          PathHelper.cleanpath('\\\\a/b\\c/d/').should == '\\\\a\\b\\c\\d'
+          expect(PathHelper.cleanpath('\\\\a/b\\c/d/')).to eq('\\\\a\\b\\c\\d')
         end
       else
         it "cleanpath removes extra slashes alone" do
-          PathHelper.cleanpath('/a///b/c/d/').should == '/a/b/c/d'
+          expect(PathHelper.cleanpath('/a///b/c/d/')).to eq('/a/b/c/d')
         end
       end
 
       describe "dirname" do
         it "dirname('abc') is '.'" do
-          PathHelper.dirname('abc').should == '.'
+          expect(PathHelper.dirname('abc')).to eq('.')
         end
         it "dirname('/') is '/'" do
-          PathHelper.dirname(PathHelper.path_separator).should == PathHelper.path_separator
+          expect(PathHelper.dirname(PathHelper.path_separator)).to eq(PathHelper.path_separator)
         end
         it "dirname('a/b/c') is 'a/b'" do
-          PathHelper.dirname(PathHelper.join('a', 'b', 'c')).should == PathHelper.join('a', 'b')
+          expect(PathHelper.dirname(PathHelper.join('a', 'b', 'c'))).to eq(PathHelper.join('a', 'b'))
         end
         it "dirname('a/b/c/') is 'a/b'" do
-          PathHelper.dirname(PathHelper.join('a', 'b', 'c', '')).should == PathHelper.join('a', 'b')
+          expect(PathHelper.dirname(PathHelper.join('a', 'b', 'c', ''))).to eq(PathHelper.join('a', 'b'))
         end
         it "dirname('/a/b/c') is '/a/b'" do
-          PathHelper.dirname(PathHelper.join('', 'a', 'b', 'c')).should == PathHelper.join('', 'a', 'b')
+          expect(PathHelper.dirname(PathHelper.join('', 'a', 'b', 'c'))).to eq(PathHelper.join('', 'a', 'b'))
         end
       end
     end
@@ -109,9 +109,9 @@ describe Chef::Util::PathHelper do
     context "on windows" do
       before(:each) do
         # pass by default
-        Chef::Platform.stub(:windows?).and_return(true)
-        PathHelper.stub(:printable?).and_return(true)
-        PathHelper.stub(:windows_max_length_exceeded?).and_return(false)
+        allow(Chef::Platform).to receive(:windows?).and_return(true)
+        allow(PathHelper).to receive(:printable?).and_return(true)
+        allow(PathHelper).to receive(:windows_max_length_exceeded?).and_return(false)
       end
 
       it "returns the path if the path passes the tests" do
@@ -123,14 +123,14 @@ describe Chef::Util::PathHelper do
       end
 
       it "raises an error if the path has invalid characters" do
-        PathHelper.stub(:printable?).and_return(false)
+        allow(PathHelper).to receive(:printable?).and_return(false)
         expect { PathHelper.validate_path("Newline!\n") }.to raise_error(Chef::Exceptions::ValidationFailed)
       end
 
       it "Adds the \\\\?\\ prefix if the path exceeds MAX_LENGTH and does not have it" do
         long_path = "C:\\" + "a" * 250 + "\\" + "b" * 250
         prefixed_long_path = "\\\\?\\" + long_path
-        PathHelper.stub(:windows_max_length_exceeded?).and_return(true)
+        allow(PathHelper).to receive(:windows_max_length_exceeded?).and_return(true)
         expect(PathHelper.validate_path(long_path)).to eql(prefixed_long_path)
       end
     end
@@ -138,38 +138,38 @@ describe Chef::Util::PathHelper do
 
   describe "windows_max_length_exceeded?" do
     it "returns true if the path is too long (259 + NUL) for the API" do
-      expect(PathHelper.windows_max_length_exceeded?("C:\\" + "a" * 250 + "\\" + "b" * 6)).to be_true
+      expect(PathHelper.windows_max_length_exceeded?("C:\\" + "a" * 250 + "\\" + "b" * 6)).to be_truthy
     end
 
     it "returns false if the path is not too long (259 + NUL) for the standard API" do
-      expect(PathHelper.windows_max_length_exceeded?("C:\\" + "a" * 250 + "\\" + "b" * 5)).to be_false
+      expect(PathHelper.windows_max_length_exceeded?("C:\\" + "a" * 250 + "\\" + "b" * 5)).to be_falsey
     end
 
     it "returns false if the path is over 259 characters but uses the \\\\?\\ prefix" do
-      expect(PathHelper.windows_max_length_exceeded?("\\\\?\\C:\\" + "a" * 250 + "\\" + "b" * 250)).to be_false
+      expect(PathHelper.windows_max_length_exceeded?("\\\\?\\C:\\" + "a" * 250 + "\\" + "b" * 250)).to be_falsey
     end
   end
 
   describe "printable?" do
     it "returns true if the string contains no non-printable characters" do
-      expect(PathHelper.printable?("C:\\Program Files (x86)\\Microsoft Office\\Files.lst")).to be_true
+      expect(PathHelper.printable?("C:\\Program Files (x86)\\Microsoft Office\\Files.lst")).to be_truthy
     end
 
     it "returns true when given 'abc' in unicode" do
-      expect(PathHelper.printable?("\u0061\u0062\u0063")).to be_true
+      expect(PathHelper.printable?("\u0061\u0062\u0063")).to be_truthy
     end
 
     it "returns true when given japanese unicode" do
-      expect(PathHelper.printable?("\uff86\uff87\uff88")).to be_true
+      expect(PathHelper.printable?("\uff86\uff87\uff88")).to be_truthy
     end
 
     it "returns false if the string contains a non-printable character" do
-      expect(PathHelper.printable?("\my files\work\notes.txt")).to be_false
+      expect(PathHelper.printable?("\my files\work\notes.txt")).to be_falsey
     end
 
     # This isn't necessarily a requirement, but here to be explicit about functionality.
     it "returns false if the string contains a newline or tab" do
-      expect(PathHelper.printable?("\tThere's no way,\n\t *no* way,\n\t that you came from my loins.\n")).to be_false
+      expect(PathHelper.printable?("\tThere's no way,\n\t *no* way,\n\t that you came from my loins.\n")).to be_falsey
     end
   end
 
@@ -189,31 +189,23 @@ describe Chef::Util::PathHelper do
     end
 
     context "not on windows", :unix_only  do
-      context "ruby is at least 1.9", :ruby_gte_19_only do
-        it "returns a canonical path" do
-          expect(PathHelper.canonical_path("/etc//apache.d/sites-enabled/../sites-available/default")).to eq("/etc/apache.d/sites-available/default")
-        end
-      end
-
-      context "ruby is less than 1.9", :ruby_18_only do
-        it "returns a canonical path" do
-          expect { PathHelper.canonical_path("/etc//apache.d/sites-enabled/../sites-available/default") }.to raise_error(NotImplementedError)
-        end
+      it "returns a canonical path" do
+        expect(PathHelper.canonical_path("/etc//apache.d/sites-enabled/../sites-available/default")).to eq("/etc/apache.d/sites-available/default")
       end
     end
   end
 
   describe "paths_eql?" do
     it "returns true if the paths are the same" do
-      PathHelper.stub(:canonical_path).with("bandit").and_return("c:/bandit/bandit")
-      PathHelper.stub(:canonical_path).with("../bandit/bandit").and_return("c:/bandit/bandit")
-      expect(PathHelper.paths_eql?("bandit", "../bandit/bandit")).to be_true
+      allow(PathHelper).to receive(:canonical_path).with("bandit").and_return("c:/bandit/bandit")
+      allow(PathHelper).to receive(:canonical_path).with("../bandit/bandit").and_return("c:/bandit/bandit")
+      expect(PathHelper.paths_eql?("bandit", "../bandit/bandit")).to be_truthy
     end
 
     it "returns false if the paths are different" do
-      PathHelper.stub(:canonical_path).with("bandit").and_return("c:/Bo/Bandit")
-      PathHelper.stub(:canonical_path).with("../bandit/bandit").and_return("c:/bandit/bandit")
-      expect(PathHelper.paths_eql?("bandit", "../bandit/bandit")).to be_false
+      allow(PathHelper).to receive(:canonical_path).with("bandit").and_return("c:/Bo/Bandit")
+      allow(PathHelper).to receive(:canonical_path).with("../bandit/bandit").and_return("c:/bandit/bandit")
+      expect(PathHelper.paths_eql?("bandit", "../bandit/bandit")).to be_falsey
     end
   end