puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/type/file/mtime_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).attrclass(:mtime) do

data/spec/unit/type/file/owner_spec.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).attrclass(:owner) do
@@ -8,19 +10,19 @@ describe Puppet::Type.type(:file).attrclass(:owner) do
   let(:owner) { resource.property(:owner) }
 
   before :each do
-    allow(Puppet.features).to receive(:root?).and_return(true)
+    Puppet.features.stubs(:root?).returns(true)
   end
 
   describe "#insync?" do
     before :each do
       resource[:owner] = ['foo', 'bar']
 
-      allow(resource.provider).to receive(:name2uid).with('foo').and_return(1001)
-      allow(resource.provider).to receive(:name2uid).with('bar').and_return(1002)
+      resource.provider.stubs(:name2uid).with('foo').returns 1001
+      resource.provider.stubs(:name2uid).with('bar').returns 1002
     end
 
     it "should fail if an owner's id can't be found by name" do
-      allow(resource.provider).to receive(:name2uid).and_return(nil)
+      resource.provider.stubs(:name2uid).returns nil
 
       expect { owner.insync?(5) }.to raise_error(/Could not find user foo/)
     end
@@ -41,13 +43,13 @@ describe Puppet::Type.type(:file).attrclass(:owner) do
   %w[is_to_s should_to_s].each do |prop_to_s|
     describe "##{prop_to_s}" do
       it "should use the name of the user if it can find it" do
-        allow(resource.provider).to receive(:uid2name).with(1001).and_return('foo')
+        resource.provider.stubs(:uid2name).with(1001).returns 'foo'
 
         expect(owner.send(prop_to_s, 1001)).to eq("'foo'")
       end
 
       it "should use the id of the user if it can't" do
-        allow(resource.provider).to receive(:uid2name).with(1001).and_return(nil)
+        resource.provider.stubs(:uid2name).with(1001).returns nil
 
         expect(owner.send(prop_to_s, 1001)).to eq('1001')
       end

data/spec/unit/type/file/selinux_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 [:seluser, :selrole, :seltype, :selrange].each do |param|
@@ -9,26 +10,26 @@ require 'spec_helper'
       @path = make_absolute("/my/file")
       @resource = Puppet::Type.type(:file).new :path => @path
       @sel = property.new :resource => @resource
-      allow(@sel).to receive(:normalize_selinux_category).with("s0").and_return("s0")
-      allow(@sel).to receive(:normalize_selinux_category).with(nil).and_return(nil)
+      @sel.stubs(:normalize_selinux_category).with("s0").returns("s0")
+      @sel.stubs(:normalize_selinux_category).with(nil).returns(nil)
     end
 
     it "retrieve on #{param} should return :absent if the file isn't statable" do
-      expect(@resource).to receive(:stat).and_return(nil)
+      @resource.expects(:stat).returns nil
       expect(@sel.retrieve).to eq(:absent)
     end
 
     it "should retrieve nil for #{param} if there is no SELinux support" do
-      stat = double('stat', :ftype => "foo")
-      expect(@resource).to receive(:stat).and_return(stat)
-      expect(@sel).to receive(:get_selinux_current_context).with(@path).and_return(nil)
+      stat = stub 'stat', :ftype => "foo"
+      @resource.expects(:stat).returns stat
+      @sel.expects(:get_selinux_current_context).with(@path).returns nil
       expect(@sel.retrieve).to be_nil
     end
 
     it "should retrieve #{param} if a SELinux context is found with a range" do
-      stat = double('stat', :ftype => "foo")
-      expect(@resource).to receive(:stat).and_return(stat)
-      expect(@sel).to receive(:get_selinux_current_context).with(@path).and_return("user_u:role_r:type_t:s0")
+      stat = stub 'stat', :ftype => "foo"
+      @resource.expects(:stat).returns stat
+      @sel.expects(:get_selinux_current_context).with(@path).returns "user_u:role_r:type_t:s0"
       expectedresult = case param
         when :seluser; "user_u"
         when :selrole; "role_r"
