puppet 5.5.12-universal-darwin → 5.5.13-universal-darwin

data/spec/unit/application/apply_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/application/apply'
@@ -11,7 +10,7 @@ describe Puppet::Application::Apply do
 
   before :each do
     @apply = Puppet::Application[:apply]
-    Puppet::Util::Log.stubs(:newdestination)
+    allow(Puppet::Util::Log).to receive(:newdestination)
     Puppet[:reports] = "none"
   end
 
@@ -29,26 +28,25 @@ describe Puppet::Application::Apply do
     end
 
     it "should store argument value when calling handle_#{option}" do
-      @apply.options.expects(:[]=).with(option, 'arg')
+      expect(@apply.options).to receive(:[]=).with(option, 'arg')
       @apply.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   it "should set the code to the provided code when :execute is used" do
-    @apply.options.expects(:[]=).with(:code, 'arg')
+    expect(@apply.options).to receive(:[]=).with(:code, 'arg')
     @apply.send("handle_execute".to_sym, 'arg')
   end
 
   describe "when applying options" do
-
     it "should set the log destination with --logdest" do
-      Puppet::Log.expects(:newdestination).with("console")
+      expect(Puppet::Log).to receive(:newdestination).with("console")
 
       @apply.handle_logdest("console")
     end
 
     it "should set the setdest options to true" do
-      @apply.options.expects(:[]=).with(:setdest,true)
+      expect(@apply.options).to receive(:[]=).with(:setdest,true)
 
       @apply.handle_logdest("console")
     end
@@ -56,16 +54,16 @@ describe Puppet::Application::Apply do
 
   describe "during setup" do
     before :each do
-      Puppet::Log.stubs(:newdestination)
-      Puppet::FileBucket::Dipper.stubs(:new)
-      STDIN.stubs(:read)
-      Puppet::Transaction::Report.indirection.stubs(:cache_class=)
+      allow(Puppet::Log).to receive(:newdestination)
+      allow(Puppet::FileBucket::Dipper).to receive(:new)
+      allow(STDIN).to receive(:read)
+      allow(Puppet::Transaction::Report.indirection).to receive(:cache_class=)
     end
 
     describe "with --test" do
       it "should call setup_test" do
         @apply.options[:test] = true
-        @apply.expects(:setup_test)
+        expect(@apply).to receive(:setup_test)
 
         @apply.setup
       end
@@ -88,20 +86,20 @@ describe Puppet::Application::Apply do
     end
 
     it "should set console as the log destination if logdest option wasn't provided" do
-      Puppet::Log.expects(:newdestination).with(:console)
+      expect(Puppet::Log).to receive(:newdestination).with(:console)
 
       @apply.setup
     end
 
     it "sets the log destination if logdest is provided via settings" do
-      Puppet::Log.expects(:newdestination).with("set_via_config")
+      expect(Puppet::Log).to receive(:newdestination).with("set_via_config")
       Puppet[:logdest] = "set_via_config"
 
       @apply.setup
     end
 
     it "should set INT trap" do
-      Signal.expects(:trap).with(:INT)
+      expect(Signal).to receive(:trap).with(:INT)
 
       @apply.setup
     end
