puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/application/facts_spec.rb

@@ -7,16 +7,7 @@ describe Puppet::Application::Facts do
     subject.command_line.stubs(:subcommand_name).returns 'facts'
   end
 
-  it "should fail if no key is given to find" do
-    subject.command_line.stubs(:args).returns %w{find}
-    expect {
-      expect { subject.run }.to exit_with 1
-    }.to have_printed /Error: puppet facts find takes 1 argument, but you gave 0/
-    @logs.first.to_s.should =~ /puppet facts find takes 1 argument, but you gave 0/
-  end
-
   it "should return facts if a key is given to find" do
-    Puppet[:stringify_facts] = false
     Puppet::Node::Facts.indirection.reset_terminus_class
     Puppet::Node::Facts.indirection.expects(:find).returns(Puppet::Node::Facts.new('whatever', {}))
     subject.command_line.stubs(:args).returns %w{find whatever --render-as yaml}
@@ -24,9 +15,9 @@ describe Puppet::Application::Facts do
     expect {
       expect {
         subject.run
-      }.to exit_with 0
+      }.to exit_with(0)
     }.to have_printed(/object:Puppet::Node::Facts/)
 
-    @logs.should be_empty
+    expect(@logs).to be_empty
   end
 end

data/spec/unit/application/filebucket_spec.rb

@@ -10,20 +10,20 @@ describe Puppet::Application::Filebucket do
   end
 
   it "should declare a get command" do
-    @filebucket.should respond_to(:get)
+    expect(@filebucket).to respond_to(:get)
   end
 
   it "should declare a backup command" do
-    @filebucket.should respond_to(:backup)
+    expect(@filebucket).to respond_to(:backup)
   end
 
   it "should declare a restore command" do
-    @filebucket.should respond_to(:restore)
+    expect(@filebucket).to respond_to(:restore)
   end
 
   [:bucket, :debug, :local, :remote, :verbose].each do |option|
     it "should declare handle_#{option} method" do
-      @filebucket.should respond_to("handle_#{option}".to_sym)
+      expect(@filebucket).to respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
@@ -57,13 +57,13 @@ describe Puppet::Application::Filebucket do
     it "should set log level to debug if --debug was passed" do
       @filebucket.options.stubs(:[]).with(:debug).returns(true)
       @filebucket.setup
-      Puppet::Log.level.should == :debug
+      expect(Puppet::Log.level).to eq(:debug)
     end
 
     it "should set log level to info if --verbose was passed" do
       @filebucket.options.stubs(:[]).with(:verbose).returns(true)
       @filebucket.setup
-      Puppet::Log.level.should == :info
+      expect(Puppet::Log.level).to eq(:info)
     end
 
     it "should print puppet config if asked to in Puppet config" do
@@ -173,7 +173,7 @@ describe Puppet::Application::Filebucket do
     describe "the command backup" do
       it "should fail if no arguments are specified" do
         @filebucket.stubs(:args).returns([])
-        lambda { @filebucket.backup }.should raise_error
+        expect { @filebucket.backup }.to raise_error
       end
 
       it "should call the client backup method for each given parameter" do

data/spec/unit/application/indirection_base_spec.rb

@@ -35,10 +35,6 @@ describe Puppet::Application::IndirectionBase do
     terminus = stub_everything("test indirection terminus")
     terminus.stubs(:name).returns(:test_indirection)
 
-    # This is necessary because Instrumentation tickles indirection, which
-    #  messes up our expectations.
-    Puppet::Util::Instrumentation.stubs(:init)
-
     Puppet::Indirector::Indirection.expects(:instance).
       with(:test_indirection).returns(terminus)
 

data/spec/unit/application/inspect_spec.rb

@@ -16,7 +16,7 @@ describe Puppet::Application::Inspect do
   end
 
   it "should operate in agent run_mode" do
-    @inspect.class.run_mode.name.should == :agent
+    expect(@inspect.class.run_mode.name).to eq(:agent)
   end
 
   describe "during setup" do
@@ -29,7 +29,7 @@ describe Puppet::Application::Inspect do
 
     it "should fail if reporting is turned off" do
       Puppet[:report] = false
-      lambda { @inspect.setup }.should raise_error(/report=true/)
+      expect { @inspect.setup }.to raise_error(/report=true/)
     end
   end
 
