puppet 5.3.4 → 6.29.0

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

@@ -5,7 +5,7 @@ require 'puppet_spec/module_tool/stub_source'
 
 require 'tmpdir'
 
-describe Puppet::ModuleTool::Applications::Installer do
+describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM == 'java' do
   include PuppetSpec::ModuleTool::SharedFunctions
   include PuppetSpec::Files
   include PuppetSpec::Fixtures
@@ -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?
+  if Puppet::Util::Platform.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
 
@@ -67,6 +66,18 @@ describe Puppet::ModuleTool::Applications::Installer do
       graph_should_include 'pmtacceptance-stdlib', nil => v('4.1.0')
     end
 
+    it 'reports a meaningful error if the name is invalid' do
+      app = installer('ntp', install_dir, options)
+      results = app.run
+      expect(results).to include :result => :failure
+      expect(results[:error][:oneline]).to eq("Could not install 'ntp', did you mean 'puppetlabs-ntp'?")
+      expect(results[:error][:multiline]).to eq(<<~END.chomp)
+        Could not install module 'ntp'
+          The name 'ntp' is invalid
+            Did you mean `puppet module install puppetlabs-ntp`?
+      END
+    end
+
     context 'with a tarball file' do
       let(:module) { fixtures('stdlib.tgz') }
 
@@ -81,7 +92,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 +113,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
@@ -248,6 +259,21 @@ describe Puppet::ModuleTool::Applications::Installer do
           expect(subject).to include :result => :success
           graph_should_include 'pmtacceptance-mysql', nil => v('0.8.0')
         end
+
+        context 'with an already installed dependency' do
+          before { preinstall('pmtacceptance-stdlib', '2.6.0') }
+
+          def options
+            super.merge(:version => '0.7.0')
+          end
+
+          it 'installs given version without errors and does not change version of dependency' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-mysql', nil => v('0.7.0')
+            expect(subject[:error]).to be_nil
+            graph_should_include 'pmtacceptance-stdlib', v('2.6.0') => v('2.6.0')
+          end
+        end
       end
 
       context 'with a --version that cannot satisfy' do
@@ -259,6 +285,47 @@ describe Puppet::ModuleTool::Applications::Installer do
           expect(subject).to include :result => :failure
         end
 
+        context 'with unsatisfiable dependencies' do
+          let(:graph) { double(SemanticPuppet::Dependency::Graph, :modules => ['pmtacceptance-mysql']) }
+          let(:exception) { SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph, constraint) }
+
+          before do
+            allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(exception)
+          end
+
+          context 'with known constraint' do
+            let(:constraint) { 'pmtacceptance-mysql' }
+
+            it 'prints a detailed error containing the modules that would not be satisfied' do
+              expect(subject[:error]).to include(:multiline)
+              expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+              expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
+              expect(subject[:error][:multiline]).to include("pmtacceptance-keystone, expects 'pmtacceptance-mysql': >=0.6.1 <1.0.0")
+              expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+            end
+          end
+
+          context 'with missing constraint' do
+            let(:constraint) { nil }
+
+            it 'prints the generic error message' do
+              expect(subject[:error]).to include(:multiline)
+              expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+              expect(subject[:error][:multiline]).to include("The requested version cannot satisfy all dependencies")
+            end
+          end
+
+          context 'with unknown constraint' do
+            let(:constraint) { 'another' }
+
+            it 'prints the generic error message' do
+              expect(subject[:error]).to include(:multiline)
+              expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (> 1.0.0)")
+              expect(subject[:error][:multiline]).to include("The requested version cannot satisfy all dependencies")
+            end
+          end
+        end
+
         context 'with --ignore-dependencies' do
           def options
             super.merge(:ignore_dependencies => true)
@@ -279,6 +346,43 @@ describe Puppet::ModuleTool::Applications::Installer do
             graph_should_include 'pmtacceptance-mysql', nil => v('2.1.0')
           end
         end