@@ -39,9 +40,9 @@ require 'spec_helper'
     end
 
     it "should retrieve #{param} if a SELinux context is found without a range" do
-      stat = double('stat', :ftype => "foo")
-      expect(@resource).to receive(:stat).and_return(stat)
-      expect(@sel).to receive(:get_selinux_current_context).with(@path).and_return("user_u:role_r:type_t")
+      stat = stub 'stat', :ftype => "foo"
+      @resource.expects(:stat).returns stat
+      @sel.expects(:get_selinux_current_context).with(@path).returns "user_u:role_r:type_t"
       expectedresult = case param
         when :seluser; "user_u"
         when :selrole; "role_r"
@@ -52,13 +53,13 @@ require 'spec_helper'
     end
 
     it "should handle no default gracefully" do
-      expect(@sel).to receive(:get_selinux_default_context).with(@path).and_return(nil)
+      @sel.expects(:get_selinux_default_context).with(@path).returns nil
       expect(@sel.default).to be_nil
     end
 
     it "should be able to detect matchpathcon defaults" do
-      allow(@sel).to receive(:debug)
-      expect(@sel).to receive(:get_selinux_default_context).with(@path).and_return("user_u:role_r:type_t:s0")
+      @sel.stubs(:debug)
+      @sel.expects(:get_selinux_default_context).with(@path).returns "user_u:role_r:type_t:s0"
       expectedresult = case param
         when :seluser; "user_u"
         when :selrole; "role_r"
@@ -75,14 +76,15 @@ require 'spec_helper'
 
     it "should be able to set a new context" do
       @sel.should = %w{newone}
-      expect(@sel).to receive(:set_selinux_context).with(@path, ["newone"], param)
+      @sel.expects(:set_selinux_context).with(@path, ["newone"], param)
       @sel.sync
     end
 
     it "should do nothing for safe_insync? if no SELinux support" do
       @sel.should = %{newcontext}
-      expect(@sel).to receive(:selinux_support?).and_return(false)
+      @sel.expects(:selinux_support?).returns false
       expect(@sel.safe_insync?("oldcontext")).to eq(true)
     end
   end
 end
+

data/spec/unit/type/file/source_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'uri'
 require 'puppet/network/http_pool'
@@ -32,7 +33,7 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
   describe "#validate" do
     it "should fail if the set values are not URLs" do
-      expect(URI).to receive(:parse).with('foo').and_raise(RuntimeError)
+      URI.expects(:parse).with('foo').raises RuntimeError
 
       expect(lambda { resource[:source] = %w{foo} }).to raise_error(Puppet::Error)
     end
@@ -95,10 +96,10 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
   describe "when returning the metadata" do
     before do
-      @metadata = double('metadata', :source= => nil)
-      allow(resource).to receive(:[]).with(:links).and_return(:manage)
-      allow(resource).to receive(:[]).with(:source_permissions).and_return(:use)
-      allow(resource).to receive(:[]).with(:checksum).and_return(:checksum)
+      @metadata = stub 'metadata', :source= => nil
+      resource.stubs(:[]).with(:links).returns :manage
+      resource.stubs(:[]).with(:source_permissions).returns :use
+      resource.stubs(:[]).with(:checksum).returns :checksum
     end
 
     it "should return already-available metadata" do
@@ -114,20 +115,18 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
     it "should collect its metadata using the Metadata class if it is not already set" do
       @source = described_class.new(:resource => resource, :value => @foobar)
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find) do |uri, options|
-        expect(uri).to eq(@foobar_uri)
-        expect(options[:environment]).to eq(environment)
-        expect(options[:links]).to eq(:manage)
-        expect(options[:checksum_type]).to eq(:checksum)
-
-        @metadata
-      end
+      Puppet::FileServing::Metadata.indirection.expects(:find).with do |uri, options|
+        expect(uri).to eq @foobar_uri
+        expect(options[:environment]).to eq environment
+        expect(options[:links]).to eq :manage
+        expect(options[:checksum_type]).to eq :checksum
+      end.returns @metadata
 
       @source.metadata
     end
 
     it "should use the metadata from the first found source" do
