puppet 5.5.12 → 5.5.13

data/spec/unit/module_tool/applications/builder_spec.rb

@@ -19,10 +19,10 @@ describe Puppet::ModuleTool::Applications::Builder do
     end
 
     def build
-      tarrer = mock('tarrer')
-      Puppet::ModuleTool::Tar.expects(:instance).returns(tarrer)
-      Dir.expects(:chdir).with(File.join(path, 'pkg')).yields
-      tarrer.expects(:pack).with(release_name, tarball)
+      tarrer = double('tarrer')
+      expect(Puppet::ModuleTool::Tar).to receive(:instance).and_return(tarrer)
+      expect(Dir).to receive(:chdir).with(File.join(path, 'pkg')).and_yield
+      expect(tarrer).to receive(:pack).with(release_name, tarball)
 
       builder.run
     end
@@ -432,7 +432,7 @@ symlinkfile
 
   context 'when in FIPS mode...' do
     it 'module builder refuses to run' do
-      Facter.stubs(:value).with(:fips_enabled).returns(true)
+      allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
       expect { builder.run }.to raise_error(/Module building is prohibited in FIPS mode/)
     end 
   end

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -21,22 +21,21 @@ describe Puppet::ModuleTool::Applications::Installer do
   let(:remote_source) { PuppetSpec::ModuleTool::StubSource.new }
 
   let(:install_dir) do
-    mock("Puppet::ModuleTool::InstallDirectory").tap do |dir|
-      dir.stubs(:prepare)
-      dir.stubs(:target).returns(primary_dir)
-    end
+    dir = double("Puppet::ModuleTool::InstallDirectory")
+    allow(dir).to receive(:prepare)
+    allow(dir).to receive(:target).and_return(primary_dir)
+    dir
   end
 
   before do
     SemanticPuppet::Dependency.clear_sources
-    installer = Puppet::ModuleTool::Applications::Installer.any_instance
-    installer.stubs(:module_repository).returns(remote_source)
+    allow_any_instance_of(Puppet::ModuleTool::Applications::Installer).to receive(:module_repository).and_return(remote_source)
   end
 
   if Puppet.features.microsoft_windows?
     before :each do
-      Puppet.settings.stubs(:[])
-      Puppet.settings.stubs(:[]).with(:module_working_dir).returns(Dir.mktmpdir('installertmp'))
+      allow(Puppet.settings).to receive(:[])
+      allow(Puppet.settings).to receive(:[]).with(:module_working_dir).and_return(Dir.mktmpdir('installertmp'))
     end
   end
 
@@ -81,7 +80,7 @@ describe Puppet::ModuleTool::Applications::Installer do
         end
 
         it 'installs the specified tarball' do
-          remote_source.expects(:fetch).never
+          expect(remote_source).not_to receive(:fetch)
           expect(subject).to include :result => :success
           graph_should_include 'puppetlabs-stdlib', nil => v('3.2.0')
         end
@@ -102,7 +101,7 @@ describe Puppet::ModuleTool::Applications::Installer do
           end
 
           it 'installs the specified tarball without dependencies' do
-            remote_source.expects(:fetch).never
+            expect(remote_source).not_to receive(:fetch)
             expect(subject).to include :result => :success
             graph_should_include 'puppetlabs-java', nil => v('1.0.0')
             graph_should_include 'puppetlabs-stdlib', nil
@@ -369,7 +368,7 @@ describe Puppet::ModuleTool::Applications::Installer do
 
     context 'when in FIPS mode...' do
       it 'module installer refuses to run' do
-        Facter.stubs(:value).with(:fips_enabled).returns(true)
+        allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
         expect {application.run}.to raise_error(/Module install is prohibited in FIPS mode./)
       end 
     end

data/spec/unit/module_tool/applications/searcher_spec.rb

@@ -6,14 +6,14 @@ describe Puppet::ModuleTool::Applications::Searcher do
   include PuppetSpec::Files
 
   describe "when searching" do
