puppet 6.4.0-x64-mingw32 → 6.4.1-x64-mingw32

data/spec/unit/ssl/validator_spec.rb

@@ -5,7 +5,7 @@ require 'puppet_spec/ssl'
 describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platform.jruby? do
   include PuppetSpec::Files
   let(:ssl_context) do
-    mock('OpenSSL::X509::StoreContext')
+    double('OpenSSL::X509::StoreContext')
   end
 
   before(:all) do
@@ -17,10 +17,10 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
   end
 
   let(:ssl_host) do
-    stub('ssl_host',
-         :ssl_store => nil,
-         :certificate => stub('cert', :content => nil),
-         :key => stub('key', :content => nil))
+    double('ssl_host',
+           :ssl_store => nil,
+           :certificate => double('cert', :content => nil),
+           :key => double('key', :content => nil))
   end
 
   subject do
@@ -28,46 +28,46 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
   end
 
   before :each do
-    subject.stubs(:read_file).returns(@pki[:root_cert].to_s)
+    allow(subject).to receive(:read_file).and_return(@pki[:root_cert].to_s)
   end
 
   describe '#call' do
     before :each do
-      ssl_context.stubs(:current_cert).returns(*cert_chain_in_callback_order)
-      ssl_context.stubs(:chain).returns(cert_chain)
+      allow(ssl_context).to receive(:current_cert).and_return(*cert_chain_in_callback_order)
+      allow(ssl_context).to receive(:chain).and_return(cert_chain)
     end
 
     context 'When pre-verification is not OK' do
       context 'and the ssl_context is in an error state' do
-        let(:root_subject) { @pki[:root_cert].subject.to_s }
+        let(:root_subject) { @pki[:root_cert].subject.to_utf8 }
         let(:code) { OpenSSL::X509::V_ERR_INVALID_CA }
 
         it 'rejects the connection' do
-          ssl_context.stubs(:error_string).returns("Something went wrong")
-          ssl_context.stubs(:error).returns(code)
+          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
+          allow(ssl_context).to receive(:error).and_return(code)
 
           expect(subject.call(false, ssl_context)).to eq(false)
         end
 
         it 'makes the error available via #verify_errors' do
-          ssl_context.stubs(:error_string).returns("Something went wrong")
-          ssl_context.stubs(:error).returns(code)
+          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
+          allow(ssl_context).to receive(:error).and_return(code)
 
           subject.call(false, ssl_context)
           expect(subject.verify_errors).to eq(["Something went wrong for #{root_subject}"])
         end
 
         it 'uses a generic message if error_string is nil' do
-          ssl_context.stubs(:error_string).returns(nil)
-          ssl_context.stubs(:error).returns(code)
+          allow(ssl_context).to receive(:error_string).and_return(nil)
+          allow(ssl_context).to receive(:error).and_return(code)
 
           subject.call(false, ssl_context)
           expect(subject.verify_errors).to eq(["OpenSSL error #{code} for #{root_subject}"])
         end
 
         it 'uses 0 for nil error codes' do
-          ssl_context.stubs(:error_string).returns("Something went wrong")
-          ssl_context.stubs(:error).returns(nil)
+          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
+          allow(ssl_context).to receive(:error).and_return(nil)
 
           subject.call(false, ssl_context)
           expect(subject.verify_errors).to eq(["Something went wrong for #{root_subject}"])
@@ -75,12 +75,12 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
 
         context "when CRL is not yet valid" do
           before :each do
-            ssl_context.stubs(:error_string).returns("CRL is not yet valid")
-            ssl_context.stubs(:error).returns(OpenSSL::X509::V_ERR_CRL_NOT_YET_VALID)
+            allow(ssl_context).to receive(:error_string).and_return("CRL is not yet valid")
+            allow(ssl_context).to receive(:error).and_return(OpenSSL::X509::V_ERR_CRL_NOT_YET_VALID)
           end
 
           it 'rejects nil CRL' do
-            ssl_context.stubs(:current_crl).returns(nil)
+            allow(ssl_context).to receive(:current_crl).and_return(nil)
 
             expect(subject.call(false, ssl_context)).to eq(false)
             expect(subject.verify_errors).to eq(["CRL is not yet valid"])
