puppet 5.3.4 → 6.29.0

data/spec/unit/application/doc_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/application/doc'
@@ -8,9 +7,9 @@ require 'puppet/util/rdoc'
 describe Puppet::Application::Doc do
   before :each do
     @doc = Puppet::Application[:doc]
-    @doc.stubs(:puts)
+    allow(@doc).to receive(:puts)
     @doc.preinit
-    Puppet::Util::Log.stubs(:newdestination)
+    allow(Puppet::Util::Log).to receive(:newdestination)
   end
 
   it "should declare an other command" do
@@ -56,49 +55,49 @@ describe Puppet::Application::Doc do
       end
 
       it "should store argument value when calling handle_#{option}" do
-        @doc.options.expects(:[]=).with(option, 'arg')
+        expect(@doc.options).to receive(:[]=).with(option, 'arg')
         @doc.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should store the format if valid" do
-      Puppet::Util::Reference.stubs(:method_defined?).with('to_format').returns(true)
+      allow(Puppet::Util::Reference).to receive(:method_defined?).with('to_format').and_return(true)
 
       @doc.handle_format('format')
       expect(@doc.options[:format]).to eq('to_format')
     end
 
     it "should raise an error if the format is not valid" do
-      Puppet::Util::Reference.stubs(:method_defined?).with('to_format').returns(false)
+      allow(Puppet::Util::Reference).to receive(:method_defined?).with('to_format').and_return(false)
       expect { @doc.handle_format('format') }.to raise_error(RuntimeError, /Invalid output format/)
     end
 
     it "should store the mode if valid" do
-      Puppet::Util::Reference.stubs(:modes).returns(stub('mode', :include? => true))
+      allow(Puppet::Util::Reference).to receive(:modes).and_return(double('mode', :include? => true))
 
       @doc.handle_mode('mode')
       expect(@doc.options[:mode]).to eq(:mode)
     end
 
     it "should store the mode if :rdoc" do
-      Puppet::Util::Reference.modes.stubs(:include?).with('rdoc').returns(false)
+      allow(Puppet::Util::Reference.modes).to receive(:include?).with('rdoc').and_return(false)
 
       @doc.handle_mode('rdoc')
       expect(@doc.options[:mode]).to eq(:rdoc)
     end
 
     it "should raise an error if the mode is not valid" do
-      Puppet::Util::Reference.modes.stubs(:include?).with('unknown').returns(false)
+      allow(Puppet::Util::Reference.modes).to receive(:include?).with('unknown').and_return(false)
       expect { @doc.handle_mode('unknown') }.to raise_error(RuntimeError, /Invalid output mode/)
     end
 
     it "should list all references on list and exit" do
-      reference = stubs 'reference'
-      ref = stubs 'ref'
-      Puppet::Util::Reference.stubs(:references).returns([reference])
+      reference = double('reference')
+      ref = double('ref')
+      allow(Puppet::Util::Reference).to receive(:references).and_return([reference])
 
-      Puppet::Util::Reference.expects(:reference).with(reference).returns(ref)
-      ref.expects(:doc)
+      expect(Puppet::Util::Reference).to receive(:reference).with(reference).and_return(ref)
+      expect(ref).to receive(:doc)
 
       expect { @doc.handle_list(nil) }.to exit_with 0
     end
@@ -113,15 +112,14 @@ describe Puppet::Application::Doc do
   end
 
   describe "during setup" do
-
     before :each do
-      Puppet::Log.stubs(:newdestination)
-      @doc.command_line.stubs(:args).returns([])
+      allow(Puppet::Log).to receive(:newdestination)
+      allow(@doc.command_line).to receive(:args).and_return([])
     end
 
     it "should default to rdoc mode if there are command line arguments" do
-      @doc.command_line.stubs(:args).returns(["1"])
-      @doc.stubs(:setup_rdoc)
+      allow(@doc.command_line).to receive(:args).and_return(["1"])
+      allow(@doc).to receive(:setup_rdoc)
 
       @doc.setup
       expect(@doc.options[:mode]).to eq(:rdoc)
