puppet 5.3.4 → 6.29.0

data/spec/unit/settings_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'ostruct'
 require 'puppet/settings/errors'
@@ -10,7 +9,7 @@ describe Puppet::Settings do
   include Matchers::Resource
 
   let(:main_config_file_default_location) do
-    File.join(Puppet::Util::RunMode[:master].conf_dir, "puppet.conf")
+    File.join(Puppet::Util::RunMode[:server].conf_dir, "puppet.conf")
   end
 
   let(:user_config_file_default_location) do
@@ -30,6 +29,17 @@ describe Puppet::Settings do
     end
   end
 
+  def stub_config_with(content)
+    allow(Puppet.features).to receive(:root?).and_return(false)
+    expect(Puppet::FileSystem).to receive(:exist?).
+      with(user_config_file_default_location).
+      and_return(true).ordered
+    expect(@settings).to receive(:read_file).
+      with(user_config_file_default_location).
+      and_return(content).ordered
+    @settings.send(:parse_config_files)
+  end
+
   describe "when specifying defaults" do
     before do
       @settings = Puppet::Settings.new
@@ -88,25 +98,15 @@ describe Puppet::Settings do
     end
   end
 
-
   describe "when initializing application defaults do" do
-    let(:default_values) do
-      values = {}
-      PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS.keys.each do |key|
-        values[key] = 'default value'
-      end
-      values
-    end
-
     before do
       @settings = Puppet::Settings.new
       @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
     end
 
     it "should fail if the app defaults hash is missing any required values" do
-      incomplete_default_values = default_values.reject { |key, _| key == :confdir }
       expect {
-        @settings.initialize_app_defaults(default_values.reject { |key, _| key == :confdir })
+        @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.reject { |key, _| key == :confdir })
       }.to raise_error(Puppet::Settings::SettingsError)
     end
 
@@ -114,16 +114,16 @@ describe Puppet::Settings do
     #  case behaviors / uses.  However, until that time... we need to make sure that our private run_mode=
     #  setter method gets properly called during app initialization.
     it "sets the preferred run mode when initializing the app defaults" do
-      @settings.initialize_app_defaults(default_values.merge(:run_mode => :master))
+      @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.merge(:run_mode => :server))
 
-      expect(@settings.preferred_run_mode).to eq(:master)
+      expect(@settings.preferred_run_mode).to eq(:server)
     end
 
     it "creates ancestor directories for all required app settings" do
       # initialize_app_defaults is called in spec_helper, before we even
       # get here, but call it here to make it explicit what we're trying
       # to do.
-      @settings.initialize_app_defaults(default_values)
+      @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES)
 
       Puppet::Settings::REQUIRED_APP_SETTINGS.each do |key|
         expect(File).to exist(File.dirname(Puppet[key]))
@@ -150,6 +150,7 @@ describe Puppet::Settings do
           end.to_not raise_error
         end
       end
+
       describe "if no interpolation error" do
         it "should not raise an error" do
           hook_values = []
@@ -179,6 +180,7 @@ describe Puppet::Settings do
               @settings.send(:call_hooks_deferred_to_application_initialization, options)
             end.to raise_error(Puppet::Settings::InterpolationError)
           end
+
           it "should contain the setting name in error message" do
             hook_values = []
             @settings.define_settings(
@@ -195,6 +197,7 @@ describe Puppet::Settings do
             end.to raise_error(Puppet::Settings::InterpolationError, /badhook/)
           end
         end
+
         describe "if no interpolation error" do
           it "should not raise an error" do
             hook_values = []
@@ -272,123 +275,129 @@ describe Puppet::Settings do
       expect(@settings[:myval]).to eq("")
     end
 
-    it "should flag string settings from the CLI" do
+    it "should retrieve numeric settings from the CLI" do
       @settings.handlearg("--myval", "12")
-      expect(@settings.set_by_cli?(:myval)).to be_truthy
+      expect(@settings.set_by_cli(:myval)).to eq(12)
+      expect(@settings.set_by_cli?(:myval)).to be true
+    end
+
+    it "should retrieve string settings from the CLI" do
+      @settings.handlearg("--myval", "something")
+      expect(@settings.set_by_cli(:myval)).to eq("something")
+      expect(@settings.set_by_cli?(:myval)).to be true
     end
 
-    it "should flag bool settings from the CLI" do
+    it "should retrieve bool settings from the CLI" do
       @settings.handlearg("--bool")
-      expect(@settings.set_by_cli?(:bool)).to be_truthy
+      expect(@settings.set_by_cli(:bool)).to be true
+      expect(@settings.set_by_cli?(:bool)).to be true
     end
 
-    it "should not flag settings memory as from CLI" do
+    it "should not retrieve settings set in memory as from CLI" do
       @settings[:myval] = "12"
-      expect(@settings.set_by_cli?(:myval)).to be_falsey
+      expect(@settings.set_by_cli?(:myval)).to be false
     end
 
     it "should find no configured settings by default" do
-      expect(@settings.set_by_config?(:myval)).to be_falsey
+      expect(@settings.set_by_config?(:myval)).to be false
     end
 
     it "should identify configured settings in memory" do
-      @settings.instance_variable_get(:@value_sets)[:memory].expects(:lookup).with(:myval).returns('foo')
+      expect(@settings.instance_variable_get(:@value_sets)[:memory]).to receive(:lookup).with(:myval).and_return('foo')
       expect(@settings.set_by_config?(:myval)).to be_truthy
     end
 
     it "should identify configured settings from CLI" do
-      @settings.instance_variable_get(:@value_sets)[:cli].expects(:lookup).with(:myval).returns('foo')
+      expect(@settings.instance_variable_get(:@value_sets)[:cli]).to receive(:lookup).with(:myval).and_return('foo')
       expect(@settings.set_by_config?(:myval)).to be_truthy
     end
 
     it "should not identify configured settings from environment by default" do
-      Puppet.lookup(:environments).expects(:get_conf).with(Puppet[:environment].to_sym).never
+      expect(Puppet.lookup(:environments)).not_to receive(:get_conf).with(Puppet[:environment].to_sym)
       expect(@settings.set_by_config?(:manifest)).to be_falsey
     end
 
     it "should identify configured settings from environment by when an environment is specified" do
-      foo = mock('environment', :manifest => 'foo')
-      Puppet.lookup(:environments).expects(:get_conf).with(Puppet[:environment].to_sym).returns(foo)
+      foo = double('environment', :manifest => 'foo')
+      expect(Puppet.lookup(:environments)).to receive(:get_conf).with(Puppet[:environment].to_sym).and_return(foo)
       expect(@settings.set_by_config?(:manifest, Puppet[:environment])).to be_truthy
     end
 
-    it "should identify configured settings from the preferred run mode" do
-      user_config_text = "[#{@settings.preferred_run_mode}]\nmyval = foo"
-      seq = sequence "config_file_sequence"
+    context "when handling puppet.conf" do
+      describe "#set_by_config?" do
+        it "should identify configured settings from the preferred run mode" do
+          stub_config_with(<<~CONFIG)
+          [#{@settings.preferred_run_mode}]
+          myval = foo
+          CONFIG
 
-      Puppet.features.stubs(:root?).returns(false)
-      Puppet::FileSystem.expects(:exist?).
-        with(user_config_file_default_location).
-        returns(true).in_sequence(seq)
-      @settings.expects(:read_file).
-        with(user_config_file_default_location).
-        returns(user_config_text).in_sequence(seq)
+          expect(@settings.set_by_config?(:myval)).to be_truthy
+        end
 
-      @settings.send(:parse_config_files)
-      expect(@settings.set_by_config?(:myval)).to be_truthy
-    end
+        it "should identify configured settings from the specified run mode" do
+          stub_config_with(<<~CONFIG)
+          [server]
+          myval = foo
+          CONFIG
 
-    it "should identify configured settings from the specified run mode" do
-      user_config_text = "[master]\nmyval = foo"
-      seq = sequence "config_file_sequence"
+          expect(@settings.set_by_config?(:myval, nil, :server)).to be_truthy
+        end
 
-      Puppet.features.stubs(:root?).returns(false)
-      Puppet::FileSystem.expects(:exist?).
-        with(user_config_file_default_location).
-        returns(true).in_sequence(seq)
-      @settings.expects(:read_file).
-        with(user_config_file_default_location).
-        returns(user_config_text).in_sequence(seq)
+        it "should not identify configured settings from an unspecified run mode" do
+          stub_config_with(<<~CONFIG)
+          [zaz]
+          myval = foo
+          CONFIG
 
-      @settings.send(:parse_config_files)
-      expect(@settings.set_by_config?(:myval, nil, :master)).to be_truthy
-    end
+          expect(@settings.set_by_config?(:myval)).to be_falsey
+        end
 
-    it "should not identify configured settings from an unspecified run mode" do
-      user_config_text = "[zaz]\nmyval = foo"
-      seq = sequence "config_file_sequence"
+        it "should identify configured settings from the main section" do
+          stub_config_with(<<~CONFIG)
+          [main]
+          myval = foo
+          CONFIG
 
-      Puppet.features.stubs(:root?).returns(false)
-      Puppet::FileSystem.expects(:exist?).
-        with(user_config_file_default_location).
-        returns(true).in_sequence(seq)
-      @settings.expects(:read_file).
-        with(user_config_file_default_location).
-        returns(user_config_text).in_sequence(seq)
+          expect(@settings.set_by_config?(:myval)).to be_truthy
+        end
+      end
 
-      @settings.send(:parse_config_files)
-      expect(@settings.set_by_config?(:myval)).to be_falsey
-    end
+      describe "#set_in_section" do
+        it "should retrieve configured settings from the specified section" do
+          stub_config_with(<<~CONFIG)
+          [agent]
+          myval = foo
+          CONFIG
 
-    it "should identify configured settings from the main section" do
-      user_config_text = "[main]\nmyval = foo"
-      seq = sequence "config_file_sequence"
+          expect(@settings.set_in_section(:myval, :agent)).to eq("foo")
+          expect(@settings.set_in_section?(:myval, :agent)).to be true
+        end
 
-      Puppet.features.stubs(:root?).returns(false)
-      Puppet::FileSystem.expects(:exist?).
-        with(user_config_file_default_location).
-        returns(true).in_sequence(seq)
-      @settings.expects(:read_file).
-        with(user_config_file_default_location).
-        returns(user_config_text).in_sequence(seq)
+        it "should not retrieve configured settings from a different section" do
+          stub_config_with(<<~CONFIG)
+          [main]
+          myval = foo
+          CONFIG
 
-      @settings.send(:parse_config_files)
-      expect(@settings.set_by_config?(:myval)).to be_truthy
+          expect(@settings.set_in_section(:myval, :agent)).to be nil
+          expect(@settings.set_in_section?(:myval, :agent)).to be false
+        end
+      end
     end
 
     it "should clear the cache when setting getopt-specific values" do
       @settings.define_settings :mysection,
           :one => { :default => "whah", :desc => "yay" },
           :two => { :default => "$one yay", :desc => "bah" }
-      @settings.expects(:unsafe_flush_cache)
+      expect(@settings).to receive(:unsafe_flush_cache)
       expect(@settings[:two]).to eq("whah yay")
       @settings.handlearg("--one", "else")
       expect(@settings[:two]).to eq("else yay")
     end
 
     it "should clear the cache when the preferred_run_mode is changed" do
-      @settings.expects(:flush_cache)
-      @settings.preferred_run_mode = :master
+      expect(@settings).to receive(:flush_cache)
+      @settings.preferred_run_mode = :server
     end
 
     it "should not clear other values when setting getopt-specific values" do
@@ -398,127 +407,325 @@ describe Puppet::Settings do
     end
 
     it "should clear the list of used sections" do
-      @settings.expects(:clearused)
+      expect(@settings).to receive(:clearused)
       @settings[:myval] = "yay"
     end
 
     describe "call_hook" do
+      let(:config_file) { tmpfile('config') }
+
+      before :each do
+        # We can't specify the config file to read from using `Puppet[:config] =`
+        # or pass it as an arg to Puppet.initialize_global_settings, because
+        # both of those will set the value on the `Puppet.settings` instance
+        # which is different from the `@settings` instance created in the test.
+        # Instead, we define a `:config` setting and set its default value to
+        # the `config_file` temp file, and then access the `config_file` within
+        # each test.
+        @settings.define_settings(:main, :config => { :type => :file, :desc => "config file", :default => config_file })
+      end
+
       Puppet::Settings::StringSetting.available_call_hook_values.each do |val|
         describe "when :#{val}" do
           describe "and definition invalid" do
             it "should raise error if no hook defined" do
               expect do
-                @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => val})
+                @settings.define_settings(:section, :setting => {:default => "yay", :desc => "boo", :call_hook => val})
               end.to raise_error(ArgumentError, /no :hook/)
             end