@@ -90,17 +90,17 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
             crl = OpenSSL::X509::CRL.new
             crl.issuer = OpenSSL::X509::Name.new([['CN','Puppet CA: puppetmaster.example.com']])
             crl.last_update = Time.now + 24 * 60 * 60
-            ssl_context.stubs(:current_crl).returns(crl)
+            allow(ssl_context).to receive(:current_crl).and_return(crl)
 
             subject.call(false, ssl_context)
-            expect(subject.verify_errors).to eq(["CRL is not yet valid for /CN=Puppet CA: puppetmaster.example.com"])
+            expect(subject.verify_errors).to eq(["CRL is not yet valid for CN=Puppet CA: puppetmaster.example.com"])
           end
 
           it 'rejects CRLs whose last_update time is more than 5 minutes in the future' do
             crl = OpenSSL::X509::CRL.new
             crl.issuer = OpenSSL::X509::Name.new([['CN','Puppet CA: puppetmaster.example.com']])
             crl.last_update = Time.now + 24 * 60 * 60
-            ssl_context.stubs(:current_crl).returns(crl)
+            allow(ssl_context).to receive(:current_crl).and_return(crl)
 
             expect(subject.call(false, ssl_context)).to eq(false)
           end
@@ -109,7 +109,7 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
             crl = OpenSSL::X509::CRL.new
             crl.issuer = OpenSSL::X509::Name.new([['CN','Puppet CA: puppetmaster.example.com']])
             crl.last_update = Time.now + 10
-            ssl_context.stubs(:current_crl).returns(crl)
+            allow(ssl_context).to receive(:current_crl).and_return(crl)
 
             expect(subject.call(false, ssl_context)).to eq(true)
           end
@@ -120,7 +120,7 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
     context 'When pre-verification is OK' do
       context 'and the ssl_context is in an error state' do
         before :each do
-          ssl_context.stubs(:error_string).returns("Something went wrong")
+          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
         end
 
         it 'does not make the error available via #verify_errors' do
@@ -146,7 +146,7 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
 
       context 'and the chain is invalid' do
         before :each do
-          subject.stubs(:read_file).returns(@pki[:unrevoked_leaf_node_cert])
+          allow(subject).to receive(:read_file).and_return(@pki[:unrevoked_leaf_node_cert])
         end
 
         it 'is true for each CA certificate in the chain' do
@@ -165,7 +165,7 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
 
       context 'an error is raised inside of #call' do
         before :each do
-          ssl_context.expects(:current_cert).raises(StandardError, "BOOM!")
+          expect(ssl_context).to receive(:current_cert).and_raise(StandardError, "BOOM!")
         end
 
         it 'is false' do
@@ -182,26 +182,25 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
 
   describe '#setup_connection' do
     it 'updates the connection for verification' do
-      subject.stubs(:ssl_certificates_are_present?).returns(true)
-      connection = mock('Net::HTTP')
+      allow(subject).to receive(:ssl_certificates_are_present?).and_return(true)
+      connection = double('Net::HTTP')
 
-      connection.expects(:cert_store=).with(ssl_host.ssl_store)
-      connection.expects(:ca_file=).with(ca_path)
-      connection.expects(:cert=).with(ssl_host.certificate.content)
-      connection.expects(:key=).with(ssl_host.key.content)
-      connection.expects(:verify_callback=).with(subject)
-      connection.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+      expect(connection).to receive(:cert_store=).with(ssl_host.ssl_store)
+      expect(connection).to receive(:ca_file=).with(ca_path)
+      expect(connection).to receive(:cert=).with(ssl_host.certificate.content)
+      expect(connection).to receive(:key=).with(ssl_host.key.content)
+      expect(connection).to receive(:verify_callback=).with(subject)
+      expect(connection).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
 
       subject.setup_connection(connection, ssl_host)
     end
 
     context 'when no file path is found' do
-
       it 'does not perform verification if certificate files are missing' do
-        subject.stubs(:ssl_certificates_are_present?).returns(false)
-        connection = mock('Net::HTTP')
+        allow(subject).to receive(:ssl_certificates_are_present?).and_return(false)
+        connection = double('Net::HTTP')
 