@@ -130,7 +128,7 @@ describe Puppet::Application::Doc do
     it "should call setup_rdoc in rdoc mode" do
       @doc.options[:mode] = :rdoc
 
-      @doc.expects(:setup_rdoc)
+      expect(@doc).to receive(:setup_rdoc)
 
       @doc.setup
     end
@@ -138,14 +136,14 @@ describe Puppet::Application::Doc do
     it "should call setup_reference if not rdoc" do
       @doc.options[:mode] = :test
 
-      @doc.expects(:setup_reference)
+      expect(@doc).to receive(:setup_reference)
 
       @doc.setup
     end
 
     describe "configuring logging" do
       before :each do
-        Puppet::Util::Log.stubs(:newdestination)
+        allow(Puppet::Util::Log).to receive(:newdestination)
       end
 
       describe "with --debug" do
@@ -159,7 +157,7 @@ describe Puppet::Application::Doc do
         end
 
         it "should set log destination to console" do
-          Puppet::Util::Log.expects(:newdestination).with(:console)
+          expect(Puppet::Util::Log).to receive(:newdestination).with(:console)
           @doc.setup
         end
       end
@@ -175,7 +173,7 @@ describe Puppet::Application::Doc do
         end
 
         it "should set log destination to console" do
-          Puppet::Util::Log.expects(:newdestination).with(:console)
+          expect(Puppet::Util::Log).to receive(:newdestination).with(:console)
           @doc.setup
         end
       end
@@ -192,7 +190,7 @@ describe Puppet::Application::Doc do
         end
 
         it "should set log destination to console" do
-          Puppet::Util::Log.expects(:newdestination).with(:console)
+          expect(Puppet::Util::Log).to receive(:newdestination).with(:console)
           @doc.setup
         end
       end
@@ -201,11 +199,11 @@ describe Puppet::Application::Doc do
     describe "in non-rdoc mode" do
       it "should get all non-dynamic reference if --all" do
         @doc.options[:all] = true
-        static = stub 'static', :dynamic? => false
-        dynamic = stub 'dynamic', :dynamic? => true
-        Puppet::Util::Reference.stubs(:reference).with(:static).returns(static)
-        Puppet::Util::Reference.stubs(:reference).with(:dynamic).returns(dynamic)
-        Puppet::Util::Reference.stubs(:references).returns([:static,:dynamic])
+        static = double('static', :dynamic? => false)
+        dynamic = double('dynamic', :dynamic? => true)
+        allow(Puppet::Util::Reference).to receive(:reference).with(:static).and_return(static)
+        allow(Puppet::Util::Reference).to receive(:reference).with(:dynamic).and_return(dynamic)
+        allow(Puppet::Util::Reference).to receive(:references).and_return([:static,:dynamic])
 
         @doc.setup_reference
         expect(@doc.options[:references]).to eq([:static])
@@ -221,7 +219,7 @@ describe Puppet::Application::Doc do
       describe "when there are unknown args" do
         it "should expand --modulepath if any" do
           @doc.unknown_args = [ { :opt => "--modulepath", :arg => "path" } ]
-          Puppet.settings.stubs(:handlearg)
+          allow(Puppet.settings).to receive(:handlearg)
 
           @doc.setup_rdoc
 
@@ -230,14 +228,14 @@ describe Puppet::Application::Doc do
 
         it "should give them to Puppet.settings" do
           @doc.unknown_args = [ { :opt => :option, :arg => :argument } ]
-          Puppet.settings.expects(:handlearg).with(:option,:argument)
+          expect(Puppet.settings).to receive(:handlearg).with(:option,:argument)
 
           @doc.setup_rdoc
         end
       end
 
