puppet 6.0.10-x86-mingw32 → 6.1.0-x86-mingw32

data/spec/unit/file_serving/mount/tasks_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/mount/tasks'
 
@@ -5,8 +6,8 @@ describe Puppet::FileServing::Mount::Tasks do
   before do
     @mount = Puppet::FileServing::Mount::Tasks.new("tasks")
 
-    @environment = double('environment', :module => nil)
-    @request = double('request', :environment => @environment)
+    @environment = stub 'environment', :module => nil
+    @request = stub 'request', :environment => @environment
   end
 
   describe "when finding task files" do
@@ -16,25 +17,25 @@ describe Puppet::FileServing::Mount::Tasks do
 
     it "should use the request's environment to find the module" do
       mod_name = 'foo'
-      expect(@environment).to receive(:module).with(mod_name)
+      @environment.expects(:module).with(mod_name)
 
       @mount.find(mod_name, @request)
     end
 
     it "should use the first segment of the request's path as the module name" do
-      expect(@environment).to receive(:module).with("foo")
+      @environment.expects(:module).with("foo")
       @mount.find("foo/bartask", @request)
     end
 
     it "should return nil if the module in the path doesn't exist" do
-      expect(@environment).to receive(:module).with("foo").and_return(nil)
+      @environment.expects(:module).with("foo").returns(nil)
       expect(@mount.find("foo/bartask", @request)).to be_nil
     end
 
     it "should return the file path from the module" do
-      mod = double('module')
-      expect(mod).to receive(:task_file).with("bartask").and_return("mocked")
-      expect(@environment).to receive(:module).with("foo").and_return(mod)
+      mod = mock('module')
+      mod.expects(:task_file).with("bartask").returns("mocked")
+      @environment.expects(:module).with("foo").returns(mod)
       expect(@mount.find("foo/bartask", @request)).to eq("mocked")
     end
   end
@@ -46,25 +47,25 @@ describe Puppet::FileServing::Mount::Tasks do
 
     it "should use the request's environment to find the module" do
       mod_name = 'foo'
-      expect(@environment).to receive(:module).with(mod_name)
+      @environment.expects(:module).with(mod_name)
 
       @mount.search(mod_name, @request)
     end
 
     it "should use the first segment of the request's path as the module name" do
-      expect(@environment).to receive(:module).with("foo")
+      @environment.expects(:module).with("foo")
       @mount.search("foo/bartask", @request)
     end
 
     it "should return nil if the module in the path doesn't exist" do
-      expect(@environment).to receive(:module).with("foo").and_return(nil)
+      @environment.expects(:module).with("foo").returns(nil)
       expect(@mount.search("foo/bartask", @request)).to be_nil
     end
 
     it "should return the file path from the module" do
-      mod = double('module')
-      expect(mod).to receive(:task_file).with("bartask").and_return("mocked")
-      expect(@environment).to receive(:module).with("foo").and_return(mod)
+      mod = mock('module')
+      mod.expects(:task_file).with("bartask").returns("mocked")
+      @environment.expects(:module).with("foo").returns(mod)
       expect(@mount.search("foo/bartask", @request)).to eq(["mocked"])
     end
   end

data/spec/unit/file_serving/mount_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/mount'
 

data/spec/unit/file_serving/terminus_helper_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/terminus_helper'
@@ -7,99 +8,103 @@ describe Puppet::FileServing::TerminusHelper do
     @helper = Object.new
     @helper.extend(Puppet::FileServing::TerminusHelper)
 
-    @model = double('model')
-    allow(@helper).to receive(:model).and_return(@model)
+    @model = mock 'model'
+    @helper.stubs(:model).returns(@model)
 
-    @request = double('request', :key => "url", :options => {})
+    @request = stub 'request', :key => "url", :options => {}
 
-    @fileset = double('fileset', :files => [], :path => "/my/file")
-    allow(Puppet::FileServing::Fileset).to receive(:new).with("/my/file", {}).and_return(@fileset)
+    @fileset = stub 'fileset', :files => [], :path => "/my/file"
+    Puppet::FileServing::Fileset.stubs(:new).with("/my/file", {}).returns(@fileset)
   end
 
   it "should find a file with absolute path" do