-      metadata = double('metadata', :source= => nil)
+      metadata = stub 'metadata', :source= => nil
       @source = described_class.new(:resource => resource, :value => [@foobar, @feebooz])
       options = {
         :environment => environment,
@@ -135,52 +134,48 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
         :source_permissions => :use,
         :checksum_type => :checksum
       }
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(@foobar_uri, options).and_return(nil)
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(@feebooz_uri, options).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, options).returns nil
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(@feebooz_uri, options).returns metadata
       expect(@source.metadata).to equal(metadata)
     end
 
     it "should store the found source as the metadata's source" do
-      metadata = double('metadata')
+      metadata = mock 'metadata'
       @source = described_class.new(:resource => resource, :value => @foobar)
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find) do |uri, options|
-        expect(uri).to eq(@foobar_uri)
-        expect(options[:environment]).to eq(environment)
-        expect(options[:links]).to eq(:manage)
-        expect(options[:checksum_type]).to eq(:checksum)
-
-        metadata
-      end
-
-      expect(metadata).to receive(:source=).with(@foobar_uri)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with do |uri, options|
+        expect(uri).to eq @foobar_uri
+        expect(options[:environment]).to eq environment
+        expect(options[:links]).to eq :manage
+        expect(options[:checksum_type]).to eq :checksum
+      end.returns metadata
+
+      metadata.expects(:source=).with(@foobar_uri)
       @source.metadata
     end
 
     it "should fail intelligently if an exception is encountered while querying for metadata" do
       @source = described_class.new(:resource => resource, :value => @foobar)
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find) do |uri, options|
-        expect(uri).to eq(@foobar_uri)
-        expect(options[:environment]).to eq(environment)
-        expect(options[:links]).to eq(:manage)
-        expect(options[:checksum_type]).to eq(:checksum)
-      end.and_raise(RuntimeError)
-
-      expect(@source).to receive(:fail).and_raise(ArgumentError)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with do |uri, options|
+        expect(uri).to eq @foobar_uri
+        expect(options[:environment]).to eq environment
+        expect(options[:links]).to eq :manage
+        expect(options[:checksum_type]).to eq :checksum
+      end.raises RuntimeError
+
+      @source.expects(:fail).raises ArgumentError
       expect { @source.metadata }.to raise_error(ArgumentError)
     end
 
     it "should fail if no specified sources can be found" do
       @source = described_class.new(:resource => resource, :value => @foobar)
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find)  do |uri, options|
-        expect(uri).to eq(@foobar_uri)
-        expect(options[:environment]).to eq(environment)
-        expect(options[:links]).to eq(:manage)
-        expect(options[:checksum_type]).to eq(:checksum)
-
-        nil
-      end
+      Puppet::FileServing::Metadata.indirection.expects(:find).with  do |uri, options|
+        expect(uri).to eq @foobar_uri
+        expect(options[:environment]).to eq environment
+        expect(options[:links]).to eq :manage
+        expect(options[:checksum_type]).to eq :checksum
+      end.returns nil
 
-      expect(@source).to receive(:fail).and_raise(RuntimeError)
+      @source.expects(:fail).raises RuntimeError
 
       expect { @source.metadata }.to raise_error(RuntimeError)
     end
@@ -191,23 +186,24 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
   end
 
   describe "when copying the source values" do
+
     before do
-      allow_any_instance_of(Puppet::Type.type(:file)).to receive(:file).and_return('my/file.pp')
-      allow_any_instance_of(Puppet::Type.type(:file)).to receive(:line).and_return(5)
+      Puppet::Type.type(:file).any_instance.stubs(:file).returns('my/file.pp')
+      Puppet::Type.type(:file).any_instance.stubs(:line).returns 5
     end
 
     before :each do
       @resource = Puppet::Type.type(:file).new :path => @foobar
 
       @source = described_class.new(:resource => @resource)