-      it "should operate in master run_mode" do
-        expect(@doc.class.run_mode.name).to eq(:master)
+      it "should operate in server run_mode" do
+        expect(@doc.class.run_mode.name).to eq(:server)
 
         @doc.setup_rdoc
       end
@@ -255,16 +253,16 @@ describe Puppet::Application::Doc do
 
       before :each do
         @doc.manifest = false
-        Puppet.stubs(:info)
+        allow(Puppet).to receive(:info)
         Puppet[:trace] = false
         Puppet[:modulepath] = modules
         Puppet[:manifest] = manifests
         @doc.options[:all] = false
         @doc.options[:outputdir] = 'doc'
         @doc.options[:charset] = nil
-        Puppet.settings.stubs(:define_settings)
-        Puppet::Util::RDoc.stubs(:rdoc)
-        @doc.command_line.stubs(:args).returns([])
+        allow(Puppet.settings).to receive(:define_settings)
+        allow(Puppet::Util::RDoc).to receive(:rdoc)
+        allow(@doc.command_line).to receive(:args).and_return([])
       end
 
       around(:each) do |example|
@@ -277,31 +275,31 @@ describe Puppet::Application::Doc do
 
       it "should set document_all on --all" do
         @doc.options[:all] = true
-        Puppet.settings.expects(:[]=).with(:document_all, true)
+        expect(Puppet.settings).to receive(:[]=).with(:document_all, true)
 
         expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.rdoc in full mode" do
-        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], nil)
+        expect(Puppet::Util::RDoc).to receive(:rdoc).with('doc', [modules, manifests], nil)
         expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.rdoc with a charset if --charset has been provided" do
         @doc.options[:charset] = 'utf-8'
-        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], "utf-8")
+        expect(Puppet::Util::RDoc).to receive(:rdoc).with('doc', [modules, manifests], "utf-8")
         expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.rdoc in full mode with outputdir set to doc if no --outputdir" do
         @doc.options[:outputdir] = false
-        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], nil)
+        expect(Puppet::Util::RDoc).to receive(:rdoc).with('doc', [modules, manifests], nil)
         expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.manifestdoc in manifest mode" do
         @doc.manifest = true
-        Puppet::Util::RDoc.expects(:manifestdoc)
+        expect(Puppet::Util::RDoc).to receive(:manifestdoc)
         expect { @doc.rdoc }.to exit_with(0)
       end
 
@@ -312,7 +310,7 @@ describe Puppet::Application::Doc do
           [modules, modules2],
           "envmanifests/site.pp")
         Puppet.override({:environments => Puppet::Environments::Static.new(env), :current_environment => env}) do
-           Puppet::Util::RDoc.stubs(:rdoc).with('doc', [modules.to_s, modules2.to_s, env.manifest.to_s], nil)
+           allow(Puppet::Util::RDoc).to receive(:rdoc).with('doc', [modules.to_s, modules2.to_s, env.manifest.to_s], nil)
           expect { @doc.rdoc }.to exit_with(0)
         end
       end
@@ -320,14 +318,14 @@ describe Puppet::Application::Doc do
 
     describe "in the other modes" do
       it "should get reference in given format" do
-        reference = stub 'reference'
+        reference = double('reference')
         @doc.options[:mode] = :none
         @doc.options[:references] = [:ref]
-        Puppet::Util::Reference.expects(:reference).with(:ref).returns(reference)
+        expect(Puppet::Util::Reference).to receive(:reference).with(:ref).and_return(reference)
         @doc.options[:format] = :format
-        @doc.stubs(:exit)
+        allow(@doc).to receive(:exit)
 
-        reference.expects(:send).with { |format,contents| format == :format }.returns('doc')
+        expect(reference).to receive(:send).with(:format, anything).and_return('doc')
         @doc.other
       end
     end

data/spec/unit/application/face_base_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/application/face_base'
 require 'tmpdir'
@@ -9,8 +8,8 @@ end
 describe Puppet::Application::FaceBase do
   let :app do
     app = Puppet::Application::FaceBase::Basetest.new