-    file = double('file', :collect => nil)
-    expect(file).to receive(:collect).with(no_args)
-    expect(@model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(file)
+    file = stub 'file', :collect => nil
+    file.expects(:collect).with(nil)
+    @model.expects(:new).with("/my/file", {:relative_path => nil}).returns(file)
     @helper.path2instance(@request, "/my/file")
   end
 
   it "should pass through links, checksum_type, and source_permissions" do
-    file = double('file', :checksum_type= => nil, :links= => nil, :collect => nil)
+    file = stub 'file', :checksum_type= => nil, :links= => nil, :collect => nil
     [[:checksum_type, :sha256], [:links, true], [:source_permissions, :use]].each {|k, v|
-      expect(file).to receive(k.to_s+'=').with(v)
+      file.expects(k.to_s+'=').with(v)
       @request.options[k] = v
     }
-    expect(file).to receive(:collect)
-    expect(@model).to receive(:new).with("/my/file", {:relative_path => :file}).and_return(file)
+    file.expects(:collect)
+    @model.expects(:new).with("/my/file", {:relative_path => :file}).returns(file)
     @helper.path2instance(@request, "/my/file", {:relative_path => :file})
   end
 
   it "should use a fileset to find paths" do
-    @fileset = double('fileset', :files => [], :path => "/my/files")
-    expect(Puppet::FileServing::Fileset).to receive(:new).with("/my/file", anything).and_return(@fileset)
+    @fileset = stub 'fileset', :files => [], :path => "/my/files"
+    Puppet::FileServing::Fileset.expects(:new).with { |key, options| key == "/my/file" }.returns(@fileset)
     @helper.path2instances(@request, "/my/file")
   end
 
   it "should support finding across multiple paths by merging the filesets" do
-    first = double('fileset', :files => [], :path => "/first/file")
-    expect(Puppet::FileServing::Fileset).to receive(:new).with("/first/file", anything).and_return(first)
-    second = double('fileset', :files => [], :path => "/second/file")
-    expect(Puppet::FileServing::Fileset).to receive(:new).with("/second/file", anything).and_return(second)
+    first = stub 'fileset', :files => [], :path => "/first/file"
+    Puppet::FileServing::Fileset.expects(:new).with { |path, options| path == "/first/file" }.returns(first)
+    second = stub 'fileset', :files => [], :path => "/second/file"
+    Puppet::FileServing::Fileset.expects(:new).with { |path, options| path == "/second/file" }.returns(second)
 
-    expect(Puppet::FileServing::Fileset).to receive(:merge).with(first, second).and_return({})
+    Puppet::FileServing::Fileset.expects(:merge).with(first, second).returns({})
 
     @helper.path2instances(@request, "/first/file", "/second/file")
   end
 
   it "should pass the indirection request to the Fileset at initialization" do
-    expect(Puppet::FileServing::Fileset).to receive(:new).with(anything, @request).and_return(@fileset)
+    Puppet::FileServing::Fileset.expects(:new).with { |path, options| options == @request }.returns @fileset
     @helper.path2instances(@request, "/my/file")
   end
 
   describe "when creating instances" do
     before do
-      allow(@request).to receive(:key).and_return("puppet://host/mount/dir")
+      @request.stubs(:key).returns "puppet://host/mount/dir"
 
-      @one = double('one', :links= => nil, :collect => nil)
-      @two = double('two', :links= => nil, :collect => nil)
+      @one = stub 'one', :links= => nil, :collect => nil
+      @two = stub 'two', :links= => nil, :collect => nil
 
-      @fileset = double('fileset', :files => %w{one two}, :path => "/my/file")
-      allow(Puppet::FileServing::Fileset).to receive(:new).and_return(@fileset)
+      @fileset = stub 'fileset', :files => %w{one two}, :path => "/my/file"
+      Puppet::FileServing::Fileset.stubs(:new).returns(@fileset)
     end
 
     it "should set each returned instance's path to the original path" do
-      expect(@model).to receive(:new).with("/my/file", anything).and_return(@one, @two)
+      @model.expects(:new).with { |key, options| key == "/my/file" }.returns(@one)
+      @model.expects(:new).with { |key, options| key == "/my/file" }.returns(@two)
       @helper.path2instances(@request, "/my/file")
     end
 
     it "should set each returned instance's relative path to the file-specific path" do
-      expect(@model).to receive(:new).with(anything, hash_including(relative_path: "one")).and_return(@one)
-      expect(@model).to receive(:new).with(anything, hash_including(relative_path: "two")).and_return(@two)
+      @model.expects(:new).with { |key, options| options[:relative_path] == "one" }.returns(@one)
+      @model.expects(:new).with { |key, options| options[:relative_path] == "two" }.returns(@two)
       @helper.path2instances(@request, "/my/file")
     end
 
     it "should set the links value on each instance if one is provided" do
-      expect(@one).to receive(:links=).with(:manage)
-      expect(@two).to receive(:links=).with(:manage)
-      expect(@model).to receive(:new).and_return(@one, @two)
+      @one.expects(:links=).with :manage
+      @two.expects(:links=).with :manage
+      @model.expects(:new).returns(@one)
+      @model.expects(:new).returns(@two)
 
       @request.options[:links] = :manage
       @helper.path2instances(@request, "/my/file")
     end
 
     it "should set the request checksum_type if one is provided" do
-      expect(@one).to receive(:checksum_type=).with(:test)
-      expect(@two).to receive(:checksum_type=).with(:test)
-      expect(@model).to receive(:new).and_return(@one, @two)
+      @one.expects(:checksum_type=).with :test
+      @two.expects(:checksum_type=).with :test
+      @model.expects(:new).returns(@one)
+      @model.expects(:new).returns(@two)
 
       @request.options[:checksum_type] = :test
       @helper.path2instances(@request, "/my/file")
     end
 
     it "should collect the instance's attributes" do
-      expect(@one).to receive(:collect)
-      expect(@two).to receive(:collect)
-      expect(@model).to receive(:new).and_return(@one, @two)
+      @one.expects(:collect)
+      @two.expects(:collect)
+      @model.expects(:new).returns(@one)
+      @model.expects(:new).returns(@two)
 
       @helper.path2instances(@request, "/my/file")
     end

data/spec/unit/file_serving/terminus_selector_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/terminus_selector'
@@ -7,56 +8,56 @@ describe Puppet::FileServing::TerminusSelector do
     @object = Object.new
     @object.extend(Puppet::FileServing::TerminusSelector)
 
-    @request = double('request', :key => "mymod/myfile", :options => {:node => "whatever"}, :server => nil, :protocol => nil)
+    @request = stub 'request', :key => "mymod/myfile", :options => {:node => "whatever"}, :server => nil, :protocol => nil
   end
 
   describe "when being used to select termini" do
     it "should return :file if the request key is fully qualified" do
-      expect(@request).to receive(:key).and_return(File.expand_path('/foo'))
+      @request.expects(:key).returns File.expand_path('/foo')
       expect(@object.select(@request)).to eq(:file)
     end
 
     it "should return :file if the URI protocol is set to 'file'" do
-      expect(@request).to receive(:protocol).and_return("file")
+      @request.expects(:protocol).returns "file"
       expect(@object.select(@request)).to eq(:file)
     end
 
     it "should return :http if the URI protocol is set to 'http'" do
-      expect(@request).to receive(:protocol).and_return("http")
+      @request.expects(:protocol).returns "http"
       expect(@object.select(@request)).to eq :http
     end
 
     it "should return :http if the URI protocol is set to 'https'" do
-      expect(@request).to receive(:protocol).and_return("https")
+      @request.expects(:protocol).returns "https"
       expect(@object.select(@request)).to eq :http
     end
 
     it "should fail when a protocol other than :puppet, :http(s) or :file is used" do
-      allow(@request).to receive(:protocol).and_return("ftp")
+      @request.stubs(:protocol).returns "ftp"
       expect { @object.select(@request) }.to raise_error(ArgumentError)
     end
 
     describe "and the protocol is 'puppet'" do
       before do
-        allow(@request).to receive(:protocol).and_return("puppet")
+        @request.stubs(:protocol).returns "puppet"
       end
 
       it "should choose :rest when a server is specified" do
-        allow(@request).to receive(:protocol).and_return("puppet")
-        expect(@request).to receive(:server).and_return("foo")
+        @request.stubs(:protocol).returns "puppet"
+        @request.expects(:server).returns "foo"
         expect(@object.select(@request)).to eq(:rest)
       end
 
       # This is so a given file location works when bootstrapping with no server.
       it "should choose :rest when default_file_terminus is rest" do
-        allow(@request).to receive(:protocol).and_return("puppet")
+        @request.stubs(:protocol).returns "puppet"
         Puppet[:server] = 'localhost'
         expect(@object.select(@request)).to eq(:rest)
       end
 
       it "should choose :file_server when default_file_terminus is file_server and no server is specified on the request" do
-        expect(@request).to receive(:protocol).and_return("puppet")
-        expect(@request).to receive(:server).and_return(nil)
+        @request.expects(:protocol).returns "puppet"
+        @request.expects(:server).returns nil
         Puppet[:default_file_terminus] = 'file_server'
         expect(@object.select(@request)).to eq(:file_server)
       end

data/spec/unit/file_system/uniquefile_spec.rb

@@ -49,8 +49,8 @@ describe Puppet::FileSystem::Uniquefile do
   it "propagates lock creation failures" do
     # use an arbitrary exception so as not accidentally collide
     # with the ENOENT that occurs when trying to call rmdir
-    allow(Puppet::FileSystem::Uniquefile).to receive(:mkdir).and_raise('arbitrary failure')
-    expect(Puppet::FileSystem::Uniquefile).not_to receive(:rmdir)
+    Puppet::FileSystem::Uniquefile.stubs(:mkdir).raises 'arbitrary failure'
+    Puppet::FileSystem::Uniquefile.expects(:rmdir).never
 
     expect {
       Puppet::FileSystem::Uniquefile.open_tmp('foo') { |tmp| }
@@ -59,10 +59,10 @@ describe Puppet::FileSystem::Uniquefile do
 
   it "only removes lock files that exist" do
     # prevent the .lock directory from being created
-    allow(Puppet::FileSystem::Uniquefile).to receive(:mkdir)
+    Puppet::FileSystem::Uniquefile.stubs(:mkdir) { }
 
     # and expect cleanup to be skipped
-    expect(Puppet::FileSystem::Uniquefile).not_to receive(:rmdir)
+    Puppet::FileSystem::Uniquefile.expects(:rmdir).never
 
     Puppet::FileSystem::Uniquefile.open_tmp('foo') { |tmp| }
   end

data/spec/unit/file_system_spec.rb

@@ -333,7 +333,7 @@ describe "Puppet::FileSystem" do
     end
 
     it "should fall back to stat when trying to lstat a file" do
-      expect(Puppet::Util::Windows::File).to receive(:stat).with(Puppet::FileSystem.assert_path(file))
+      Puppet::Util::Windows::File.expects(:stat).with(Puppet::FileSystem.assert_path(file))
 
       Puppet::FileSystem.lstat(file)
     end
@@ -812,7 +812,7 @@ describe "Puppet::FileSystem" do
       describe 'on non-Windows', :unless => Puppet::Util::Platform.windows? do
         it 'should produce the same results as the Ruby File.expand_path' do
           # on Windows this may be 8.3 style, but not so on other platforms
-          # only done since expect(::File).to receive(:expand_path).with(path).at_least(:once)
+          # only done since ::File.expects(:expand_path).with(path).at_least_once
           # cannot be used since it will cause a stack overflow
           path = tmpdir('foobar')
 

data/spec/unit/forge/errors_spec.rb

@@ -41,7 +41,7 @@ Could not connect to http://fake.com:1111
 
   describe 'ResponseError' do
     subject { Puppet::Forge::Errors::ResponseError }
-    let(:response) { double(:body => '{}', :code => '404', :message => "not found") }
+    let(:response) { stub(:body => '{}', :code => '404', :message => "not found") }
 
     context 'without message' do
       let(:exception) { subject.new(:uri => 'http://fake.com:1111', :response => response, :input => 'user/module') }

data/spec/unit/forge/forge_spec.rb

@@ -22,7 +22,7 @@ describe Puppet::Forge do
   let (:mixed_utf8_query_param) { "foo + A\u06FF\u16A0\u{2070E}" } # Aۿᚠ
   let (:mixed_utf8_query_param_encoded) { "foo%20%2B%20A%DB%BF%E1%9A%A0%F0%A0%9C%8E"}
   let (:empty_json) { '{ "results": [], "pagination" : { "next" : null } }' }
-  let (:ok_response) { double('response', :code => '200', :body => empty_json) }
+  let (:ok_response) { stub('response', :code => '200', :body => empty_json) }
 
   describe "making a" do
     before :each do
@@ -30,13 +30,14 @@ describe Puppet::Forge do
     end
 
     context "search request" do
+
       it "includes any defined module_groups, ensuring to only encode them once in the URI" do
         Puppet[:module_groups] = 'base+pe'
 
         # ignores Puppet::Forge::Repository#read_response, provides response to search
         performs_an_http_request(ok_response) do |http|
           encoded_uri = "/v3/modules?query=#{mixed_utf8_query_param_encoded}&module_groups=base%20pe"
-          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
+          http.expects(:request).with(responds_with(:path, encoded_uri))
         end
 
         forge.search(mixed_utf8_query_param)
@@ -46,7 +47,7 @@ describe Puppet::Forge do
         # ignores Puppet::Forge::Repository#read_response, provides response to search
         performs_an_http_request(ok_response) do |http|
           encoded_uri = "/v3/modules?query=#{mixed_utf8_query_param_encoded}"
-          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
+          http.expects(:request).with(responds_with(:path, encoded_uri))
         end
 
         forge.search(mixed_utf8_query_param)
@@ -58,12 +59,11 @@ describe Puppet::Forge do
       it "includes any defined module_groups, ensuring to only encode them once in the URI" do
         Puppet[:module_groups] = 'base+pe'
         module_name = 'puppetlabs-acl'
-        exclusions = "readme%2Cchangelog%2Clicense%2Curi%2Cmodule%2Ctags%2Csupported%2Cfile_size%2Cdownloads%2Ccreated_at%2Cupdated_at%2Cdeleted_at"
 
         # ignores Puppet::Forge::Repository#read_response, provides response to fetch
         performs_an_http_request(ok_response) do |http|
-          encoded_uri = "/v3/releases?module=#{module_name}&sort_by=version&exclude_fields=#{exclusions}&module_groups=base%20pe"
-          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
+          encoded_uri = "/v3/releases?module=#{module_name}&sort_by=version&module_groups=base%20pe"
+          http.expects(:request).with(responds_with(:path, encoded_uri))
         end
 
         forge.fetch(module_name)
@@ -71,12 +71,11 @@ describe Puppet::Forge do
 
       it "single encodes the module name term in the URI" do
         module_name = "puppetlabs-#{mixed_utf8_query_param}"
-        exclusions = "readme%2Cchangelog%2Clicense%2Curi%2Cmodule%2Ctags%2Csupported%2Cfile_size%2Cdownloads%2Ccreated_at%2Cupdated_at%2Cdeleted_at"
 
         # ignores Puppet::Forge::Repository#read_response, provides response to fetch
         performs_an_http_request(ok_response) do |http|
-          encoded_uri = "/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}&sort_by=version&exclude_fields=#{exclusions}"
-          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
+          encoded_uri = "/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}&sort_by=version"
+          http.expects(:request).with(responds_with(:path, encoded_uri))
         end
 
         forge.fetch(module_name)
@@ -95,17 +94,17 @@ describe Puppet::Forge do
   end
 
   def mock_proxy(port, proxy_args, result, &block)
-    http = double("http client")
-    proxy = double("http proxy")
-    proxy_class = double("http proxy class")
+    http = mock("http client")
+    proxy = mock("http proxy")
+    proxy_class = mock("http proxy class")
 
-    expect(Net::HTTP).to receive(:Proxy).with(*proxy_args).and_return(proxy_class)
-    expect(proxy_class).to receive(:new).with(host, port).and_return(proxy)
+    Net::HTTP.expects(:Proxy).with(*proxy_args).returns(proxy_class)
+    proxy_class.expects(:new).with(host, port).returns(proxy)
 
-    expect(proxy).to receive(:open_timeout=)
-    expect(proxy).to receive(:read_timeout=)
+    proxy.expects(:open_timeout=)
+    proxy.expects(:read_timeout=)
 
-    expect(proxy).to receive(:start).and_yield(http).and_return(result)
+    proxy.expects(:start).yields(http).returns(result)
     yield http
 
     proxy

data/spec/unit/forge/module_release_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Forge::ModuleRelease do
 
   let(:mock_file) {
     mock_io = StringIO.new
-    allow(mock_io).to receive(:path).and_return('/dev/null')
+    mock_io.stubs(:path).returns('/dev/null')
     mock_io
   }
 
@@ -28,19 +28,19 @@ describe Puppet::Forge::ModuleRelease do
 
   shared_examples 'a module release' do
     def mock_digest_file_with_md5(md5)
-      allow(Digest::MD5).to receive(:file).and_return(double(:hexdigest => md5))
+      Digest::MD5.stubs(:file).returns(stub(:hexdigest => md5))
     end
 
     describe '#prepare' do
       before :each do
-        allow(release).to receive(:tmpfile).and_return(mock_file)
-        allow(release).to receive(:tmpdir).and_return(mock_dir)
+        release.stubs(:tmpfile).returns(mock_file)
+        release.stubs(:tmpdir).returns(mock_dir)
       end
 
       it 'should call sub methods with correct params' do
-        expect(release).to receive(:download).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file)
-        expect(release).to receive(:validate_checksum).with(mock_file, module_md5)
-        expect(release).to receive(:unpack).with(mock_file, mock_dir)
+        release.expects(:download).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file)
+        release.expects(:validate_checksum).with(mock_file, module_md5)
+        release.expects(:unpack).with(mock_file, mock_dir)
 
         release.prepare
       end
