puppet 5.5.12-x86-mingw32 → 5.5.13-x86-mingw32

data/spec/unit/application/master_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/application/master'
@@ -9,16 +8,20 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
   before :each do
     Puppet[:bindaddress] = '127.0.0.1'
     @master = Puppet::Application[:master]
-    @daemon = stub_everything 'daemon'
-    Puppet::Daemon.stubs(:new).returns(@daemon)
-    Puppet::Util::Log.stubs(:newdestination)
-
-    Puppet::Node.indirection.stubs(:terminus_class=)
-    Puppet::Node::Facts.indirection.stubs(:terminus_class=)
-    Puppet::Node::Facts.indirection.stubs(:cache_class=)
-    Puppet::Transaction::Report.indirection.stubs(:terminus_class=)
-    Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
-    Puppet::SSL::Host.stubs(:ca_location=)
+    @daemon = double('daemon')
+    allow(@daemon).to receive(:argv=)
+    allow(@daemon).to receive(:server=)
+    allow(@daemon).to receive(:set_signal_traps)
+    allow(@daemon).to receive(:start)
+    allow(Puppet::Daemon).to receive(:new).and_return(@daemon)
+    allow(Puppet::Util::Log).to receive(:newdestination)
+
+    allow(Puppet::Node.indirection).to receive(:terminus_class=)
+    allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
+    allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
+    allow(Puppet::Transaction::Report.indirection).to receive(:terminus_class=)
+    allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class=)
+    allow(Puppet::SSL::Host).to receive(:ca_location=)
   end
 
   it "should operate in master run_mode" do
@@ -39,11 +42,11 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
 
   describe "during preinit" do
     before :each do
-      @master.stubs(:trap)
+      allow(@master).to receive(:trap)
     end
 
     it "should catch INT" do
-      @master.stubs(:trap).with { |arg,block| arg == :INT }
+      allow(@master).to receive(:trap) { |arg,block| arg == :INT }
 
       @master.preinit
     end
@@ -55,32 +58,32 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
     end
 
     it "should store argument value when calling handle_#{option}" do
-      @master.options.expects(:[]=).with(option, 'arg')
+      expect(@master.options).to receive(:[]=).with(option, 'arg')
       @master.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   describe "when applying options" do
     before do
-      @master.command_line.stubs(:args).returns([])
+      allow(@master.command_line).to receive(:args).and_return([])
     end
 
     it "should set the log destination with --logdest" do
-      Puppet::Log.expects(:newdestination).with("console")
+      expect(Puppet::Log).to receive(:newdestination).with("console")
 
       @master.handle_logdest("console")
     end
 
     it "should put the setdest options to true" do
-      @master.options.expects(:[]=).with(:setdest,true)
+      expect(@master.options).to receive(:[]=).with(:setdest,true)
 
       @master.handle_logdest("console")
     end
 
     it "should parse the log destination from ARGV" do
-      @master.command_line.stubs(:args).returns(%w{--logdest /my/file})
+      allow(@master.command_line).to receive(:args).and_return(%w{--logdest /my/file})
 
-      Puppet::Util::Log.expects(:newdestination).with("/my/file")
+      expect(Puppet::Util::Log).to receive(:newdestination).with("/my/file")
 
       @master.parse_options
     end
@@ -99,65 +102,64 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
 
   describe "during setup" do
     before :each do
-      Puppet::Log.stubs(:newdestination)
-      Puppet.stubs(:settraps)
-      Puppet::SSL::CertificateAuthority.stubs(:instance)
-      Puppet::SSL::CertificateAuthority.stubs(:ca?)
-      Puppet.settings.stubs(:use)
+      allow(Puppet::Log).to receive(:newdestination)
+      allow(Puppet).to receive(:settraps)
+      allow(Puppet::SSL::CertificateAuthority).to receive(:instance)
+      allow(Puppet::SSL::CertificateAuthority).to receive(:ca?)
+      allow(Puppet.settings).to receive(:use)
 
-      @master.options.stubs(:[]).with(any_parameters)
+      allow(@master.options).to receive(:[])
     end
 
     it "should abort stating that the master is not supported on Windows" do
-      Puppet.features.stubs(:microsoft_windows?).returns(true)
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
 
       expect { @master.setup }.to raise_error(Puppet::Error, /Puppet master is not supported on Microsoft Windows/)
     end
 
     describe "setting up logging" do
       it "sets the log level" do