-    app.command_line.stubs(:subcommand_name).returns('subcommand')
-    Puppet::Util::Log.stubs(:newdestination)
+    allow(app.command_line).to receive(:subcommand_name).and_return('subcommand')
+    allow(Puppet::Util::Log).to receive(:newdestination)
     app
   end
 
@@ -20,8 +19,8 @@ describe Puppet::Application::FaceBase do
 
   describe "#find_global_settings_argument" do
     it "should not match --ca to --ca-location" do
-      option = mock('ca option', :optparse_args => ["--ca"])
-      Puppet.settings.expects(:each).yields(:ca, option)
+      option = double('ca option', :optparse_args => ["--ca"])
+      expect(Puppet.settings).to receive(:each).and_yield(:ca, option)
 
       expect(app.find_global_settings_argument("--ca-location")).to be_nil
     end
@@ -29,7 +28,7 @@ describe Puppet::Application::FaceBase do
 
   describe "#parse_options" do
     before :each do
-      app.command_line.stubs(:args).returns %w{}
+      allow(app.command_line).to receive(:args).and_return(%w{})
     end
 
     describe "with just an action" do
@@ -40,8 +39,8 @@ describe Puppet::Application::FaceBase do
         #
         # It would be nice to fix this elsewhere, but it is actually hard to
         # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
-        Signal.stubs(:trap)
-        app.command_line.stubs(:args).returns %w{foo}
+        allow(Signal).to receive(:trap)
+        allow(app.command_line).to receive(:args).and_return(%w{foo})
         app.preinit
         app.parse_options
       end
@@ -57,7 +56,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should stop if the first thing found is not an action" do
-      app.command_line.stubs(:args).returns %w{banana count_args}
+      allow(app.command_line).to receive(:args).and_return(%w{banana count_args})
 
       expect { app.run }.to exit_with(1)
 
@@ -65,29 +64,29 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should use the default action if not given any arguments" do
-      app.command_line.stubs(:args).returns []
-      action = stub(:options => [], :render_as => nil)
-      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
-      app.stubs(:main)
+      allow(app.command_line).to receive(:args).and_return([])
+      action = double(:options => [], :render_as => nil)
+      expect(Puppet::Face[:basetest, '0.0.1']).to receive(:get_default_action).and_return(action)
+      allow(app).to receive(:main)
       app.run
       expect(app.action).to eq(action)
       expect(app.arguments).to eq([ { } ])
     end
 
     it "should use the default action if not given a valid one" do
-      app.command_line.stubs(:args).returns %w{bar}
-      action = stub(:options => [], :render_as => nil)
-      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
-      app.stubs(:main)
+      allow(app.command_line).to receive(:args).and_return(%w{bar})
+      action = double(:options => [], :render_as => nil)
+      expect(Puppet::Face[:basetest, '0.0.1']).to receive(:get_default_action).and_return(action)
+      allow(app).to receive(:main)
       app.run
       expect(app.action).to eq(action)
       expect(app.arguments).to eq([ 'bar', { } ])
     end
 
     it "should have no action if not given a valid one and there is no default action" do
-      app.command_line.stubs(:args).returns %w{bar}
-      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
-      app.stubs(:main)
+      allow(app.command_line).to receive(:args).and_return(%w{bar})
+      expect(Puppet::Face[:basetest, '0.0.1']).to receive(:get_default_action).and_return(nil)
+      allow(app).to receive(:main)
       expect { app.run }.to exit_with(1)
       expect(@logs.first.message).to match(/has no 'bar' action./)
     end
@@ -95,9 +94,9 @@ describe Puppet::Application::FaceBase do
     [%w{something_I_cannot_do},
      %w{something_I_cannot_do argument}].each do |input|
       it "should report unknown actions nicely" do