-    let(:forge) { mock 'forge', :host => 'http://nowhe.re' }
+    let(:forge) { double('forge', :host => 'http://nowhe.re') }
     let(:searcher) do
       described_class.new('search_term', forge)
     end
 
     it "should return results from a forge query when successful" do
       results = 'mock results'
-      forge.expects(:search).with('search_term').returns(results)
+      expect(forge).to receive(:search).with('search_term').and_return(results)
 
       search_result = searcher.run
       expect(search_result).to eq({
@@ -23,7 +23,7 @@ describe Puppet::ModuleTool::Applications::Searcher do
     end
 
     it "should return an error when the forge query throws an exception" do
-      forge.expects(:search).with('search_term').raises Puppet::Forge::Errors::ForgeError.new("something went wrong")
+      expect(forge).to receive(:search).with('search_term').and_raise(Puppet::Forge::Errors::ForgeError.new("something went wrong"))
 
       search_result = searcher.run
       expect(search_result).to eq({

data/spec/unit/module_tool/applications/uninstaller_spec.rb

@@ -165,9 +165,8 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
 
   context 'when in FIPS mode...' do
     it 'module uninstaller refuses to run' do
-      Facter.stubs(:value).with(:fips_enabled).returns(true)
+      allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
       expect {application.run}.to raise_error(/Module uninstall is prohibited in FIPS mode/)
     end 
   end
-
 end

data/spec/unit/module_tool/applications/unpacker_spec.rb

@@ -14,13 +14,13 @@ describe Puppet::ModuleTool::Applications::Unpacker do
   let(:working_dir) { tmpdir("working_dir") }
 
   before :each do
-    Puppet.settings.stubs(:[])
-    Puppet.settings.stubs(:[]).with(:module_working_dir).returns(working_dir)
+    allow(Puppet.settings).to receive(:[])
+    allow(Puppet.settings).to receive(:[]).with(:module_working_dir).and_return(working_dir)
   end
 
   it "should attempt to untar file to temporary location" do
-    untar = mock('Tar')
-    untar.expects(:unpack).with(filename, anything()) do |src, dest, _|
+    untar = double('Tar')
+    expect(untar).to receive(:unpack).with(filename, anything, anything) do |src, dest, _|
       FileUtils.mkdir(File.join(dest, 'extractedmodule'))
       File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
         file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
@@ -28,15 +28,15 @@ describe Puppet::ModuleTool::Applications::Unpacker do
       true
     end
 
-    Puppet::ModuleTool::Tar.expects(:instance).returns(untar)
+    expect(Puppet::ModuleTool::Tar).to receive(:instance).and_return(untar)
 
     Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
     expect(File).to be_directory(File.join(target, 'mytarball'))
   end
 
   it "should warn about symlinks", :if => Puppet.features.manages_symlinks? do
-    untar = mock('Tar')
-    untar.expects(:unpack).with(filename, anything()) do |src, dest, _|
+    untar = double('Tar')
+    expect(untar).to receive(:unpack).with(filename, anything, anything) do |src, dest, _|
       FileUtils.mkdir(File.join(dest, 'extractedmodule'))
       File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
         file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
@@ -46,16 +46,16 @@ describe Puppet::ModuleTool::Applications::Unpacker do
       true
     end
 
-    Puppet::ModuleTool::Tar.expects(:instance).returns(untar)
-    Puppet.expects(:warning).with(regexp_matches(/symlinks/i))
+    expect(Puppet::ModuleTool::Tar).to receive(:instance).and_return(untar)
+    expect(Puppet).to receive(:warning).with(/symlinks/i)
 
     Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
     expect(File).to be_directory(File.join(target, 'mytarball'))
   end
 
   it "should warn about symlinks in subdirectories", :if => Puppet.features.manages_symlinks? do
-    untar = mock('Tar')
-    untar.expects(:unpack).with(filename, anything()) do |src, dest, _|
+    untar = double('Tar')
+    expect(untar).to receive(:unpack).with(filename, anything, anything) do |src, dest, _|
       FileUtils.mkdir(File.join(dest, 'extractedmodule'))
       File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
         file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
@@ -66,8 +66,8 @@ describe Puppet::ModuleTool::Applications::Unpacker do
       true
     end
 
-    Puppet::ModuleTool::Tar.expects(:instance).returns(untar)
-    Puppet.expects(:warning).with(regexp_matches(/symlinks/i))
+    expect(Puppet::ModuleTool::Tar).to receive(:instance).and_return(untar)
+    expect(Puppet).to receive(:warning).with(/symlinks/i)
 
     Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
     expect(File).to be_directory(File.join(target, 'mytarball'))

data/spec/unit/module_tool/applications/upgrader_spec.rb

@@ -27,14 +27,13 @@ describe Puppet::ModuleTool::Applications::Upgrader do
 
   before do
     SemanticPuppet::Dependency.clear_sources
-    installer = Puppet::ModuleTool::Applications::Upgrader.any_instance
-    installer.stubs(:module_repository).returns(remote_source)
+    allow_any_instance_of(Puppet::ModuleTool::Applications::Upgrader).to receive(:module_repository).and_return(remote_source)
   end
 
   if Puppet.features.microsoft_windows?
     before :each do
-      Puppet.settings.stubs(:[])
-      Puppet.settings.stubs(:[]).with(:module_working_dir).returns(Dir.mktmpdir('upgradertmp'))
+      allow(Puppet.settings).to receive(:[])
+      allow(Puppet.settings).to receive(:[]).with(:module_working_dir).and_return(Dir.mktmpdir('upgradertmp'))
     end
   end
 
@@ -327,9 +326,10 @@ describe Puppet::ModuleTool::Applications::Upgrader do
         end
       end
     end
+
     context 'when in FIPS mode...' do
       it 'module unpgrader refuses to run' do
-        Facter.stubs(:value).with(:fips_enabled).returns(true)
+        allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
         expect { application.run }.to raise_error(/Module upgrade is prohibited in FIPS mode/)
       end 
     end

data/spec/unit/module_tool/install_directory_spec.rb

@@ -12,7 +12,7 @@ describe Puppet::ModuleTool::InstallDirectory do
 
   it "(#15202) creates the install directory" do
     target_dir = the_directory('foo', :directory? => false, :exist? => false)
-    target_dir.expects(:mkpath)
+    expect(target_dir).to receive(:mkpath)
 
     install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
 
@@ -21,7 +21,7 @@ describe Puppet::ModuleTool::InstallDirectory do
 
   it "(#15202) errors when the directory is not accessible" do
     target_dir = the_directory('foo', :directory? => false, :exist? => false)
-    target_dir.expects(:mkpath).raises(Errno::EACCES)
+    expect(target_dir).to receive(:mkpath).and_raise(Errno::EACCES)
 
     install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
 
@@ -34,7 +34,7 @@ describe Puppet::ModuleTool::InstallDirectory do
 
   it "(#15202) errors when an entry along the path is not a directory" do
     target_dir = the_directory("foo/bar", :exist? => false, :directory? => false)
-    target_dir.expects(:mkpath).raises(Errno::EEXIST)
+    expect(target_dir).to receive(:mkpath).and_raise(Errno::EEXIST)
 
     install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
 
@@ -45,7 +45,7 @@ describe Puppet::ModuleTool::InstallDirectory do
 
   it "(#15202) simply re-raises an unknown error" do
     target_dir = the_directory("foo/bar", :exist? => false, :directory? => false)
-    target_dir.expects(:mkpath).raises("unknown error")
+    expect(target_dir).to receive(:mkpath).and_raise("unknown error")
 
     install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
 
@@ -54,7 +54,7 @@ describe Puppet::ModuleTool::InstallDirectory do
 
   it "(#15202) simply re-raises an unknown system call error" do
     target_dir = the_directory("foo/bar", :exist? => false, :directory? => false)
-    target_dir.expects(:mkpath).raises(SystemCallError, "unknown")
+    expect(target_dir).to receive(:mkpath).and_raise(SystemCallError, "unknown")
 
     install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
 
@@ -62,9 +62,9 @@ describe Puppet::ModuleTool::InstallDirectory do
   end
 
   def the_directory(name, options)
-    dir = mock("Pathname<#{name}>")
-    dir.stubs(:exist?).returns(options.fetch(:exist?, true))
-    dir.stubs(:directory?).returns(options.fetch(:directory?, true))
+    dir = double("Pathname<#{name}>")
+    allow(dir).to receive(:exist?).and_return(options.fetch(:exist?, true))
+    allow(dir).to receive(:directory?).and_return(options.fetch(:directory?, true))
     dir
   end
 end

data/spec/unit/module_tool/installed_modules_spec.rb

@@ -24,14 +24,14 @@ describe Puppet::ModuleTool::InstalledModules do
 
   it 'defaults when not given a semantic version' do
     mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => 'banana'})
-    Puppet.expects(:warning).with(regexp_matches(/Semantic Version/))
+    expect(Puppet).to receive(:warning).with(/Semantic Version/)
     installed = described_class.new(@env)
     expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
   end
 
   it 'defaults when not given a full semantic version' do
     mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => '1.2'})