-        connection.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+        expect(connection).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
 
         subject.setup_connection(connection, ssl_host)
       end
@@ -215,7 +214,7 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
 
     context 'when the peer presents a valid chain' do
       before :each do
-        subject.stubs(:has_authz_peer_cert).returns(true)
+        allow(subject).to receive(:has_authz_peer_cert).and_return(true)
       end
 
       it 'is true' do
@@ -225,7 +224,7 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
 
     context 'when the peer presents an invalid chain' do
       before :each do
-        subject.stubs(:has_authz_peer_cert).returns(false)
+        allow(subject).to receive(:has_authz_peer_cert).and_return(false)
       end
 
       it 'is false' do
@@ -234,7 +233,9 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
 
       it 'makes a helpful error message available via #verify_errors' do
         subject.valid_peer?
-        expect(subject.verify_errors).to eq([expected_authz_error_msg])
+        expect(subject.verify_errors).to eq([<<END.chomp])
+The server presented a SSL certificate chain which does not include a CA listed in the ssl_client_ca_auth file.  Authorized Issuers: CN=root-ca-𠜎  Peer Chain: CN=unrevoked-int-node => CN=unrevoked-int-caۿᚠ𠜎 => CN=root-ca-𠜎
+END
       end
     end
   end
@@ -272,16 +273,4 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
   def cert_chain_in_callback_order
     cert_chain.reverse
   end
-
-  let :authz_error_prefix do
-    "The server presented a SSL certificate chain which does not include a CA listed in the ssl_client_ca_auth file.  "
-  end
-
-  let :expected_authz_error_msg do
-    authz_ca_certs = subject.decode_cert_bundle(subject.read_file)
-    msg = authz_error_prefix
-    msg << "Authorized Issuers: #{authz_ca_certs.collect {|c| c.subject}.join(', ')}  "
-    msg << "Peer Chain: #{cert_chain.collect {|c| c.subject}.join(' => ')}"
-    msg
-  end
 end

data/spec/unit/ssl/verifier_spec.rb

@@ -40,7 +40,7 @@ describe Puppet::SSL::Verifier do
 
   context '#setup_connection' do
     it 'copies parameters from the ssl_context to the connection' do
-      store = stub('store')
+      store = double('store')
       options.merge!(store: store)
       verifier.setup_connection(http)
 
@@ -48,7 +48,7 @@ describe Puppet::SSL::Verifier do
     end
 
     it 'defaults to VERIFY_PEER' do
-      http.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+      expect(http).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
 
       verifier.setup_connection(http)
     end
@@ -56,7 +56,7 @@ describe Puppet::SSL::Verifier do
     it 'only uses VERIFY_NONE if explicitly disabled' do
       options.merge!(verify_peer: false)
 
-      http.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+      expect(http).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
 
       verifier.setup_connection(http)
     end
@@ -74,27 +74,27 @@ describe Puppet::SSL::Verifier do
     let(:ssl_error) { OpenSSL::SSL::SSLError.new("certificate verify failed") }
 
     it "raises a verification error for a CA cert" do
-      store_context = stub('store_context', current_cert: peer_cert, chain: [peer_cert], error: OpenSSL::X509::V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, error_string: "unable to get local issuer certificate")
+      store_context = double('store_context', current_cert: peer_cert, chain: [peer_cert], error: OpenSSL::X509::V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, error_string: "unable to get local issuer certificate")
       verifier.call(false, store_context)
 
       expect {
         verifier.handle_connection_error(http, ssl_error)
-      }.to raise_error(Puppet::SSL::CertVerifyError, "certificate verify failed [unable to get local issuer certificate for /CN=127.0.0.1]")
+      }.to raise_error(Puppet::SSL::CertVerifyError, "certificate verify failed [unable to get local issuer certificate for CN=127.0.0.1]")
     end
 
     it "raises a verification error for the server cert" do
