puppet 5.5.22 → 6.0.0

data/spec/unit/application/doc_spec.rb

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

data/spec/unit/application/face_base_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/application/face_base'
 require 'tmpdir'
@@ -8,8 +9,8 @@ end
 describe Puppet::Application::FaceBase do
   let :app do
     app = Puppet::Application::FaceBase::Basetest.new
-    allow(app.command_line).to receive(:subcommand_name).and_return('subcommand')
-    allow(Puppet::Util::Log).to receive(:newdestination)
+    app.command_line.stubs(:subcommand_name).returns('subcommand')
+    Puppet::Util::Log.stubs(:newdestination)
     app
   end
 
@@ -19,8 +20,8 @@ describe Puppet::Application::FaceBase do
 
   describe "#find_global_settings_argument" do
     it "should not match --ca to --ca-location" do
-      option = double('ca option', :optparse_args => ["--ca"])
-      expect(Puppet.settings).to receive(:each).and_yield(:ca, option)
+      option = mock('ca option', :optparse_args => ["--ca"])
+      Puppet.settings.expects(:each).yields(:ca, option)
 
       expect(app.find_global_settings_argument("--ca-location")).to be_nil
     end
@@ -28,7 +29,7 @@ describe Puppet::Application::FaceBase do
 
   describe "#parse_options" do
     before :each do
-      allow(app.command_line).to receive(:args).and_return(%w{})
+      app.command_line.stubs(:args).returns %w{}
     end
 
     describe "with just an action" do
@@ -39,8 +40,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
-        allow(Signal).to receive(:trap)
-        allow(app.command_line).to receive(:args).and_return(%w{foo})
+        Signal.stubs(:trap)
+        app.command_line.stubs(:args).returns %w{foo}
         app.preinit
         app.parse_options
       end
@@ -56,7 +57,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should stop if the first thing found is not an action" do
-      allow(app.command_line).to receive(:args).and_return(%w{banana count_args})
+      app.command_line.stubs(:args).returns %w{banana count_args}
 
       expect { app.run }.to exit_with(1)
 
@@ -64,29 +65,29 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should use the default action if not given any arguments" do
-      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.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)
       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
-      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.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)
       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
-      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)
+      app.command_line.stubs(:args).returns %w{bar}
+      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
+      app.stubs(:main)
       expect { app.run }.to exit_with(1)
       expect(@logs.first.message).to match(/has no 'bar' action./)
     end
@@ -94,9 +95,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
-        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)
+        app.command_line.stubs(:args).returns input
+        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
+        app.stubs(:main)
         expect { app.run }.to exit_with(1)
         expect(@logs.first.message).to match(/has no 'something_I_cannot_do' action/)
       end
@@ -105,40 +106,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
-        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)
+        app.command_line.stubs(:args).returns input
+        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
+        app.stubs(: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
-      allow(app.command_line).to receive(:args).and_return(%w{--action=bar foo})
+      app.command_line.stubs(:args).returns %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
-      allow(app.command_line).to receive(:args).and_return(%w{--action foo})
+      app.command_line.stubs(:args).returns %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
-      allow(app.command_line).to receive(:args).and_return(%w{--bar foo})
+      app.command_line.stubs(:args).returns %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
-      allow(app.command_line).to receive(:args).and_return(%w{foo --bar})
+      app.command_line.stubs(:args).returns %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
-      allow(app.command_line).to receive(:args).and_return(%w{foo --mandatory --bar})
+      app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -146,7 +147,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should accept --bar as an argument to a mandatory option before action" do
-      allow(app.command_line).to receive(:args).and_return(%w{--mandatory --bar foo})
+      app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -154,13 +155,13 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should not skip when --foo=bar is given" do
-      allow(app.command_line).to receive(:args).and_return(%w{--mandatory=bar --bar foo})
+      app.command_line.stubs(:args).returns %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
-      allow(app.command_line).to receive(:args).and_return(%w{--confdir=/tmp/puppet foo})
+      app.command_line.stubs(:args).returns %w{--confdir=/tmp/puppet foo}
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -168,7 +169,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "does not skip when a puppet global setting is given as two items" do
-      allow(app.command_line).to receive(:args).and_return(%w{--confdir /tmp/puppet foo})
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo}
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -176,7 +177,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should not add :debug to the application-level options" do
-      allow(app.command_line).to receive(:args).and_return(%w{--confdir /tmp/puppet foo --debug})
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo --debug}
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -184,7 +185,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should not add :verbose to the application-level options" do
-      allow(app.command_line).to receive(:args).and_return(%w{--confdir /tmp/puppet foo --verbose})
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo --verbose}
       app.preinit
       app.parse_options
       expect(app.action.name).to eq(:foo)
@@ -195,7 +196,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
-        allow(app.command_line).to receive(:args).and_return(args)
+        app.command_line.stubs(:args).returns args
         Puppet.settings.initialize_global_settings(args)
         app.preinit
         app.parse_options
