puppet 6.0.7-x64-mingw32 → 6.0.8-x64-mingw32

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

data/spec/unit/application/ssl_spec.rb

@@ -146,8 +146,8 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
       end.to_return(status: 200)
       stub_request(:get, %r{puppet-ca/v1/certificate/#{name}}).to_return(status: 404)
 
-      Puppet.stubs(:warning) # ignore unrelated warnings
-      Puppet.expects(:warning).with("The local CSR does not match the agent's public key. Generating a new CSR.")
+      allow(Puppet).to receive(:warning) # ignore unrelated warnings
+      expect(Puppet).to receive(:warning).with("The local CSR does not match the agent's public key. Generating a new CSR.")
       expects_command_to_pass(%r{Submitted certificate request for '#{name}' to https://.*})
     end
 
@@ -266,7 +266,7 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
     end
 
     it 'reports when verification succeeds' do
-      OpenSSL::X509::Store.any_instance.stubs(:verify).returns(true)
+      allow_any_instance_of(OpenSSL::X509::Store).to receive(:verify).and_return(true)
 
       expects_command_to_pass(/Verified certificate '#{name}'/)
     end

data/spec/unit/application_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/application'
@@ -12,8 +11,7 @@ describe Puppet::Application do
     @app = Class.new(Puppet::Application).new
     @appclass = @app.class
 
-    @app.stubs(:name).returns("test_app")
-
+    allow(@app).to receive(:name).and_return("test_app")
   end
 
   describe "application commandline" do
@@ -32,8 +30,8 @@ describe Puppet::Application do
 
   describe "application defaults" do
     it "should fail if required app default values are missing" do
-      @app.stubs(:app_defaults).returns({ :foo => 'bar' })
-      Puppet.expects(:send_log).with(:err, regexp_matches(/missing required app default setting/))
+      allow(@app).to receive(:app_defaults).and_return({ :foo => 'bar' })
+      expect(Puppet).to receive(:send_log).with(:err, /missing required app default setting/)
       expect {
         @app.run
       }.to exit_with(1)
@@ -43,7 +41,7 @@ describe Puppet::Application do
   describe "finding" do
     before do
       @klass = Puppet::Application
-      @klass.stubs(:puts)
+      allow(@klass).to receive(:puts)
     end
 
     it "should find classes in the namespace" do
@@ -55,10 +53,10 @@ describe Puppet::Application do
     end
 
     it "should error if it can't find a class" do
-      Puppet.expects(:send_log).with do |_level, message|
-        message =~ /Unable to find application 'ThisShallNeverEverEverExist'/ and
-          message =~ /puppet\/application\/thisshallneverevereverexist/ and
-          message =~ /no such file to load|cannot load such file/
+      expect(Puppet).to receive(:send_log) do |_level, message|
+        expect(message).to match(/Unable to find application 'ThisShallNeverEverEverExist'/)
+        expect(message).to match(/puppet\/application\/thisshallneverevereverexist/)
+        expect(message).to match(/no such file to load|cannot load such file/)
       end
 
       expect {
@@ -70,43 +68,43 @@ describe Puppet::Application do
   describe "#available_application_names" do
     it 'should be able to find available application names' do
       apps =  %w{describe filebucket kick queue resource agent cert apply doc master}
-      Puppet::Util::Autoload.expects(:files_to_load).returns(apps)
+      expect(Puppet::Util::Autoload).to receive(:files_to_load).and_return(apps)
 
       expect(Puppet::Application.available_application_names).to match_array(apps)
     end
 
     it 'should find applications from multiple paths' do
-      Puppet::Util::Autoload.expects(:files_to_load).with(
+      expect(Puppet::Util::Autoload).to receive(:files_to_load).with(
         'puppet/application',
-        is_a(Puppet::Node::Environment)
-      ).returns(%w{ /a/foo.rb /b/bar.rb })
+        be_a(Puppet::Node::Environment)
+      ).and_return(%w{ /a/foo.rb /b/bar.rb })
 
       expect(Puppet::Application.available_application_names).to match_array(%w{ foo bar })
     end
 
     it 'should return unique application names' do
-      Puppet::Util::Autoload.expects(:files_to_load).with(
+      expect(Puppet::Util::Autoload).to receive(:files_to_load).with(
         'puppet/application',
-        is_a(Puppet::Node::Environment)
-      ).returns(%w{ /a/foo.rb /b/foo.rb })
+        be_a(Puppet::Node::Environment)
+      ).and_return(%w{ /a/foo.rb /b/foo.rb })
 
       expect(Puppet::Application.available_application_names).to eq(%w{ foo })
     end
 
     it 'finds the application using the configured environment' do
       Puppet[:environment] = 'production'
-      Puppet::Util::Autoload.expects(:files_to_load).with do |_, env|
+      expect(Puppet::Util::Autoload).to receive(:files_to_load) do |_, env|
         expect(env.name).to eq(:production)
-      end.returns(%w{ /a/foo.rb })
+      end.and_return(%w{ /a/foo.rb })
 
       expect(Puppet::Application.available_application_names).to eq(%w{ foo })
     end
 
     it "falls back to the current environment if the configured environment doesn't exist" do
       Puppet[:environment] = 'doesnotexist'
-      Puppet::Util::Autoload.expects(:files_to_load).with do |_, env|
+      expect(Puppet::Util::Autoload).to receive(:files_to_load) do |_, env|
         expect(env.name).to eq(:'*root*')
-      end.returns(%w[a/foo.rb])
+      end.and_return(%w[a/foo.rb])
 
       expect(Puppet::Application.available_application_names).to eq(%w[foo])
     end
@@ -157,7 +155,7 @@ describe Puppet::Application do
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #initialize_app_defaults" do
-      Puppet.features.stubs(:syslog?).returns(true)
+      allow(Puppet.features).to receive(:syslog?).and_return(true)
 
       app = TestApp.new
       app.initialize_app_defaults
@@ -207,7 +205,7 @@ describe Puppet::Application do
   end
 
   it "should invoke main as the default" do
-    @app.expects( :main )
+    expect(@app).to receive(:main)
     @app.run_command
   end
 
@@ -303,8 +301,8 @@ describe Puppet::Application do
   describe 'when performing a controlled_run' do
     it 'should not execute block if not :clear?' do
       Puppet::Application.run_status = :stop_requested
-      target = mock 'target'
-      target.expects(:some_method).never
+      target = double('target')
+      expect(target).not_to receive(:some_method)
       Puppet::Application.controlled_run do
         target.some_method
       end
@@ -312,8 +310,8 @@ describe Puppet::Application do
 
     it 'should execute block if :clear?' do
       Puppet::Application.run_status = nil
-      target = mock 'target'
-      target.expects(:some_method).once
+      target = double('target')
+      expect(target).to receive(:some_method).once
       Puppet::Application.controlled_run do
         target.some_method
       end
@@ -354,38 +352,36 @@ describe Puppet::Application do
   describe "when parsing command-line options" do
 
     before :each do
-      @app.command_line.stubs(:args).returns([])
+      allow(@app.command_line).to receive(:args).and_return([])
 
-      Puppet.settings.stubs(:optparse_addargs).returns([])
+      allow(Puppet.settings).to receive(:optparse_addargs).and_return([])
     end
 
     it "should pass the banner to the option parser" do
-      option_parser = stub "option parser"
-      option_parser.stubs(:on)
-      option_parser.stubs(:parse!)
+      option_parser = double("option parser")
+      allow(option_parser).to receive(:on)
+      allow(option_parser).to receive(:parse!)
       @app.class.instance_eval do
         banner "banner"
       end
 
-      OptionParser.expects(:new).with("banner").returns(option_parser)
+      expect(OptionParser).to receive(:new).with("banner").and_return(option_parser)
 
       @app.parse_options
     end
 
     it "should ask OptionParser to parse the command-line argument" do
-      @app.command_line.stubs(:args).returns(%w{ fake args })
-      OptionParser.any_instance.expects(:parse!).with(%w{ fake args })
+      allow(@app.command_line).to receive(:args).and_return(%w{ fake args })
+      expect_any_instance_of(OptionParser).to receive(:parse!).with(%w{ fake args })
 
       @app.parse_options
     end
 
     describe "when using --help" do
-
       it "should call exit" do
-        @app.stubs(:puts)
+        allow(@app).to receive(:puts)
         expect { @app.handle_help(nil) }.to exit_with 0
       end
-
     end
 
     describe "when using --version" do
@@ -394,66 +390,65 @@ describe Puppet::Application do
       end
 
       it "should exit after printing the version" do
-        @app.stubs(:puts)
+        allow(@app).to receive(:puts)
         expect { @app.handle_version(nil) }.to exit_with 0
       end
     end
 
     describe "when dealing with an argument not declared directly by the application" do
       it "should pass it to handle_unknown if this method exists" do
-        Puppet.settings.stubs(:optparse_addargs).returns([["--not-handled", :REQUIRED]])
+        allow(Puppet.settings).to receive(:optparse_addargs).and_return([["--not-handled", :REQUIRED]])
 
-        @app.expects(:handle_unknown).with("--not-handled", "value").returns(true)
-        @app.command_line.stubs(:args).returns(["--not-handled", "value"])
+        expect(@app).to receive(:handle_unknown).with("--not-handled", "value").and_return(true)
+        allow(@app.command_line).to receive(:args).and_return(["--not-handled", "value"])
         @app.parse_options
       end
 
       it "should transform boolean option to normal form for Puppet.settings" do
-        @app.expects(:handle_unknown).with("--option", true)
+        expect(@app).to receive(:handle_unknown).with("--option", true)
         @app.send(:handlearg, "--[no-]option", true)
       end
 
       it "should transform boolean option to no- form for Puppet.settings" do
-        @app.expects(:handle_unknown).with("--no-option", false)
+        expect(@app).to receive(:handle_unknown).with("--no-option", false)
         @app.send(:handlearg, "--[no-]option", false)
       end
-
     end
   end
 
   describe "when calling default setup" do
     before :each do
-      @app.options.stubs(:[])
+      allow(@app.options).to receive(:[])
     end
 
     [ :debug, :verbose ].each do |level|
       it "should honor option #{level}" do
-        @app.options.stubs(:[]).with(level).returns(true)
-        Puppet::Util::Log.stubs(:newdestination)
+        allow(@app.options).to receive(:[]).with(level).and_return(true)
+        allow(Puppet::Util::Log).to receive(:newdestination)
         @app.setup
         expect(Puppet::Util::Log.level).to eq(level == :verbose ? :info : :debug)
       end
     end
 
     it "should honor setdest option" do
-      @app.options.stubs(:[]).with(:setdest).returns(false)
+      allow(@app.options).to receive(:[]).with(:setdest).and_return(false)
 
-      Puppet::Util::Log.expects(:setup_default)
+      expect(Puppet::Util::Log).to receive(:setup_default)
 
       @app.setup
     end
-  
+
     it "sets the log destination if provided via settings" do
-      @app.options.unstub(:[])
+      allow(@app.options).to receive(:[]).and_call_original
       Puppet[:logdest] = "set_via_config"
-      Puppet::Util::Log.expects(:newdestination).with("set_via_config")
+      expect(Puppet::Util::Log).to receive(:newdestination).with("set_via_config")
 
       @app.setup
     end
 
     it "does not downgrade the loglevel when --verbose is specified" do
       Puppet[:log_level] = :debug
-      @app.options.stubs(:[]).with(:verbose).returns(true)
+      allow(@app.options).to receive(:[]).with(:verbose).and_return(true)
       @app.setup_logs
 
       expect(Puppet::Util::Log.level).to eq(:debug)
@@ -516,69 +511,65 @@ describe Puppet::Application do
   end
 
   describe "when running" do
-
     before :each do
-      @app.stubs(:preinit)
-      @app.stubs(:setup)
-      @app.stubs(:parse_options)
+      allow(@app).to receive(:preinit)
+      allow(@app).to receive(:setup)
+      allow(@app).to receive(:parse_options)
     end
 
     it "should call preinit" do
-      @app.stubs(:run_command)
+      allow(@app).to receive(:run_command)
 
-      @app.expects(:preinit)
+      expect(@app).to receive(:preinit)
 
       @app.run
     end
 
     it "should call parse_options" do
-      @app.stubs(:run_command)
+      allow(@app).to receive(:run_command)
 
-      @app.expects(:parse_options)
+      expect(@app).to receive(:parse_options)
 
       @app.run
     end
 
     it "should call run_command" do
-
-      @app.expects(:run_command)
+      expect(@app).to receive(:run_command)
 
       @app.run
     end
 
-
     it "should call run_command" do
-      @app.expects(:run_command)
+      expect(@app).to receive(:run_command)
 
       @app.run
     end
 
     it "should call main as the default command" do
-      @app.expects(:main)
+      expect(@app).to receive(:main)
 
       @app.run
     end
 
     it "should warn and exit if no command can be called" do
-      Puppet.expects(:send_log).with(:err, "Could not run: No valid command or main")
+      expect(Puppet).to receive(:send_log).with(:err, "Could not run: No valid command or main")
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns no command" do
-      @app.stubs(:get_command).returns(nil)
-      Puppet.expects(:send_log).with(:err, "Could not run: No valid command or main")
+      allow(@app).to receive(:get_command).and_return(nil)
+      expect(Puppet).to receive(:send_log).with(:err, "Could not run: No valid command or main")
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns an invalid command" do
-      @app.stubs(:get_command).returns(:this_function_doesnt_exist)
-      Puppet.expects(:send_log).with(:err, "Could not run: No valid command or main")
+      allow(@app).to receive(:get_command).and_return(:this_function_doesnt_exist)
+      expect(Puppet).to receive(:send_log).with(:err, "Could not run: No valid command or main")
       expect { @app.run }.to exit_with 1
     end
   end
 
   describe "when metaprogramming" do
-
     describe "when calling option" do
       it "should create a new method named after the option" do
         @app.class.option("--test1","-t") do
@@ -611,8 +602,8 @@ describe Puppet::Application do
         end
 
         it "should declare the option to OptionParser" do
-          OptionParser.any_instance.stubs(:on)
-          OptionParser.any_instance.expects(:on).with { |*arg| arg[0] == "--[no-]test3" }
+          allow_any_instance_of(OptionParser).to receive(:on)
+          expect_any_instance_of(OptionParser).to receive(:on).with("--[no-]test3", anything)
 
           @app.class.option("--[no-]test3","-t") do
           end
@@ -621,10 +612,10 @@ describe Puppet::Application do
         end
 
         it "should pass a block that calls our defined method" do
-          OptionParser.any_instance.stubs(:on)
-          OptionParser.any_instance.stubs(:on).with('--test4','-t').yields(nil)
+          allow_any_instance_of(OptionParser).to receive(:on)
+          allow_any_instance_of(OptionParser).to receive(:on).with('--test4', '-t').and_yield(nil)
 
-          @app.expects(:send).with(:handle_test4, nil)
+          expect(@app).to receive(:send).with(:handle_test4, nil)
 
           @app.class.option("--test4","-t") do
           end
@@ -635,8 +626,8 @@ describe Puppet::Application do
 
       describe "when no block is given" do
         it "should declare the option to OptionParser" do
-          OptionParser.any_instance.stubs(:on)
-          OptionParser.any_instance.expects(:on).with("--test4","-t")
+          allow_any_instance_of(OptionParser).to receive(:on)
+          expect_any_instance_of(OptionParser).to receive(:on).with("--test4", "-t")
 
           @app.class.option("--test4","-t")
 
@@ -644,10 +635,10 @@ describe Puppet::Application do
         end
 
         it "should give to OptionParser a block that adds the value to the options array" do
-          OptionParser.any_instance.stubs(:on)
-          OptionParser.any_instance.stubs(:on).with("--test4","-t").yields(nil)
+          allow_any_instance_of(OptionParser).to receive(:on)
+          allow_any_instance_of(OptionParser).to receive(:on).with("--test4", "-t").and_yield(nil)
 
-          @app.options.expects(:[]=).with(:test4,nil)
+          expect(@app.options).to receive(:[]=).with(:test4, nil)
 
           @app.class.option("--test4","-t")
 
@@ -655,7 +646,6 @@ describe Puppet::Application do
         end
       end
     end
-
   end
 
   describe "#handle_logdest_arg" do
@@ -663,38 +653,38 @@ describe Puppet::Application do
 
     it "should log an exception that is raised" do
       our_exception = Puppet::DevError.new("test exception")
-      Puppet::Util::Log.expects(:newdestination).with(test_arg).raises(our_exception)
-      Puppet.expects(:log_and_raise).with(our_exception, anything)
+      expect(Puppet::Util::Log).to receive(:newdestination).with(test_arg).and_raise(our_exception)
+      expect(Puppet).to receive(:log_and_raise).with(our_exception, anything)
       @app.handle_logdest_arg(test_arg)
     end
 
     it "should exit when an exception is raised" do
       our_exception = Puppet::DevError.new("test exception")
-      Puppet::Util::Log.expects(:newdestination).with(test_arg).raises(our_exception)
-      Puppet.expects(:log_and_raise).with(our_exception, anything).raises(our_exception)
+      expect(Puppet::Util::Log).to receive(:newdestination).with(test_arg).and_raise(our_exception)
+      expect(Puppet).to receive(:log_and_raise).with(our_exception, anything).and_raise(our_exception)
       expect { @app.handle_logdest_arg(test_arg) }.to raise_error(Puppet::DevError)
     end
 
     it "should set the new log destination" do
-      Puppet::Util::Log.expects(:newdestination).with(test_arg)
+      expect(Puppet::Util::Log).to receive(:newdestination).with(test_arg)
       @app.handle_logdest_arg(test_arg)
     end
 
     it "should set the flag that a destination is set in the options hash" do
-      Puppet::Util::Log.stubs(:newdestination).with(test_arg)
+      allow(Puppet::Util::Log).to receive(:newdestination).with(test_arg)
       @app.handle_logdest_arg(test_arg)
       expect(@app.options[:setdest]).to be_truthy
     end
 
     it "does not set the log destination if setdest is true" do
-      Puppet::Util::Log.expects(:newdestination).never
+      expect(Puppet::Util::Log).not_to receive(:newdestination)
       @app.options[:setdest] = true
 
       @app.handle_logdest_arg(test_arg)
     end
 
     it "does not set the log destination if arg is nil" do
-      Puppet::Util::Log.expects(:newdestination).never
+      expect(Puppet::Util::Log).not_to receive(:newdestination)
 
       @app.handle_logdest_arg(nil)
     end