-        @master.expects(:set_log_level)
+        expect(@master).to receive(:set_log_level)
         @master.setup
       end
 
       describe "when the log destination is not explicitly configured" do
         before do
-          @master.options.stubs(:[]).with(:setdest).returns false
+          allow(@master.options).to receive(:[]).with(:setdest).and_return(false)
         end
 
         it "should log to the console when --compile is given" do
-          @master.options.stubs(:[]).with(:node).returns "default"
-          Puppet::Util::Log.expects(:newdestination).with(:console)
+          allow(@master.options).to receive(:[]).with(:node).and_return("default")
+          expect(Puppet::Util::Log).to receive(:newdestination).with(:console)
           @master.setup
         end
 
         it "should log to the console when the master is not daemonized or run with rack" do
-          Puppet::Util::Log.expects(:newdestination).with(:console)
+          expect(Puppet::Util::Log).to receive(:newdestination).with(:console)
           Puppet[:daemonize] = false
-          @master.options.stubs(:[]).with(:rack).returns(false)
+          allow(@master.options).to receive(:[]).with(:rack).and_return(false)
           @master.setup
         end
 
         it "should log to syslog when the master is daemonized" do
-
-          Puppet::Util::Log.expects(:newdestination).with(:console).never
-          Puppet::Util::Log.expects(:newdestination).with(:syslog)
+          expect(Puppet::Util::Log).not_to receive(:newdestination).with(:console)
+          expect(Puppet::Util::Log).to receive(:newdestination).with(:syslog)
           Puppet[:daemonize] = true
-          @master.options.stubs(:[]).with(:rack).returns(false)
+          allow(@master.options).to receive(:[]).with(:rack).and_return(false)
           @master.setup
         end
 
         it "should log to syslog when the master is run with rack" do
-          Puppet::Util::Log.expects(:newdestination).with(:console).never
-          Puppet::Util::Log.expects(:newdestination).with(:syslog)
+          expect(Puppet::Util::Log).not_to receive(:newdestination).with(:console)
+          expect(Puppet::Util::Log).to receive(:newdestination).with(:syslog)
           Puppet[:daemonize] = false
-          @master.options.stubs(:[]).with(:rack).returns(true)
+          allow(@master.options).to receive(:[]).with(:rack).and_return(true)
           @master.setup
         end
       end
 
       it "sets the log destination using settings" do
-        Puppet::Util::Log.expects(:newdestination).with("set_via_config")
+        expect(Puppet::Util::Log).to receive(:newdestination).with("set_via_config")
         Puppet[:logdest] = "set_via_config"
 
         @master.setup
@@ -165,26 +167,25 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
     end
 
     it "should print puppet config if asked to in Puppet config" do
-      Puppet.settings.stubs(:print_configs?).returns(true)
-      Puppet.settings.expects(:print_configs).returns(true)
+      allow(Puppet.settings).to receive(:print_configs?).and_return(true)
+      expect(Puppet.settings).to receive(:print_configs).and_return(true)
       expect { @master.setup }.to exit_with 0
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
-      Puppet.settings.stubs(:print_configs?).returns(true)
+      allow(Puppet.settings).to receive(:print_configs?).and_return(true)
       expect { @master.setup }.to exit_with 1
     end
 
     it "should tell Puppet.settings to use :main,:ssl,:master and :metrics category" do
-      Puppet.settings.expects(:use).with(:main,:master,:ssl,:metrics)
+      expect(Puppet.settings).to receive(:use).with(:main,:master,:ssl,:metrics)
 
       @master.setup
     end
 
     describe "with no ca" do
-
       it "should set the ca_location to none" do
-        Puppet::SSL::Host.expects(:ca_location=).with(:none)
+        expect(Puppet::SSL::Host).to receive(:ca_location=).with(:none)
 
         @master.setup
       end
@@ -192,25 +193,24 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
     end
 
     describe "with a ca configured" do
-
       before :each do
-        Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
+        allow(Puppet::SSL::CertificateAuthority).to receive(:ca?).and_return(true)
       end
 
       it "should set the ca_location to local" do
-        Puppet::SSL::Host.expects(:ca_location=).with(:local)
+        expect(Puppet::SSL::Host).to receive(:ca_location=).with(:local)
 
         @master.setup
       end
 
       it "should tell Puppet.settings to use :ca category" do
-        Puppet.settings.expects(:use).with(:ca)
+        expect(Puppet.settings).to receive(:use).with(:ca)
 
         @master.setup
       end
 
       it "should instantiate the CertificateAuthority singleton" do