@@ -119,25 +117,24 @@ describe Puppet::Application::Apply do
     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 { @apply.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 { @apply.setup }.to exit_with 1
     end
 
     it "should use :main, :puppetd, and :ssl" do
-      Puppet.settings.unstub(:use)
-      Puppet.settings.expects(:use).with(:main, :agent, :ssl)
+      expect(Puppet.settings).to receive(:use).with(:main, :agent, :ssl)
 
       @apply.setup
     end
 
     it "should tell the report handler to cache locally as yaml" do
-      Puppet::Transaction::Report.indirection.expects(:cache_class=).with(:yaml)
+      expect(Puppet::Transaction::Report.indirection).to receive(:cache_class=).with(:yaml)
 
       @apply.setup
     end
@@ -169,14 +166,14 @@ describe Puppet::Application::Apply do
     it "should dispatch to 'apply' if it was called with 'apply'" do
       @apply.options[:catalog] = "foo"
 
-      @apply.expects(:apply)
+      expect(@apply).to receive(:apply)
       @apply.run_command
     end
 
     it "should dispatch to main otherwise" do
-      @apply.stubs(:options).returns({})
+      allow(@apply).to receive(:options).and_return({})
 
-      @apply.expects(:main)
+      expect(@apply).to receive(:main)
       @apply.run_command
     end
 
@@ -197,17 +194,17 @@ describe Puppet::Application::Apply do
         Puppet::Node.indirection.save(@node)
 
         @catalog = Puppet::Resource::Catalog.new("testing", Puppet.lookup(:environments).get(Puppet[:environment]))
-        @catalog.stubs(:to_ral).returns(@catalog)
+        allow(@catalog).to receive(:to_ral).and_return(@catalog)
 
-        Puppet::Resource::Catalog.indirection.stubs(:find).returns(@catalog)
+        allow(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
 
-        STDIN.stubs(:read)
+        allow(STDIN).to receive(:read)
 
-        @transaction = stub('transaction')
-        @catalog.stubs(:apply).returns(@transaction)
+        @transaction = double('transaction')
+        allow(@catalog).to receive(:apply).and_return(@transaction)
 
-        Puppet::Util::Storage.stubs(:load)
-        Puppet::Configurer.any_instance.stubs(:save_last_run_summary) # to prevent it from trying to write files
+        allow(Puppet::Util::Storage).to receive(:load)
+        allow_any_instance_of(Puppet::Configurer).to receive(:save_last_run_summary) # to prevent it from trying to write files
       end
 
       after :each do
@@ -224,23 +221,23 @@ describe Puppet::Application::Apply do
 
       it "should set the code to run from --code" do
         @apply.options[:code] = "code to run"
-        Puppet.expects(:[]=).with(:code,"code to run")
+        expect(Puppet).to receive(:[]=).with(:code,"code to run")
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should set the code to run from STDIN if no arguments" do
-        @apply.command_line.stubs(:args).returns([])
-        STDIN.stubs(:read).returns("code to run")
+        allow(@apply.command_line).to receive(:args).and_return([])
+        allow(STDIN).to receive(:read).and_return("code to run")
 
-        Puppet.expects(:[]=).with(:code,"code to run")
+        expect(Puppet).to receive(:[]=).with(:code,"code to run")
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should raise an error if a file is passed on command line and the file does not exist" do
         noexist = tmpfile('noexist.pp')
-        @apply.command_line.stubs(:args).returns([noexist])
+        allow(@apply.command_line).to receive(:args).and_return([noexist])
         expect { @apply.main }.to raise_error(RuntimeError, "Could not find file #{noexist}")
       end
 
@@ -248,7 +245,7 @@ describe Puppet::Application::Apply do
         manifest = tmpfile('starwarsIV')
         FileUtils.touch(manifest)
 
-        @apply.command_line.stubs(:args).returns([manifest, 'starwarsI', 'starwarsII'])
+        allow(@apply.command_line).to receive(:args).and_return([manifest, 'starwarsI', 'starwarsII'])
 
         expect { @apply.main }.to exit_with 0
 
@@ -258,13 +255,13 @@ describe Puppet::Application::Apply do
       end
 
       it "should splay" do
-        @apply.expects(:splay)
+        expect(@apply).to receive(:splay)
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should raise an error if we can't find the node" do
-        Puppet::Node.indirection.expects(:find).returns(nil)
+        expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
 
         expect { @apply.main }.to raise_error(RuntimeError, /Could not find node/)
       end
@@ -275,63 +272,63 @@ describe Puppet::Application::Apply do
         File.open(classfile, 'w') { |c| c.puts 'class' }
         Puppet[:classfile] = classfile
 
-        @node.expects(:classes=).with(['class'])
+        expect(@node).to receive(:classes=).with(['class'])
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should compile the catalog" do
-        Puppet::Resource::Catalog.indirection.expects(:find).returns(@catalog)
+        expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
 
         expect { @apply.main }.to exit_with 0
       end
 
       it 'should make the Puppet::Pops::Loaders available when applying the compiled catalog' do
-        Puppet::Resource::Catalog.indirection.expects(:find).returns(@catalog)
-        @apply.expects(:apply_catalog).with(@catalog) do
+        expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
+        expect(@apply).to receive(:apply_catalog) do |catalog|
+          expect(@catalog).to eq(@catalog)
           fail('Loaders not found') unless Puppet.lookup(:loaders) { nil }.is_a?(Puppet::Pops::Loaders)
           true
-        end.returns(0)
+        end.and_return(0)
         expect { @apply.main }.to exit_with 0
       end
 
       it "should transform the catalog to ral" do
-
-        @catalog.expects(:to_ral).returns(@catalog)
+        expect(@catalog).to receive(:to_ral).and_return(@catalog)
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should finalize the catalog" do
-        @catalog.expects(:finalize)
+        expect(@catalog).to receive(:finalize)
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should not save the classes or resource file by default" do
-        @catalog.expects(:write_class_file).never
-        @catalog.expects(:write_resource_file).never
+        expect(@catalog).not_to receive(:write_class_file)
+        expect(@catalog).not_to receive(:write_resource_file)
         expect { @apply.main }.to exit_with 0
       end
 
       it "should save the classes and resources files when requested" do
         @apply.options[:write_catalog_summary] = true
 
-        @catalog.expects(:write_class_file).once
-        @catalog.expects(:write_resource_file).once
+        expect(@catalog).to receive(:write_class_file).once
+        expect(@catalog).to receive(:write_resource_file).once
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should call the prerun and postrun commands on a Configurer instance" do
-        Puppet::Configurer.any_instance.expects(:execute_prerun_command).returns(true)
-        Puppet::Configurer.any_instance.expects(:execute_postrun_command).returns(true)
+        expect_any_instance_of(Puppet::Configurer).to receive(:execute_prerun_command).and_return(true)
+        expect_any_instance_of(Puppet::Configurer).to receive(:execute_postrun_command).and_return(true)
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should apply the catalog" do
-        @catalog.expects(:apply).returns(stub_everything('transaction'))
+        expect(@catalog).to receive(:apply).and_return(double('transaction'))
 
         expect { @apply.main }.to exit_with 0
       end
@@ -339,9 +336,9 @@ describe Puppet::Application::Apply do
       it "should save the last run summary" do
         Puppet[:noop] = false
         report = Puppet::Transaction::Report.new
-        Puppet::Transaction::Report.stubs(:new).returns(report)
+        allow(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
-        Puppet::Configurer.any_instance.expects(:save_last_run_summary).with(report)
+        expect_any_instance_of(Puppet::Configurer).to receive(:save_last_run_summary).with(report)
         expect { @apply.main }.to exit_with 0
       end
 
@@ -373,7 +370,7 @@ describe Puppet::Application::Apply do
         end
 
         it "should raise an error if we can't find the facts" do
-          Puppet::Node::Facts.indirection.expects(:find).returns(nil)
+          expect(Puppet::Node::Facts.indirection).to receive(:find).and_return(nil)
 
           expect { @apply.main }.to raise_error(RuntimeError, /Could not find facts/)
         end
@@ -386,30 +383,30 @@ describe Puppet::Application::Apply do
 
         it "should exit with report's computed exit status" do
           Puppet[:noop] = false
-          Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
+          allow_any_instance_of(Puppet::Transaction::Report).to receive(:exit_status).and_return(666)
 
           expect { @apply.main }.to exit_with 666
         end
 
         it "should exit with report's computed exit status, even if --noop is set" do
           Puppet[:noop] = true
-          Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
+          allow_any_instance_of(Puppet::Transaction::Report).to receive(:exit_status).and_return(666)
 
           expect { @apply.main }.to exit_with 666
         end
 
         it "should always exit with 0 if option is disabled" do
           Puppet[:noop] = false
-          report = stub 'report', :exit_status => 666
-          @transaction.stubs(:report).returns(report)
+          report = double('report', :exit_status => 666)
+          allow(@transaction).to receive(:report).and_return(report)
 
           expect { @apply.main }.to exit_with 0
         end
 
         it "should always exit with 0 if --noop" do
           Puppet[:noop] = true
-          report = stub 'report', :exit_status => 666
-          @transaction.stubs(:report).returns(report)
+          report = double('report', :exit_status => 666)
+          allow(@transaction).to receive(:report).and_return(report)
 
           expect { @apply.main }.to exit_with 0
         end
@@ -429,23 +426,23 @@ describe Puppet::Application::Apply do
       it "should read the catalog in from disk if a file name is provided" do
         @apply.options[:catalog] = temporary_catalog
         catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
-        Puppet::Resource::Catalog.stubs(:convert_from).with(:json,'"something"').returns(catalog)
+        allow(Puppet::Resource::Catalog).to receive(:convert_from).with(:json,'"something"').and_return(catalog)
         @apply.apply
       end
 
       it "should read the catalog in from stdin if '-' is provided" do
         @apply.options[:catalog] = "-"
-        $stdin.expects(:read).returns '"something"'
+        expect($stdin).to receive(:read).and_return('"something"')
         catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
-        Puppet::Resource::Catalog.stubs(:convert_from).with(:json,'"something"').returns(catalog)
+        allow(Puppet::Resource::Catalog).to receive(:convert_from).with(:json,'"something"').and_return(catalog)
         @apply.apply
       end
 
       it "should deserialize the catalog from the default format" do
         @apply.options[:catalog] = temporary_catalog
-        Puppet::Resource::Catalog.stubs(:default_format).returns :rot13_piglatin
+        allow(Puppet::Resource::Catalog).to receive(:default_format).and_return(:rot13_piglatin)
         catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
-        Puppet::Resource::Catalog.stubs(:convert_from).with(:rot13_piglatin,'"something"').returns(catalog)
+        allow(Puppet::Resource::Catalog).to receive(:convert_from).with(:rot13_piglatin,'"something"').and_return(catalog)
         @apply.apply
       end
 
@@ -457,12 +454,12 @@ describe Puppet::Application::Apply do
       it "should convert the catalog to a RAL catalog and use a Configurer instance to apply it" do
         @apply.options[:catalog] = temporary_catalog
         catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
-        Puppet::Resource::Catalog.stubs(:convert_from).with(:json,'"something"').returns catalog
-        catalog.expects(:to_ral).returns "mycatalog"
+        allow(Puppet::Resource::Catalog).to receive(:convert_from).with(:json,'"something"').and_return(catalog)
+        expect(catalog).to receive(:to_ral).and_return("mycatalog")
 
-        configurer = stub 'configurer'
-        Puppet::Configurer.expects(:new).returns configurer
-        configurer.expects(:run).
+        configurer = double('configurer')
+        expect(Puppet::Configurer).to receive(:new).and_return(configurer)
+        expect(configurer).to receive(:run).
           with(:catalog => "mycatalog", :pluginsync => false)
 
         @apply.apply
@@ -471,11 +468,13 @@ describe Puppet::Application::Apply do
       it 'should make the Puppet::Pops::Loaders available when applying a catalog' do
         @apply.options[:catalog] = temporary_catalog
         catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
-        @apply.expects(:read_catalog).with('something') do
+        expect(@apply).to receive(:read_catalog) do |arg|
+          expect(arg).to eq('"something"')
           fail('Loaders not found') unless Puppet.lookup(:loaders) { nil }.is_a?(Puppet::Pops::Loaders)
           true
-        end.returns(catalog)
-        @apply.expects(:apply_catalog).with(catalog) do
+        end.and_return(catalog)
+        expect(@apply).to receive(:apply_catalog) do |cat|
+          expect(cat).to eq(catalog)
           fail('Loaders not found') unless Puppet.lookup(:loaders) { nil }.is_a?(Puppet::Pops::Loaders)
           true
         end
@@ -505,7 +504,7 @@ describe Puppet::Application::Apply do
       Puppet.settings[:classfile] = classfile
 
       #We don't actually need the resource to do anything, we are using it's properties in other parts of the workflow.
-      Puppet::Util::Execution.stubs(:execute)
+      allow(Puppet::Util::Execution).to receive(:execute)
 
       expect { @apply.main }.to exit_with 0
 
@@ -519,7 +518,7 @@ describe Puppet::Application::Apply do
   describe "apply_catalog" do
     it "should call the configurer with the catalog" do
       catalog = "I am a catalog"
-      Puppet::Configurer.any_instance.expects(:run).
+      expect_any_instance_of(Puppet::Configurer).to receive(:run).
         with(:catalog => catalog, :pluginsync => false)
       @apply.send(:apply_catalog, catalog)
     end
@@ -527,7 +526,7 @@ describe Puppet::Application::Apply do
 
   it "should honor the catalog_cache_terminus setting" do
     Puppet.settings[:catalog_cache_terminus] = "json"
-    Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:json)
+    expect(Puppet::Resource::Catalog.indirection).to receive(:cache_class=).with(:json)
 
     @apply.initialize_app_defaults
     @apply.setup

data/spec/unit/application/cert_spec.rb

@@ -1,11 +1,10 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/application/cert'
 
 describe Puppet::Application::Cert => true do
   before :each do
     @cert_app = Puppet::Application[:cert]
-    Puppet::Util::Log.stubs(:newdestination)
+    allow(Puppet::Util::Log).to receive(:newdestination)
   end
 
   it "should operate in master run_mode" do
@@ -83,55 +82,55 @@ describe Puppet::Application::Cert => true do
   describe "during setup" do
 
     before :each do
-      Puppet::Log.stubs(:newdestination)
-      Puppet::SSL::Host.stubs(:ca_location=)
-      Puppet::SSL::CertificateAuthority.stubs(:new)
+      allow(Puppet::Log).to receive(:newdestination)
+      allow(Puppet::SSL::Host).to receive(:ca_location=)
+      allow(Puppet::SSL::CertificateAuthority).to receive(:new)
     end
 
     it "should set console as the log destination" do
-      Puppet::Log.expects(:newdestination).with(:console)
+      expect(Puppet::Log).to receive(:newdestination).with(:console)
 
       @cert_app.setup
     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 { @cert_app.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 { @cert_app.setup }.to exit_with 1
     end
 
     it "should set the CA location to 'only'" do
-      Puppet::SSL::Host.expects(:ca_location=).with(:only)
+      expect(Puppet::SSL::Host).to receive(:ca_location=).with(:only)
 
       @cert_app.setup
     end
 
     it "should create a new certificate authority" do
-      Puppet::SSL::CertificateAuthority.expects(:new)
+      expect(Puppet::SSL::CertificateAuthority).to receive(:new)
 
       @cert_app.setup
     end
 
     it "should set the ca_location to :local if the cert_mode is generate" do
       @cert_app.subcommand = 'generate'
-      Puppet::SSL::Host.expects(:ca_location=).with(:local)
+      expect(Puppet::SSL::Host).to receive(:ca_location=).with(:local)
       @cert_app.setup
     end
 
     it "should set the ca_location to :local if the cert_mode is destroy" do
       @cert_app.subcommand = 'destroy'
-      Puppet::SSL::Host.expects(:ca_location=).with(:local)
+      expect(Puppet::SSL::Host).to receive(:ca_location=).with(:local)
       @cert_app.setup
     end
 
     it "should set the ca_location to :only if the cert_mode is print" do
       @cert_app.subcommand = 'print'
-      Puppet::SSL::Host.expects(:ca_location=).with(:only)
+      expect(Puppet::SSL::Host).to receive(:ca_location=).with(:only)
       @cert_app.setup
     end
   end
@@ -139,15 +138,15 @@ describe Puppet::Application::Cert => true do
   describe "when running" do
     before :each do
       @cert_app.all = false
-      @ca = stub_everything( 'ca', :waiting? => ['unsigned-node'] )
+      @ca = double('ca', :waiting? => ['unsigned-node'])
       @cert_app.ca = @ca
-      @cert_app.command_line.stubs(:args).returns([])
-      @iface = stub_everything 'iface'
-      Puppet::SSL::CertificateAuthority::Interface.stubs(:new).returns(@iface)
+      allow(@cert_app.command_line).to receive(:args).and_return([])
+      @iface = double('iface', apply: nil)
+      allow(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).and_return(@iface)
     end
 
     it "should delegate to the CertificateAuthority" do
-      @iface.expects(:apply)
+      expect(@iface).to receive(:apply)
 
       @cert_app.main
     end
@@ -155,61 +154,55 @@ describe Puppet::Application::Cert => true do
     it "should delegate with :all if option --all was given" do
       @cert_app.handle_all(0)
 
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with { |cert_mode,to| to[:to] == :all }
+      expect(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).with(anything, hash_including(to: :all)).and_return(@iface)
 
       @cert_app.main
     end
 
     it "should delegate to ca.apply with the hosts given on command line" do
-      @cert_app.command_line.stubs(:args).returns(["host"])
+      allow(@cert_app.command_line).to receive(:args).and_return(["host"])
 
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with { |cert_mode,to| to[:to] == ["host"]}
+      expect(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).with(anything, hash_including(to: ["host"])).and_return(@iface)
 
       @cert_app.main
     end
 
     it "should send the currently set digest" do
-      @cert_app.command_line.stubs(:args).returns(["host"])
+      allow(@cert_app.command_line).to receive(:args).and_return(["host"])
       @cert_app.handle_digest(:digest)
 
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with { |cert_mode,to| to[:digest] == :digest}
+      expect(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).with(anything, hash_including(digest: :digest)).and_return(@iface)
 
       @cert_app.main
     end
 
     it "should revoke cert if cert_mode is clean" do
       @cert_app.subcommand = :destroy
-      @cert_app.command_line.stubs(:args).returns(["host"])
+      allow(@cert_app.command_line).to receive(:args).and_return(["host"])
 
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with { |cert_mode,to| cert_mode == :revoke }
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with { |cert_mode,to| cert_mode == :destroy }
+      expect(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).with(:revoke, anything).and_return(@iface)
+      expect(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).with(:destroy, anything).and_return(@iface)
 
       @cert_app.main
     end
 
     it "should not revoke cert if node does not have a signed certificate" do
       @cert_app.subcommand = :destroy
-      @cert_app.command_line.stubs(:args).returns(["unsigned-node"])
+      allow(@cert_app.command_line).to receive(:args).and_return(["unsigned-node"])
 
-      Puppet::SSL::CertificateAuthority::Interface.unstub(:new)
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).with(:revoke, anything).never
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).with(:destroy, {:to => ['unsigned-node'], :digest => nil}).returns(@iface)
+      allow(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).and_call_original
+      expect(Puppet::SSL::CertificateAuthority::Interface).not_to receive(:new).with(:revoke, anything)
+      expect(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).with(:destroy, {:to => ['unsigned-node'], :digest => nil}).and_return(@iface)
 
       @cert_app.main
     end
 
     it "should only revoke signed certificate and destroy certificate signing requests" do
       @cert_app.subcommand = :destroy
-      @cert_app.command_line.stubs(:args).returns(["host","unsigned-node"])
+      allow(@cert_app.command_line).to receive(:args).and_return(["host","unsigned-node"])
 
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with do |cert_mode,to|
-        cert_mode == :revoke &&
-        to[:to] == ["host"]
-      end
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).returns(@iface).with do |cert_mode,to|
-        cert_mode == :destroy &&
-        to[:to] == ["host","unsigned-node"]
-      end
+      expect(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).with(:revoke, hash_including(to: ["host"])).and_return(@iface)
+      expect(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).with(:destroy, hash_including(to: ["host", "unsigned-node"])).and_return(@iface)
 
       @cert_app.main
     end