@@ -76,9 +76,9 @@ describe Puppet::Application::Inspect do
         properties = events.inject({}) do |property_values, event|
           property_values.merge(event.property => event.previous_value)
         end
-        properties["ensure"].should == :file
-        properties["content"].should == "{#{digest_algorithm}}#{checksum}"
-        properties.has_key?("target").should == false
+        expect(properties["ensure"]).to eq(:file)
+        expect(properties["content"]).to eq("{#{digest_algorithm}}#{checksum}")
+        expect(properties.has_key?("target")).to eq(false)
       end
     end
 
@@ -98,7 +98,7 @@ describe Puppet::Application::Inspect do
       @inspect.run_command
 
       events.each do |event|
-        event.audited.should == true
+        expect(event.audited).to eq(true)
       end
     end
 
@@ -122,7 +122,7 @@ describe Puppet::Application::Inspect do
       properties = events.inject({}) do |property_values, event|
         property_values.merge(event.property => event.previous_value)
       end
-      properties.should == {"ensure" => :absent}
+      expect(properties).to eq({"ensure" => :absent})
     end
 
     describe "when archiving to a bucket" do
@@ -151,7 +151,7 @@ describe Puppet::Application::Inspect do
           @inspect.run_command
         end
 
-        it "should not send unreadable files", :unless => Puppet.features.microsoft_windows? do
+        it "should not send unreadable files", :unless => (Puppet.features.microsoft_windows? || Puppet.features.root?) do
           File.open(@file, 'w') { |f| f.write('stuff') }
           File.chmod(0, @file)
           Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
@@ -182,8 +182,8 @@ describe Puppet::Application::Inspect do
 
           @inspect.run_command
 
-          @report.logs.first.should_not == nil
-          @report.logs.first.message.should =~ /Could not back up/
+          expect(@report.logs.first).not_to eq(nil)
+          expect(@report.logs.first.message).to match(/Could not back up/)
         end
       end
 
@@ -253,17 +253,17 @@ describe Puppet::Application::Inspect do
 
         @inspect.run_command
 
-        @report.status.should == "failed"
-        @report.logs.select{|log| log.message =~ /Could not inspect/}.size.should == 1
-        @report.resource_statuses.size.should == 1
-        @report.resource_statuses['Stub_type[foo]'].events.size.should == 1
+        expect(@report.status).to eq("failed")
+        expect(@report.logs.select{|log| log.message =~ /Could not inspect/}.size).to eq(1)
+        expect(@report.resource_statuses.size).to eq(1)
+        expect(@report.resource_statuses['Stub_type[foo]'].events.size).to eq(1)
 
         event = @report.resource_statuses['Stub_type[foo]'].events.first
-        event.property.should == "content"
-        event.status.should == "failure"
-        event.audited.should == true
-        event.instance_variables.should_not include "@previous_value"
-        event.instance_variables.should_not include :@previous_value
+        expect(event.property).to eq("content")
+        expect(event.status).to eq("failure")
+        expect(event.audited).to eq(true)
+        expect(event.instance_variables).not_to include "@previous_value"
+        expect(event.instance_variables).not_to include :@previous_value
       end
 
       it "should continue to the next resource" do
@@ -274,8 +274,8 @@ describe Puppet::Application::Inspect do
 
         @inspect.run_command
 
-        @report.resource_statuses.size.should == 2
-        @report.resource_statuses.keys.should =~ ['Stub_type[foo]', 'Stub_type[bar]']
+        expect(@report.resource_statuses.size).to eq(2)
+        expect(@report.resource_statuses.keys).to match_array(['Stub_type[foo]', 'Stub_type[bar]'])
       end
     end
   end

data/spec/unit/application/master_spec.rb

@@ -22,19 +22,19 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
   end
 
   it "should operate in master run_mode" do
-    @master.class.run_mode.name.should equal(:master)
+    expect(@master.class.run_mode.name).to equal(:master)
   end
 
   it "should declare a main command" do
-    @master.should respond_to(:main)
+    expect(@master).to respond_to(:main)
   end
 
   it "should declare a compile command" do
-    @master.should respond_to(:compile)
+    expect(@master).to respond_to(:compile)
   end
 
   it "should declare a preinit block" do