-    Puppet.expects(:warning).with(regexp_matches(/Semantic Version/))
+    expect(Puppet).to receive(:warning).with(/Semantic Version/)
     installed = described_class.new(@env)
     expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
   end
@@ -40,7 +40,7 @@ describe Puppet::ModuleTool::InstalledModules do
     mod1 = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => 'banana'})
     mod2 = PuppetSpec::Modules.create('goodsemver', @modpath, :metadata => {:version => '1.2.3'})
     mod3 = PuppetSpec::Modules.create('notquitesemver', @modpath, :metadata => {:version => '1.2'})
-    Puppet.expects(:warning).with(regexp_matches(/Semantic Version/)).twice
+    expect(Puppet).to receive(:warning).with(/Semantic Version/).twice
     installed = described_class.new(@env)
     expect(installed.modules["puppetlabs-#{mod1.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
     expect(installed.modules["puppetlabs-#{mod2.name}"].version).to eq(SemanticPuppet::Version.parse('1.2.3'))

data/spec/unit/module_tool/tar/gnu_spec.rb

@@ -8,16 +8,16 @@ describe Puppet::ModuleTool::Tar::Gnu do
   let(:destfile)   { '/space path/the/dest/file.tar.gz' }
 
   it "unpacks a tar file" do
-    Dir.expects(:chdir).with(File.expand_path(destdir)).yields(mock)
-    Puppet::Util::Execution.expects(:execute).with("gzip -dc #{Shellwords.shellescape(File.expand_path(sourcefile))} | tar xof -")
-    Puppet::Util::Execution.expects(:execute).with("find . -type d -exec chmod 755 {} +")
-    Puppet::Util::Execution.expects(:execute).with("find . -type f -exec chmod u+rw,g+r,a-st {} +")
-    Puppet::Util::Execution.expects(:execute).with("chown -R <owner:group> .")
+    expect(Dir).to receive(:chdir).with(File.expand_path(destdir)).and_yield
+    expect(Puppet::Util::Execution).to receive(:execute).with("gzip -dc #{Shellwords.shellescape(File.expand_path(sourcefile))} | tar xof -")
+    expect(Puppet::Util::Execution).to receive(:execute).with("find . -type d -exec chmod 755 {} +")
+    expect(Puppet::Util::Execution).to receive(:execute).with("find . -type f -exec chmod u+rw,g+r,a-st {} +")
+    expect(Puppet::Util::Execution).to receive(:execute).with("chown -R <owner:group> .")
     subject.unpack(sourcefile, destdir, '<owner:group>')
   end
 
   it "packs a tar file" do
-    Puppet::Util::Execution.expects(:execute).with("tar cf - #{sourcedir} | gzip -c > #{File.basename(destfile)}")
+    expect(Puppet::Util::Execution).to receive(:execute).with("tar cf - #{sourcedir} | gzip -c > #{File.basename(destfile)}")
     subject.pack(sourcedir, destfile)
   end
 end

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -57,33 +57,33 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
   end
 
   it "packs a tar file" do
-    writer = stub('GzipWriter')
+    writer = double('GzipWriter')
 
-    Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
+    expect(Zlib::GzipWriter).to receive(:open).with(destfile).and_yield(writer)
     stats = {:mode => 0222}
-    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer).yields(:file_start, 'abc', stats)
+    expect(Archive::Tar::Minitar).to receive(:pack).with(sourcedir, writer).and_yield(:file_start, 'abc', stats)
 
     minitar.pack(sourcedir, destfile)
   end
 
   it "packs a tar file on Windows" do
-    writer = stub('GzipWriter')
+    writer = double('GzipWriter')
 
-    Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
-    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer).
-        yields(:file_start, 'abc', {:entry => MockFileStatEntry.new(nil)})
+    expect(Zlib::GzipWriter).to receive(:open).with(destfile).and_yield(writer)
+    expect(Archive::Tar::Minitar).to receive(:pack).with(sourcedir, writer).
+        and_yield(:file_start, 'abc', {:entry => MockFileStatEntry.new(nil)})
 
     minitar.pack(sourcedir, destfile)
   end
 
   def unpacks_the_entry(type, name, mode = 0100)