+
             it "should include the setting name in the error message" do
               expect do
-                @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => val})
-              end.to raise_error(ArgumentError, /for :hooker/)
+                @settings.define_settings(:section, :setting => {:default => "yay", :desc => "boo", :call_hook => val})
+              end.to raise_error(ArgumentError, /for :setting/)
             end
           end
+
           describe "and definition valid" do
             before(:each) do
               hook_values = []
-              @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => val, :hook => lambda { |v| hook_values << v  }})
+              @settings.define_settings(:section, :setting => {:default => "yay", :desc => "boo", :call_hook => val, :hook => lambda { |v| hook_values << v  }})
             end
 
             it "should call the hook when value written" do
-              @settings.setting(:hooker).expects(:handle).with("something").once
-              @settings[:hooker] = "something"
+              expect(@settings.setting(:setting)).to receive(:handle).with("something").once
+              @settings[:setting] = "something"
             end
           end
         end
       end
 
       it "should have a default value of :on_write_only" do
-        @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| hook_values << v  }})
-        expect(@settings.setting(:hooker).call_hook).to eq(:on_write_only)
+        @settings.define_settings(:section, :setting => {:default => "yay", :desc => "boo", :hook => lambda { |v| hook_values << v  }})
+        expect(@settings.setting(:setting).call_hook).to eq(:on_write_only)
       end
 
       describe "when nil" do
         it "should generate a warning" do
-          Puppet.expects(:warning)
-          @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => nil, :hook => lambda { |v| hook_values << v  }})
+          expect(Puppet).to receive(:warning)
+          @settings.define_settings(:section, :setting => {:default => "yay", :desc => "boo", :call_hook => nil, :hook => lambda { |v| hook_values << v  }})
         end
+
         it "should use default" do
-          @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => nil, :hook => lambda { |v| hook_values << v  }})
-          expect(@settings.setting(:hooker).call_hook).to eq(:on_write_only)
+          @settings.define_settings(:section, :setting => {:default => "yay", :desc => "boo", :call_hook => nil, :hook => lambda { |v| hook_values << v  }})
+          expect(@settings.setting(:setting).call_hook).to eq(:on_write_only)
         end
       end
 
       describe "when invalid" do
         it "should raise an error" do
           expect do
-            @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => :foo, :hook => lambda { |v| hook_values << v  }})
+            @settings.define_settings(:section, :setting => {:default => "yay", :desc => "boo", :call_hook => :foo, :hook => lambda { |v| hook_values << v  }})
           end.to raise_error(ArgumentError, /invalid.*call_hook/i)
         end
       end
 
+      describe "when :on_write_only" do
+        it "returns its hook type" do
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :hook => lambda { |_| }})
+
+          expect(@settings.setting(:setting).call_hook).to eq(:on_write_only)
+        end
+
+        it "should not call the hook at definition" do
+          hook_values = []
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :hook => lambda { |v| hook_values << v  }})
+
+          expect(hook_values).to eq(%w[])
+        end
+
+        it "calls the hook when initializing global defaults with the value from the `main` section" do
+          hook_values = []
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :hook => lambda { |v| hook_values << v  }})
+
+          File.write(config_file, <<~END)
+            [main]
+            setting=in_main
+          END
+          @settings.initialize_global_settings
+
+          expect(@settings[:setting]).to eq('in_main')
+          expect(hook_values).to eq(%w[in_main])
+        end
+
+        it "doesn't call the hook when initializing app defaults" do
+          hook_values = []
+          @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :hook => lambda { |v| hook_values << v }})
+
+          File.write(config_file, <<~END)
+            [main]
+            setting=in_main
+            [agent]
+            setting=in_agent
+          END
+          @settings.initialize_global_settings
+
+          hook_values.clear
+
+          @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES)
+
+          expect(@settings[:setting]).to eq('in_main')
+          expect(hook_values).to eq(%w[])
+        end
+
+        it "doesn't call the hook with value from a section that matches the run_mode" do
+          hook_values = []
+          @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :hook => lambda { |v| hook_values << v  }})
+
+          File.write(config_file, <<~END)
+            [main]
+            setting=in_main
+            [agent]
+            setting=in_agent
+          END
+          @settings.initialize_global_settings
+
+          hook_values.clear
+
+          @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.merge(:run_mode => :agent))
+
+          expect(@settings[:setting]).to eq('in_agent')
+          expect(hook_values).to eq(%w[])
+        end
+      end
+
       describe "when :on_define_and_write" do
-        it "should call the hook at definition" do
+        it "returns its hook type" do
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |_| }})
+
+          expect(@settings.setting(:setting).call_hook).to eq(:on_define_and_write)
+        end
+
+        it "should call the hook at definition with the default value" do
           hook_values = []
-          @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| hook_values << v  }})
-          expect(@settings.setting(:hooker).call_hook).to eq(:on_define_and_write)
-          expect(hook_values).to eq(%w{yay})
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| hook_values << v  }})
+
+          expect(hook_values).to eq(%w[yay])
+        end
+
+        it "calls the hook when initializing global defaults with the value from the `main` section" do
+          hook_values = []
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| hook_values << v  }})
+
+          File.write(config_file, <<~END)
+            [main]
+            setting=in_main
+          END
+          @settings.initialize_global_settings
+
+          expect(@settings[:setting]).to eq('in_main')
+          expect(hook_values).to eq(%w[yay in_main])
+        end
+
+        it "doesn't call the hook when initializing app defaults" do
+          hook_values = []
+          @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| hook_values << v  }})
+
+          File.write(config_file, <<~END)
+            [main]
+            setting=in_main
+            [agent]
+            setting=in_agent
+          END
+          @settings.initialize_global_settings
+
+          hook_values.clear
+
+          @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES)
+
+          expect(@settings[:setting]).to eq('in_main')
+          expect(hook_values).to eq([])
+        end
+
+        it "doesn't call the hook with value from a section that matches the run_mode" do
+          hook_values = []
+          @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| hook_values << v  }})
+
+          File.write(config_file, <<~END)
+            [main]
+            setting=in_main
+            [agent]
+            setting=in_agent
+          END
+
+          @settings.initialize_global_settings
+
+          hook_values.clear
+
+          @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.merge(:run_mode => :agent))
+
+          # The correct value is returned
+          expect(@settings[:setting]).to eq('in_agent')
+
+          # but the hook is never called, seems like a bug!
+          expect(hook_values).to eq([])
         end
       end
 
       describe "when :on_initialize_and_write" do
-        before(:each) do
-          @hook_values = []
-          @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| @hook_values << v  }})
+        it "returns its hook type" do
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |_| }})
+
+          expect(@settings.setting(:setting).call_hook).to eq(:on_initialize_and_write)
         end
 
         it "should not call the hook at definition" do
-          expect(@hook_values).to eq([])
-          expect(@hook_values).not_to eq(%w{yay})
+          hook_values = []
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| hook_values << v }})
+          expect(hook_values).to eq([])
         end
 
-        it "should call the hook at initialization" do
-          app_defaults = {}
-          Puppet::Settings::REQUIRED_APP_SETTINGS.each do |key|
-            app_defaults[key] = "foo"
-          end
-          app_defaults[:run_mode] = :user
+        it "calls the hook when initializing global defaults with the value from the `main` section" do
+          hook_values = []
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| hook_values << v }})
+
+          File.write(config_file, <<~END)
+            [main]
+            setting=in_main
+          END
+          @settings.initialize_global_settings
+
+          expect(@settings[:setting]).to eq('in_main')
+          expect(hook_values).to eq(%w[in_main])
+        end
+
+        it "calls the hook when initializing app defaults" do
+          hook_values = []
           @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| hook_values << v }})
+
+          File.write(config_file, <<~END)
+            [main]
+            setting=in_main
+            [agent]
+            setting=in_agent
+          END
+          @settings.initialize_global_settings
 
-          @settings.setting(:hooker).expects(:handle).with("yay").once
+          hook_values.clear
 
-          @settings.initialize_app_defaults app_defaults
+          @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES)
+
+          expect(@settings[:setting]).to eq('in_main')
+          expect(hook_values).to eq(%w[in_main])
+        end
+
+        it "calls the hook with the overridden value from a section that matches the run_mode" do
+          hook_values = []
+          @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
+          @settings.define_settings(:main, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| hook_values << v  }})
+
+          File.write(config_file, <<~END)
+            [main]
+            setting=in_main
+            [agent]
+            setting=in_agent
+          END
+          @settings.initialize_global_settings
+
+          hook_values.clear
+
+          @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.merge(:run_mode => :agent))
+
+          expect(@settings[:setting]).to eq('in_agent')
+          expect(hook_values).to eq(%w[in_agent])
         end
       end
     end
 
     it "should call passed blocks when values are set" do
       values = []