-      store_context = stub('store_context', current_cert: peer_cert, chain: chain, error: OpenSSL::X509::V_ERR_CERT_REJECTED, error_string: "certificate rejected")
+      store_context = double('store_context', current_cert: peer_cert, chain: chain, error: OpenSSL::X509::V_ERR_CERT_REJECTED, error_string: "certificate rejected")
       verifier.call(false, store_context)
 
       expect {
         verifier.handle_connection_error(http, ssl_error)
-      }.to raise_error(Puppet::SSL::CertVerifyError, "certificate verify failed [certificate rejected for /CN=127.0.0.1]")
+      }.to raise_error(Puppet::SSL::CertVerifyError, "certificate verify failed [certificate rejected for CN=127.0.0.1]")
     end
 
     it "raises cert mismatch error on ruby < 2.4" do
-      http.expects(:peer_cert).returns(peer_cert)
+      expect(http).to receive(:peer_cert).and_return(peer_cert)
 
-      store_context = stub('store_context')
+      store_context = double('store_context')
       verifier.call(true, store_context)
 
       ssl_error = OpenSSL::SSL::SSLError.new("hostname 'example'com' does not match the server certificate")
@@ -105,7 +105,7 @@ describe Puppet::SSL::Verifier do
     end
 
     it "raises cert mismatch error on ruby >= 2.4" do
-      store_context = stub('store_context', current_cert: peer_cert, chain: chain, error: OpenSSL::X509::V_OK, error_string: "ok")
+      store_context = double('store_context', current_cert: peer_cert, chain: chain, error: OpenSSL::X509::V_OK, error_string: "ok")
       verifier.call(false, store_context)
 
       expect {

data/spec/unit/task_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_spec/modules'
@@ -24,9 +23,9 @@ describe Puppet::Module::Task do
 
   it "constructs tasks as expected when every task has a metadata file with the same name (besides extension)" do
     task_files = %w{task1.json task1 task2.json task2.exe task3.json task3.sh}.map { |bn| "#{tasks_path}/#{bn}" }
-    Dir.expects(:glob).with(tasks_glob).returns(task_files)
+    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    Puppet::Module::Task.any_instance.stubs(:metadata).returns({})
+    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({})
 
     expect(tasks.count).to eq(3)
     expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1 mymod::task2 mymod::task3})
@@ -52,8 +51,8 @@ describe Puppet::Module::Task do
 
   it "constructs tasks as expected when some tasks don't have a metadata file" do
     task_files = %w{task1 task2.exe task3.json task3.sh}.map { |bn| "#{tasks_path}/#{bn}" }
-    Dir.expects(:glob).with(tasks_glob).returns(task_files)
-    Puppet::Module::Task.any_instance.stubs(:metadata).returns({})
+    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
+    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({})
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
     expect(tasks.count).to eq(3)
@@ -66,9 +65,9 @@ describe Puppet::Module::Task do
 
   it "constructs a task as expected when a task has implementations" do
     task_files = %w{task1.elf task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    Dir.expects(:glob).with(tasks_glob).returns(task_files)
+    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [{"name" => "task1.sh"}]})
+    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'implementations' => [{"name" => "task1.sh"}]})
 
     expect(tasks.count).to eq(1)
     expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
@@ -78,10 +77,10 @@ describe Puppet::Module::Task do
 
   it "constructs a task as expected when task metadata declares additional files" do
     task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    Dir.expects(:glob).with(tasks_glob).returns(task_files)