-    reader = stub('GzipReader')
+    reader = double('GzipReader')
 
-    Zlib::GzipReader.expects(:open).with(sourcefile).yields(reader)
-    minitar.expects(:find_valid_files).with(reader).returns([name])
+    expect(Zlib::GzipReader).to receive(:open).with(sourcefile).and_yield(reader)
+    expect(minitar).to receive(:find_valid_files).with(reader).and_return([name])
     entry = MockFileStatEntry.new(mode)
-    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir, [name]).
-        yields(type, name, {:entry => entry})
+    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name]).
+        and_yield(type, name, {:entry => entry})
     entry
   end
 end

data/spec/unit/module_tool/tar_spec.rb

@@ -2,35 +2,34 @@ require 'spec_helper'
 require 'puppet/module_tool/tar'
 
 describe Puppet::ModuleTool::Tar do
-
   [
     { :name => 'ObscureLinuxDistro', :win => false }, 
     { :name => 'Windows', :win => true }
   ].each do |os|
     it "always prefers minitar if it and zlib are present, even with tar available" do
-      Facter.stubs(:value).with('osfamily').returns os[:name]
-      Puppet::Util.stubs(:which).with('tar').returns '/usr/bin/tar'
-      Puppet::Util::Platform.stubs(:windows?).returns os[:win]
-      Puppet.stubs(:features).returns(stub(:minitar? => true, :zlib? => true))
+      allow(Facter).to receive(:value).with('osfamily').and_return(os[:name])
+      allow(Puppet::Util).to receive(:which).with('tar').and_return('/usr/bin/tar')
+      allow(Puppet::Util::Platform).to receive(:windows?).and_return(os[:win])
+      allow(Puppet).to receive(:features).and_return(double(:minitar? => true, :zlib? => true))
 
       expect(described_class.instance).to be_a_kind_of Puppet::ModuleTool::Tar::Mini
     end
   end
 
   it "falls back to tar when minitar not present and not on Windows" do