-      @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
+      @settings.define_settings(:section, :setting => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
       expect(values).to eq([])
 
-      @settings[:hooker] = "something"
+      @settings[:setting] = "something"
       expect(values).to eq(%w{something})
     end
 
     it "should call passed blocks when values are set via the command line" do
       values = []
-      @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
+      @settings.define_settings(:section, :setting => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
       expect(values).to eq([])
 
-      @settings.handlearg("--hooker", "yay")
+      @settings.handlearg("--setting", "yay")
 
       expect(values).to eq(%w{yay})
     end
 
     it "should provide an option to call passed blocks during definition" do
       values = []
-      @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| values << v }})
+      @settings.define_settings(:section, :setting => {:default => "yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| values << v }})
       expect(values).to eq(%w{yay})
     end
 
     it "should pass the fully interpolated value to the hook when called on definition" do
       values = []
       @settings.define_settings(:section, :one => { :default => "test", :desc => "a" })
-      @settings.define_settings(:section, :hooker => {:default => "$one/yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| values << v }})
+      @settings.define_settings(:section, :setting => {:default => "$one/yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| values << v }})
       expect(values).to eq(%w{test/yay})
     end
 
@@ -556,8 +763,9 @@ describe Puppet::Settings do
           :two    => { :default => "$one TWO", :desc => "b"},
           :three  => { :default => "$one $two THREE", :desc => "c"},
           :four   => { :default => "$two $three FOUR", :desc => "d"},
-          :five   => { :default => nil, :desc => "e" }
-      Puppet::FileSystem.stubs(:exist?).returns true
+          :five   => { :default => nil, :desc => "e" },
+          :code   => { :default => "", :desc => "my code"}
+      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
     end
 
     it "should provide a mechanism for returning set values" do
@@ -566,12 +774,8 @@ describe Puppet::Settings do
     end
 
     it "setting a value to nil causes it to return to its default" do
-      default_values = { :one => "skipped value" }
-      [:logdir, :confdir, :codedir, :vardir].each do |key|
-        default_values[key] = 'default value'
-      end
       @settings.define_settings :main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS
-      @settings.initialize_app_defaults(default_values)
+      @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.merge(:one => "skipped value"))
       @settings[:one] = "value will disappear"
 
       @settings[:one] = nil
@@ -612,6 +816,13 @@ describe Puppet::Settings do
       expect(@settings[:two]).to eq("one TWO")
     end
 
+    it "should not interpolate the value of the :code setting" do
+      @code = @settings.setting(:code)
+      expect(@code).not_to receive(:munge)
+
+      expect(@settings[:code]).to eq("")
+    end
+
     it "should have a run_mode that defaults to user" do
       expect(@settings.preferred_run_mode).to eq(:user)
     end
@@ -625,13 +836,14 @@ describe Puppet::Settings do
   end
 
   describe "when choosing which value to return" do
+    let(:config_file) { tmpfile('settings') }
+
     before do
       @settings = Puppet::Settings.new
       @settings.define_settings :section,
-        :config => { :type => :file, :default => "/my/file", :desc => "a" },
+        :config => { :type => :file, :default => config_file, :desc => "a" },
         :one => { :default => "ONE", :desc => "a" },
         :two => { :default => "TWO", :desc => "b" }
-      Puppet::FileSystem.stubs(:exist?).returns true
       @settings.preferred_run_mode = :agent
     end
 
@@ -640,27 +852,44 @@ describe Puppet::Settings do
     end
 
     it "should return values set on the cli before values set in the configuration file" do
-      text = "[main]\none = fileval\n"
-      @settings.stubs(:read_file).returns(text)
+      File.write(config_file, "[main]\none = fileval\n")
       @settings.handlearg("--one", "clival")
-      @settings.send(:parse_config_files)
+      @settings.initialize_global_settings
 
       expect(@settings[:one]).to eq("clival")
     end
 
     it "should return values set in the mode-specific section before values set in the main section" do
-      text = "[main]\none = mainval\n[agent]\none = modeval\n"
-      @settings.stubs(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(config_file, "[main]\none = mainval\n[agent]\none = modeval\n")
+      @settings.initialize_global_settings
 
       expect(@settings[:one]).to eq("modeval")
     end
 
+    [:master, :server].each do |run_mode|
+      describe "when run mode is '#{run_mode}'" do
+        before(:each) { @settings.preferred_run_mode = run_mode }
+
+        it "returns values set in the 'master' section if the 'server' section does not exist" do
+          File.write(config_file, "[main]\none = mainval\n[master]\none = modeval\n")
+          @settings.initialize_global_settings
+
+          expect(@settings[:one]).to eq("modeval")
+        end
+
+        it "prioritizes values set in the 'server' section if set" do
+          File.write(config_file,  "[main]\none = mainval\n[server]\none = serverval\n[master]\none = masterval\n")
+          @settings.initialize_global_settings
+
+          expect(@settings[:one]).to eq("serverval")
+        end
+      end
+    end
+
     it "should not return values outside of its search path" do
-      text = "[other]\none = oval\n"
-      file = "/some/file"
-      @settings.stubs(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(config_file, "[other]\none = oval\n")
+      @settings.initialize_global_settings
+
       expect(@settings[:one]).to eq("ONE")
     end
 
@@ -678,22 +907,57 @@ describe Puppet::Settings do
 
     describe "when root" do
       it "should look for the main config file default location config settings haven't been overridden'" do
-        Puppet.features.stubs(:root?).returns(true)
-        Puppet::FileSystem.expects(:exist?).with(main_config_file_default_location).returns(false)
-        Puppet::FileSystem.expects(:exist?).with(user_config_file_default_location).never
+        allow(Puppet.features).to receive(:root?).and_return(true)
+        expect(Puppet::FileSystem).to receive(:exist?).with(main_config_file_default_location).and_return(false)
+        expect(Puppet::FileSystem).not_to receive(:exist?).with(user_config_file_default_location)
 
-        @settings.send(:parse_config_files)
+        @settings.initialize_global_settings
       end
     end
 
     describe "when not root" do
       it "should look for user config file default location if config settings haven't been overridden'" do
-        Puppet.features.stubs(:root?).returns(false)
+        allow(Puppet.features).to receive(:root?).and_return(false)
 
-        seq = sequence "load config files"
-        Puppet::FileSystem.expects(:exist?).with(user_config_file_default_location).returns(false).in_sequence(seq)
+        expect(Puppet::FileSystem).to receive(:exist?).with(user_config_file_default_location).and_return(false)
 
-        @settings.send(:parse_config_files)
+        @settings.initialize_global_settings
+      end
+    end
+
+    describe "when the file exists" do
+      it "fails if the file is not readable" do
+        expect(Puppet::FileSystem).to receive(:exist?).with(user_config_file_default_location).and_return(true)
+        expect(@settings).to receive(:read_file).and_raise('Permission denied')
+
+        expect{ @settings.initialize_global_settings }.to raise_error(RuntimeError, /Could not load #{user_config_file_default_location}: Permission denied/)
+      end
+
+      it "does not fail if the file is not readable and when `require_config` is false" do
+        expect(Puppet::FileSystem).to receive(:exist?).with(user_config_file_default_location).and_return(true)
+        expect(@settings).to receive(:read_file).and_raise('Permission denied')
+
+        expect(@settings).not_to receive(:parse_config)
+        expect(Puppet).to receive(:log_exception)
+
+        expect{ @settings.initialize_global_settings([], false) }.not_to raise_error
+      end
+
+      it "reads the file if it is readable" do
+        expect(Puppet::FileSystem).to receive(:exist?).with(user_config_file_default_location).and_return(true)
+        expect(@settings).to receive(:read_file).and_return('server = host.string')
+        expect(@settings).to receive(:parse_config)
+
+        @settings.initialize_global_settings
+      end
+    end
+
+    describe "when the file does not exist" do
+      it "does not attempt to parse the config file" do
+        expect(Puppet::FileSystem).to receive(:exist?).with(user_config_file_default_location).and_return(false)
+        expect(@settings).not_to receive(:parse_config)
+
+        @settings.initialize_global_settings
       end
     end
   end
@@ -701,88 +965,94 @@ describe Puppet::Settings do
   describe "when parsing its configuration" do
     before do
       @settings = Puppet::Settings.new
-      @settings.stubs(:service_user_available?).returns true
-      @settings.stubs(:service_group_available?).returns true
-      @file = make_absolute("/some/file")
-      @userconfig = make_absolute("/test/userconfigfile")
+      allow(@settings).to receive(:service_user_available?).and_return(true)
+      allow(@settings).to receive(:service_group_available?).and_return(true)
+      @file = tmpfile("somefile")
       @settings.define_settings :section, :user => { :default => "suser", :desc => "doc" }, :group => { :default => "sgroup", :desc => "doc" }
       @settings.define_settings :section,
           :config => { :type => :file, :default => @file, :desc => "eh" },
           :one => { :default => "ONE", :desc => "a" },
           :two => { :default => "$one TWO", :desc => "b" },
           :three => { :default => "$one $two THREE", :desc => "c" }
-      @settings.stubs(:user_config_file).returns(@userconfig)
-      Puppet::FileSystem.stubs(:exist?).with(@file).returns true
-      Puppet::FileSystem.stubs(:exist?).with(@userconfig).returns false
+
+      userconfig = tmpfile("userconfig")
+      allow(@settings).to receive(:user_config_file).and_return(userconfig)
     end
 
     it "should not ignore the report setting" do
       @settings.define_settings :section, :report => { :default => "false", :desc => "a" }
-      # This is needed in order to make sure we pass on windows
-      myfile = File.expand_path(@file)
-      @settings[:config] = myfile
-      text = <<-CONF
+      File.write(@file, <<~CONF)
         [puppetd]
-          report=true
+        report=true
       CONF
-      Puppet::FileSystem.expects(:exist?).with(myfile).returns(true)
-      @settings.expects(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+
+      @settings.initialize_global_settings
+
       expect(@settings[:report]).to be_truthy
     end
 
     it "should use its current ':config' value for the file to parse" do
-      myfile = make_absolute("/my/file") # do not stub expand_path here, as this leads to a stack overflow, when mocha tries to use it
-      @settings[:config] = myfile
-
-      Puppet::FileSystem.expects(:exist?).with(myfile).returns(true)
+      myfile = tmpfile('myfile')
+      File.write(myfile, <<~CONF)
+        [main]
+        one=myfile
+      CONF
 
-      Puppet::FileSystem.expects(:read).with(myfile, :encoding => 'utf-8').returns "[main]"
+      @settings[:config] = myfile
+      @settings.initialize_global_settings
 
-      @settings.send(:parse_config_files)
+      expect(@settings[:one]).to eq('myfile')
     end
 
     it "should not try to parse non-existent files" do
-      Puppet::FileSystem.expects(:exist?).with(@file).returns false
+      expect(Puppet::FileSystem).to receive(:exist?).with(@file).and_return(false)
 
-      File.expects(:read).with(@file).never
+      expect(File).not_to receive(:read).with(@file)
 
-      @settings.send(:parse_config_files)
+      @settings.initialize_global_settings
     end
 
     it "should return values set in the configuration file" do
-      text = "[main]
-      one = fileval
-      "
-      @settings.expects(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(@file, <<~CONF)
+        [main]
+        one = fileval
+      CONF
+
+      @settings.initialize_global_settings
       expect(@settings[:one]).to eq("fileval")
     end
 
     #484 - this should probably be in the regression area
     it "should not throw an exception on unknown parameters" do
-      text = "[main]\nnosuchparam = mval\n"
-      @settings.expects(:read_file).returns(text)
-      expect { @settings.send(:parse_config_files) }.not_to raise_error
+      File.write(@file, <<~CONF)
+        [main]
+        nosuchparam = mval
+      CONF
+
+      expect { @settings.initialize_global_settings }.not_to raise_error
     end
 
     it "should convert booleans in the configuration file into Ruby booleans" do
-      text = "[main]
-      one = true
-      two = false
-      "
-      @settings.expects(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(@file, <<~CONF)
+        [main]
+        one = true
+        two = false
+      CONF
+
+      @settings.initialize_global_settings
+
       expect(@settings[:one]).to eq(true)
       expect(@settings[:two]).to eq(false)
     end
 
     it "should convert integers in the configuration file into Ruby Integers" do
-      text = "[main]
-      one = 65
-      "
-      @settings.expects(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(@file, <<~CONF)
+        [main]
+        one = 65
+      CONF
+
+      @settings.initialize_global_settings
+
       expect(@settings[:one]).to eq(65)
     end
 
@@ -813,57 +1083,193 @@ describe Puppet::Settings do
     end
 
     it "should support loading metadata (owner, group, or mode) from a run_mode section in the configuration file" do
-      default_values = {}
-      PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS.keys.each do |key|
-        default_values[key] = 'default value'
-      end
       @settings.define_settings :main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS
-      @settings.define_settings :master, :myfile => { :type => :file, :default => make_absolute("/myfile"), :desc => "a" }
+      @settings.define_settings :server, :myfile => { :type => :file, :default => make_absolute("/myfile"), :desc => "a" }
 
       otherfile = make_absolute("/other/file")
-      text = "[master]
-      myfile = #{otherfile} {mode = 664}
-      "
-      @settings.expects(:read_file).returns(text)
+      File.write(@file, <<~CONF)
+        [server]
+        myfile = #{otherfile} {mode = 664}
+      CONF
 
       # will start initialization as user
       expect(@settings.preferred_run_mode).to eq(:user)
-      @settings.send(:parse_config_files)
+      @settings.initialize_global_settings
 
-      # change app run_mode to master
-      @settings.initialize_app_defaults(default_values.merge(:run_mode => :master))
-      expect(@settings.preferred_run_mode).to eq(:master)
+      # change app run_mode to server
+      @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.merge(:run_mode => :server))
+      expect(@settings.preferred_run_mode).to eq(:server)
 
       # initializing the app should have reloaded the metadata based on run_mode
       expect(@settings[:myfile]).to eq(otherfile)
       expect(metadata(@settings.setting(:myfile))).to eq({:mode => "664"})
     end
 
-    it "does not use the metadata from the same setting in a different section" do
-      default_values = {}
-      PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS.keys.each do |key|
-        default_values[key] = 'default value'
+    context "when setting serverport and masterport" do
+      before(:each) do
+        @settings.define_settings :main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS
+        @settings.define_settings :server, :masterport => { :desc => "a", :default => 1000 }
+        @settings.define_settings :server, :serverport => { :type => :alias, :alias_for => :masterport }
+        @settings.define_settings :server, :ca_port => { :desc => "a", :default => "$serverport" }
+        @settings.define_settings :server, :report_port => { :desc => "a", :default => "$serverport" }
+
+        config_file = tmpfile('config')
+        @settings[:config] = config_file
+        File.write(config_file, text)
+
+        @settings.initialize_global_settings
+        @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.merge(:run_mode => :agent))
+        expect(@settings.preferred_run_mode).to eq(:agent)
+      end
+
+      context 'with serverport in main and masterport in agent' do
+        let(:text) do
+          "[main]
+      serverport = 444
+      [agent]
+      masterport = 445
+      "
+        end
+
+        it { expect(@settings[:serverport]).to eq(444) }
+        it { expect(@settings[:ca_port]).to eq("444") }
+        it { expect(@settings[:report_port]).to eq("444") }
+        it { expect(@settings[:masterport]).to eq(445) }
       end
 
+      context 'with serverport and masterport in main' do
+        let(:text) do
+          "[main]
+      serverport = 445
+      masterport = 444
+      "
+        end
+
+        it { expect(@settings[:serverport]).to eq(445) }
+        it { expect(@settings[:ca_port]).to eq("445") }
+        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:masterport]).to eq(444) }
+      end
+
+      context 'with serverport and masterport in agent' do
+        let(:text) do
+          "[agent]
+      serverport = 445
+      masterport = 444
+      "
+        end
+
+        it { expect(@settings[:serverport]).to eq(445) }
+        it { expect(@settings[:ca_port]).to eq("445") }
+        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:masterport]).to eq(444) }
+      end
+
+      context 'with both serverport and masterport in main and agent' do
+        let(:text) do
+          "[main]
+      serverport = 447
+      masterport = 442
+      [agent]
+      serverport = 445
+      masterport = 444
+      "
+        end
+
+        it { expect(@settings[:serverport]).to eq(445) }
+        it { expect(@settings[:ca_port]).to eq("445") }
+        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:masterport]).to eq(444) }
+      end
+
+      context 'with serverport in agent and masterport in main' do
+        let(:text) do
+          "[agent]
+      serverport = 444
+      [main]
+      masterport = 445
+      "
+        end
+
+        it { expect(@settings[:serverport]).to eq(444) }
+        it { expect(@settings[:ca_port]).to eq("444") }
+        it { expect(@settings[:report_port]).to eq("444") }
+        it { expect(@settings[:masterport]).to eq(445) }
+      end
+
+      context 'with masterport in main' do
+        let(:text) do
+          "[main]
+      masterport = 445
+      "
+        end
+
+        it { expect(@settings[:serverport]).to eq(445) }
+        it { expect(@settings[:ca_port]).to eq("445") }
+        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:masterport]).to eq(445) }
+      end
+
+      context 'with masterport in agent' do
+        let(:text) do
+          "[agent]
+      masterport = 445
+      "
+        end
+
+        it { expect(@settings[:serverport]).to eq(445) }
+        it { expect(@settings[:ca_port]).to eq("445") }
+        it { expect(@settings[:report_port]).to eq("445") }
+        it { expect(@settings[:masterport]).to eq(445) }
+      end
+
+      context 'with serverport in agent' do
+        let(:text) do
+          "[agent]
+      serverport = 445
+      "
+        end
+
+        it { expect(@settings[:serverport]).to eq(445) }
+        it { expect(@settings[:masterport]).to eq(1000) }
+        it { expect(@settings[:ca_port]).to eq("445") }
+        it { expect(@settings[:report_port]).to eq("445") }
+      end
+
+      context 'with serverport in main' do
+        let(:text) do
+          "[main]
+      serverport = 445
+      "
+        end
+
+        it { expect(@settings[:serverport]).to eq(445) }
+        it { expect(@settings[:masterport]).to eq(1000) }
+        it { expect(@settings[:ca_port]).to eq("445") }
+        it { expect(@settings[:report_port]).to eq("445") }
+      end
+    end
+
+    it "does not use the metadata from the same setting in a different section" do
       file = make_absolute("/file")
       default_mode = "0600"
       @settings.define_settings :main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS
-      @settings.define_settings :master, :myfile => { :type => :file, :default => file, :desc => "a", :mode => default_mode }
+      @settings.define_settings :server, :myfile => { :type => :file, :default => file, :desc => "a", :mode => default_mode }
 
-      text = "[master]
-      myfile = #{file}/foo
-      [agent]
-      myfile = #{file} {mode = 664}
-      "
-      @settings.expects(:read_file).returns(text)
+      File.write(@file, <<~CONF)
+        [server]
+        myfile = #{file}/foo
+        [agent]
+        myfile = #{file} {mode = 664}
+      CONF
 
       # will start initialization as user
       expect(@settings.preferred_run_mode).to eq(:user)
-      @settings.send(:parse_config_files)
+      @settings.initialize_global_settings
 
-      # change app run_mode to master
-      @settings.initialize_app_defaults(default_values.merge(:run_mode => :master))
-      expect(@settings.preferred_run_mode).to eq(:master)
+      # change app run_mode to server
+      @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.merge(:run_mode => :server))
+      expect(@settings.preferred_run_mode).to eq(:server)
 
       # initializing the app should have reloaded the metadata based on run_mode
       expect(@settings[:myfile]).to eq("#{file}/foo")
@@ -874,11 +1280,12 @@ describe Puppet::Settings do
       values = []
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
-      text = "[main]
-      mysetting = setval
-      "
-      @settings.expects(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(@file, <<~CONF)
+        [main]
+        mysetting = setval
+      CONF
+      @settings.initialize_global_settings
+
       expect(values).to eq(["setval"])
     end
 
@@ -886,13 +1293,14 @@ describe Puppet::Settings do
       values = []
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
-      text = "[user]
-      mysetting = setval
-      [main]
-      mysetting = other
-      "
-      @settings.expects(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(@file, <<~CONF)
+        [user]
+        mysetting = setval
+        [main]
+        mysetting = other
+      CONF
+      @settings.initialize_global_settings
+
       expect(values).to eq(["setval"])
     end
 
@@ -901,11 +1309,12 @@ describe Puppet::Settings do
       @settings.define_settings :section, :base => {:default => "yay", :desc => "a", :hook => proc { |v| values << v }}
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
-      text = "[main]
-      mysetting = $base/setval
-      "
-      @settings.expects(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(@file, <<~CONF)
+        [main]
+        mysetting = $base/setval
+      CONF
+      @settings.initialize_global_settings
+
       expect(values).to eq(["yay/setval"])
     end
 
@@ -915,86 +1324,70 @@ describe Puppet::Settings do
                                                          :hook => proc { |v| hook_invoked = true },
                                                          :call_hook => :on_initialize_and_write, }
 
+      # This test relies on `confdir` defaulting to nil which causes the default
+      # value of `deferred=$confdir/goose` to raise an interpolation error during
+      # global initialization, and the hook to be skipped
       @settings.define_settings(:main,
-        :logdir       => { :type => :directory, :default => nil, :desc => "logdir" },
-        :confdir      => { :type => :directory, :default => nil, :desc => "confdir" },
-        :codedir      => { :type => :directory, :default => nil, :desc => "codedir" },
-        :vardir       => { :type => :directory, :default => nil, :desc => "vardir" })
+                                PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS.merge(
+                                  :confdir => { :type => :directory, :default => nil, :desc => "confdir" }))
 
-      text = <<-EOD
-      [main]
-      deferred=$confdir/goose
+      File.write(@file, <<~EOD)
+        [main]
+        deferred=$confdir/goose
       EOD
 
-      @settings.stubs(:read_file).returns(text)
       @settings.initialize_global_settings
 
       expect(hook_invoked).to be_falsey
 
-      @settings.initialize_app_defaults(:logdir => '/path/to/logdir', :confdir => '/path/to/confdir', :vardir => '/path/to/vardir', :codedir => '/path/to/codedir')
+      # And now that we initialize app defaults with `confdir`, then `deferred`
+      # can be interpolated and its hook called
+      @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.merge(:confdir => '/path/to/confdir'))
 
       expect(hook_invoked).to be_truthy
       expect(@settings[:deferred]).to eq(File.expand_path('/path/to/confdir/goose'))
     end
 
     it "does not require the value for a setting without a hook to resolve during global setup" do
