puppet 6.0.10 → 6.1.0

data/spec/unit/ssl/key_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/ssl/key'
@@ -47,36 +48,36 @@ describe Puppet::SSL::Key do
 
     it "should be able to read keys from disk" do
       path = "/my/path"
-      expect(Puppet::FileSystem).to receive(:read).with(path, :encoding => Encoding::ASCII).and_return("my key")
-      key = double('key')
-      expect(OpenSSL::PKey::RSA).to receive(:new).and_return(key)
+      Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding::ASCII).returns("my key")
+      key = mock 'key'
+      OpenSSL::PKey::RSA.expects(:new).returns(key)
       expect(@key.read(path)).to equal(key)
       expect(@key.content).to equal(key)
     end
 
     it "should not try to use the provided password file if the file does not exist" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
+      Puppet::FileSystem.stubs(:exist?).returns false
       @key.password_file = "/path/to/password"
 
       path = "/my/path"
 
-      allow(Puppet::FileSystem).to receive(:read).with(path, :encoding => Encoding::ASCII).and_return("my key")
-      expect(OpenSSL::PKey::RSA).to receive(:new).with("my key", nil).and_return(double('key'))
-      expect(Puppet::FileSystem).not_to receive(:read).with("/path/to/password", :encoding => Encoding::BINARY)
+      Puppet::FileSystem.stubs(:read).with(path, :encoding => Encoding::ASCII).returns("my key")
+      OpenSSL::PKey::RSA.expects(:new).with("my key", nil).returns(mock('key'))
+      Puppet::FileSystem.expects(:read).with("/path/to/password", :encoding => Encoding::BINARY).never
 
       @key.read(path)
     end
 
     it "should read the key with the password retrieved from the password file if one is provided" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
       @key.password_file = "/path/to/password"
 
       path = "/my/path"
-      expect(Puppet::FileSystem).to receive(:read).with(path, :encoding => Encoding::ASCII).and_return("my key")
-      expect(Puppet::FileSystem).to receive(:read).with("/path/to/password", :encoding => Encoding::BINARY).and_return("my password")
+      Puppet::FileSystem.expects(:read).with(path, :encoding => Encoding::ASCII).returns("my key")
+      Puppet::FileSystem.expects(:read).with("/path/to/password", :encoding => Encoding::BINARY).returns("my password")
 
-      key = double('key')
-      expect(OpenSSL::PKey::RSA).to receive(:new).with("my key", "my password").and_return(key)
+      key = mock 'key'
+      OpenSSL::PKey::RSA.expects(:new).with("my key", "my password").returns(key)
       expect(@key.read(path)).to equal(key)
       expect(@key.content).to equal(key)
     end
@@ -86,14 +87,14 @@ describe Puppet::SSL::Key do
     end
 
     it "should convert the key to pem format when converted to a string" do
-      key = double('key', :to_pem => "pem")
+      key = mock 'key', :to_pem => "pem"
       @key.content = key
       expect(@key.to_s).to eq("pem")
     end
 
     it "should have a :to_text method that it delegates to the actual key" do
-      real_key = double('key')
-      expect(real_key).to receive(:to_text).and_return("keytext")
+      real_key = mock 'key'
+      real_key.expects(:to_text).returns "keytext"
       @key.content = real_key
       expect(@key.to_text).to eq("keytext")
     end
@@ -103,43 +104,43 @@ describe Puppet::SSL::Key do
     before do
       @instance = @class.new("test")
 
-      @key = double('key')
+      @key = mock 'key'
     end
 
     it "should create an instance of OpenSSL::PKey::RSA" do
-      expect(OpenSSL::PKey::RSA).to receive(:new).and_return(@key)
+      OpenSSL::PKey::RSA.expects(:new).returns(@key)
 
       @instance.generate
     end
 
     it "should create the private key with the keylength specified in the settings" do
       Puppet[:keylength] = 513
-      expect(OpenSSL::PKey::RSA).to receive(:new).with(513).and_return(@key)
+      OpenSSL::PKey::RSA.expects(:new).with(513).returns(@key)
 
       @instance.generate
     end
 
     it "should set the content to the generated key" do