@@ -48,7 +48,7 @@ describe Puppet::Forge::ModuleRelease do
 
     describe '#tmpfile' do
       it 'should be opened in binary mode' do
-        allow(Puppet::Forge::Cache).to receive(:base_path).and_return(Dir.tmpdir)
+        Puppet::Forge::Cache.stubs(:base_path).returns(Dir.tmpdir)
         expect(release.send(:tmpfile).binmode?).to be_truthy
       end
     end
@@ -56,14 +56,14 @@ describe Puppet::Forge::ModuleRelease do
     describe '#download' do
       it 'should call make_http_request with correct params' do
         # valid URI comes from file_uri in JSON blob above
-        expect(ssl_repository).to receive(:make_http_request).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file).and_return(double(:body => '{}', :code => '200'))
+        ssl_repository.expects(:make_http_request).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file).returns(stub(:body => '{}', :code => '200'))
 
         release.send(:download, "/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file)
       end
 
       it 'should raise a response error when it receives an error from forge' do
-        allow(ssl_repository).to receive(:make_http_request).and_return(double(:body => '{"errors": ["error"]}', :code => '500', :message => 'server error'))
-        expect { release.send(:download, "/some/path", mock_file)}.to raise_error Puppet::Forge::Errors::ResponseError
+        ssl_repository.stubs(:make_http_request).returns(stub(:body => '{"errors": ["error"]}', :code => '500', :message => 'server error'))
+        expect { release.send(:download, "/some/path", mock_file)}. to raise_error Puppet::Forge::Errors::ResponseError
       end
     end
 
@@ -84,7 +84,7 @@ describe Puppet::Forge::ModuleRelease do
 
     describe '#unpack' do
       it 'should call unpacker with correct params' do
-        expect(Puppet::ModuleTool::Applications::Unpacker).to receive(:unpack).with(mock_file.path, mock_dir).and_return(true)
+        Puppet::ModuleTool::Applications::Unpacker.expects(:unpack).with(mock_file.path, mock_dir).returns(true)
 
         release.send(:unpack, mock_file, mock_dir)
       end
@@ -271,15 +271,15 @@ describe Puppet::Forge::ModuleRelease do
 
     describe '#prepare' do
       before :each do
-        allow(release).to receive(:tmpfile).and_return(mock_file)
-        allow(release).to receive(:tmpdir).and_return(mock_dir)
-        allow(release).to receive(:download)
-        allow(release).to receive(:validate_checksum)
-        allow(release).to receive(:unpack)
+        release.stubs(:tmpfile).returns(mock_file)
+        release.stubs(:tmpdir).returns(mock_dir)
+        release.stubs(:download)
+        release.stubs(:validate_checksum)
+        release.stubs(:unpack)
       end
 
       it 'should emit warning about module deprecation' do
-        expect(Puppet).to receive(:warning).with(/#{Regexp.escape(module_full_name)}.*deprecated/i)
+        Puppet.expects(:warning).with(regexp_matches(/#{Regexp.escape(module_full_name)}.*deprecated/i))
 
         release.prepare
       end