-    Puppet::Module::Task.expects(:find_extra_files).returns([{'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"}])
+    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
+    expect(Puppet::Module::Task).to receive(:find_extra_files).and_return([{'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"}])
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'files' => ["mymod/lib/file0.elf"]})
+    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'files' => ["mymod/lib/file0.elf"]})
 
     expect(tasks.count).to eq(1)
     expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
@@ -91,10 +90,10 @@ describe Puppet::Module::Task do
 
   it "constructs a task as expected when a task implementation declares additional files" do
     task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    Dir.expects(:glob).with(tasks_glob).returns(task_files)
-    Puppet::Module::Task.expects(:find_extra_files).returns([{'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"}])
+    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
+    expect(Puppet::Module::Task).to receive(:find_extra_files).and_return([{'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"}])
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [{"name" => "task1.sh", "files" => ["mymod/lib/file0.elf"]}]})
+    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'implementations' => [{"name" => "task1.sh", "files" => ["mymod/lib/file0.elf"]}]})
 
     expect(tasks.count).to eq(1)
     expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
@@ -104,13 +103,13 @@ describe Puppet::Module::Task do
 
   it "constructs a task as expected when task metadata and a task implementation both declare additional files" do
     task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    Dir.expects(:glob).with(tasks_glob).returns(task_files)
-    Puppet::Module::Task.expects(:find_extra_files).returns([
+    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
+    expect(Puppet::Module::Task).to receive(:find_extra_files).and_return([
       {'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"},
       {'name' => 'yourmod/files/file1.txt', 'path' => "/other/path/to/file1.txt"}
     ])
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [{"name" => "task1.sh", "files" => ["mymod/lib/file0.elf"]}]})
+    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'implementations' => [{"name" => "task1.sh", "files" => ["mymod/lib/file0.elf"]}]})
 
     expect(tasks.count).to eq(1)
     expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
@@ -124,14 +123,14 @@ describe Puppet::Module::Task do
 
   it "constructs a task as expected when a task has files" do
     og_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    Dir.expects(:glob).with(tasks_glob).returns(og_files)
-    File.expects(:exist?).with(any_parameters).returns(true).at_least(1)
+    expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
+    expect(File).to receive(:exist?).with(any_args).and_return(true).at_least(:once)
 
-    Puppet::Module.expects(:find).with(othermod.name, "production").returns(othermod).at_least(1)
+    expect(Puppet::Module).to receive(:find).with(othermod.name, "production").and_return(othermod).at_least(:once)
     short_files = %w{other_task.sh other_task.json task_2.sh}.map { |bn| "#{othermod.name}/tasks/#{bn}" }
     long_files = %w{other_task.sh other_task.json task_2.sh}.map { |bn| "#{other_tasks_path}/#{bn}" }
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'files' => short_files})
+    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'files' => short_files})
 
     expect(tasks.count).to eq(1)
     expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh"] + long_files])
@@ -139,18 +138,18 @@ describe Puppet::Module::Task do
 
   it "fails to load a task if its metadata specifies a non-existent file" do
     og_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    Dir.stubs(:glob).with(tasks_glob).returns(og_files)
-    File.stubs(:exist?).with(any_parameters).returns(true)
+    allow(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
+    allow(File).to receive(:exist?).with(any_args).and_return(true)
 
-    Puppet::Module.expects(:find).with(othermod.name, "production").returns(nil).at_least(1)
+    expect(Puppet::Module).to receive(:find).with(othermod.name, "production").and_return(nil).at_least(:once)
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'files' => ["#{othermod.name}/files/test"]})
+    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'files' => ["#{othermod.name}/files/test"]})
 
     expect { tasks.first.files }.to raise_error(Puppet::Module::Task::InvalidMetadata, /Could not find module #{othermod.name} containing task file test/)
   end
 
   it "finds files whose names (besides extensions) are valid task names" do
-    Dir.expects(:glob).with(tasks_glob).returns(%w{task task_1 xx_t_a_s_k_2_xx})
+    expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task task_1 xx_t_a_s_k_2_xx})
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
     expect(tasks.count).to eq(3)
@@ -158,7 +157,7 @@ describe Puppet::Module::Task do
   end
 
   it "ignores files that have names (besides extensions) that are not valid task names" do
-    Dir.expects(:glob).with(tasks_glob).returns(%w{.nottask.exe .wat !runme _task 2task2furious def_a_task_PSYCH Fake_task not-a-task realtask})
+    expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{.nottask.exe .wat !runme _task 2task2furious def_a_task_PSYCH Fake_task not-a-task realtask})
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
     expect(tasks.count).to eq(1)
@@ -166,7 +165,7 @@ describe Puppet::Module::Task do
   end
 
   it "ignores files that have names ending in .conf and .md" do
-    Dir.expects(:glob).with(tasks_glob).returns(%w{ginuwine_task task.conf readme.md other_task.md})
+    expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{ginuwine_task task.conf readme.md other_task.md})
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
     expect(tasks.count).to eq(1)