-      @metadata = double('metadata', :owner => 100, :group => 200, :mode => "173", :checksum => "{md5}asdfasdf", :checksum_type => "md5", :ftype => "file", :source => @foobar)
-      allow(@source).to receive(:metadata).and_return(@metadata)
+      @metadata = stub 'metadata', :owner => 100, :group => 200, :mode => "173", :checksum => "{md5}asdfasdf", :checksum_type => "md5", :ftype => "file", :source => @foobar
+      @source.stubs(:metadata).returns @metadata
 
-      allow(Puppet.features).to receive(:root?).and_return(true)
+      Puppet.features.stubs(:root?).returns true
     end
 
     it "should not issue an error - except on Windows - if the source mode value is a Numeric" do
-      allow(@metadata).to receive(:mode).and_return(0173)
+      @metadata.stubs(:mode).returns 0173
       @resource[:source_permissions] = :use
       if Puppet::Util::Platform.windows?
         expect { @source.copy_source_values }.to raise_error("Should not have tried to use source owner/mode/group on Windows (file: my/file.pp, line: 5)")
@@ -217,7 +213,7 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
     end
 
     it "should not issue an error - except on Windows - if the source mode value is a String" do
-      allow(@metadata).to receive(:mode).and_return("173")
+      @metadata.stubs(:mode).returns "173"
       @resource[:source_permissions] = :use
       if Puppet::Util::Platform.windows?
         expect { @source.copy_source_values }.to raise_error("Should not have tried to use source owner/mode/group on Windows (file: my/file.pp, line: 5)")
@@ -227,20 +223,20 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
     end
 
     it "should fail if there is no metadata" do
-      allow(@source).to receive(:metadata).and_return(nil)
-      expect(@source).to receive(:devfail).and_raise(ArgumentError)
+      @source.stubs(:metadata).returns nil
+      @source.expects(:devfail).raises ArgumentError
       expect { @source.copy_source_values }.to raise_error(ArgumentError)
     end
 
     it "should set :ensure to the file type" do
-      allow(@metadata).to receive(:ftype).and_return("file")
+      @metadata.stubs(:ftype).returns "file"
 
       @source.copy_source_values
       expect(@resource[:ensure]).to eq(:file)
     end
 
     it "should not set 'ensure' if it is already set to 'absent'" do
-      allow(@metadata).to receive(:ftype).and_return("file")
+      @metadata.stubs(:ftype).returns "file"
 
       @resource[:ensure] = :absent
       @source.copy_source_values
@@ -249,8 +245,8 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
     describe "and the source is a file" do
       before do
-        allow(@metadata).to receive(:ftype).and_return("file")
-        allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+        @metadata.stubs(:ftype).returns "file"
+        Puppet::Util::Platform.stubs(:windows?).returns false
       end
 
       context "when source_permissions is `use`" do
@@ -288,7 +284,7 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
         describe "and puppet is not running as root" do
           before do
-            allow(Puppet.features).to receive(:root?).and_return(false)
+            Puppet.features.stubs(:root?).returns false
           end
 
           it "should not try to set the owner" do
@@ -306,13 +302,13 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
       context "when source_permissions is `use_when_creating`" do
         before :each do
           @resource[:source_permissions] = "use_when_creating"
-          expect(Puppet.features).to receive(:root?).and_return(true)
-          allow(@source).to receive(:local?).and_return(false)
+          Puppet.features.expects(:root?).returns true
+          @source.stubs(:local?).returns(false)
         end
 
         context "when managing a new file" do
           it "should copy owner and group from local sources" do
-            allow(@source).to receive(:local?).and_return(true)
+            @source.stubs(:local?).returns true
 
             @source.copy_source_values
 
@@ -342,11 +338,11 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
         context "when managing an existing file" do
           before :each do