@@ -218,10 +211,10 @@ describe Puppet::Application::Cert => true do
       @cert_app.subcommand = :destroy
       @cert_app.all = true
 
-      Puppet::SSL::CertificateAuthority::Interface.unstub(:new)
-      Puppet::SSL::CertificateAuthority::Interface.expects(:new).never
+      allow(Puppet::SSL::CertificateAuthority::Interface).to receive(:new).and_call_original
+      expect(Puppet::SSL::CertificateAuthority::Interface).not_to receive(:new)
 
-      Puppet.expects(:log_exception).with {|e| e.message == "Refusing to destroy all certs, provide an explicit list of certs to destroy"}
+      expect(Puppet).to receive(:log_exception) {|e| expect(e.message).to eq("Refusing to destroy all certs, provide an explicit list of certs to destroy")}
 
       expect { @cert_app.main }.to exit_with(24)
     end
@@ -230,7 +223,7 @@ describe Puppet::Application::Cert => true do
   describe "when identifying subcommands" do
     before :each do
       @cert_app.all = false
-      @ca = stub_everything 'ca'
+      @ca = double('ca')
       @cert_app.ca = @ca
     end
 
@@ -245,7 +238,7 @@ describe Puppet::Application::Cert => true do
         it "should recognise '#{option}'" do
           args = [option, "fun.example.com"]
 