-      hook_invoked = false
       @settings.define_settings :section, :can_cause_problems  => {:desc => '' }
 
-      @settings.define_settings(:main,
-        :logdir       => { :type => :directory, :default => nil, :desc => "logdir" },
-        :confdir      => { :type => :directory, :default => nil, :desc => "confdir" },
-        :codedir      => { :type => :directory, :default => nil, :desc => "codedir" },
-        :vardir       => { :type => :directory, :default => nil, :desc => "vardir" })
+      @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
 
-      text = <<-EOD
+      File.write(@file, <<~EOD)
       [main]
       can_cause_problems=$confdir/goose
       EOD
 
-      @settings.stubs(:read_file).returns(text)
       @settings.initialize_global_settings
-      @settings.initialize_app_defaults(:logdir => '/path/to/logdir', :confdir => '/path/to/confdir', :vardir => '/path/to/vardir', :codedir => '/path/to/codedir')
+      @settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES.merge(:confdir => '/path/to/confdir'))
 
-      expect(@settings[:can_cause_problems]).to eq(File.expand_path('/path/to/confdir/goose'))
+      expect(@settings[:can_cause_problems]).to eq('/path/to/confdir/goose')
     end
 
     it "should allow empty values" do
       @settings.define_settings :section, :myarg => { :default => "myfile", :desc => "a" }
 
-      text = "[main]
-      myarg =
-      "
-      @settings.stubs(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(@file, <<~CONF)
+        [main]
+        myarg =
+      CONF
+      @settings.initialize_global_settings
+
       expect(@settings[:myarg]).to eq("")
     end
 
     describe "deprecations" do
       let(:settings) { Puppet::Settings.new }
-      let(:app_defaults) {
-        {
-          :logdir     => "/dev/null",
-          :confdir    => "/dev/null",
-          :codedir    => "/dev/null",
-          :vardir     => "/dev/null",
-        }
-      }
 
       def assert_accessing_setting_is_deprecated(settings, setting)
-        Puppet.expects(:deprecation_warning).with("Accessing '#{setting}' as a setting is deprecated.")
-        Puppet.expects(:deprecation_warning).with("Modifying '#{setting}' as a setting is deprecated.")
+        expect(Puppet).to receive(:deprecation_warning).with("Accessing '#{setting}' as a setting is deprecated.")
+        expect(Puppet).to receive(:deprecation_warning).with("Modifying '#{setting}' as a setting is deprecated.")
         settings[setting.intern] = apath = File.expand_path('foo')
         expect(settings[setting.intern]).to eq(apath)
       end
 
       before(:each) do
-        settings.define_settings(:main, {
-          :logdir => { :default => 'a', :desc => 'a' },
-          :confdir => { :default => 'b', :desc => 'b' },
-          :vardir => { :default => 'c', :desc => 'c' },
-          :codedir => { :default => 'd', :desc => 'd' },
-        })
+        settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
       end
 
       context "complete" do
@@ -1010,20 +1403,20 @@ describe Puppet::Settings do
         end
 
         it "warns when set in puppet.conf" do
-          Puppet.expects(:deprecation_warning).with(regexp_matches(/completely_deprecated_setting is deprecated\./), 'setting-completely_deprecated_setting')
+          expect(Puppet).to receive(:deprecation_warning).with(/completely_deprecated_setting is deprecated\./, 'setting-completely_deprecated_setting')
 
           completely_deprecated_settings.parse_config(<<-CONF)
             completely_deprecated_setting='should warn'
           CONF
-          completely_deprecated_settings.initialize_app_defaults(app_defaults)
+          completely_deprecated_settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES)
         end
 
         it "warns when set on the commandline" do
-          Puppet.expects(:deprecation_warning).with(regexp_matches(/completely_deprecated_setting is deprecated\./), 'setting-completely_deprecated_setting')
+          expect(Puppet).to receive(:deprecation_warning).with(/completely_deprecated_setting is deprecated\./, 'setting-completely_deprecated_setting')
 
           args = ["--completely_deprecated_setting", "/some/value"]
           completely_deprecated_settings.send(:parse_global_options, args)
-          completely_deprecated_settings.initialize_app_defaults(app_defaults)
+          completely_deprecated_settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES)
         end
 
         it "warns when set in code" do
@@ -1044,19 +1437,19 @@ describe Puppet::Settings do
         end
 
         it "warns for a deprecated setting allowed on the command line set in puppet.conf" do
-          Puppet.expects(:deprecation_warning).with(regexp_matches(/partially_deprecated_setting is deprecated in puppet\.conf/), 'puppet-conf-setting-partially_deprecated_setting')
+          expect(Puppet).to receive(:deprecation_warning).with(/partially_deprecated_setting is deprecated in puppet\.conf/, 'puppet-conf-setting-partially_deprecated_setting')
           partially_deprecated_settings.parse_config(<<-CONF)
             partially_deprecated_setting='should warn'
           CONF
-          partially_deprecated_settings.initialize_app_defaults(app_defaults)
+          partially_deprecated_settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES)
         end
 
         it "does not warn when manifest is set on command line" do
-          Puppet.expects(:deprecation_warning).never
+          expect(Puppet).not_to receive(:deprecation_warning)
 
           args = ["--partially_deprecated_setting", "/some/value"]
           partially_deprecated_settings.send(:parse_global_options, args)
-          partially_deprecated_settings.initialize_app_defaults(app_defaults)
+          partially_deprecated_settings.initialize_app_defaults(PuppetSpec::Settings::TEST_APP_DEFAULT_VALUES)
         end
 
         it "warns when set in code" do
@@ -1069,7 +1462,6 @@ describe Puppet::Settings do
   describe "when there are multiple config files" do
     let(:main_config_text) { "[main]\none = main\ntwo = main2" }
     let(:user_config_text) { "[main]\none = user\n" }
-    let(:seq) { sequence "config_file_sequence" }
 
     before :each do
       @settings = Puppet::Settings.new
@@ -1082,13 +1474,13 @@ describe Puppet::Settings do
 
     context "running non-root without explicit config file" do
       before :each do
-        Puppet.features.stubs(:root?).returns(false)
-        Puppet::FileSystem.expects(:exist?).
+        allow(Puppet.features).to receive(:root?).and_return(false)
+        expect(Puppet::FileSystem).to receive(:exist?).
           with(user_config_file_default_location).
-          returns(true).in_sequence(seq)
-        @settings.expects(:read_file).
+          and_return(true).ordered
+        expect(@settings).to receive(:read_file).
           with(user_config_file_default_location).
-          returns(user_config_text).in_sequence(seq)
+          and_return(user_config_text).ordered
       end
 
       it "should return values from the user config file" do
@@ -1104,13 +1496,13 @@ describe Puppet::Settings do
 
     context "running as root without explicit config file" do
       before :each do
-        Puppet.features.stubs(:root?).returns(true)
-        Puppet::FileSystem.expects(:exist?).
+        allow(Puppet.features).to receive(:root?).and_return(true)
+        expect(Puppet::FileSystem).to receive(:exist?).
           with(main_config_file_default_location).
-          returns(true).in_sequence(seq)
-        @settings.expects(:read_file).
+          and_return(true).ordered
+        expect(@settings).to receive(:read_file).
           with(main_config_file_default_location).
-          returns(main_config_text).in_sequence(seq)
+          and_return(main_config_text).ordered
       end
 
       it "should return values from the main config file" do
@@ -1126,14 +1518,14 @@ describe Puppet::Settings do
 
     context "running with an explicit config file as a user (e.g. Apache + Passenger)" do
       before :each do
-        Puppet.features.stubs(:root?).returns(false)
+        allow(Puppet.features).to receive(:root?).and_return(false)
         @settings[:confdir] = File.dirname(main_config_file_default_location)
-        Puppet::FileSystem.expects(:exist?).
+        expect(Puppet::FileSystem).to receive(:exist?).
           with(main_config_file_default_location).
-          returns(true).in_sequence(seq)
-        @settings.expects(:read_file).
+          and_return(true).ordered
+        expect(@settings).to receive(:read_file).
           with(main_config_file_default_location).
-          returns(main_config_text).in_sequence(seq)
+          and_return(main_config_text).ordered
       end
 
       it "should return values from the main config file" do
@@ -1150,24 +1542,25 @@ describe Puppet::Settings do
 
   describe "when reparsing its configuration" do
     before do
-      @file = make_absolute("/test/file")
-      @userconfig = make_absolute("/test/userconfigfile")
+      @file = tmpfile("testfile")
+      Puppet::FileSystem.touch(@file)
+
       @settings = Puppet::Settings.new
       @settings.define_settings :section,
           :config => { :type => :file, :default => @file, :desc => "a" },
           :one => { :default => "ONE", :desc => "a" },
           :two => { :default => "$one TWO", :desc => "b" },
           :three => { :default => "$one $two THREE", :desc => "c" }
-      Puppet::FileSystem.stubs(:exist?).with(@file).returns true
-      Puppet::FileSystem.stubs(:exist?).with(@userconfig).returns false
-      @settings.stubs(:user_config_file).returns(@userconfig)
+
+      userconfig = tmpfile("userconfig")
+      allow(@settings).to receive(:user_config_file).and_return(userconfig)
     end
 
     it "does not create the WatchedFile instance and should not parse if the file does not exist" do
-      Puppet::FileSystem.expects(:exist?).with(@file).returns false
-      Puppet::Util::WatchedFile.expects(:new).never
+      Puppet::FileSystem.unlink(@file)
 
-      @settings.expects(:parse_config_files).never
+      expect(Puppet::Util::WatchedFile).not_to receive(:new)
+      expect(@settings).not_to receive(:parse_config_files)
 
       @settings.reparse_config_files
     end
@@ -1175,38 +1568,38 @@ describe Puppet::Settings do
     context "and watched file exists" do
       before do
         @watched_file = Puppet::Util::WatchedFile.new(@file)
-        Puppet::Util::WatchedFile.expects(:new).with(@file).returns @watched_file
+        expect(Puppet::Util::WatchedFile).to receive(:new).with(@file).and_return(@watched_file)
       end
 
       it "uses a WatchedFile instance to determine if the file has changed" do
-        @watched_file.expects(:changed?)
+        expect(@watched_file).to receive(:changed?)
 
         @settings.reparse_config_files
       end
 
       it "does not reparse if the file has not changed" do
-        @watched_file.expects(:changed?).returns false
+        expect(@watched_file).to receive(:changed?).and_return(false)
 
-        @settings.expects(:parse_config_files).never
+        expect(@settings).not_to receive(:parse_config_files)
 
         @settings.reparse_config_files
       end
 
       it "reparses if the file has changed" do
