puppet 5.5.22-x86-mingw32 → 6.0.0-x86-mingw32

data/spec/integration/reference/providers_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/reference'
@@ -10,6 +11,12 @@ describe reference do
   end
 
   it "should be able to be rendered as markdown" do
+    # We have a :confine block that calls execute in our upstart provider, which fails
+    # on jruby. Thus, we stub it out here since we don't care to do any assertions on it.
+    # This is only an issue if you're running these unit tests on a platform where upstart
+    # is a default provider, like Ubuntu trusty.
+    Puppet::Util::Execution.stubs(:execute)
+
     reference.to_markdown
   end
 end

data/spec/integration/reports_spec.rb

@@ -1,10 +1,11 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/reports'
 
 describe Puppet::Reports, " when using report types" do
   before do
-    allow(Puppet.settings).to receive(:use)
+    Puppet.settings.stubs(:use)
   end
 
   it "should load report types as modules" do

data/spec/integration/resource/catalog_spec.rb

@@ -1,46 +1,49 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Resource::Catalog do
   describe "when using the indirector" do
     before do
       # This is so the tests work w/out networking.
-      allow(Facter).to receive(:to_hash).and_return({"hostname" => "foo.domain.com"})
-      allow(Facter).to receive(:value).and_return("eh")
+      Facter.stubs(:to_hash).returns({"hostname" => "foo.domain.com"})
+      Facter.stubs(:value).returns("eh")
     end
 
+
     it "should be able to delegate to the :yaml terminus" do
-      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class).and_return(:yaml)
+      Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :yaml
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Resource::Catalog.indirection.terminus(:yaml)
-      expect(terminus).to receive(:path).with("me").and_return("/my/yaml/file")
+      terminus.expects(:path).with("me").returns "/my/yaml/file"
 
-      expect(Puppet::FileSystem).to receive(:exist?).with("/my/yaml/file").and_return(false)
+      Puppet::FileSystem.expects(:exist?).with("/my/yaml/file").returns false
       expect(Puppet::Resource::Catalog.indirection.find("me")).to be_nil
     end
 
     it "should be able to delegate to the :compiler terminus" do
-      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class).and_return(:compiler)
+      Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :compiler
 
       # Load now, before we stub the exists? method.
       compiler = Puppet::Resource::Catalog.indirection.terminus(:compiler)
 
-      node = double('node', :add_server_facts => nil, :trusted_data= => nil, :environment => nil)
+      node = mock 'node'
+      node.stub_everything
 
-      expect(Puppet::Node.indirection).to receive(:find).and_return(node)
-      expect(compiler).to receive(:compile).with(node, anything).and_return(nil)
+      Puppet::Node.indirection.expects(:find).returns(node)
+      compiler.expects(:compile).with(node, anything).returns nil
 
       expect(Puppet::Resource::Catalog.indirection.find("me")).to be_nil
     end
 
     it "should pass provided node information directly to the terminus" do
-      node = double('node')
-      terminus = double('terminus')
-      allow(terminus).to receive(:validate)
-      expect(terminus).to receive(:find) { |request| expect(request.options[:use_node]).to eq(node) }
+      terminus = mock 'terminus'
 
-      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus).and_return(terminus)
+      Puppet::Resource::Catalog.indirection.stubs(:terminus).returns terminus
 
+      node = mock 'node'
+      terminus.stubs(:validate)
+      terminus.expects(:find).with { |request| request.options[:use_node] == node }
       Puppet::Resource::Catalog.indirection.find("me", :use_node => node)
     end
   end

data/spec/integration/resource/type_collection_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/files'
@@ -12,12 +13,12 @@ describe Puppet::Resource::TypeCollection do
       FileUtils.mkdir_p @dir
 
       loader = Object.new
-      allow(loader).to receive(:load).and_return(nil)
-      allow(loader).to receive(:set_entry)
+      loader.stubs(:load).returns nil
+      loader.stubs(:set_entry)
 
       loaders = Object.new
-      expect(loaders).to receive(:runtime3_type_loader).at_most(:once).and_return(loader)
-      expect(Puppet::Pops::Loaders).to receive(:loaders).at_most(:once).and_return(loaders)
+      loaders.expects(:runtime3_type_loader).at_most_once.returns loader
+      Puppet::Pops::Loaders.expects(:loaders).at_most_once.returns loaders
 
       environment = Puppet::Node::Environment.create(:env, [@dir])
       @code = environment.known_resource_types

data/spec/integration/ssl/certificate_request_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/ssl/certificate_request'
@@ -12,8 +13,6 @@ describe Puppet::SSL::CertificateRequest do
     Puppet.settings[:confdir] = dir
     Puppet.settings[:vardir] = dir
 