-        Puppet::SSL::CertificateAuthority.expects(:instance)
+        expect(Puppet::SSL::CertificateAuthority).to receive(:instance)
 
         @master.setup
       end
@@ -244,55 +244,55 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
 
     it "should dispatch to compile if called with --compile" do
       @master.options[:node] = "foo"
-      @master.expects(:compile)
+      expect(@master).to receive(:compile)
       @master.run_command
     end
 
     it "should dispatch to main otherwise" do
       @master.options[:node] = nil
 
-      @master.expects(:main)
+      expect(@master).to receive(:main)
       @master.run_command
     end
 
     describe "the compile command" do
       before do
         Puppet[:manifest] = "site.pp"
-        Puppet.stubs(:err)
-        @master.stubs(:puts)
+        allow(Puppet).to receive(:err)
+        allow(@master).to receive(:puts)
       end
 
       it "should compile a catalog for the specified node" do
         @master.options[:node] = "foo"
-        Puppet::Resource::Catalog.indirection.expects(:find).with("foo").returns Puppet::Resource::Catalog.new
+        expect(Puppet::Resource::Catalog.indirection).to receive(:find).with("foo").and_return(Puppet::Resource::Catalog.new)
 
         expect { @master.compile }.to exit_with 0
       end
 
       it "should convert the catalog to a pure-resource catalog and use 'JSON::pretty_generate' to pretty-print the catalog" do
         catalog = Puppet::Resource::Catalog.new
-        JSON.stubs(:pretty_generate)
-        Puppet::Resource::Catalog.indirection.expects(:find).returns catalog
+        allow(JSON).to receive(:pretty_generate)
+        expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(catalog)
 
-        catalog.expects(:to_resource).returns("rescat")
+        expect(catalog).to receive(:to_resource).and_return("rescat")
 
         @master.options[:node] = "foo"
-        JSON.expects(:pretty_generate).with('rescat', :allow_nan => true, :max_nesting => false)
+        expect(JSON).to receive(:pretty_generate).with('rescat', :allow_nan => true, :max_nesting => false)
 
         expect { @master.compile }.to exit_with 0
       end
 
       it "should exit with error code 30 if no catalog can be found" do
         @master.options[:node] = "foo"
-        Puppet::Resource::Catalog.indirection.expects(:find).returns nil
-        Puppet.expects(:log_exception)
+        expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(nil)
+        expect(Puppet).to receive(:log_exception)
         expect { @master.compile }.to exit_with 30
       end
 
       it "should exit with error code 30 if there's a failure" do
         @master.options[:node] = "foo"
-        Puppet::Resource::Catalog.indirection.expects(:find).raises ArgumentError
-        Puppet.expects(:log_exception)
+        expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_raise(ArgumentError)
+        expect(Puppet).to receive(:log_exception)
         expect { @master.compile }.to exit_with 30
       end
     end
@@ -300,72 +300,72 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
     describe "the main command" do
       before :each do
         @master.preinit
-        @server = stub_everything 'server'
-        Puppet::Network::Server.stubs(:new).returns(@server)
-        @app = stub_everything 'app'
-        Puppet::SSL::Host.stubs(:localhost)
-        Puppet::SSL::CertificateAuthority.stubs(:ca?)
-        Process.stubs(:uid).returns(1000)
-        Puppet.stubs(:service)
+        @server = double('server')
+        allow(Puppet::Network::Server).to receive(:new).and_return(@server)
+        @app = double('app')
+        allow(Puppet::SSL::Host).to receive(:localhost)
+        allow(Puppet::SSL::CertificateAuthority).to receive(:ca?)
+        allow(Process).to receive(:uid).and_return(1000)
+        allow(Puppet).to receive(:service)
         Puppet[:daemonize] = false
-        Puppet.stubs(:notice)
-        Puppet.stubs(:start)
-        Puppet::Util.stubs(:chuser)
+        allow(Puppet).to receive(:notice)
+        allow(Puppet).to receive(:start)
+        allow(Puppet::Util).to receive(:chuser)
       end
 
       it "should create a Server" do
-        Puppet::Network::Server.expects(:new)
+        expect(Puppet::Network::Server).to receive(:new)
 
         @master.main
       end
 
       it "should give the server to the daemon" do
-        @daemon.expects(:server=).with(@server)
+        expect(@daemon).to receive(:server=).with(@server)
 
         @master.main
       end
 
       it "should generate a SSL cert for localhost" do