-      allow(OpenSSL::PKey::RSA).to receive(:new).and_return(@key)
+      OpenSSL::PKey::RSA.stubs(:new).returns(@key)
       @instance.generate
       expect(@instance.content).to equal(@key)
     end
 
     it "should return the generated key" do
-      allow(OpenSSL::PKey::RSA).to receive(:new).and_return(@key)
+      OpenSSL::PKey::RSA.stubs(:new).returns(@key)
       expect(@instance.generate).to equal(@key)
     end
 
     it "should return the key in pem format" do
       @instance.generate
-      expect(@instance.content).to receive(:to_pem).and_return("my normal key")
+      @instance.content.expects(:to_pem).returns "my normal key"
       expect(@instance.to_s).to eq("my normal key")
     end
 
     describe "with a password file set" do
       it "should return a nil password if the password file does not exist" do
-        expect(Puppet::FileSystem).to receive(:exist?).with("/path/to/pass").and_return(false)
-        expect(Puppet::FileSystem).not_to receive(:read).with("/path/to/pass", :encoding => Encoding::BINARY)
+        Puppet::FileSystem.expects(:exist?).with("/path/to/pass").returns false
+        Puppet::FileSystem.expects(:read).with("/path/to/pass", :encoding => Encoding::BINARY).never
 
         @instance.password_file = "/path/to/pass"
 
@@ -147,8 +148,8 @@ describe Puppet::SSL::Key do
       end
 
       it "should return the contents of the password file as its password" do
-        expect(Puppet::FileSystem).to receive(:exist?).with("/path/to/pass").and_return(true)
-        expect(Puppet::FileSystem).to receive(:read).with("/path/to/pass", :encoding => Encoding::BINARY).and_return("my password")
+        Puppet::FileSystem.expects(:exist?).with("/path/to/pass").returns true
+        Puppet::FileSystem.expects(:read).with("/path/to/pass", :encoding => Encoding::BINARY).returns "my password"
 
         @instance.password_file = "/path/to/pass"
 
@@ -157,14 +158,14 @@ describe Puppet::SSL::Key do
 
       it "should export the private key to text using the password" do
         @instance.password_file = "/path/to/pass"
-        allow(@instance).to receive(:password).and_return("my password")
+        @instance.stubs(:password).returns "my password"
 
-        expect(OpenSSL::PKey::RSA).to receive(:new).and_return(@key)
+        OpenSSL::PKey::RSA.expects(:new).returns(@key)
         @instance.generate
 