-        @watched_file.expects(:changed?).returns true
+        expect(@watched_file).to receive(:changed?).and_return(true)
 
-        @settings.expects(:parse_config_files)
+        expect(@settings).to receive(:parse_config_files)
 
         @settings.reparse_config_files
       end
 
       it "replaces in-memory values with on-file values" do
-        @watched_file.stubs(:changed?).returns(true)
+        allow(@watched_file).to receive(:changed?).and_return(true)
         @settings[:one] = "init"
 
         # Now replace the value
-        text = "[main]\none = disk-replace\n"
-        @settings.stubs(:read_file).returns(text)
+        File.write(@file, "[main]\none = disk-replace\n")
+
         @settings.reparse_config_files
         expect(@settings[:one]).to eq("disk-replace")
       end
@@ -1215,23 +1608,20 @@ describe Puppet::Settings do
     it "should retain parameters set by cli when configuration files are reparsed" do
       @settings.handlearg("--one", "clival")
 
-      text = "[main]\none = on-disk\n"
-      @settings.stubs(:read_file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(@file, "[main]\none = on-disk\n")
+      @settings.initialize_global_settings
 
       expect(@settings[:one]).to eq("clival")
     end
 
     it "should remove in-memory values that are no longer set in the file" do
       # Init the value
-      text = "[main]\none = disk-init\n"
-      @settings.expects(:read_file).returns(text)
+      File.write(@file, "[main]\none = disk-init\n")
       @settings.send(:parse_config_files)
       expect(@settings[:one]).to eq("disk-init")
 
       # Now replace the value
-      text = "[main]\ntwo = disk-replace\n"
-      @settings.expects(:read_file).returns(text)
+      File.write(@file, "[main]\ntwo = disk-replace\n")
       @settings.send(:parse_config_files)
 
       # The originally-overridden value should be replaced with the default
@@ -1243,14 +1633,12 @@ describe Puppet::Settings do
 
     it "should retain in-memory values if the file has a syntax error" do
       # Init the value
-      text = "[main]\none = initial-value\n"
-      @settings.expects(:read_file).with(@file).returns(text)
-      @settings.send(:parse_config_files)
+      File.write(@file, "[main]\none = initial-value\n")
+      @settings.initialize_global_settings
       expect(@settings[:one]).to eq("initial-value")
 
       # Now replace the value with something bogus
-      text = "[main]\nkenny = killed-by-what-follows\n1 is 2, blah blah florp\n"
-      @settings.expects(:read_file).with(@file).returns(text)
+      File.write(@file, "[main]\nkenny = killed-by-what-follows\n1 is 2, blah blah florp\n")
       @settings.send(:parse_config_files)
 
       # The originally-overridden value should not be replaced with the default
@@ -1262,55 +1650,58 @@ describe Puppet::Settings do
   end
 
   it "should provide a method for creating a catalog of resources from its configuration" do
-    expect(Puppet::Settings.new).to respond_to(:to_catalog)
+    expect(Puppet::Settings.new.to_catalog).to be_an_instance_of(Puppet::Resource::Catalog)
   end
 
   describe "when creating a catalog" do
+    let(:maindir) { make_absolute('/maindir') }
+    let(:seconddir) { make_absolute('/seconddir') }
+    let(:otherdir) { make_absolute('/otherdir') }
+
     before do
       @settings = Puppet::Settings.new
-      @settings.stubs(:service_user_available?).returns true
-      @prefix = Puppet.features.posix? ? "" : "C:"
+      allow(@settings).to receive(:service_user_available?).and_return(true)
     end
 
     it "should add all file resources to the catalog if no sections have been specified" do
       @settings.define_settings :main,
-          :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a"},
-          :seconddir => { :type => :directory, :default => @prefix+"/seconddir", :desc => "a"}
+          :maindir => { :type => :directory, :default => maindir, :desc => "a"},
+          :seconddir => { :type => :directory, :default => seconddir, :desc => "a"}
       @settings.define_settings :other,
-          :otherdir => { :type => :directory, :default => @prefix+"/otherdir", :desc => "a" }
+          :otherdir => { :type => :directory, :default => otherdir, :desc => "a" }
 
       catalog = @settings.to_catalog
 
-      [@prefix+"/maindir", @prefix+"/seconddir", @prefix+"/otherdir"].each do |path|
+      [maindir, seconddir, otherdir].each do |path|
         expect(catalog.resource(:file, path)).to be_instance_of(Puppet::Resource)
       end
     end
 
     it "should add only files in the specified sections if section names are provided" do
-      @settings.define_settings :main, :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
-      @settings.define_settings :other, :otherdir => { :type => :directory, :default => @prefix+"/otherdir", :desc => "a" }
+      @settings.define_settings :main, :maindir => { :type => :directory, :default => maindir, :desc => "a" }
+      @settings.define_settings :other, :otherdir => { :type => :directory, :default => otherdir, :desc => "a" }
       catalog = @settings.to_catalog(:main)
-      expect(catalog.resource(:file, @prefix+"/otherdir")).to be_nil
-      expect(catalog.resource(:file, @prefix+"/maindir")).to be_instance_of(Puppet::Resource)
+      expect(catalog.resource(:file, otherdir)).to be_nil
+      expect(catalog.resource(:file, maindir)).to be_instance_of(Puppet::Resource)
     end
 
     it "should not try to add the same file twice" do
-      @settings.define_settings :main, :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
-      @settings.define_settings :other, :otherdir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
+      @settings.define_settings :main, :maindir => { :type => :directory, :default => maindir, :desc => "a" }
+      @settings.define_settings :other, :otherdir => { :type => :directory, :default => maindir, :desc => "a" }
       expect { @settings.to_catalog }.not_to raise_error
     end
 
     it "should ignore files whose :to_resource method returns nil" do
-      @settings.define_settings :main, :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
-      @settings.setting(:maindir).expects(:to_resource).returns nil
+      @settings.define_settings :main, :maindir => { :type => :directory, :default => maindir, :desc => "a" }
+      expect(@settings.setting(:maindir)).to receive(:to_resource).and_return(nil)
 
-      Puppet::Resource::Catalog.any_instance.expects(:add_resource).never
+      expect_any_instance_of(Puppet::Resource::Catalog).not_to receive(:add_resource)
       @settings.to_catalog
     end
 
-    describe "on Microsoft Windows", :if => Puppet.features.microsoft_windows? do
+    describe "on Microsoft Windows", :if => Puppet::Util::Platform.windows? do
       before :each do
-        Puppet.features.stubs(:root?).returns true
+        allow(Puppet.features).to receive(:root?).and_return(true)
 
         @settings.define_settings :foo,
             :mkusers => { :type => :boolean, :default => true, :desc => "e" },
@@ -1331,6 +1722,7 @@ describe Puppet::Settings do
     describe "adding default directory environment to the catalog" do
       let(:tmpenv) { tmpdir("envs") }
       let(:default_path) { "#{tmpenv}/environments" }
+
       before(:each) do
         @settings.define_settings :main,
           :environment     => { :default => "production", :desc => "env"},
@@ -1354,6 +1746,49 @@ describe Puppet::Settings do
         expect(catalog.resource_keys).to include(["File", "#{envdir}/production"])
       end
 
+      it 'adds the creation of the production directory when not run as root' do
+        envdir = "#{tmpenv}/custom_envpath"
+        envpath = "#{envdir}#{File::PATH_SEPARATOR}/some/other/envdir"
+        @settings[:environmentpath] = envpath
+        Dir.mkdir(envdir)
+        allow(Puppet.features).to receive(:root?).and_return(false)
+        catalog = @settings.to_catalog
+        resource = catalog.resource('File', File.join(envdir, 'production'))
+        expect(resource[:mode]).to eq('0750')
+        expect(resource[:owner]).to be_nil
+        expect(resource[:group]).to be_nil
+      end
+
+      it 'adds the creation of the production directory with service owner and group information when available' do
+        envdir = "#{tmpenv}/custom_envpath"
+        envpath = "#{envdir}#{File::PATH_SEPARATOR}/some/other/envdir"
+        @settings[:environmentpath] = envpath
+        Dir.mkdir(envdir)
+        allow(Puppet.features).to receive(:root?).and_return(true)
+        allow(@settings).to receive(:service_user_available?).and_return(true)
+        allow(@settings).to receive(:service_group_available?).and_return(true)
+        catalog = @settings.to_catalog
+        resource = catalog.resource('File', File.join(envdir, 'production'))
+        expect(resource[:mode]).to eq('0750')
+        expect(resource[:owner]).to eq('puppet')
+        expect(resource[:group]).to eq('puppet')
+      end
+
+      it 'adds the creation of the production directory without service owner and group when not available' do
+        envdir = "#{tmpenv}/custom_envpath"
+        envpath = "#{envdir}#{File::PATH_SEPARATOR}/some/other/envdir"
+        @settings[:environmentpath] = envpath
+        Dir.mkdir(envdir)
+        allow(Puppet.features).to receive(:root?).and_return(true)
+        allow(@settings).to receive(:service_user_available?).and_return(false)
+        allow(@settings).to receive(:service_group_available?).and_return(false)
+        catalog = @settings.to_catalog
+        resource = catalog.resource('File', File.join(envdir, 'production'))
+        expect(resource[:mode]).to eq('0750')
+        expect(resource[:owner]).to be_nil
+        expect(resource[:group]).to be_nil
+      end
+
       it "handles a non-existent environmentpath" do
         catalog = @settings.to_catalog
         expect(catalog.resource_keys).to be_empty
@@ -1377,7 +1812,7 @@ describe Puppet::Settings do
       before :all do
         # when this spec is run in isolation to build a settings catalog
         # it will not be able to autorequire and load types for the first time
-        # on Windows with microsoft_windows? stubbed to false, because
+        # on Windows with windows? stubbed to false, because
         # Puppet::Util.path_to_uri is called to generate a URI to load code
         # and it manipulates the path based on OS
         # so instead we forcefully "prime" the cached types
@@ -1387,9 +1822,9 @@ describe Puppet::Settings do
       end
 
       before do
-        Puppet.features.stubs(:root?).returns true
+        allow(Puppet.features).to receive(:root?).and_return(true)
         # stubbed to false, as Windows catalogs don't add users / groups
-        Puppet.features.stubs(:microsoft_windows?).returns false
+        allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
 
         @settings.define_settings :foo,
             :mkusers => { :type => :boolean, :default => true, :desc => "e" },
@@ -1413,7 +1848,7 @@ describe Puppet::Settings do
       end
 
       it "should not add users or groups to the catalog if :mkusers not running as root" do
-        Puppet.features.stubs(:root?).returns false
+        allow(Puppet.features).to receive(:root?).and_return(false)
 
         catalog = @settings.to_catalog
         expect(catalog.resource(:user, "suser")).to be_nil
@@ -1421,7 +1856,7 @@ describe Puppet::Settings do
       end
 
       it "should not add users or groups to the catalog if :mkusers is not a valid setting" do
-        Puppet.features.stubs(:root?).returns true
+        allow(Puppet.features).to receive(:root?).and_return(true)
         settings = Puppet::Settings.new
         settings.define_settings :other, :otherdir => {:type => :directory, :default => "/otherdir", :desc => "a", :owner => "service", :group => "service"}
 
@@ -1432,6 +1867,8 @@ describe Puppet::Settings do
 
       it "should not add users or groups to the catalog if :mkusers is a valid setting but is disabled" do
         @settings[:mkusers] = false
+        allow(@settings).to receive(:service_user_available?).and_return(false)
+        allow(@settings).to receive(:service_group_available?).and_return(false)
 
         catalog = @settings.to_catalog
         expect(catalog.resource(:user, "suser")).to be_nil
@@ -1455,7 +1892,7 @@ describe Puppet::Settings do
       end
 
       it "should not attempt to manage the root user" do
-        Puppet.features.stubs(:root?).returns true
+        allow(Puppet.features).to receive(:root?).and_return(true)
         @settings.define_settings :foo, :foodir => {:type => :directory, :default => "/foodir", :desc => "a", :owner => "root", :group => "service"}
 
         expect(@settings.to_catalog.resource(:user, "root")).to be_nil
@@ -1474,15 +1911,15 @@ describe Puppet::Settings do
           :maindir => { :type => :directory, :default => "/maindir", :desc => "a"},
           :seconddir => { :type => :directory, :default => "/seconddir", :desc => "a"}
 
-      main = stub 'main_resource', :ref => "File[/maindir]"
-      main.expects(:to_manifest).returns "maindir"
-      main.expects(:'[]').with(:alias).returns nil
-      second = stub 'second_resource', :ref => "File[/seconddir]"
-      second.expects(:to_manifest).returns "seconddir"
-      second.expects(:'[]').with(:alias).returns nil
+      main = double('main_resource', :ref => "File[/maindir]")
+      expect(main).to receive(:to_manifest).and_return("maindir")
+      expect(main).to receive(:'[]').with(:alias).and_return(nil)
+      second = double('second_resource', :ref => "File[/seconddir]")
+      expect(second).to receive(:to_manifest).and_return("seconddir")
+      expect(second).to receive(:'[]').with(:alias).and_return(nil)
 
-      @settings.setting(:maindir).expects(:to_resource).returns main
-      @settings.setting(:seconddir).expects(:to_resource).returns second
+      expect(@settings.setting(:maindir)).to receive(:to_resource).and_return(main)
+      expect(@settings.setting(:seconddir)).to receive(:to_resource).and_return(second)
 
       expect(@settings.to_manifest.split("\n\n").sort).to eq(%w{maindir seconddir})
     end
@@ -1491,8 +1928,8 @@ describe Puppet::Settings do
   describe "when using sections of the configuration to manage the local host" do
     before do
       @settings = Puppet::Settings.new
-      @settings.stubs(:service_user_available?).returns true
-      @settings.stubs(:service_group_available?).returns true
+      allow(@settings).to receive(:service_user_available?).and_return(true)
+      allow(@settings).to receive(:service_group_available?).and_return(true)
       @settings.define_settings :main, :noop => { :default => false, :desc => "", :type => :boolean }
       @settings.define_settings :main,
           :maindir => { :type => :directory, :default => make_absolute("/maindir"), :desc => "a" },
@@ -1504,44 +1941,44 @@ describe Puppet::Settings do
     end
 
     it "should create a catalog with the specified sections" do
-      @settings.expects(:to_catalog).with(:main, :other).returns Puppet::Resource::Catalog.new("foo")
+      expect(@settings).to receive(:to_catalog).with(:main, :other).and_return(Puppet::Resource::Catalog.new("foo"))
       @settings.use(:main, :other)
     end
 
     it "should canonicalize the sections" do
-      @settings.expects(:to_catalog).with(:main, :other).returns Puppet::Resource::Catalog.new("foo")
+      expect(@settings).to receive(:to_catalog).with(:main, :other).and_return(Puppet::Resource::Catalog.new("foo"))
       @settings.use("main", "other")
     end
 
     it "should ignore sections that have already been used" do
-      @settings.expects(:to_catalog).with(:main).returns Puppet::Resource::Catalog.new("foo")
+      expect(@settings).to receive(:to_catalog).with(:main).and_return(Puppet::Resource::Catalog.new("foo"))
       @settings.use(:main)
-      @settings.expects(:to_catalog).with(:other).returns Puppet::Resource::Catalog.new("foo")
+      expect(@settings).to receive(:to_catalog).with(:other).and_return(Puppet::Resource::Catalog.new("foo"))
       @settings.use(:main, :other)
     end
 
     it "should convert the created catalog to a RAL catalog" do
       @catalog = Puppet::Resource::Catalog.new("foo")
-      @settings.expects(:to_catalog).with(:main).returns @catalog
+      expect(@settings).to receive(:to_catalog).with(:main).and_return(@catalog)
 
-      @catalog.expects(:to_ral).returns @catalog
+      expect(@catalog).to receive(:to_ral).and_return(@catalog)
       @settings.use(:main)
     end
 
     it "should specify that it is not managing a host catalog" do
       catalog = Puppet::Resource::Catalog.new("foo")
-      catalog.expects(:apply)
-      @settings.expects(:to_catalog).returns catalog
+      expect(catalog).to receive(:apply)
+      expect(@settings).to receive(:to_catalog).and_return(catalog)
 
-      catalog.stubs(:to_ral).returns catalog
+      allow(catalog).to receive(:to_ral).and_return(catalog)
 
-      catalog.expects(:host_config=).with false
+      expect(catalog).to receive(:host_config=).with(false)
 
       @settings.use(:main)
     end
 
     it "should support a method for re-using all currently used sections" do
-      @settings.expects(:to_catalog).with(:main, :third).times(2).returns Puppet::Resource::Catalog.new("foo")
+      expect(@settings).to receive(:to_catalog).with(:main, :third).exactly(2).times.and_return(Puppet::Resource::Catalog.new("foo"))
 
       @settings.use(:main, :third)
       @settings.reuse
@@ -1549,13 +1986,13 @@ describe Puppet::Settings do
 
     it "should fail with an appropriate message if any resources fail" do
       @catalog = Puppet::Resource::Catalog.new("foo")
-      @catalog.stubs(:to_ral).returns @catalog
-      @settings.expects(:to_catalog).returns @catalog
+      allow(@catalog).to receive(:to_ral).and_return(@catalog)
+      expect(@settings).to receive(:to_catalog).and_return(@catalog)
 
-      @trans = mock("transaction")
-      @catalog.expects(:apply).yields(@trans)
+      @trans = double("transaction")
+      expect(@catalog).to receive(:apply).and_yield(@trans)
 
-      @trans.expects(:any_failed?).returns(true)
+      expect(@trans).to receive(:any_failed?).and_return(true)
 
       resource = Puppet::Type.type(:notify).new(:title => 'failed')
       status = Puppet::Resource::Status.new(resource)
@@ -1568,9 +2005,9 @@ describe Puppet::Settings do
       report = Puppet::Transaction::Report.new('apply')
       report.add_resource_status(status)
 
-      @trans.expects(:report).returns report
+      expect(@trans).to receive(:report).and_return(report)
 
-      @settings.expects(:raise).with(includes("My failure"))
+      expect(@settings).to receive(:raise).with(/My failure/)
       @settings.use(:whatever)
     end
   end
@@ -1579,10 +2016,10 @@ describe Puppet::Settings do
     before do
       @settings = Puppet::Settings.new
       #these are the magic default values
-      @settings.stubs(:value).with(:configprint).returns("")
-      @settings.stubs(:value).with(:genconfig).returns(false)
-      @settings.stubs(:value).with(:genmanifest).returns(false)
-      @settings.stubs(:value).with(:environment).returns(nil)
+      allow(@settings).to receive(:value).with(:configprint).and_return("")
+      allow(@settings).to receive(:value).with(:genconfig).and_return(false)
+      allow(@settings).to receive(:value).with(:genmanifest).and_return(false)
+      allow(@settings).to receive(:value).with(:environment).and_return(nil)
     end
 
     describe "when checking print_config?" do
@@ -1591,17 +2028,17 @@ describe Puppet::Settings do
       end
 
       it "should return true when :configprint has a value" do
-        @settings.stubs(:value).with(:configprint).returns("something")
+        allow(@settings).to receive(:value).with(:configprint).and_return("something")
         expect(@settings.print_configs?).to be_truthy
       end
 
       it "should return true when :genconfig has a value" do
-        @settings.stubs(:value).with(:genconfig).returns(true)
+        allow(@settings).to receive(:value).with(:genconfig).and_return(true)
         expect(@settings.print_configs?).to be_truthy
       end
 
       it "should return true when :genmanifest has a value" do
-        @settings.stubs(:value).with(:genmanifest).returns(true)
+        allow(@settings).to receive(:value).with(:genmanifest).and_return(true)
         expect(@settings.print_configs?).to be_truthy
       end
     end
@@ -1609,87 +2046,87 @@ describe Puppet::Settings do
     describe "when printing configs" do
       describe "when :configprint has a value" do
         it "should call print_config_options" do
-          @settings.stubs(:value).with(:configprint).returns("something")
-          @settings.expects(:print_config_options)
+          allow(@settings).to receive(:value).with(:configprint).and_return("something")
+          expect(@settings).to receive(:print_config_options)
           @settings.print_configs
         end
 
         it "should get the value of the option using the environment" do
-          @settings.stubs(:value).with(:configprint).returns("something")
-          @settings.stubs(:include?).with("something").returns(true)
-          @settings.expects(:value).with(:environment).returns("env")
-          @settings.expects(:value).with("something", "env").returns("foo")
-          @settings.stubs(:puts).with("foo")
+          allow(@settings).to receive(:value).with(:configprint).and_return("something")
+          allow(@settings).to receive(:include?).with("something").and_return(true)
+          expect(@settings).to receive(:value).with(:environment).and_return("env")
+          expect(@settings).to receive(:value).with("something", "env").and_return("foo")
+          allow(@settings).to receive(:puts).with("foo")
           @settings.print_configs
         end
 
         it "should print the value of the option" do
-          @settings.stubs(:value).with(:configprint).returns("something")
-          @settings.stubs(:include?).with("something").returns(true)
-          @settings.stubs(:value).with("something", nil).returns("foo")
-          @settings.expects(:puts).with("foo")
+          allow(@settings).to receive(:value).with(:configprint).and_return("something")
+          allow(@settings).to receive(:include?).with("something").and_return(true)
+          allow(@settings).to receive(:value).with("something", nil).and_return("foo")
+          expect(@settings).to receive(:puts).with("foo")
           @settings.print_configs
         end
 
         it "should print the value pairs if there are multiple options" do
-          @settings.stubs(:value).with(:configprint).returns("bar,baz")
-          @settings.stubs(:include?).with("bar").returns(true)
-          @settings.stubs(:include?).with("baz").returns(true)
-          @settings.stubs(:value).with("bar", nil).returns("foo")
-          @settings.stubs(:value).with("baz", nil).returns("fud")
-          @settings.expects(:puts).with("bar = foo")
-          @settings.expects(:puts).with("baz = fud")
+          allow(@settings).to receive(:value).with(:configprint).and_return("bar,baz")
+          allow(@settings).to receive(:include?).with("bar").and_return(true)
+          allow(@settings).to receive(:include?).with("baz").and_return(true)
+          allow(@settings).to receive(:value).with("bar", nil).and_return("foo")
+          allow(@settings).to receive(:value).with("baz", nil).and_return("fud")
+          expect(@settings).to receive(:puts).with("bar = foo")
+          expect(@settings).to receive(:puts).with("baz = fud")
           @settings.print_configs
         end
 
         it "should return true after printing" do
-          @settings.stubs(:value).with(:configprint).returns("something")
-          @settings.stubs(:include?).with("something").returns(true)
-          @settings.stubs(:value).with("something", nil).returns("foo")
-          @settings.stubs(:puts).with("foo")
+          allow(@settings).to receive(:value).with(:configprint).and_return("something")
+          allow(@settings).to receive(:include?).with("something").and_return(true)
+          allow(@settings).to receive(:value).with("something", nil).and_return("foo")
+          allow(@settings).to receive(:puts).with("foo")
           expect(@settings.print_configs).to be_truthy
         end
 
         it "should return false if a config param is not found" do
-          @settings.stubs :puts
-          @settings.stubs(:value).with(:configprint).returns("something")
-          @settings.stubs(:include?).with("something").returns(false)
+          allow(@settings).to receive(:puts)
+          allow(@settings).to receive(:value).with(:configprint).and_return("something")
+          allow(@settings).to receive(:include?).with("something").and_return(false)
           expect(@settings.print_configs).to be_falsey
         end
       end
 
       describe "when genconfig is true" do
         before do
-          @settings.stubs :puts
+          allow(@settings).to receive(:puts)
         end
 
         it "should call to_config" do
-          @settings.stubs(:value).with(:genconfig).returns(true)
-          @settings.expects(:to_config)
+          allow(@settings).to receive(:value).with(:genconfig).and_return(true)
+          expect(@settings).to receive(:to_config)
           @settings.print_configs
         end
 
         it "should return true from print_configs" do
-          @settings.stubs(:value).with(:genconfig).returns(true)
-          @settings.stubs(:to_config)
+          allow(@settings).to receive(:value).with(:genconfig).and_return(true)
+          allow(@settings).to receive(:to_config)
           expect(@settings.print_configs).to be_truthy
         end
       end
 
       describe "when genmanifest is true" do
         before do
-          @settings.stubs :puts
+          allow(@settings).to receive(:puts)
         end
 
         it "should call to_config" do
-          @settings.stubs(:value).with(:genmanifest).returns(true)
-          @settings.expects(:to_manifest)
+          allow(@settings).to receive(:value).with(:genmanifest).and_return(true)
+          expect(@settings).to receive(:to_manifest)
           @settings.print_configs
         end
 
         it "should return true from print_configs" do
-          @settings.stubs(:value).with(:genmanifest).returns(true)
-          @settings.stubs(:to_manifest)
+          allow(@settings).to receive(:value).with(:genmanifest).and_return(true)
+          allow(@settings).to receive(:to_manifest)
           expect(@settings.print_configs).to be_truthy
         end
       end
@@ -1704,8 +2141,8 @@ describe Puppet::Settings do
     end
 
     def a_user_type_for(username)
-      user = mock 'user'
-      Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == username }.returns user
+      user = double('user', 'suitable?': true, to_s: "User[#{username}]")
+      expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: username)).and_return(user)
       user
     end
 