-    @master.should respond_to(:preinit)
+    expect(@master).to respond_to(:preinit)
   end
 
   describe "during preinit" do
@@ -51,7 +51,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
 
   [:debug,:verbose].each do |option|
     it "should declare handle_#{option} method" do
-      @master.should respond_to("handle_#{option}".to_sym)
+      expect(@master).to respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
@@ -91,7 +91,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
       @master.preinit
       @master.parse_options
 
-      Puppet[:dns_alt_names].should == "foo,bar,baz"
+      expect(Puppet[:dns_alt_names]).to eq("foo,bar,baz")
     end
 
 
@@ -285,6 +285,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         Puppet[:daemonize] = false
         Puppet.stubs(:notice)
         Puppet.stubs(:start)
+        Puppet::Util.stubs(:chuser)
       end
 
       it "should create a Server" do
@@ -353,11 +354,9 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
           @master.options.stubs(:[]).with(:rack).returns(:true)
 
           app = @master.main
-          app.should equal(@app)
+          expect(app).to equal(@app)
         end
-
       end
-
     end
   end
 end

data/spec/unit/application/resource_spec.rb

@@ -8,13 +8,12 @@ describe Puppet::Application::Resource do
   before :each do
     @resource_app = Puppet::Application[:resource]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Resource.indirection.stubs(:terminus_class=)
   end
 
   describe "in preinit" do
     it "should init extra_params to empty array" do
       @resource_app.preinit
-      @resource_app.extra_params.should == []
+      expect(@resource_app.extra_params).to eq([])
     end
   end
 
@@ -26,11 +25,6 @@ describe Puppet::Application::Resource do
       end
     end
 
-    it "should set options[:host] to given host" do
-      @resource_app.handle_host(:whatever)
-      @resource_app.host.should == :whatever
-    end
-
     it "should load a display all types with types option" do
       type1 = stub_everything 'type1', :name => :type1
       type2 = stub_everything 'type2', :name => :type2
@@ -44,7 +38,7 @@ describe Puppet::Application::Resource do
       @resource_app.extra_params = [ :param1 ]
       @resource_app.handle_param("whatever")
 
-      @resource_app.extra_params.should == [ :param1, :whatever ]
+      expect(@resource_app.extra_params).to eq([ :param1, :whatever ])
     end
 
     it "should get a parameter in the printed data if extra_params are passed" do
@@ -74,14 +68,14 @@ describe Puppet::Application::Resource do
     it "should set log level to debug if --debug was passed" do
       @resource_app.options.stubs(:[]).with(:debug).returns(true)
       @resource_app.setup
-      Puppet::Log.level.should == :debug
+      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)
       @resource_app.setup
-      Puppet::Log.level.should == :info
+      expect(Puppet::Log.level).to eq(:info)
     end
 
   end
@@ -95,89 +89,43 @@ describe Puppet::Application::Resource do
       @res = stub_everything "resource"
       @res.stubs(:prune_parameters).returns(@res)
       @report = stub_everything "report"
+
+      @resource_app.stubs(:puts)
+
+      Puppet::Resource.indirection.stubs(:find  ).never
+      Puppet::Resource.indirection.stubs(:search).never
+      Puppet::Resource.indirection.stubs(:save  ).never
     end
 
     it "should raise an error if no type is given" do
       @resource_app.command_line.stubs(:args).returns([])
-      lambda { @resource_app.main }.should raise_error(RuntimeError, "You must specify the type to display")
-    end
-
-    it "should raise an error when editing a remote host" do
-      @resource_app.options.stubs(:[]).with(:edit).returns(true)
-      @resource_app.host = 'host'
-
-      lambda { @resource_app.main }.should raise_error(RuntimeError, "You cannot edit a remote host")
+      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)
 
-      lambda { @resource_app.main }.should raise_error(RuntimeError, 'Could not find type mytype')
+      expect { @resource_app.main }.to raise_error(RuntimeError, 'Could not find type mytype')
     end
 