-        cipher = double('cipher')
-        expect(OpenSSL::Cipher::DES).to receive(:new).with(:EDE3, :CBC).and_return(cipher)
-        expect(@key).to receive(:export).with(cipher, "my password").and_return("my encrypted key")
+        cipher = mock 'cipher'
+        OpenSSL::Cipher::DES.expects(:new).with(:EDE3, :CBC).returns cipher
+        @key.expects(:export).with(cipher, "my password").returns "my encrypted key"
 
         expect(@instance.to_s).to eq("my encrypted key")
       end

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
-    double('OpenSSL::X509::StoreContext')
+    mock('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
-    double('ssl_host',
-           :ssl_store => nil,
-           :certificate => double('cert', :content => nil),
-           :key => double('key', :content => nil))
+    stub('ssl_host',
+         :ssl_store => nil,
+         :certificate => stub('cert', :content => nil),
+         :key => stub('key', :content => nil))
   end
 
   subject do
@@ -28,13 +28,13 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
   end
 
   before :each do
-    allow(subject).to receive(:read_file).and_return(@pki[:root_cert].to_s)
+    subject.stubs(:read_file).returns(@pki[:root_cert].to_s)
   end
 
   describe '#call' do
     before :each do
-      allow(ssl_context).to receive(:current_cert).and_return(*cert_chain_in_callback_order)
-      allow(ssl_context).to receive(:chain).and_return(cert_chain)
+      ssl_context.stubs(:current_cert).returns(*cert_chain_in_callback_order)
+      ssl_context.stubs(:chain).returns(cert_chain)
     end
 
     context 'When pre-verification is not OK' do
@@ -43,31 +43,31 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
         let(:code) { OpenSSL::X509::V_ERR_INVALID_CA }
 
         it 'rejects the connection' do
-          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
-          allow(ssl_context).to receive(:error).and_return(code)
+          ssl_context.stubs(:error_string).returns("Something went wrong")
+          ssl_context.stubs(:error).returns(code)
 
           expect(subject.call(false, ssl_context)).to eq(false)
         end
 
         it 'makes the error available via #verify_errors' do
-          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
-          allow(ssl_context).to receive(:error).and_return(code)
+          ssl_context.stubs(:error_string).returns("Something went wrong")
+          ssl_context.stubs(:error).returns(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
-          allow(ssl_context).to receive(:error_string).and_return(nil)
-          allow(ssl_context).to receive(:error).and_return(code)
+          ssl_context.stubs(:error_string).returns(nil)
+          ssl_context.stubs(:error).returns(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
-          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
-          allow(ssl_context).to receive(:error).and_return(nil)
+          ssl_context.stubs(:error_string).returns("Something went wrong")
+          ssl_context.stubs(:error).returns(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
-            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)
+            ssl_context.stubs(:error_string).returns("CRL is not yet valid")
+            ssl_context.stubs(:error).returns(OpenSSL::X509::V_ERR_CRL_NOT_YET_VALID)
           end
 
           it 'rejects nil CRL' do
-            allow(ssl_context).to receive(:current_crl).and_return(nil)
+            ssl_context.stubs(:current_crl).returns(nil)
 
             expect(subject.call(false, ssl_context)).to eq(false)
             expect(subject.verify_errors).to eq(["CRL is not yet valid"])
@@ -90,7 +90,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 + 24 * 60 * 60
-            allow(ssl_context).to receive(:current_crl).and_return(crl)
+            ssl_context.stubs(:current_crl).returns(crl)
 
             subject.call(false, ssl_context)
             expect(subject.verify_errors).to eq(["CRL is not yet valid for /CN=Puppet CA: puppetmaster.example.com"])
@@ -100,7 +100,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 + 24 * 60 * 60
-            allow(ssl_context).to receive(:current_crl).and_return(crl)
+            ssl_context.stubs(:current_crl).returns(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
-            allow(ssl_context).to receive(:current_crl).and_return(crl)
+            ssl_context.stubs(:current_crl).returns(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
-          allow(ssl_context).to receive(:error_string).and_return("Something went wrong")
+          ssl_context.stubs(:error_string).returns("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
-          allow(subject).to receive(:read_file).and_return(@pki[:unrevoked_leaf_node_cert])
+          subject.stubs(:read_file).returns(@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
-          expect(ssl_context).to receive(:current_cert).and_raise(StandardError, "BOOM!")
+          ssl_context.expects(:current_cert).raises(StandardError, "BOOM!")
         end
 
         it 'is false' do
@@ -182,27 +182,26 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
 
   describe '#setup_connection' do
     it 'updates the connection for verification' do
-      allow(subject).to receive(:ssl_certificates_are_present?).and_return(true)
-      connection = double('Net::HTTP')
+      subject.stubs(:ssl_certificates_are_present?).returns(true)
+      connection = mock('Net::HTTP')
 
-      allow(connection).to receive(:address).and_return('puppet.com')
-      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)
+      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)
 
       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
-        allow(subject).to receive(:ssl_certificates_are_present?).and_return(false)
-        connection = double('Net::HTTP')
+        subject.stubs(:ssl_certificates_are_present?).returns(false)
+        connection = mock('Net::HTTP')
 
-        allow(connection).to receive(:address).and_return('puppet.com')
-        expect(connection).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+        connection.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
 
         subject.setup_connection(connection, ssl_host)
       end
@@ -216,7 +215,7 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
 
     context 'when the peer presents a valid chain' do
       before :each do
-        allow(subject).to receive(:has_authz_peer_cert).and_return(true)
+        subject.stubs(:has_authz_peer_cert).returns(true)
       end
 
       it 'is true' do
@@ -226,7 +225,7 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
 
     context 'when the peer presents an invalid chain' do
       before :each do
-        allow(subject).to receive(:has_authz_peer_cert).and_return(false)
+        subject.stubs(:has_authz_peer_cert).returns(false)
       end
 
       it 'is false' do

data/spec/unit/task_spec.rb

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