puppet 3.8.7 → 4.0.0

data/spec/unit/application/face_base_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::Application::FaceBase do
       option = mock('ca option', :optparse_args => ["--ca"])
       Puppet.settings.expects(:each).yields(:ca, option)
 
-      app.find_global_settings_argument("--ca-location").should be_nil
+      expect(app.find_global_settings_argument("--ca-location")).to be_nil
     end
   end
 
@@ -47,21 +47,21 @@ describe Puppet::Application::FaceBase do
       end
 
       it "should set the face based on the type" do
-        app.face.name.should == :basetest
+        expect(app.face.name).to eq(:basetest)
       end
 
       it "should find the action" do
-        app.action.should be
-        app.action.name.should == :foo
+        expect(app.action).to be
+        expect(app.action.name).to eq(:foo)
       end
     end
 
     it "should stop if the first thing found is not an action" do
       app.command_line.stubs(:args).returns %w{banana count_args}
 
-      expect { app.run }.to exit_with 1
+      expect { app.run }.to exit_with(1)
 
-      @logs.map(&:message).should == ["'basetest' has no 'banana' action.  See `puppet help basetest`."]
+      expect(@logs.map(&:message)).to eq(["'basetest' has no 'banana' action.  See `puppet help basetest`."])
     end
 
     it "should use the default action if not given any arguments" do
@@ -70,8 +70,8 @@ describe Puppet::Application::FaceBase do
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
-      app.action.should == action
-      app.arguments.should == [ { } ]
+      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
@@ -80,16 +80,16 @@ describe Puppet::Application::FaceBase do
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
-      app.action.should == action
-      app.arguments.should == [ 'bar', { } ]
+      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)
-      expect { app.run }.to exit_with 1
-      @logs.first.message.should =~ /has no 'bar' action./
+      expect { app.run }.to exit_with(1)
+      expect(@logs.first.message).to match(/has no 'bar' action./)
     end
 
     [%w{something_I_cannot_do},
@@ -98,8 +98,8 @@ describe Puppet::Application::FaceBase do
         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
-        @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
+        expect { app.run }.to exit_with(1)
+        expect(@logs.first.message).to match(/has no 'something_I_cannot_do' action/)
       end
     end
 
@@ -109,71 +109,87 @@ describe Puppet::Application::FaceBase do
         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
-        @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
+        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}
       expect { app.preinit; app.parse_options }.
-        to raise_error OptionParser::InvalidOption, /invalid option: --action/
+        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}
       expect { app.preinit; app.parse_options }.
-        to raise_error OptionParser::InvalidOption, /invalid option: --action/
+        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}
       expect { app.preinit; app.parse_options }.
-        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+        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}
       expect { app.preinit; app.parse_options }.
-        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+        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}
       app.preinit
       app.parse_options
-      app.action.name.should == :foo
-      app.options.should == { :mandatory => "--bar" }
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({ :mandatory => "--bar" })
     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}
       app.preinit
       app.parse_options
-      app.action.name.should == :foo
-      app.options.should == { :mandatory => "--bar" }
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({ :mandatory => "--bar" })
     end
 
     it "should not skip when --foo=bar is given" do
       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/
+        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}
       app.preinit
       app.parse_options
-      app.action.name.should == :foo
-      app.options.should == {}
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
     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}
       app.preinit
       app.parse_options
-      app.action.name.should == :foo
-      app.options.should == {}
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
+    end
+
+    it "should not add :debug to the application-level options" do
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo --debug}
+      app.preinit
+      app.parse_options
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
+    end
+
+    it "should not add :verbose to the application-level options" do
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo --verbose}
+      app.preinit
+      app.parse_options
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
     end
 
     { "boolean options before" => %w{--trace foo},
@@ -184,7 +200,7 @@ describe Puppet::Application::FaceBase do
         Puppet.settings.initialize_global_settings(args)
         app.preinit
         app.parse_options
-        Puppet[:trace].should be_true
+        expect(Puppet[:trace]).to be_truthy
       end
     end
 
@@ -196,7 +212,7 @@ describe Puppet::Application::FaceBase do
         Puppet.settings.initialize_global_settings(args)
         app.preinit
         app.parse_options
-        Puppet[:syslogfacility].should == "user1"
+        expect(Puppet[:syslogfacility]).to eq("user1")
       end
     end
 
@@ -204,7 +220,7 @@ describe Puppet::Application::FaceBase do
       app.command_line.stubs(:args).returns %w{--verbose return_true}
       app.preinit
       app.parse_options
-      app.face.name.should == :basetest
+      expect(app.face.name).to eq(:basetest)
     end
   end
 
@@ -214,7 +230,7 @@ describe Puppet::Application::FaceBase do
       app.preinit
       app.parse_options
       app.setup
-      app.arguments.should == [{ :mandatory => "--bar" }]
+      expect(app.arguments).to eq([{ :mandatory => "--bar" }])
     end
 
     it "should pass positional arguments" do
@@ -223,7 +239,7 @@ describe Puppet::Application::FaceBase do
       app.preinit
       app.parse_options
       app.setup
-      app.arguments.should == ['bar', 'baz', 'quux', { :mandatory => "--bar" }]
+      expect(app.arguments).to eq(['bar', 'baz', 'quux', { :mandatory => "--bar" }])
     end
   end
 
@@ -238,18 +254,18 @@ describe Puppet::Application::FaceBase do
 
     it "should send the specified verb and name to the face" do
       app.face.expects(:foo).with(*app.arguments)
-      expect { app.main }.to exit_with 0
+      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 { app.main }.to exit_with 1
+      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.main }.to exit_with 0
+      expect { app.main }.to exit_with(0)
     end
   end
 