-        app.command_line.stubs(:args).returns input
-        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
-        app.stubs(:main)
+        allow(app.command_line).to receive(:args).and_return(input)
+        expect(Puppet::Face[:basetest, '0.0.1']).to receive(:get_default_action).and_return(nil)
+        allow(app).to receive(:main)
         expect { app.run }.to exit_with(1)
         expect(@logs.first.message).to match(/has no 'something_I_cannot_do' action/)
       end
@@ -106,40 +105,40 @@ describe Puppet::Application::FaceBase do
     [%w{something_I_cannot_do --unknown-option},
      %w{something_I_cannot_do argument --unknown-option}].each do |input|
       it "should report unknown actions even if there are unknown options" do
-        app.command_line.stubs(:args).returns input
-        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
-        app.stubs(:main)
+        allow(app.command_line).to receive(:args).and_return(input)
+        expect(Puppet::Face[:basetest, '0.0.1']).to receive(:get_default_action).and_return(nil)
+        allow(app).to receive(:main)
         expect { app.run }.to exit_with(1)
         expect(@logs.first.message).to match(/has no 'something_I_cannot_do' action/)
       end
     end
 
     it "should report a sensible error when options with = fail" do
-      app.command_line.stubs(:args).returns %w{--action=bar foo}
+      allow(app.command_line).to receive(:args).and_return(%w{--action=bar foo})
       expect { app.preinit; app.parse_options }.
         to raise_error(OptionParser::InvalidOption, /invalid option: --action/)
     end
 
     it "should fail if an action option is before the action" do
-      app.command_line.stubs(:args).returns %w{--action foo}
+      allow(app.command_line).to receive(:args).and_return(%w{--action foo})
       expect { app.preinit; app.parse_options }.
         to raise_error(OptionParser::InvalidOption, /invalid option: --action/)
     end
 
     it "should fail if an unknown option is before the action" do
-      app.command_line.stubs(:args).returns %w{--bar foo}
+      allow(app.command_line).to receive(:args).and_return(%w{--bar foo})
       expect { app.preinit; app.parse_options }.
         to raise_error(OptionParser::InvalidOption, /invalid option: --bar/)
     end
 
     it "should fail if an unknown option is after the action" do
-      app.command_line.stubs(:args).returns %w{foo --bar}
+      allow(app.command_line).to receive(:args).and_return(%w{foo --bar})
       expect { app.preinit; app.parse_options }.
         to raise_error(OptionParser::InvalidOption, /invalid option: --bar/)
     end
 
     it "should accept --bar as an argument to a mandatory option after action" do
-      app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
+      allow(app.command_line).to receive(:args).and_return(%w{foo --mandatory --bar})
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -147,7 +146,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should accept --bar as an argument to a mandatory option before action" do
-      app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
+      allow(app.command_line).to receive(:args).and_return(%w{--mandatory --bar foo})
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -155,13 +154,13 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should not skip when --foo=bar is given" do
-      app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
+      allow(app.command_line).to receive(:args).and_return(%w{--mandatory=bar --bar foo})
       expect { app.preinit; app.parse_options }.
         to raise_error(OptionParser::InvalidOption, /invalid option: --bar/)
     end
 
     it "does not skip when a puppet global setting is given as one item" do
-      app.command_line.stubs(:args).returns %w{--confdir=/tmp/puppet foo}
+      allow(app.command_line).to receive(:args).and_return(%w{--confdir=/tmp/puppet foo})
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -169,7 +168,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "does not skip when a puppet global setting is given as two items" do
-      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo}
+      allow(app.command_line).to receive(:args).and_return(%w{--confdir /tmp/puppet foo})
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -177,7 +176,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should not add :debug to the application-level options" do
-      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo --debug}
+      allow(app.command_line).to receive(:args).and_return(%w{--confdir /tmp/puppet foo --debug})
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -185,7 +184,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should not add :verbose to the application-level options" do
-      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo --verbose}
+      allow(app.command_line).to receive(:args).and_return(%w{--confdir /tmp/puppet foo --verbose})
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -196,7 +195,7 @@ describe Puppet::Application::FaceBase do
       "boolean options after"  => %w{foo --trace}
     }.each do |name, args|
       it "should accept global boolean settings #{name} the action" do