-    Facter.stubs(:value).with('osfamily').returns 'ObscureLinuxDistro'
-    Puppet::Util.stubs(:which).with('tar').returns '/usr/bin/tar'
-    Puppet::Util::Platform.stubs(:windows?).returns false
-    Puppet.stubs(:features).returns(stub(:minitar? => false))
+    allow(Facter).to receive(:value).with('osfamily').and_return('ObscureLinuxDistro')
+    allow(Puppet::Util).to receive(:which).with('tar').and_return('/usr/bin/tar')
+    allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+    allow(Puppet).to receive(:features).and_return(double(:minitar? => false))
 
     expect(described_class.instance).to be_a_kind_of Puppet::ModuleTool::Tar::Gnu
   end
 
   it "fails when there is no possible implementation" do
-    Facter.stubs(:value).with('osfamily').returns 'Windows'
-    Puppet::Util.stubs(:which).with('tar')
-    Puppet::Util::Platform.stubs(:windows?).returns true
-    Puppet.stubs(:features).returns(stub(:minitar? => false, :zlib? => false))
+    allow(Facter).to receive(:value).with('osfamily').and_return('Windows')
+    allow(Puppet::Util).to receive(:which).with('tar')
+    allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
+    allow(Puppet).to receive(:features).and_return(double(:minitar? => false, :zlib? => false))
 
     expect { described_class.instance }.to raise_error RuntimeError, /No suitable tar/
   end