-            allow(Puppet::FileSystem).to receive(:exist?).with(@resource[:path]).and_return(true)
+            Puppet::FileSystem.stubs(:exist?).with(@resource[:path]).returns(true)
           end
 
           it "should not copy owner, group or mode from local sources" do
-            allow(@source).to receive(:local?).and_return(true)
+            @source.stubs(:local?).returns true
 
             @source.copy_source_values
 
@@ -377,12 +373,12 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
       context "when source_permissions is default" do
         before :each do
-          allow(@source).to receive(:local?).and_return(false)
-          expect(Puppet.features).to receive(:root?).and_return(true)
+          @source.stubs(:local?).returns(false)
+          Puppet.features.expects(:root?).returns true
         end
 
         it "should not copy owner, group or mode from local sources" do
-          allow(@source).to receive(:local?).and_return(true)
+          @source.stubs(:local?).returns true
 
           @source.copy_source_values
 
@@ -413,19 +409,19 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
     describe "and the source is a link" do
       before do
-        allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+        Puppet::Util::Platform.stubs(:windows?).returns false
       end
 
       it "should set the target to the link destination" do
-        allow(@metadata).to receive(:ftype).and_return("link")
-        allow(@metadata).to receive(:links).and_return("manage")
-        allow(@metadata).to receive(:checksum_type).and_return(nil)
-        allow(@resource).to receive(:[])
-        allow(@resource).to receive(:[]=)
+        @metadata.stubs(:ftype).returns "link"
+        @metadata.stubs(:links).returns "manage"
+        @metadata.stubs(:checksum_type).returns nil
+        @resource.stubs(:[])
+        @resource.stubs(:[]=)
 
-        expect(@metadata).to receive(:destination).and_return("/path/to/symlink")
+        @metadata.expects(:destination).returns "/path/to/symlink"
 
-        expect(@resource).to receive(:[]=).with(:target, "/path/to/symlink")
+        @resource.expects(:[]=).with(:target, "/path/to/symlink")
         @source.copy_source_values
       end
     end
@@ -488,10 +484,11 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
 
         before(:each) do
           metadata = Puppet::FileServing::Metadata.new(path, :source => uri, 'type' => 'file')
-          allow(Puppet::FileServing::Metadata.indirection).to receive(:find).
-            with(uri, include(:environment, :links)).and_return(metadata)
-          allow(Puppet::FileServing::Metadata.indirection).to receive(:find).
-            with(uri, include(:environment, :links)).and_return(metadata)
+          #metadata = stub('remote', :ftype => "file", :source => uri)
+          Puppet::FileServing::Metadata.indirection.stubs(:find).
+            with(uri,all_of(has_key(:environment), has_key(:links))).returns metadata
+          Puppet::FileServing::Metadata.indirection.stubs(:find).
+            with(uri,all_of(has_key(:environment), has_key(:links))).returns metadata
           resource[:source] = uri
         end
 
@@ -584,52 +581,52 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
     describe 'from remote source' do
       let(:source_content) { "source file content\n"*10 }
       let(:source) { resource.newattr(:source) }
-      let(:response) { double('response', :[] => nil, :body => nil, :message => nil) }
-      let(:conn) { double('connection') }
+      let(:response) { stub_everything('response') }
+      let(:conn) { mock('connection') }
 
       before do
         resource[:backup] = false
 
-        expectation = receive(:read_body)
-        source_content.lines.each { |line| expectation = expectation.and_yield(line) }
-        allow(response).to expectation
-        allow(conn).to receive(:request_get).and_yield(response)
+        response.stubs(:read_body).multiple_yields(*source_content.lines)
+        conn.stubs(:request_get).yields(response)
       end
 
       it 'should use an explicit fileserver if source starts with puppet://' do