-    Puppet::SSL::Host.ca_location = :none
-
     @csr = Puppet::SSL::CertificateRequest.new("luke.madstop.com")
 
     @key = OpenSSL::PKey::RSA.new(512)

data/spec/integration/ssl/host_spec.rb

@@ -1,8 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/test_ca'
 
 require 'puppet/ssl/host'
 
-describe Puppet::SSL::Host do
+describe Puppet::SSL::Host, if: !Puppet::Util::Platform.jruby? do
   include PuppetSpec::Files
 
   before do
@@ -11,19 +13,18 @@ describe Puppet::SSL::Host do
 
     Puppet.settings[:confdir] = dir
     Puppet.settings[:vardir] = dir
-
-    Puppet::SSL::Host.ca_location = :local
+    Puppet.settings.use :main, :ssl
 
     @host = Puppet::SSL::Host.new("luke.madstop.com")
-    @ca = Puppet::SSL::CertificateAuthority.new
-  end
-
-  after {
-    Puppet::SSL::Host.ca_location = :none
-  }
+    @host.stubs(:submit_certificate_request)
 
-  it "should be considered a CA host if its name is equal to 'ca'" do
-    expect(Puppet::SSL::Host.new(Puppet::SSL::CA_NAME)).to be_ca
+    @ca = Puppet::TestCa.new
+    Puppet::Util.replace_file(Puppet[:localcacert], 0644) do |f|
+      f.write(@ca.ca_cert.to_s)
+    end
+    Puppet::Util.replace_file(Puppet[:hostcrl], 0644) do |f|
+      f.write(@ca.ca_crl.to_s)
+    end
   end
 
   describe "when managing its key" do
@@ -60,20 +61,12 @@ describe Puppet::SSL::Host do
     end
   end
 
-  describe "when the CA host" do
-    it "should never store its key in the :privatekeydir" do
-      Puppet.settings.use(:main, :ssl, :ca)
-      @ca = Puppet::SSL::Host.new(Puppet::SSL::Host.ca_name)
-      @ca.generate_key
-
-      expect(Puppet::FileSystem.exist?(File.join(Puppet[:privatekeydir], "ca.pem"))).to be_falsey
-    end
-  end
-
   it "should pass the verification of its own SSL store", :unless => Puppet.features.microsoft_windows? do
-    @host.generate
-    @ca = Puppet::SSL::CertificateAuthority.new
-    @ca.sign(@host.name)
+    @host.generate_certificate_request
+    cert = @ca.sign(@host.certificate_request.content)
+    Puppet::Util.replace_file(File.join(Puppet[:certdir], "#{@host.name}.pem"), 0644) do |f|
+      f.write(cert)
+    end
 
     expect(@host.ssl_store.verify(@host.certificate.content)).to be_truthy
   end

data/spec/integration/ssl/key_spec.rb

@@ -1,8 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/ssl/key'
 
-describe Puppet::SSL::Key do
+describe Puppet::SSL::Key, unless: Puppet::Util::Platform.jruby? do
   include PuppetSpec::Files
 
   # different UTF-8 widths
@@ -40,6 +41,8 @@ describe Puppet::SSL::Key do
     end
 
     it "should be able to read an existing private key given the correct password" do
+      Puppet[:keylength] = '50'
+
       key_name = 'test'
       # use OpenSSL APIs to generate a private key
       private_key = OpenSSL::PKey::RSA.generate(512)
@@ -55,7 +58,7 @@ describe Puppet::SSL::Key do
 
       # indirector loads existing .pem off disk instead of replacing it
       host = Puppet::SSL::Host.new(key_name)
-      host.generate
+      host.key
 
       # newly loaded host private key matches the manually created key
       # Private-Key: (512 bit) style data
@@ -66,6 +69,8 @@ describe Puppet::SSL::Key do
     end
 
     it 'should export the private key to PEM using the password' do
+      Puppet[:keylength] = '50'
+
       key_name = 'test'
 
       # uses specified :passfile when writing the private key

data/spec/integration/test/test_helper_spec.rb