-        app.command_line.stubs(:args).returns args
+        allow(app.command_line).to receive(:args).and_return(args)
         Puppet.settings.initialize_global_settings(args)
         app.preinit
         app.parse_options
@@ -208,7 +207,7 @@ describe Puppet::Application::FaceBase do
       " after" => %w{foo --syslogfacility user1}
     }.each do |name, args|
       it "should accept global settings with arguments #{name} the action" do
-        app.command_line.stubs(:args).returns args
+        allow(app.command_line).to receive(:args).and_return(args)
         Puppet.settings.initialize_global_settings(args)
         app.preinit
         app.parse_options
@@ -217,7 +216,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should handle application-level options" do
-      app.command_line.stubs(:args).returns %w{--verbose return_true}
+      allow(app.command_line).to receive(:args).and_return(%w{--verbose return_true})
       app.preinit
       app.parse_options
       expect(app.face.name).to eq(:basetest)
@@ -226,7 +225,7 @@ describe Puppet::Application::FaceBase do
 
   describe "#setup" do
     it "should remove the action name from the arguments" do
-      app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
+      allow(app.command_line).to receive(:args).and_return(%w{--mandatory --bar foo})
       app.preinit
       app.parse_options
       app.setup
@@ -235,7 +234,7 @@ describe Puppet::Application::FaceBase do
 
     it "should pass positional arguments" do
       myargs = %w{--mandatory --bar foo bar baz quux}
-      app.command_line.stubs(:args).returns(myargs)
+      allow(app.command_line).to receive(:args).and_return(myargs)
       app.preinit
       app.parse_options
       app.setup
@@ -245,7 +244,7 @@ describe Puppet::Application::FaceBase do
 
   describe "#main" do
     before :each do
-      app.stubs(:puts)          # don't dump text to screen.
+      allow(app).to receive(:puts)          # don't dump text to screen.
 
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
@@ -253,41 +252,41 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should send the specified verb and name to the face" do
-      app.face.expects(:foo).with(*app.arguments)
+      expect(app.face).to receive(:foo).with(*app.arguments)
       expect { app.main }.to exit_with(0)
     end
 
     it "should lookup help when it cannot do anything else" do
       app.action = nil
-      Puppet::Face[:help, :current].expects(:help).with(:basetest)
+      expect(Puppet::Face[:help, :current]).to receive(:help).with(:basetest)
       expect { app.main }.to exit_with(1)
     end
 
     it "should use its render method to render any result" do
-      app.expects(:render).with(app.arguments.length + 1, ["myname", "myarg"])
+      expect(app).to receive(:render).with(app.arguments.length + 1, ["myname", "myarg"])
       expect { app.main }.to exit_with(0)
     end
 
     it "should issue a deprecation warning if the face is deprecated" do
       # since app is shared across examples, stub to avoid affecting shared context
-      app.face.stubs(:deprecated?).returns(true)
-      app.face.expects(:foo).with(*app.arguments)
-      Puppet.expects(:deprecation_warning).with(regexp_matches(/'puppet basetest' is deprecated/))
+      allow(app.face).to receive(:deprecated?).and_return(true)
+      expect(app.face).to receive(:foo).with(*app.arguments)
+      expect(Puppet).to receive(:deprecation_warning).with(/'puppet basetest' is deprecated/)
       expect { app.main }.to exit_with(0)
     end
 
     it "should not issue a deprecation warning if the face is not deprecated" do
-      Puppet.expects(:deprecation_warning).never
+      expect(Puppet).not_to receive(:deprecation_warning)
       # since app is shared across examples, stub to avoid affecting shared context