-        allow(response).to receive(:code).and_return('200')
-        allow(source).to receive(:metadata).and_return(double('metadata', :source => 'puppet://somehostname/test/foo', :ftype => 'file', :content_uri => nil))
-        expect(Puppet::Network::HttpPool).to receive(:http_instance).with('somehostname', anything).and_return(conn)
+        response.stubs(:code).returns('200')
+        source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet://somehostname/test/foo', :ftype => 'file')
+        Puppet::Network::HttpPool.expects(:http_instance).with('somehostname', anything).returns(conn)
 
         resource.write(source)
       end
 
       it 'should use the default fileserver if source starts with puppet:///' do
-        allow(response).to receive(:code).and_return('200')
-        allow(source).to receive(:metadata).and_return(double('metadata', :source => 'puppet:///test/foo', :ftype => 'file', :content_uri => nil))
-        expect(Puppet::Network::HttpPool).to receive(:http_instance).with(Puppet.settings[:server], anything).and_return(conn)
+        response.stubs(:code).returns('200')
+        source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo', :ftype => 'file')
+        Puppet::Network::HttpPool.expects(:http_instance).with(Puppet.settings[:server], anything).returns(conn)
 
         resource.write(source)
       end
 
       it 'should percent encode reserved characters' do
-        allow(response).to receive(:code).and_return('200')
-        allow(Puppet::Network::HttpPool).to receive(:http_instance).and_return(conn)
-        allow(source).to receive(:metadata).and_return(double('metadata', :source => 'puppet:///test/foo bar', :ftype => 'file', :content_uri => nil))
+        response.stubs(:code).returns('200')
+        Puppet::Network::HttpPool.stubs(:http_instance).returns(conn)
+        source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo bar', :ftype => 'file')
 
-        expect(conn).to receive(:request_get).with("#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3/file_content/test/foo%20bar?environment=myenv&", anything).and_yield(response)
+        conn.unstub(:request_get)
+        conn.expects(:request_get).with("#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3/file_content/test/foo%20bar?environment=myenv&", anything).yields(response)
 
         resource.write(source)
       end
 
       it 'should request binary content' do
-        allow(response).to receive(:code).and_return('200')
-        allow(Puppet::Network::HttpPool).to receive(:http_instance).and_return(conn)
-        allow(source).to receive(:metadata).and_return(double('metadata', :source => 'puppet:///test/foo bar', :ftype => 'file', :content_uri => nil))
+        response.stubs(:code).returns('200')
+        Puppet::Network::HttpPool.stubs(:http_instance).returns(conn)
+        source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo bar', :ftype => 'file')
 
-        expect(conn).to receive(:request_get) do |_, options|
+        conn.unstub(:request_get)
+        conn.expects(:request_get).with do |_, options|
           expect(options).to include('Accept' => 'application/octet-stream')
-        end.and_yield(response)
+        end.yields(response)
 
         resource.write(source)
       end
@@ -640,25 +637,25 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
         end
 
         before(:each) do
-          allow(Puppet::Network::HttpPool).to receive(:http_instance).and_return(conn)
-          allow(source).to receive(:metadata).and_return(double('metadata', :source => 'puppet:///test/foo', :ftype => 'file', :content_uri => nil))
+          Puppet::Network::HttpPool.stubs(:http_instance).returns(conn)
+          source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo', :ftype => 'file')
         end
 
         it 'should not write anything if source is not found' do
-          allow(response).to receive(:code).and_return('404')
+          response.stubs(:code).returns('404')
 
           expect { resource.write(source) }.to raise_error(Net::HTTPError, /404/)
           expect(File.read(filename)).to eq('initial file content')
         end
 
         it 'should raise an HTTP error in case of server error' do
-          allow(response).to receive(:code).and_return('500')
+          response.stubs(:code).returns('500')
 
           expect { resource.write(source) }.to raise_error(Net::HTTPError, /500/)
         end
 
         context 'and the request was successful' do
-          before(:each) { allow(response).to receive(:code).and_return('200') }
+          before(:each) { response.stubs(:code).returns '200' }
 
           it 'should write the contents to the file' do
             resource.write(source)