@@ -207,7 +208,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
-        allow(app.command_line).to receive(:args).and_return(args)
+        app.command_line.stubs(:args).returns args
         Puppet.settings.initialize_global_settings(args)
         app.preinit
         app.parse_options
@@ -216,7 +217,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should handle application-level options" do
-      allow(app.command_line).to receive(:args).and_return(%w{--verbose return_true})
+      app.command_line.stubs(:args).returns %w{--verbose return_true}
       app.preinit
       app.parse_options
       expect(app.face.name).to eq(:basetest)
@@ -225,7 +226,7 @@ describe Puppet::Application::FaceBase do
 
   describe "#setup" do
     it "should remove the action name from the arguments" do
-      allow(app.command_line).to receive(:args).and_return(%w{--mandatory --bar foo})
+      app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       app.setup
@@ -234,7 +235,7 @@ describe Puppet::Application::FaceBase do
 
     it "should pass positional arguments" do
       myargs = %w{--mandatory --bar foo bar baz quux}
-      allow(app.command_line).to receive(:args).and_return(myargs)
+      app.command_line.stubs(:args).returns(myargs)
       app.preinit
       app.parse_options
       app.setup
@@ -244,7 +245,7 @@ describe Puppet::Application::FaceBase do
 
   describe "#main" do
     before :each do
-      allow(app).to receive(:puts)          # don't dump text to screen.
+      app.stubs(:puts)          # don't dump text to screen.
 
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
@@ -252,41 +253,41 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should send the specified verb and name to the face" do
-      expect(app.face).to receive(:foo).with(*app.arguments)
+      app.face.expects(: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
-      expect(Puppet::Face[:help, :current]).to receive(:help).with(:basetest)
+      Puppet::Face[:help, :current].expects(:help).with(:basetest)
       expect { app.main }.to exit_with(1)
     end
 
     it "should use its render method to render any result" do
-      expect(app).to receive(:render).with(app.arguments.length + 1, ["myname", "myarg"])
+      app.expects(: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
-      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/)
+      app.face.stubs(:deprecated?).returns(true)
+      app.face.expects(:foo).with(*app.arguments)
+      Puppet.expects(:deprecation_warning).with(regexp_matches(/'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
-      expect(Puppet).not_to receive(:deprecation_warning)
+      Puppet.expects(:deprecation_warning).never
       # since app is shared across examples, stub to avoid affecting shared context
-      allow(app.face).to receive(:deprecated?).and_return(false)
-      expect(app.face).to receive(:foo).with(*app.arguments)
+      app.face.stubs(:deprecated?).returns(false)
+      app.face.expects(:foo).with(*app.arguments)
       expect { app.main }.to exit_with(0)
     end
   end
 
   describe "error reporting" do
     before :each do
-      allow(app).to receive(:puts)          # don't dump text to screen.
+      app.stubs(:puts)          # don't dump text to screen.
 
       app.render_as = :json
       app.face      = Puppet::Face[:basetest, '0.0.1']
@@ -410,25 +411,25 @@ EOT
     end
 
     it "should fail early if asked to render an invalid format" do
-      allow(app.command_line).to receive(:args).and_return(%w{--render-as interpretive-dance return_true})
+      app.command_line.stubs(:args).returns %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
-      expect(Puppet::Face[:help, :current]).not_to receive(:help)
+      Puppet::Face[:help, :current].expects(:help).never
 
-      expect(Puppet).to receive(:err).with("Could not parse application options: I don't know how to render 'interpretive-dance'")
+      Puppet.expects(:err).with("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
-      allow(app.command_line).to receive(:args).and_return(%w{count_args a b c --render-as json})
+      app.command_line.stubs(:args).returns %w{count_args a b c --render-as json}
       expect {
         expect { app.run }.to exit_with(0)
       }.to have_printed(/3/)
     end
 
     it "should invoke when_rendering hook 's' when asked to render-as 's'" do
-      allow(app.command_line).to receive(:args).and_return(%w{with_s_rendering_hook --render-as s})
+      app.command_line.stubs(:args).returns %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)
@@ -438,14 +439,14 @@ EOT
 
   describe "#help" do
     it "should generate help for --help" do
-      allow(app.command_line).to receive(:args).and_return(%w{--help})
-      expect(Puppet::Face[:help, :current]).to receive(:help)
+      app.command_line.stubs(:args).returns %w{--help}
+      Puppet::Face[:help, :current].expects(:help)
       expect { app.run }.to exit_with(0)
     end
 
     it "should generate help for -h" do
-      allow(app.command_line).to receive(:args).and_return(%w{-h})
-      expect(Puppet::Face[:help, :current]).to receive(:help)
+      app.command_line.stubs(:args).returns %w{-h}
+      Puppet::Face[:help, :current].expects(:help)
       expect { app.run }.to exit_with(0)
     end
   end