-      app.face.stubs(:deprecated?).returns(false)
-      app.face.expects(:foo).with(*app.arguments)
+      allow(app.face).to receive(:deprecated?).and_return(false)
+      expect(app.face).to receive(:foo).with(*app.arguments)
       expect { app.main }.to exit_with(0)
     end
   end
 
   describe "error reporting" do
     before :each do
-      app.stubs(:puts)          # don't dump text to screen.
+      allow(app).to receive(:puts)          # don't dump text to screen.
 
       app.render_as = :json
       app.face      = Puppet::Face[:basetest, '0.0.1']
@@ -343,7 +342,7 @@ describe Puppet::Application::FaceBase do
 
       it "should render a non-trivially-keyed Hash with using pretty printed JSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
-        expect(app.render(hash, {})).to eq(JSON.pretty_generate(hash).chomp)
+        expect(app.render(hash, {})).to eq(Puppet::Util::Json.dump(hash, :pretty => true).chomp)
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
@@ -356,7 +355,7 @@ describe Puppet::Application::FaceBase do
         expect(app.render(hash, {})).to eq <<EOT
 5      5
 6.0    6
-four   #{object.to_json.chomp}
+four   #{Puppet::Util::Json.dump(object).chomp}
 one    1
 three  {}
 two    []
@@ -411,42 +410,44 @@ EOT
     end
 
     it "should fail early if asked to render an invalid format" do
-      app.command_line.stubs(:args).returns %w{--render-as interpretive-dance return_true}
+      allow(app.command_line).to receive(:args).and_return(%w{--render-as interpretive-dance return_true})
       # We shouldn't get here, thanks to the exception, and our expectation on
       # it, but this helps us fail if that slips up and all. --daniel 2011-04-27
-      Puppet::Face[:help, :current].expects(:help).never
+      expect(Puppet::Face[:help, :current]).not_to receive(:help)
 
-      Puppet.expects(:err).with("Could not parse application options: I don't know how to render 'interpretive-dance'")
+      expect(Puppet).to receive(:send_log).with(:err, "Could not parse application options: I don't know how to render 'interpretive-dance'")
 
       expect { app.run }.to exit_with(1)
     end
 
     it "should work if asked to render json" do
-      app.command_line.stubs(:args).returns %w{count_args a b c --render-as json}
+      allow(app.command_line).to receive(:args).and_return(%w{count_args a b c --render-as json})
       expect {
-        expect { app.run }.to exit_with(0)
-      }.to have_printed(/3/)
+        app.run
+      }.to exit_with(0)
+       .and output(/3/).to_stdout
     end
 
     it "should invoke when_rendering hook 's' when asked to render-as 's'" do
-      app.command_line.stubs(:args).returns %w{with_s_rendering_hook --render-as s}
+      allow(app.command_line).to receive(:args).and_return(%w{with_s_rendering_hook --render-as s})
       app.action = app.face.get_action(:with_s_rendering_hook)
       expect {
-        expect { app.run }.to exit_with(0)
-      }.to have_printed(/you invoked the 's' rendering hook/)
+        app.run
+      }.to exit_with(0)
+       .and output(/you invoked the 's' rendering hook/).to_stdout
     end
   end
 
   describe "#help" do
     it "should generate help for --help" do
-      app.command_line.stubs(:args).returns %w{--help}
-      Puppet::Face[:help, :current].expects(:help)
+      allow(app.command_line).to receive(:args).and_return(%w{--help})
+      expect(Puppet::Face[:help, :current]).to receive(:help)
       expect { app.run }.to exit_with(0)
     end
 
     it "should generate help for -h" do
-      app.command_line.stubs(:args).returns %w{-h}
-      Puppet::Face[:help, :current].expects(:help)
+      allow(app.command_line).to receive(:args).and_return(%w{-h})
+      expect(Puppet::Face[:help, :current]).to receive(:help)
       expect { app.run }.to exit_with(0)
     end
   end