@@ -180,8 +179,8 @@ describe Puppet::Module::Task do
   describe :metadata do
     it "loads metadata for a task" do
       metadata  = {'desciption': 'some info'}
-      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe task1.json})
-      Puppet::Module::Task.stubs(:read_metadata).returns(metadata)
+      expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.exe task1.json})
+      allow(Puppet::Module::Task).to receive(:read_metadata).and_return(metadata)
 
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
@@ -190,7 +189,7 @@ describe Puppet::Module::Task do
     end
 
     it 'returns nil for metadata if no file is present' do
-      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe})
+      expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.exe})
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
       expect(tasks.count).to eq(1)
@@ -213,7 +212,7 @@ describe Puppet::Module::Task do
 
   describe :validate do
     it "validates when there is no metadata" do
-      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe})
+      expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.exe})
 
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
@@ -224,8 +223,8 @@ describe Puppet::Module::Task do
     it "validates when an implementation isn't used" do
       metadata  = {'desciption' => 'some info',
         'implementations' => [ {"name" => "task1.exe"}, ] }
-      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe task1.sh task1.json})
-      Puppet::Module::Task.stubs(:read_metadata).returns(metadata)
+      expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.exe task1.sh task1.json})
+      allow(Puppet::Module::Task).to receive(:read_metadata).and_return(metadata)
 
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
@@ -236,8 +235,8 @@ describe Puppet::Module::Task do
     it "validates when an implementation is another task" do
       metadata  = {'desciption' => 'some info',
                    'implementations' => [ {"name" => "task2.sh"}, ] }
-      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe task2.sh task1.json})
-      Puppet::Module::Task.stubs(:read_metadata).returns(metadata)
+      expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.exe task2.sh task1.json})
+      allow(Puppet::Module::Task).to receive(:read_metadata).and_return(metadata)
 
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
@@ -246,9 +245,9 @@ describe Puppet::Module::Task do
     end
 
     it "fails validation when there is no metadata and multiple task files" do
-      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.elf task1.exe task1.json task2.ps1 task2.sh})
+      expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.elf task1.exe task1.json task2.ps1 task2.sh})
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      Puppet::Module::Task.any_instance.stubs(:metadata).returns({})
+      allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({})
 
       tasks.each do |task|
         expect {task.validate}.to raise_error(Puppet::Module::Task::InvalidTask)
@@ -256,9 +255,9 @@ describe Puppet::Module::Task do
     end
 
     it "fails validation when an implementation references a non-existant file" do
-      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.elf task1.exe task1.json})
+      expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.elf task1.exe task1.json})
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [ { 'name' => 'task1.sh' } ] })
+      allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'implementations' => [ { 'name' => 'task1.sh' } ] })
 
       tasks.each do |task|
         expect {task.validate}.to raise_error(Puppet::Module::Task::InvalidTask)
@@ -266,25 +265,25 @@ describe Puppet::Module::Task do
     end
 
     it 'fails validation when there is metadata but no executable' do
-      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.json task2.sh})
+      expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.json task2.sh})
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      Puppet::Module::Task.any_instance.stubs(:metadata).returns({})
+      allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({})
 
       expect { tasks.find { |t| t.name == 'mymod::task1' }.validate }.to raise_error(Puppet::Module::Task::InvalidTask)
     end
 
     it 'fails validation when the implementations are not an array' do
-      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.json task2.sh})
+      expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.json task2.sh})
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      Puppet::Module::Task.any_instance.stubs(:metadata).returns({"implemenations" => {}})
+      allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({"implemenations" => {}})
 
       expect { tasks.find { |t| t.name == 'mymod::task1' }.validate }.to raise_error(Puppet::Module::Task::InvalidTask)
     end
 
     it 'fails validation when the implementation is json' do
-      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.json task1.sh})
+      expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.json task1.sh})
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [ { 'name' => 'task1.json' } ] })
+      allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'implementations' => [ { 'name' => 'task1.json' } ] })
 
       expect { tasks.find { |t| t.name == 'mymod::task1' }.validate }.to raise_error(Puppet::Module::Task::InvalidTask)
     end