data/spec/unit/module_tool_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 # encoding: UTF-8
 
 require 'spec_helper'
@@ -7,15 +6,13 @@ require 'puppet/module_tool'
 describe Puppet::ModuleTool do
   describe '.is_module_root?' do
     it 'should return true if directory has a metadata.json file' do
-      FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/metadata.json')).
-        returns(true)
+      expect(FileTest).to receive(:file?).with(have_attributes(to_s: '/a/b/c/metadata.json')).and_return(true)
 
       expect(subject.is_module_root?(Pathname.new('/a/b/c'))).to be_truthy
     end
 
     it 'should return false if directory does not have a metadata.json file' do
-      FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/metadata.json')).
-        returns(false)
+      expect(FileTest).to receive(:file?).with(have_attributes(to_s: '/a/b/c/metadata.json')).and_return(false)
 
       expect(subject.is_module_root?(Pathname.new('/a/b/c'))).to be_falsey
     end
@@ -25,23 +22,21 @@ describe Puppet::ModuleTool do
     let(:sample_path) { Pathname.new('/a/b/c').expand_path }
 
     it 'should return the first path as a pathname when it contains a module file' do
-      Puppet::ModuleTool.expects(:is_module_root?).with(sample_path).
-        returns(true)
+      expect(Puppet::ModuleTool).to receive(:is_module_root?).with(sample_path).
+        and_return(true)
 
       expect(subject.find_module_root(sample_path)).to eq(sample_path)
     end
 
     it 'should return a parent path as a pathname when it contains a module file' do
-      Puppet::ModuleTool.expects(:is_module_root?).
-        with(responds_with(:to_s, File.expand_path('/a/b/c'))).returns(false)
-      Puppet::ModuleTool.expects(:is_module_root?).
-        with(responds_with(:to_s, File.expand_path('/a/b'))).returns(true)
+      expect(Puppet::ModuleTool).to receive(:is_module_root?).with(have_attributes(to_s: File.expand_path('/a/b/c'))).and_return(false)
+      expect(Puppet::ModuleTool).to receive(:is_module_root?).with(have_attributes(to_s: File.expand_path('/a/b'))).and_return(true)
 
       expect(subject.find_module_root(sample_path)).to eq(Pathname.new('/a/b').expand_path)
     end
 
     it 'should return nil when no module root can be found' do
-      Puppet::ModuleTool.expects(:is_module_root?).at_least_once.returns(false)
+      expect(Puppet::ModuleTool).to receive(:is_module_root?).at_least(:once).and_return(false)
       expect(subject.find_module_root(sample_path)).to be_nil
     end
   end