-          @cert_app.command_line.stubs(:args).returns(args)
+          allow(@cert_app.command_line).to receive(:args).and_return(args)
           @cert_app.parse_options
           expect(@cert_app.subcommand).to eq(cmd.to_sym)
 
@@ -258,7 +251,7 @@ describe Puppet::Application::Cert => true do
       it "should recognise the '#{ugly}' option as destroy" do
         args = [ugly, "fun.example.com"]
 
-        @cert_app.command_line.stubs(:args).returns(args)
+        allow(@cert_app.command_line).to receive(:args).and_return(args)
         @cert_app.parse_options
         expect(@cert_app.subcommand).to eq(:destroy)
 
@@ -268,9 +261,9 @@ describe Puppet::Application::Cert => true do
 
     it "should print help and exit if there is no subcommand" do
       args = []
-      @cert_app.command_line.stubs(:args).returns(args)
-      @cert_app.stubs(:help).returns("I called for help!")
-      @cert_app.expects(:puts).with("I called for help!")
+      allow(@cert_app.command_line).to receive(:args).and_return(args)
+      allow(@cert_app).to receive(:help).and_return("I called for help!")
+      expect(@cert_app).to receive(:puts).with("I called for help!")
 
       expect { @cert_app.parse_options }.to exit_with 0
       expect(@cert_app.subcommand).to be_nil