@@ -0,0 +1,32 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe "Windows UTF8 environment variables", :if => Puppet::Util::Platform.windows? do
+  # The Puppet::Util::Windows::Process class is used to manipulate environment variables as it is known to handle UTF8 characters. Where as the implementation of ENV in ruby does not.
+  # before and end all are used to inject environment variables before the test helper 'before_each_test' function is called
+  # Do not use before and after hooks in these tests as it may have unintended consequences
+
+  before(:all) {
+    @varname = 'test_helper_spec-test_variable'
+    @rune_utf8 = "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7"
+
+    Puppet::Util::Windows::Process.set_environment_variable(@varname, @rune_utf8)
+  }
+  after(:all) {
+    # Need to cleanup this environment variable otherwise it contaminates any subsequent tests
+    Puppet::Util::Windows::Process.set_environment_variable(@varname, nil)
+  }
+
+  it "#after_each_test should preserve UTF8 environment variables" do
+    envhash = Puppet::Util::Windows::Process.get_environment_strings
+    expect(envhash[@varname]).to eq(@rune_utf8)
+    # Change the value in the test to force test_helper to restore the environment
+    ENV[@varname] = 'bad foo'
+
+    # Prematurely trigger the after_each_test method
+    Puppet::Test::TestHelper.after_each_test
+
+    envhash = Puppet::Util::Windows::Process.get_environment_strings
+    expect(envhash[@varname]).to eq(@rune_utf8)
+  end
+end

data/spec/integration/transaction/report_spec.rb

@@ -1,23 +1,28 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 
 describe Puppet::Transaction::Report do
   before :each do
     # Enable persistence during tests
-    allow_any_instance_of(Puppet::Transaction::Persistence).to receive(:enabled?).and_return(true)
+    Puppet::Transaction::Persistence.any_instance.stubs(:enabled?).returns(true)
   end
 
   describe "when using the indirector" do
+    after do
+      Puppet.settings.stubs(:use)
+    end
+
     it "should be able to delegate to the :processor terminus" do
-      allow(Puppet::Transaction::Report.indirection).to receive(:terminus_class).and_return(:processor)
+      Puppet::Transaction::Report.indirection.stubs(:terminus_class).returns :processor
 
       terminus = Puppet::Transaction::Report.indirection.terminus(:processor)
 
-      allow(Facter).to receive(:value).and_return("host.domain.com")
+      Facter.stubs(:value).returns "host.domain.com"
 
       report = Puppet::Transaction::Report.new
 
-      expect(terminus).to receive(:process).with(report)
+      terminus.expects(:process).with(report)
 
       Puppet::Transaction::Report.indirection.save(report)
     end
@@ -45,10 +50,10 @@ describe Puppet::Transaction::Report do
 
     def run_catalogs(resources1, resources2, noop1 = false, noop2 = false, &block)
       last_run_report = nil
-      expect(Puppet::Transaction::Report.indirection).to receive(:save) do |report, x|
+      Puppet::Transaction::Report.indirection.expects(:save).twice.with do |report, x|
         last_run_report = report
         true
-      end.twice
+      end
 
       Puppet[:report] = true
       Puppet[:noop] = noop1
@@ -380,7 +385,7 @@ describe Puppet::Transaction::Report do
         expect(get_cc_count(report)).to eq(0)
       end
 
-      it "link with ensure property change present => absent", :unless => Puppet.features.microsoft_windows? do
+      it "link with ensure property change present => absent", :unless => Puppet::Util::Platform.windows? do
         file = tmpfile("test_file")
         FileUtils.symlink(file, tmpfile("test_link"))
 
@@ -435,7 +440,7 @@ describe Puppet::Transaction::Report do
         expect(get_cc_count(report)).to eq(0)
       end
 