+
+        context 'with an already installed dependency' do
+          let(:graph) {
+            double(SemanticPuppet::Dependency::Graph,
+              :dependencies => {
+                'pmtacceptance-mysql' => {
+                  :version => '2.1.0'
+                }
+              },
+              :modules => ['pmtacceptance-mysql'],
+              :unsatisfied => 'pmtacceptance-stdlib'
+            )
+          }
+
+          let(:unsatisfiable_graph_exception) { SemanticPuppet::Dependency::UnsatisfiableGraph.new(graph) }
+
+          before do
+            allow(SemanticPuppet::Dependency).to receive(:resolve).and_raise(unsatisfiable_graph_exception)
+            allow(unsatisfiable_graph_exception).to receive(:respond_to?).and_return(true)
+            allow(unsatisfiable_graph_exception).to receive(:unsatisfied).and_return(graph.unsatisfied)
+
+            preinstall('pmtacceptance-stdlib', '2.6.0')
+          end
+
+          def options
+            super.merge(:version => '2.1.0')
+          end
+
+          it 'fails to install and outputs a multiline error containing the versions, expectations and workaround' do
+            expect(subject).to include :result => :failure
+            expect(subject[:error]).to include(:multiline)
+            expect(subject[:error][:multiline]).to include("Could not install module 'pmtacceptance-mysql' (v2.1.0)")
+            expect(subject[:error][:multiline]).to include("The requested version cannot satisfy one or more of the following installed modules:")
+            expect(subject[:error][:multiline]).to include("pmtacceptance-stdlib, installed: 2.6.0, expected: >= 2.2.1")
+            expect(subject[:error][:multiline]).to include("Use `puppet module install 'pmtacceptance-mysql' --ignore-dependencies` to install only this module")
+          end
+        end
       end
     end
 
@@ -367,5 +471,4 @@ describe Puppet::ModuleTool::Applications::Installer do
       end
     end
   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

@@ -58,6 +58,12 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
       subject[:affected_modules].length == 1
     end
 
+    it 'should refuse to uninstall in FIPS mode' do
+      allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
+      err = subject[:error][:oneline]
+      expect(err).to eq("Either the `--ignore_changes` or `--force` argument must be specified to uninstall modules when running in FIPS mode.")
+    end
+
     context 'in two modulepaths' do
       before { preinstall('pmtacceptance-stdlib', '2.0.0', :into => secondary_dir) }
 
@@ -126,6 +132,11 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
         it 'overwrites the installed module with the greatest version matching that range' do
           expect(subject).to include :result => :success
         end
+
+        it 'uninstalls in FIPS mode' do
+          allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
+          expect(subject).to include :result => :success
+        end
       end
 
       context 'without local changes' do
@@ -150,6 +161,11 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
           expect(subject[:affected_modules].length).to eq(1)
           expect(subject[:affected_modules].first.forge_name).to eq("pmtacceptance/stdlib")
         end
+
+        it 'uninstalls in FIPS mode' do
+          allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
+          expect(subject).to include :result => :success
+        end
       end
 
       context "while depended upon" do

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

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'json'
+require 'puppet/util/json'
 
 require 'puppet/module_tool/applications'
 require 'puppet/file_system'
@@ -14,51 +14,51 @@ 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 JSON.generate('name' => module_name, 'version' => '1.0.0')
+        file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
       end
       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 JSON.generate('name' => module_name, 'version' => '1.0.0')
+        file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
       end
       FileUtils.touch(File.join(dest, 'extractedmodule/tempfile'))
       Puppet::FileSystem.symlink(File.join(dest, 'extractedmodule/tempfile'), File.join(dest, 'extractedmodule/tempfile2'))
       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 JSON.generate('name' => module_name, 'version' => '1.0.0')
+        file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
       end
       FileUtils.mkdir(File.join(dest, 'extractedmodule/manifests'))
       FileUtils.touch(File.join(dest, 'extractedmodule/manifests/tempfile'))
@@ -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?
+  if Puppet::Util::Platform.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,5 +326,12 @@ describe Puppet::ModuleTool::Applications::Upgrader do
         end
       end
     end
+
+    context 'when in FIPS mode...' do
+      it 'module unpgrader refuses to run' do
+        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
   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,53 @@ 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], :fsync => false).
+        and_yield(type, name, {:entry => entry})
     entry
   end
+
+  describe "Extracts tars with long and short pathnames" do
+    let (:sourcetar) { fixtures('module.tar.gz') }
+    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
+    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
+
+    it "unpacks a tar with a short path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
+    end
+
+    it "unpacks a tar with a long path length" do
+      extractdir = PuppetSpec::Files.tmpdir('minitar')
+
+      minitar.unpack(sourcetar,extractdir,'module')
+      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
+    end
+  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