-    describe "with a host" do
-      before :each do
-        @resource_app.stubs(:puts)
-        @resource_app.host = 'host'
-
-        Puppet::Resource.indirection.stubs(:find  ).never
-        Puppet::Resource.indirection.stubs(:search).never
-        Puppet::Resource.indirection.stubs(:save  ).never
-      end
-
-      it "should search for resources" do
-        @resource_app.command_line.stubs(:args).returns(['type'])
-        Puppet::Resource.indirection.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
-        @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('https://host:8139/production/resources/type/name').returns(@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'])
-
-        Puppet::Resource.indirection.expects(:save).
-          with(@res, 'https://host:8139/production/resources/type/name').
-          returns([@res, @report])
-        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
-
-        @resource_app.main
-      end
+    it "should search for resources" do
+      Puppet::Resource.indirection.expects(:search).with('mytype/', {}).returns([])
+      @resource_app.main
     end
 
-    describe "without a host" do
-      before :each do
-        @resource_app.stubs(:puts)
-        @resource_app.host = nil
-
-        Puppet::Resource.indirection.stubs(:find  ).never
-        Puppet::Resource.indirection.stubs(:search).never
-        Puppet::Resource.indirection.stubs(:save  ).never
-      end
-
-      it "should search for resources" do
-        Puppet::Resource.indirection.expects(:search).with('mytype/', {}).returns([])
-        @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)
-        @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)
+      @resource_app.main
+    end
 