-      it "exec with idempotence issue", :unless => Puppet.features.microsoft_windows? do
+      it "exec with idempotence issue", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
         report = run_catalogs(Puppet::Type.type(:exec).new(:title => "exec1",
                                                            :command => "/bin/echo foo"),
                               Puppet::Type.type(:exec).new(:title => "exec1",
@@ -453,7 +458,7 @@ describe Puppet::Transaction::Report do
         expect(get_cc_count(report)).to eq(1)
       end
 
-      it "exec with no idempotence issue", :unless => Puppet.features.microsoft_windows? do
+      it "exec with no idempotence issue", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
         report = run_catalogs(Puppet::Type.type(:exec).new(:title => "exec1",
                                                            :command => "echo foo",
                                                            :path => "/bin",

data/spec/integration/type/exec_spec.rb

@@ -1,8 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/files'
 
-describe Puppet::Type.type(:exec) do
+describe Puppet::Type.type(:exec), unless: Puppet::Util::Platform.jruby? do
   include PuppetSpec::Files
 
   let(:catalog) { Puppet::Resource::Catalog.new }

data/spec/integration/type/file_spec.rb

@@ -1,8 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/files'
 
-if Puppet.features.microsoft_windows?
+if Puppet::Util::Platform.windows?
   require 'puppet/util/windows'
   class WindowsSecurity
     extend Puppet::Util::Windows::Security
@@ -21,13 +22,6 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
     File.join(parent, 'file_testing')
   end
 
-  let(:path_protected) do
-    # we create a file inside windows protected folders (C:\Windows, C:\Windows\system32, etc)
-    # the file will also be removed after the tests
-    parent = 'C:\Windows'
-    File.join(parent, 'file_testing')
-  end
-
   let(:dir) do
     # we create a directory first so backups of :path that are stored in
     # the same directory will also be removed after the tests
@@ -85,10 +79,10 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
   before do
     # stub this to not try to create state.yaml
-    allow(Puppet::Util::Storage).to receive(:store)
+    Puppet::Util::Storage.stubs(:store)
 
-    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
 
   it "should not attempt to manage files that do not exist if no means of creating the file is specified" do
@@ -275,27 +269,6 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
           expect(get_mode(path) & 07777).to eq(0666)
         end
 
-        context "file is in protected windows directory", :if => Puppet.features.microsoft_windows? do
-          after { FileUtils.rm(path_protected) }
-
-          it "should set and get the correct mode for files inside protected windows folders" do
-            catalog.add_resource described_class.new(:path => path_protected, :ensure => :file, :mode => '0640')
-            catalog.apply
-  
-            expect(get_mode(path_protected) & 07777).to eq(0640)
-          end
-
-          it "should not change resource's status inside protected windows folders if mode is the same" do
-            FileUtils.touch(path_protected)
-            set_mode(0644, path_protected)
-            catalog.add_resource described_class.new(:path => path_protected, :ensure => :file, :mode => '0644')
-            result = catalog.apply
-            status = result.report.resource_statuses["File[#{path_protected}]"]
-            expect(status).not_to be_failed
-            expect(status).not_to be_changed
-          end
-        end
-        
         it "should not set executable bits when replacing an executable directory (#10365)" do
           pending("bug #10365")
 
@@ -446,7 +419,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
             it "should not give a deprecation warning about using a checksum in content when using source to define content" do
               FileUtils.touch(path)
-              expect(Puppet).not_to receive(:puppet_deprecation_warning)
+              Puppet.expects(:puppet_deprecation_warning).never
               catalog.add_resource described_class.new(:path => path, :source => link, :links => :follow)
               catalog.apply
             end
@@ -560,7 +533,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
         # Create a directory where the backup should be so that writing to it fails
         Dir.mkdir(File.join(dir, "testfile.bak"))
 
-        allow(Puppet::Util::Log).to receive(:newmessage)
+        Puppet::Util::Log.stubs(:newmessage)
 
         catalog.apply
 
@@ -606,7 +579,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
         if Puppet::Util::Platform.windows? && ['sha512', 'sha384'].include?(example.metadata[:digest_algorithm])
           skip "PUP-8257: Skip file bucket test on windows for #{example.metadata[:digest_algorithm]} due to long path names"
         end
-
+        
         bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
         file = described_class.new({:path => tmpfile("bucket_backs"), :backup => "mybucket", :content => "foo", :force => true}.merge(resource_options))
         catalog.add_resource file
@@ -630,7 +603,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
     end
 
     it "should not give a checksum deprecation warning when given actual content" do
-      expect(Puppet).not_to receive(:puppet_deprecation_warning)
+      Puppet.expects(:puppet_deprecation_warning).never
       catalog.add_resource described_class.new(:path => path, :content => 'this is content')
       catalog.apply
     end
@@ -641,14 +614,14 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
       end
 
       it "should give a checksum deprecation warning" do
-        expect(Puppet).to receive(:puppet_deprecation_warning).with('Using a checksum in a file\'s "content" property is deprecated. The ability to use a checksum to retrieve content from the filebucket using the "content" property will be removed in a future release. The literal value of the "content" property will be written to the file. The checksum retrieval functionality is being replaced by the use of static catalogs. See https://puppet.com/docs/puppet/latest/static_catalogs.html for more information.', {:file => 'my/file.pp', :line => 5})
+        Puppet.expects(:puppet_deprecation_warning).with('Using a checksum in a file\'s "content" property is deprecated. The ability to use a checksum to retrieve content from the filebucket using the "content" property will be removed in a future release. The literal value of the "content" property will be written to the file. The checksum retrieval functionality is being replaced by the use of static catalogs. See https://puppet.com/docs/puppet/latest/static_catalogs.html for more information.', {:file => 'my/file.pp', :line => 5})
         d = digest("this is some content")
         catalog.add_resource described_class.new(:path => path, :content => "{#{digest_algorithm}}#{d}")
         catalog.apply
       end
 
       it "should not give a checksum deprecation warning when no content is specified while checksum and checksum value are used" do
-        expect(Puppet).not_to receive(:puppet_deprecation_warning)
+        Puppet.expects(:puppet_deprecation_warning).never
         d = digest("this is some content")
         catalog.add_resource described_class.new(:path => path, :checksum => digest_algorithm, :checksum_value => d)
         catalog.apply
@@ -1157,7 +1130,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
       uri_path = resource.parameters[:source].uri.path
 
       # note that Windows file:// style URIs get an extra / in front of c:/ like /c:/
-      source_prefix = Puppet.features.microsoft_windows? ? '/' : ''
+      source_prefix = Puppet::Util::Platform.windows? ? '/' : ''
 
       # the URI can be round-tripped through unescape
       expect(URI.unescape(uri_path)).to eq(source_prefix + source)
@@ -1309,8 +1282,8 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
   describe "when sourcing" do
     it "should give a deprecation warning when the user sets source_permissions" do
-      expect(Puppet).to receive(:puppet_deprecation_warning).with(
-        'The `source_permissions` parameter is deprecated. Explicitly set `owner`, `group`, and `mode`.',
+      Puppet.expects(:puppet_deprecation_warning).with(
+        'The `source_permissions` parameter is deprecated. Explicitly set `owner`, `group`, and `mode`.', 
         {:file => 'my/file.pp', :line => 5})
 
       catalog.add_resource described_class.new(:path => path, :content => 'this is content', :source_permissions => :use_when_creating)
@@ -1318,7 +1291,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
     end
 
     it "should not give a deprecation warning when the user does not set source_permissions" do
-      expect(Puppet).not_to receive(:puppet_deprecation_warning)
+      Puppet.expects(:puppet_deprecation_warning).never
       catalog.add_resource described_class.new(:path => path, :content => 'this is content')
       catalog.apply
     end
@@ -1465,7 +1438,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
       end
     end
 
-    describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
+    describe "on Windows systems", :if => Puppet::Util::Platform.windows? do
       def expects_sid_granted_full_access_explicitly(path, sid)
         inherited_ace = Puppet::Util::Windows::AccessControlEntry::INHERITED_ACE
 
@@ -1552,6 +1525,15 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
               catalog.apply
             end
 
+            it "should allow the user to explicitly set the mode to 4" do
+              system_aces = get_aces_for_path_by_sid(path, @sids[:system])
+              expect(system_aces).not_to be_empty
+
+              system_aces.each do |ace|
+                expect(ace.mask).to eq(Puppet::Util::Windows::File::FILE_GENERIC_READ)
+              end
+            end
+
             it "prepends SYSTEM ace when changing group from system to power users" do
               @file[:group] = @sids[:power_users]
               catalog.apply
@@ -1630,6 +1612,16 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
                 catalog.apply
               end
 
+              it "should allow the user to explicitly set the mode to 4" do
+                system_aces = get_aces_for_path_by_sid(dir, @sids[:system])
+                expect(system_aces).not_to be_empty
+
+                system_aces.each do |ace|
+                  # unlike files, Puppet sets execute bit on directories that are readable
+                  expect(ace.mask).to eq(Puppet::Util::Windows::File::FILE_GENERIC_READ | Puppet::Util::Windows::File::FILE_GENERIC_EXECUTE)
+                end
+              end
+
               it "prepends SYSTEM ace when changing group from system to power users" do
                 @directory[:group] = @sids[:power_users]
                 catalog.apply
@@ -1710,7 +1702,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
   describe "when using validate_cmd" do
     it "should fail the file resource if command fails" do
       catalog.add_resource(described_class.new(:path => path, :content => "foo", :validate_cmd => "/usr/bin/env false"))
-      expect(Puppet::Util::Execution).to receive(:execute).with("/usr/bin/env false", {:combine => true, :failonfail => true}).and_raise(Puppet::ExecutionFailure, "Failed")
+      Puppet::Util::Execution.expects(:execute).with("/usr/bin/env false", {:combine => true, :failonfail => true}).raises(Puppet::ExecutionFailure, "Failed")
       report = catalog.apply.report
       expect(report.resource_statuses["File[#{path}]"]).to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_falsey
@@ -1718,9 +1710,9 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
     it "should succeed the file resource if command succeeds" do
       catalog.add_resource(described_class.new(:path => path, :content => "foo", :validate_cmd => "/usr/bin/env true"))
-      expect(Puppet::Util::Execution).to receive(:execute)
+      Puppet::Util::Execution.expects(:execute)
         .with("/usr/bin/env true", {:combine => true, :failonfail => true})
-        .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+        .returns Puppet::Util::Execution::ProcessOutput.new('', 0)
       report = catalog.apply.report
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_truthy