@@ -1716,7 +2153,7 @@ describe Puppet::Settings do
     it "should return false if the user provider says the user is missing" do
       settings[:user] = "foo"
 
-      a_user_type_for("foo").expects(:exists?).returns false
+      expect(a_user_type_for("foo")).to receive(:exists?).and_return(false)
 
       expect(settings).not_to be_service_user_available
     end
@@ -1724,7 +2161,7 @@ describe Puppet::Settings do
     it "should return true if the user provider says the user is present" do
       settings[:user] = "foo"
 
-      a_user_type_for("foo").expects(:exists?).returns true
+      expect(a_user_type_for("foo")).to receive(:exists?).and_return(true)
 
       expect(settings).to be_service_user_available
     end
@@ -1732,11 +2169,21 @@ describe Puppet::Settings do
     it "caches the result of determining if the user is present" do
       settings[:user] = "foo"
 
-      a_user_type_for("foo").expects(:exists?).returns true
+      expect(a_user_type_for("foo")).to receive(:exists?).and_return(true)
       expect(settings).to be_service_user_available
 
       expect(settings).to be_service_user_available
     end
+
+    it "raises if the user is not suitable" do
+      settings[:user] = "foo"
+
+      expect(a_user_type_for("foo")).to receive(:suitable?).and_return(false)
+
+      expect {
+        settings.service_user_available?
+      }.to raise_error(Puppet::Error, /Cannot manage owner permissions, because the provider for 'User\[foo\]' is not functional/)
+    end
   end
 
   describe "when determining if the service group is available" do