-        Puppet::SSL::Host.expects(:localhost)
+        expect(Puppet::SSL::Host).to receive(:localhost)
 
         @master.main
       end
 
       it "should make sure to *only* hit the CA for data" do
-        Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
+        allow(Puppet::SSL::CertificateAuthority).to receive(:ca?).and_return(true)
 
-        Puppet::SSL::Host.expects(:ca_location=).with(:only)
+        expect(Puppet::SSL::Host).to receive(:ca_location=).with(:only)
 
         @master.main
       end
 
       def a_user_type_for(username)
-        user = mock 'user'
-        Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == username }.returns user
+        user = double('user')
+        expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: username)).and_return(user)
         user
       end
 
       context "user privileges" do
         it "should drop privileges if running as root and the puppet user exists" do
-          Puppet.features.stubs(:root?).returns true
-          a_user_type_for("puppet").expects(:exists?).returns true
+          allow(Puppet.features).to receive(:root?).and_return(true)
+          expect(a_user_type_for("puppet")).to receive(:exists?).and_return(true)
 
-          Puppet::Util.expects(:chuser)
+          expect(Puppet::Util).to receive(:chuser)
 
           @master.main
         end
 
         it "should exit and log an error if running as root and the puppet user does not exist" do
-          Puppet.features.stubs(:root?).returns true
-          a_user_type_for("puppet").expects(:exists?).returns false
-          Puppet.expects(:err).with('Could not change user to puppet. User does not exist and is required to continue.')
+          allow(Puppet.features).to receive(:root?).and_return(true)
+          expect(a_user_type_for("puppet")).to receive(:exists?).and_return(false)
+          expect(Puppet).to receive(:err).with('Could not change user to puppet. User does not exist and is required to continue.')
           expect { @master.main }.to exit_with 74
         end
       end
 
       it "should log a deprecation notice when running a WEBrick server" do
-        Puppet.expects(:deprecation_warning).with("The WEBrick Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppet.com/deprecate-rack-webrick-servers for more information.")
-        Puppet.expects(:deprecation_warning).with("Accessing 'bindaddress' as a setting is deprecated.")
+        expect(Puppet).to receive(:deprecation_warning).with("The WEBrick Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppet.com/deprecate-rack-webrick-servers for more information.")
+        expect(Puppet).to receive(:deprecation_warning).with("Accessing 'bindaddress' as a setting is deprecated.")
 
         @master.main
       end
@@ -373,13 +373,13 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
       it "should daemonize if needed" do
         Puppet[:daemonize] = true
 
-        @daemon.expects(:daemonize)
+        expect(@daemon).to receive(:daemonize)
 
         @master.main
       end
 
       it "should start the service" do
-        @daemon.expects(:start)
+        expect(@daemon).to receive(:start)
 
         @master.main
       end
@@ -387,13 +387,13 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
       describe "with --rack", :if => Puppet.features.rack? do
         before do
           require 'puppet/network/http/rack'
-          Puppet::Network::HTTP::Rack.stubs(:new).returns(@app)
+          allow(Puppet::Network::HTTP::Rack).to receive(:new).and_return(@app)
 
-          @master.options.stubs(:[]).with(:rack).returns(:true)
+          allow(@master.options).to receive(:[]).with(:rack).and_return(:true)
         end
 
         it "it should not start a daemon" do
-          @daemon.expects(:start).never
+          expect(@daemon).not_to receive(:start)
 
           @master.main
         end
@@ -404,7 +404,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         end
 
         it "should log a deprecation notice" do
-          Puppet.expects(:deprecation_warning).with("The Rack Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppet.com/deprecate-rack-webrick-servers for more information.")
+          expect(Puppet).to receive(:deprecation_warning).with("The Rack Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppet.com/deprecate-rack-webrick-servers for more information.")
 
           @master.main
         end

data/spec/unit/application/resource_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/application/resource'
@@ -6,9 +5,10 @@ require 'puppet_spec/character_encoding'
 
 describe Puppet::Application::Resource do
   include PuppetSpec::Files
+
   before :each do
     @resource_app = Puppet::Application[:resource]
-    Puppet::Util::Log.stubs(:newdestination)
+    allow(Puppet::Util::Log).to receive(:newdestination)
   end
 
   describe "in preinit" do