-      it "should add given parameters to the object" do
-        @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
+    it "should add given parameters to the object" do
+      @resource_app.command_line.stubs(:args).returns(['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)
+      Puppet::Resource.indirection.expects(:save).with(@res, 'type/name').returns([@res, @report])
+      Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
 
-        @resource_app.main
-      end
+      @resource_app.main
     end
   end
 
@@ -190,7 +138,7 @@ describe Puppet::Application::Resource do
     it "should raise an exception if no file specified" do
       @resource_app.command_line.stubs(:args).returns(['file'])
 
-      lambda { @resource_app.main }.should raise_error(RuntimeError, /Listing all file instances is not supported/)
+      expect { @resource_app.main }.to raise_error(RuntimeError, /Listing all file instances is not supported/)
     end
 
     it "should output a file resource when given a file path" do
@@ -200,7 +148,7 @@ describe Puppet::Application::Resource do
 
       @resource_app.command_line.stubs(:args).returns(['file', path])
       @resource_app.expects(:puts).with do |args|
-        args.should =~ /file \{ '#{Regexp.escape(path)}'/m
+        expect(args).to match(/file \{ '#{Regexp.escape(path)}'/m)
       end
 
       @resource_app.main

data/spec/unit/application_spec.rb

@@ -9,7 +9,6 @@ require 'timeout'
 describe Puppet::Application do
 
   before(:each) do
-    Puppet::Util::Instrumentation.stubs(:init)
     @app = Class.new(Puppet::Application).new
     @appclass = @app.class
 
@@ -26,8 +25,8 @@ describe Puppet::Application do
       args[0] = 'different_subcommand'
       args[1] = '--other-arg'
 
-      app.command_line.subcommand_name.should == 'subcommand'
-      app.command_line.args.should == ['--arg']
+      expect(app.command_line.subcommand_name).to eq('subcommand')
+      expect(app.command_line.args).to eq(['--arg'])
     end
   end
 
@@ -37,7 +36,7 @@ describe Puppet::Application do
       Puppet.expects(:err).with(regexp_matches(/missing required app default setting/))
       expect {
         @app.run
-      }.to exit_with 1
+      }.to exit_with(1)
     end
   end
 
@@ -48,7 +47,7 @@ describe Puppet::Application do
     end
 
     it "should find classes in the namespace" do
-      @klass.find("Agent").should == @klass::Agent
+      expect(@klass.find("Agent")).to eq(@klass::Agent)
     end
 
     it "should not find classes outside the namespace" do
@@ -69,8 +68,8 @@ describe Puppet::Application do
 
     it "#12114: should prevent File namespace collisions" do
       # have to require the file face once, then the second time around it would fail
-      @klass.find("File").should == Puppet::Application::File
-      @klass.find("File").should == Puppet::Application::File
+      expect(@klass.find("File")).to eq(Puppet::Application::File)
+      expect(@klass.find("File")).to eq(Puppet::Application::File)
     end
   end
 
@@ -79,30 +78,30 @@ describe Puppet::Application do
       apps =  %w{describe filebucket kick queue resource agent cert apply doc master}
       Puppet::Util::Autoload.expects(:files_to_load).returns(apps)
 
-      Puppet::Application.available_application_names.should =~ 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('puppet/application').returns(%w{ /a/foo.rb /b/bar.rb })
 
-      Puppet::Application.available_application_names.should =~ %w{ foo bar }
+      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('puppet/application').returns(%w{ /a/foo.rb /b/foo.rb })
 
-      Puppet::Application.available_application_names.should == %w{ foo }
+      expect(Puppet::Application.available_application_names).to eq(%w{ foo })
     end
   end
 
   describe ".run_mode" do
     it "should default to user" do
-      @appclass.run_mode.name.should == :user
+      expect(@appclass.run_mode.name).to eq(:user)
     end
 
     it "should set and get a value" do
       @appclass.run_mode :agent
-      @appclass.run_mode.name.should == :agent
+      expect(@appclass.run_mode.name).to eq(:agent)
     end
   end
 
@@ -127,16 +126,16 @@ describe Puppet::Application do
       app = TestApp.new
       app.initialize_app_defaults
 
-      Puppet.run_mode.should be_master
+      expect(Puppet.run_mode).to be_master
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #run" do
       app = TestApp.new
       app.run
 
-      app.class.run_mode.name.should == :master
+      expect(app.class.run_mode.name).to eq(:master)
 
-      Puppet.run_mode.should be_master
+      expect(Puppet.run_mode).to be_master
     end
   end
 
@@ -152,23 +151,23 @@ describe Puppet::Application do
   end
 
   it "should have a run entry-point" do
-    @app.should respond_to(:run)
+    expect(@app).to respond_to(:run)
   end
 
   it "should have a read accessor to options" do
-    @app.should respond_to(:options)
+    expect(@app).to respond_to(:options)
   end
 
   it "should include a default setup method" do
-    @app.should respond_to(:setup)
+    expect(@app).to respond_to(:setup)
   end
 
   it "should include a default preinit method" do
-    @app.should respond_to(:preinit)
+    expect(@app).to respond_to(:preinit)
   end
 
   it "should include a default run_command method" do
-    @app.should respond_to(:run_command)
+    expect(@app).to respond_to(:run_command)
   end
 
   it "should invoke main as the default" do
@@ -176,22 +175,6 @@ describe Puppet::Application do
     @app.run_command
   end
 
-  it "should initialize the Puppet Instrumentation layer early in the life cycle" do
-    # Not proud of this, but the fact that we are stubbing init_app_defaults
-    #  below means that we will get errors if anyone tries to access any
-    #  settings that depend on app_defaults.  In general this whole test
-    #  seems to be testing too many implementation details rather than
-    #  functionality, but, hey.
-    Puppet[:route_file] = "/dev/null"
-
-    startup_sequence = sequence('startup')
-    @app.expects(:initialize_app_defaults).in_sequence(startup_sequence)
-    Puppet::Util::Instrumentation.expects(:init).in_sequence(startup_sequence)
-    @app.expects(:preinit).in_sequence(startup_sequence)
-
-    expect { @app.run }.to exit_with(1)
-  end
-
   describe 'when invoking clear!' do
     before :each do
       Puppet::Application.run_status = :stop_requested
@@ -199,23 +182,23 @@ describe Puppet::Application do
     end
 
     it 'should have nil run_status' do
-      Puppet::Application.run_status.should be_nil
+      expect(Puppet::Application.run_status).to be_nil
     end
 
     it 'should return false for restart_requested?' do
-      Puppet::Application.restart_requested?.should be_false
+      expect(Puppet::Application.restart_requested?).to be_falsey
     end
 
     it 'should return false for stop_requested?' do
-      Puppet::Application.stop_requested?.should be_false
+      expect(Puppet::Application.stop_requested?).to be_falsey
     end
 
     it 'should return false for interrupted?' do
-      Puppet::Application.interrupted?.should be_false
+      expect(Puppet::Application.interrupted?).to be_falsey
     end
 
     it 'should return true for clear?' do
-      Puppet::Application.clear?.should be_true
+      expect(Puppet::Application.clear?).to be_truthy
     end
   end
 
@@ -230,23 +213,23 @@ describe Puppet::Application do
     end
 
     it 'should have run_status of :stop_requested' do
-      Puppet::Application.run_status.should == :stop_requested
+      expect(Puppet::Application.run_status).to eq(:stop_requested)
     end
 
     it 'should return true for stop_requested?' do
-      Puppet::Application.stop_requested?.should be_true
+      expect(Puppet::Application.stop_requested?).to be_truthy
     end
 
     it 'should return false for restart_requested?' do
-      Puppet::Application.restart_requested?.should be_false
+      expect(Puppet::Application.restart_requested?).to be_falsey
     end
 
     it 'should return true for interrupted?' do
-      Puppet::Application.interrupted?.should be_true
+      expect(Puppet::Application.interrupted?).to be_truthy
     end
 
     it 'should return false for clear?' do
-      Puppet::Application.clear?.should be_false
+      expect(Puppet::Application.clear?).to be_falsey
     end
   end
 
@@ -261,23 +244,23 @@ describe Puppet::Application do
     end
 
     it 'should have run_status of :restart_requested' do
-      Puppet::Application.run_status.should == :restart_requested
+      expect(Puppet::Application.run_status).to eq(:restart_requested)
     end
 
     it 'should return true for restart_requested?' do
-      Puppet::Application.restart_requested?.should be_true
+      expect(Puppet::Application.restart_requested?).to be_truthy
     end
 
     it 'should return false for stop_requested?' do
-      Puppet::Application.stop_requested?.should be_false
+      expect(Puppet::Application.stop_requested?).to be_falsey
     end
 
     it 'should return true for interrupted?' do
-      Puppet::Application.interrupted?.should be_true
+      expect(Puppet::Application.interrupted?).to be_truthy
     end
 
     it 'should return false for clear?' do
-      Puppet::Application.clear?.should be_false
+      expect(Puppet::Application.clear?).to be_falsey
     end
   end
 
@@ -371,7 +354,7 @@ describe Puppet::Application do
 
     describe "when using --version" do
       it "should declare a version option" do
-        @app.should respond_to(:handle_version)
+        expect(@app).to respond_to(:handle_version)
       end
 
       it "should exit after printing the version" do
@@ -413,7 +396,7 @@ describe Puppet::Application do
         @app.options.stubs(:[]).with(level).returns(true)
         Puppet::Util::Log.stubs(:newdestination)
         @app.setup
-        Puppet::Util::Log.level.should == (level == :verbose ? :info : :debug)
+        expect(Puppet::Util::Log.level).to eq(level == :verbose ? :info : :debug)
       end
     end
 
@@ -425,6 +408,19 @@ describe Puppet::Application do
       @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)
+      @app.setup_logs
+
+      expect(Puppet::Util::Log.level).to eq(:debug)
+    end
+
+    it "allows the loglevel to be specified as an argument" do
+      @app.set_log_level(:debug => true)
+
+      expect(Puppet::Util::Log.level).to eq(:debug)
+    end
   end
 
   describe "when configuring routes" do
@@ -455,7 +451,7 @@ describe Puppet::Application do
 
       @app.configure_indirector_routes
 
-      Puppet::Node.indirection.terminus_class.should == 'exec'
+      expect(Puppet::Node.indirection.terminus_class).to eq('exec')
     end
 
     it "should not fail if the route file doesn't exist" do
@@ -545,21 +541,21 @@ describe Puppet::Application do
         @app.class.option("--test1","-t") do
         end
 
-        @app.should respond_to(:handle_test1)
+        expect(@app).to respond_to(:handle_test1)
       end
 
       it "should transpose in option name any '-' into '_'" do
         @app.class.option("--test-dashes-again","-t") do
         end
 
-        @app.should respond_to(:handle_test_dashes_again)
+        expect(@app).to respond_to(:handle_test_dashes_again)
       end
 
       it "should create a new method called handle_test2 with option(\"--[no-]test2\")" do
         @app.class.option("--[no-]test2","-t") do
         end
 
-        @app.should respond_to(:handle_test2)
+        expect(@app).to respond_to(:handle_test2)
       end
 
       describe "when a block is passed" do
@@ -638,7 +634,7 @@ describe Puppet::Application do
     it "should set the flag that a destination is set in the options hash" do
       Puppet::Util::Log.stubs(:newdestination).with(test_arg)
       @app.handle_logdest_arg(test_arg)
-      @app.options[:setdest].should be_true
+      expect(@app.options[:setdest]).to be_truthy
     end
   end