@@ -1747,8 +2194,8 @@ describe Puppet::Settings do
     end
 
     def a_group_type_for(groupname)
-      group = mock 'group'
-      Puppet::Type.type(:group).expects(:new).with { |args| args[:name] == groupname }.returns group
+      group = double('group', 'suitable?': true, to_s: "Group[#{groupname}]")
+      expect(Puppet::Type.type(:group)).to receive(:new).with(hash_including(name: groupname)).and_return(group)
       group
     end
 
@@ -1759,7 +2206,7 @@ describe Puppet::Settings do
     it "should return false if the group provider says the group is missing" do
       settings[:group] = "foo"
 
-      a_group_type_for("foo").expects(:exists?).returns false
+      expect(a_group_type_for("foo")).to receive(:exists?).and_return(false)
 
       expect(settings).not_to be_service_group_available
     end
@@ -1767,7 +2214,7 @@ describe Puppet::Settings do
     it "should return true if the group provider says the group is present" do
       settings[:group] = "foo"
 
-      a_group_type_for("foo").expects(:exists?).returns true
+      expect(a_group_type_for("foo")).to receive(:exists?).and_return(true)
 
       expect(settings).to be_service_group_available
     end
@@ -1775,25 +2222,35 @@ describe Puppet::Settings do
     it "caches the result of determining if the group is present" do
       settings[:group] = "foo"
 
-      a_group_type_for("foo").expects(:exists?).returns true
+      expect(a_group_type_for("foo")).to receive(:exists?).and_return(true)
       expect(settings).to be_service_group_available
 
       expect(settings).to be_service_group_available
     end
+
+    it "raises if the group is not suitable" do
+      settings[:group] = "foo"
+
+      expect(a_group_type_for("foo")).to receive(:suitable?).and_return(false)
+
+      expect {
+        settings.service_group_available?
+      }.to raise_error(Puppet::Error, /Cannot manage group permissions, because the provider for 'Group\[foo\]' is not functional/)
+    end
   end
 
   describe "when dealing with command-line options" do
     let(:settings) { Puppet::Settings.new }
 
     it "should get options from Puppet.settings.optparse_addargs" do
-      settings.expects(:optparse_addargs).returns([])
+      expect(settings).to receive(:optparse_addargs).and_return([])
 
       settings.send(:parse_global_options, [])
     end
 
     it "should add options to OptionParser" do
-      settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option", :NONE]])
-      settings.expects(:handlearg).with("--option", true)
+      allow(settings).to receive(:optparse_addargs).and_return([["--option","-o", "Funny Option", :NONE]])
+      expect(settings).to receive(:handlearg).with("--option", true)
       settings.send(:parse_global_options, ["--option"])
     end
 
@@ -1802,13 +2259,13 @@ describe Puppet::Settings do
     end
 
     it "should not pass an unrecognized option to handleargs" do
-      settings.expects(:handlearg).with("--topuppet", "value").never
+      expect(settings).not_to receive(:handlearg).with("--topuppet", "value")
       expect { settings.send(:parse_global_options, ["--topuppet", "value"]) } .to_not raise_error
     end
 
     it "should pass valid puppet settings options to handlearg even if they appear after an unrecognized option" do
-      settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option", :NONE]])
-      settings.expects(:handlearg).with("--option", true)
+      allow(settings).to receive(:optparse_addargs).and_return([["--option","-o", "Funny Option", :NONE]])
+      expect(settings).to receive(:handlearg).with("--option", true)
       settings.send(:parse_global_options, ["--invalidoption", "--option"])
     end
 
@@ -1821,18 +2278,18 @@ describe Puppet::Settings do
     end
 
     it "should set preferred run mode from --run_mode <foo> string without error" do
-      args = ["--run_mode", "master"]
-      settings.expects(:handlearg).with("--run_mode", "master").never
+      args = ["--run_mode", "server"]
+      expect(settings).not_to receive(:handlearg).with("--run_mode", "server")
       expect { settings.send(:parse_global_options, args) } .to_not raise_error
-      expect(Puppet.settings.preferred_run_mode).to eq(:master)
+      expect(Puppet.settings.preferred_run_mode).to eq(:server)
       expect(args.empty?).to eq(true)
     end
 
     it "should set preferred run mode from --run_mode=<foo> string without error" do
-      args = ["--run_mode=master"]
-      settings.expects(:handlearg).with("--run_mode", "master").never
-      expect { settings.send(:parse_global_options, args) } .to_not raise_error
-      expect(Puppet.settings.preferred_run_mode).to eq(:master)
+      args = ["--run_mode=server"]
+      expect(settings).not_to receive(:handlearg).with("--run_mode", "server")
+      expect { settings.send(:parse_global_options, args) }.to_not raise_error
+      expect(Puppet.settings.preferred_run_mode).to eq(:server)
       expect(args.empty?).to eq(true)
     end
   end
@@ -1840,8 +2297,8 @@ describe Puppet::Settings do
   describe "default_certname" do
     describe "using hostname and domain" do
       before :each do
-        Puppet::Settings.stubs(:hostname_fact).returns("testhostname")
-        Puppet::Settings.stubs(:domain_fact).returns("domain.test.")
+        allow(Puppet::Settings).to receive(:hostname_fact).and_return("testhostname")
+        allow(Puppet::Settings).to receive(:domain_fact).and_return("domain.test.")
       end
 
       it "should use both to generate fqdn" do
@@ -1854,8 +2311,8 @@ describe Puppet::Settings do
 
     describe "using just hostname" do
       before :each do
-        Puppet::Settings.stubs(:hostname_fact).returns("testhostname")
-        Puppet::Settings.stubs(:domain_fact).returns("")
+        allow(Puppet::Settings).to receive(:hostname_fact).and_return("testhostname")
+        allow(Puppet::Settings).to receive(:domain_fact).and_return("")
       end
 
       it "should use only hostname to generate fqdn" do