@@ -21,17 +21,17 @@ describe Puppet::Application::Resource do
   describe "when handling options" do
     [:debug, :verbose, :edit].each do |option|
       it "should store argument value when calling handle_#{option}" do
-        @resource_app.options.expects(:[]=).with(option, 'arg')
+        expect(@resource_app.options).to receive(:[]=).with(option, 'arg')
         @resource_app.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should load a display all types with types option" do
-      type1 = stub_everything 'type1', :name => :type1
-      type2 = stub_everything 'type2', :name => :type2
-      Puppet::Type.stubs(:loadall)
-      Puppet::Type.stubs(:eachtype).multiple_yields(type1,type2)
-      @resource_app.expects(:puts).with(['type1','type2'])
+      type1 = double('type1', :name => :type1)
+      type2 = double('type2', :name => :type2)
+      allow(Puppet::Type).to receive(:loadall)
+      allow(Puppet::Type).to receive(:eachtype).and_yield(type1).and_yield(type2)
+      expect(@resource_app).to receive(:puts).with(['type1','type2'])
       expect { @resource_app.handle_types(nil) }.to exit_with 0
     end
 
@@ -43,10 +43,10 @@ describe Puppet::Application::Resource do
     end
 
     it "should get a parameter in the printed data if extra_params are passed" do
-      tty  = stub("tty",  :tty? => true )
+      tty  = double("tty",  :tty? => true )
       path = tmpfile('testfile')
       command_line = Puppet::Util::CommandLine.new("puppet", [ 'resource', 'file', path ], tty )
-      @resource_app.stubs(:command_line).returns command_line
+      allow(@resource_app).to receive(:command_line).and_return(command_line)
 
       # provider is a parameter that should always be available
       @resource_app.extra_params = [ :provider ]
@@ -57,75 +57,70 @@ describe Puppet::Application::Resource do
 
   describe "during setup" do
     before :each do
-      Puppet::Log.stubs(:newdestination)
+      allow(Puppet::Log).to receive(:newdestination)
     end
 
     it "should set console as the log destination" do
-      Puppet::Log.expects(:newdestination).with(:console)
+      expect(Puppet::Log).to receive(:newdestination).with(:console)
 
       @resource_app.setup
     end
 
     it "should set log level to debug if --debug was passed" do
-      @resource_app.options.stubs(:[]).with(:debug).returns(true)
+      allow(@resource_app.options).to receive(:[]).with(:debug).and_return(true)
       @resource_app.setup
       expect(Puppet::Log.level).to eq(:debug)
     end
 
     it "should set log level to info if --verbose was passed" do
-      @resource_app.options.stubs(:[]).with(:debug).returns(false)
-      @resource_app.options.stubs(:[]).with(:verbose).returns(true)
+      allow(@resource_app.options).to receive(:[]).with(:debug).and_return(false)
+      allow(@resource_app.options).to receive(:[]).with(:verbose).and_return(true)
       @resource_app.setup
       expect(Puppet::Log.level).to eq(:info)
     end
-
   end
 
   describe "when running" do
     before :each do
-      @type = stub_everything 'type', :properties => []
-      @resource_app.command_line.stubs(:args).returns(['mytype'])
-      Puppet::Type.stubs(:type).returns(@type)
-
-      @res = stub_everything "resource"
-      @res.stubs(:prune_parameters).returns(@res)
-      @res.stubs(:to_manifest).returns("resource")
-      @report = stub_everything "report"
+      @type = double('type', :properties => [])
+      allow(@resource_app.command_line).to receive(:args).and_return(['mytype'])
+      allow(Puppet::Type).to receive(:type).and_return(@type)
 
-      @resource_app.stubs(:puts)
+      @res = double("resource")
+      allow(@res).to receive(:prune_parameters).and_return(@res)
+      allow(@res).to receive(:to_manifest).and_return("resource")
+      @report = double("report")
 
-      Puppet::Resource.indirection.stubs(:find  ).never
-      Puppet::Resource.indirection.stubs(:search).never
-      Puppet::Resource.indirection.stubs(:save  ).never
+      allow(@resource_app).to receive(:puts)
     end
 
     it "should raise an error if no type is given" do
-      @resource_app.command_line.stubs(:args).returns([])
+      allow(@resource_app.command_line).to receive(:args).and_return([])
       expect { @resource_app.main }.to raise_error(RuntimeError, "You must specify the type to display")
     end
 
     it "should raise an error if the type is not found" do