@@ -264,27 +280,27 @@ describe Puppet::Application::FaceBase do
 
     it "should exit 0 when the action returns true" do
       app.action    = app.face.get_action :return_true
-      expect { app.main }.to exit_with 0
+      expect { app.main }.to exit_with(0)
     end
 
     it "should exit 0 when the action returns false" do
       app.action = app.face.get_action :return_false
-      expect { app.main }.to exit_with 0
+      expect { app.main }.to exit_with(0)
     end
 
     it "should exit 0 when the action returns nil" do
       app.action = app.face.get_action :return_nil
-      expect { app.main }.to exit_with 0
+      expect { app.main }.to exit_with(0)
     end
 
     it "should exit non-0 when the action raises" do
       app.action = app.face.get_action :return_raise
-      expect { app.main }.not_to exit_with 0
+      expect { app.main }.not_to exit_with(0)
     end
 
     it "should use the exit code set by the action" do
       app.action = app.face.get_action :with_specific_exit_code
-      expect { app.main }.to exit_with 5
+      expect { app.main }.to exit_with(5)
     end
   end
 
@@ -299,19 +315,19 @@ describe Puppet::Application::FaceBase do
 
       ["hello", 1, 1.0].each do |input|
         it "should just return a #{input.class.name}" do
-          app.render(input, {}).should == input
+          expect(app.render(input, {})).to eq(input)
         end
       end
 
       [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
         it "should render Array as one item per line" do
-          app.render(input, {}).should == input.collect { |item| item.to_s + "\n" }.join('')
+          expect(app.render(input, {})).to eq(input.collect { |item| item.to_s + "\n" }.join(''))
         end
       end
 
-      it "should render a non-trivially-keyed Hash with using JSON" do
+      it "should render a non-trivially-keyed Hash with using pretty printed PSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
-        app.render(hash, {}).should == hash.to_pson.chomp
+        expect(app.render(hash, {})).to eq(PSON.pretty_generate(hash).chomp)
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
@@ -321,7 +337,7 @@ describe Puppet::Application::FaceBase do
 
         # Gotta love ASCII-betical sort order.  Hope your objects are better
         # structured for display than my test one is. --daniel 2011-04-18
-        app.render(hash, {}).should == <<EOT
+        expect(app.render(hash, {})).to eq <<EOT
 5      5
 6.0    6
 four   #{object.to_pson.chomp}
@@ -337,7 +353,7 @@ EOT
           "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
           "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
         }
-        app.render(hash, {}).should == <<EOT
+        expect(app.render(hash, {})).to eq <<EOT
 number  {"1"=>"1111111111111111111111111111111111111111",
          "2"=>"2222222222222222222222222222222222222222",
          "3"=>"3333333333333333333333333333333333333333"}
@@ -355,7 +371,7 @@ EOT
 
         it "should invoke the action rendering hook while rendering" do
           app.action.set_rendering_method_for(:console, proc { |value| "bi-winning!" })
-          app.render("bi-polar?", {}).should == "bi-winning!"
+          expect(app.render("bi-polar?", {})).to eq("bi-winning!")
         end
 
         it "should invoke the action rendering hook with args and options while rendering" do
@@ -365,16 +381,16 @@ EOT
             :console,
             proc { |value, name, options| "I'm #{name}, no wait, I'm #{options[:altername]}" }
           )
-          app.render("bi-polar?", ['bob', {:altername => 'sue'}]).should == "I'm bob, no wait, I'm sue"
+          expect(app.render("bi-polar?", ['bob', {:altername => 'sue'}])).to eq("I'm bob, no wait, I'm sue")
         end
       end
 
       it "should render JSON when asked for json" do
         app.render_as = :json
         json = app.render({ :one => 1, :two => 2 }, {})
-        json.should =~ /"one":\s*1\b/
-        json.should =~ /"two":\s*2\b/
-        PSON.parse(json).should == { "one" => 1, "two" => 2 }
+        expect(json).to match(/"one":\s*1\b/)
+        expect(json).to match(/"two":\s*2\b/)
+        expect(PSON.parse(json)).to eq({ "one" => 1, "two" => 2 })
       end
     end
 
@@ -386,23 +402,36 @@ EOT
 
       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
-
+      expect { app.run }.to exit_with(1)
     end
 
     it "should work if asked to render a NetworkHandler format" do
-      app.command_line.stubs(:args).returns %w{count_args a b c --render-as yaml}
+      app.command_line.stubs(:args).returns %w{count_args a b c --render-as pson}
       expect {
-        expect { app.run }.to exit_with 0
-      }.to have_printed(/--- 3/)
+        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
       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
+        expect { app.run }.to exit_with(0)
       }.to have_printed(/you invoked the 's' rendering hook/)
     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)
+      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)
+      expect { app.run }.to exit_with(0)
+    end
+  end
 end

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