-      Puppet::Type.stubs(:type).returns(nil)
+      allow(Puppet::Type).to receive(:type).and_return(nil)
 
       expect { @resource_app.main }.to raise_error(RuntimeError, 'Could not find type mytype')
     end
 
     it "should search for resources" do
-      Puppet::Resource.indirection.expects(:search).with('mytype/', {}).returns([])
+      expect(Puppet::Resource.indirection).to receive(:search).with('mytype/', {}).and_return([])
       @resource_app.main
     end
 
     it "should describe the given resource" do
-      @resource_app.command_line.stubs(:args).returns(['type','name'])
-      Puppet::Resource.indirection.expects(:find).with('type/name').returns(@res)
+      allow(@resource_app.command_line).to receive(:args).and_return(['type','name'])
+      expect(Puppet::Resource.indirection).to receive(:find).with('type/name').and_return(@res)
       @resource_app.main
     end
 
     it "should add given parameters to the object" do
-      @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
+      allow(@resource_app.command_line).to receive(:args).and_return(['type','name','param=temp'])
 
-      Puppet::Resource.indirection.expects(:save).with(@res, 'type/name').returns([@res, @report])
-      Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
+      expect(Puppet::Resource.indirection).to receive(:save).with(@res, 'type/name').and_return([@res, @report])
+      expect(Puppet::Resource).to receive(:new).with('type', 'name', :parameters => {'param' => 'temp'}).and_return(@res)
 
       @resource_app.main
     end
@@ -137,11 +132,11 @@ describe Puppet::Application::Resource do
         Puppet::Type.type(:user).new(:name => "\u2603".force_encoding(Encoding::UTF_8)).to_resource,
         Puppet::Type.type(:user).new(:name => "Jos\xE9".force_encoding(Encoding::ISO_8859_1)).to_resource
       ]
-      Puppet::Resource.indirection.expects(:search).with('user/', {}).returns(resources)
-      @resource_app.command_line.stubs(:args).returns(['user'])
+      expect(Puppet::Resource.indirection).to receive(:search).with('user/', {}).and_return(resources)
+      allow(@resource_app.command_line).to receive(:args).and_return(['user'])
 
       # All of our output should be in external encoding
-      @resource_app.expects(:puts).with { |args| expect(args.encoding).to eq(Encoding::ISO_8859_1) }
+      expect(@resource_app).to receive(:puts) { |args| expect(args.encoding).to eq(Encoding::ISO_8859_1) }
 
       # This would raise an error if we weren't handling it
       PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
@@ -152,12 +147,12 @@ describe Puppet::Application::Resource do
 
   describe "when handling file type" do
     before :each do
-      Facter.stubs(:loadfacts)
+      allow(Facter).to receive(:loadfacts)
       @resource_app.preinit
     end
 
     it "should raise an exception if no file specified" do
-      @resource_app.command_line.stubs(:args).returns(['file'])
+      allow(@resource_app.command_line).to receive(:args).and_return(['file'])
 
       expect { @resource_app.main }.to raise_error(RuntimeError, /Listing all file instances is not supported/)
     end
@@ -165,12 +160,10 @@ describe Puppet::Application::Resource do
     it "should output a file resource when given a file path" do
       path = File.expand_path('/etc')
       res = Puppet::Type.type(:file).new(:path => path).to_resource
-      Puppet::Resource.indirection.expects(:find).returns(res)
+      expect(Puppet::Resource.indirection).to receive(:find).and_return(res)
 
-      @resource_app.command_line.stubs(:args).returns(['file', path])
-      @resource_app.expects(:puts).with do |args|
-        expect(args).to match(/file \{ '#{Regexp.escape(path)}'/m)
-      end
+      allow(@resource_app.command_line).to receive(:args).and_return(['file', path])
+      expect(@resource_app).to receive(:puts).with(/file \{ '#{Regexp.escape(path)}'/m)
 
       @resource_app.main
     end
@@ -187,8 +180,9 @@ describe Puppet::Application::Resource do
           @instances ||= [new(:name => name)]
         end
       end
-      @resource_app.command_line.stubs(:args).returns(['testing', 'hello'])
-      @resource_app.expects(:puts).with { |args| expect(args).to eql("testing { 'hello':\n}") }
+
+      allow(@resource_app.command_line).to receive(:args).and_return(['testing', 'hello'])
+      expect(@resource_app).to receive(:puts).with("testing { 'hello':\n}")
       expect { @resource_app.main }.not_to raise_error
     end
   end