puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/settings/path_setting_spec.rb

@@ -1,7 +1,8 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Settings::PathSetting do
-  subject { described_class.new(:settings => double('settings'), :desc => "test") }
+  subject { described_class.new(:settings => mock('settings'), :desc => "test") }
 
   context "#munge" do
     it "should expand all path elements" do

data/spec/unit/settings/priority_setting_spec.rb

@@ -1,3 +1,4 @@
+#!/usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
@@ -5,7 +6,7 @@ require 'puppet/settings/priority_setting'
 require 'puppet/util/platform'
 
 describe Puppet::Settings::PrioritySetting do
-  let(:setting) { described_class.new(:settings => double('settings'), :desc => "test") }
+  let(:setting) { described_class.new(:settings => mock('settings'), :desc => "test") }
 
   it "is of type :priority" do
     expect(setting.type).to eq(:priority)

data/spec/unit/settings/string_setting_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
@@ -7,21 +8,21 @@ describe Puppet::Settings::StringSetting do
   StringSetting = Puppet::Settings::StringSetting
 
   before(:each) do
-    @test_setting_name = :test_setting
+    @test_setting_name = :test_setting 
     @test_setting_default = "my_crazy_default/$var"
     @application_setting = "application/$var"
-    @application_defaults = { }
+    @application_defaults = { } 
     Puppet::Settings::REQUIRED_APP_SETTINGS.each do |key|
       @application_defaults[key] = "foo"
     end
     @application_defaults[:run_mode] = :user
     @settings = Puppet::Settings.new
     @application_defaults.each { |k,v| @settings.define_settings :main, k => {:default=>"", :desc => "blah"} }
-    @settings.define_settings :main, :var               => {  :default => "interpolate!",
-                                                              :type => :string,
+    @settings.define_settings :main, :var               => {  :default => "interpolate!", 
+                                                              :type => :string, 
                                                               :desc => "my var desc" },
-                                     @test_setting_name => {  :default => @test_setting_default,
-                                                              :type => :string,
+                                     @test_setting_name => {  :default => @test_setting_default, 
+                                                              :type => :string, 
                                                               :desc => "my test desc" }
     @test_setting = @settings.setting(@test_setting_name)
   end
@@ -31,40 +32,40 @@ describe Puppet::Settings::StringSetting do
       it "should return the setting default" do
         expect(@test_setting.default).to eq(@test_setting_default)
       end
-
+      
       it "should be uninterpolated" do
         expect(@test_setting.default).not_to match(/interpolate/)
       end
     end
-
+    
     describe "checking application defaults first" do
       describe "if application defaults set" do
         before(:each) do
           @settings.initialize_app_defaults @application_defaults.merge @test_setting_name => @application_setting
         end
-
+        
         it "should return the application-set default" do
           expect(@test_setting.default(true)).to eq(@application_setting)
         end
-
+        
         it "should be uninterpolated" do
           expect(@test_setting.default(true)).not_to match(/interpolate/)
         end
-
+        
       end
-
+      
       describe "if application defaults not set" do
         it "should return the regular default" do
           expect(@test_setting.default(true)).to eq(@test_setting_default)
         end
-
+        
         it "should be uninterpolated" do
           expect(@test_setting.default(true)).not_to match(/interpolate/)
         end
       end
     end
   end
-
+  
   describe "#value" do
     it "should be interpolated" do
       expect(@test_setting.value).to match(/interpolate/)

data/spec/unit/settings/terminus_setting_spec.rb

@@ -1,7 +1,8 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Settings::TerminusSetting do
-  let(:setting) { described_class.new(:settings => double('settings'), :desc => "test") }
+  let(:setting) { described_class.new(:settings => mock('settings'), :desc => "test") }
 
   describe "#munge" do
     it "converts strings to symbols" do

data/spec/unit/settings/value_translator_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/settings/value_translator'
 

data/spec/unit/settings_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'ostruct'
 require 'puppet/settings/errors'
@@ -290,36 +291,37 @@ describe Puppet::Settings do
     end
 
     it "should identify configured settings in memory" do
-      expect(@settings.instance_variable_get(:@value_sets)[:memory]).to receive(:lookup).with(:myval).and_return('foo')
+      @settings.instance_variable_get(:@value_sets)[:memory].expects(:lookup).with(:myval).returns('foo')
       expect(@settings.set_by_config?(:myval)).to be_truthy
     end
 
     it "should identify configured settings from CLI" do
-      expect(@settings.instance_variable_get(:@value_sets)[:cli]).to receive(:lookup).with(:myval).and_return('foo')
+      @settings.instance_variable_get(:@value_sets)[:cli].expects(:lookup).with(:myval).returns('foo')
       expect(@settings.set_by_config?(:myval)).to be_truthy
     end
 
     it "should not identify configured settings from environment by default" do
-      expect(Puppet.lookup(:environments)).not_to receive(:get_conf).with(Puppet[:environment].to_sym)
+      Puppet.lookup(:environments).expects(:get_conf).with(Puppet[:environment].to_sym).never
       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 = double('environment', :manifest => 'foo')
-      expect(Puppet.lookup(:environments)).to receive(:get_conf).with(Puppet[:environment].to_sym).and_return(foo)
+      foo = mock('environment', :manifest => 'foo')
+      Puppet.lookup(:environments).expects(:get_conf).with(Puppet[:environment].to_sym).returns(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"
 
-      allow(Puppet.features).to receive(:root?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
         with(user_config_file_default_location).
-        and_return(true).ordered
-      expect(@settings).to receive(:read_file).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
         with(user_config_file_default_location).
-        and_return(user_config_text).ordered
+        returns(user_config_text).in_sequence(seq)
 
       @settings.send(:parse_config_files)
       expect(@settings.set_by_config?(:myval)).to be_truthy
@@ -327,14 +329,15 @@ describe Puppet::Settings do
 
     it "should identify configured settings from the specified run mode" do
       user_config_text = "[master]\nmyval = foo"
+      seq = sequence "config_file_sequence"
 
-      allow(Puppet.features).to receive(:root?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
         with(user_config_file_default_location).
-        and_return(true).ordered
-      expect(@settings).to receive(:read_file).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
         with(user_config_file_default_location).
-        and_return(user_config_text).ordered
+        returns(user_config_text).in_sequence(seq)
 
       @settings.send(:parse_config_files)
       expect(@settings.set_by_config?(:myval, nil, :master)).to be_truthy
@@ -342,14 +345,15 @@ describe Puppet::Settings do
 
     it "should not identify configured settings from an unspecified run mode" do
       user_config_text = "[zaz]\nmyval = foo"
+      seq = sequence "config_file_sequence"
 
-      allow(Puppet.features).to receive(:root?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
         with(user_config_file_default_location).
-        and_return(true).ordered
-      expect(@settings).to receive(:read_file).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
         with(user_config_file_default_location).
-        and_return(user_config_text).ordered
+        returns(user_config_text).in_sequence(seq)
 
       @settings.send(:parse_config_files)
       expect(@settings.set_by_config?(:myval)).to be_falsey
@@ -357,14 +361,15 @@ describe Puppet::Settings do
 
     it "should identify configured settings from the main section" do
       user_config_text = "[main]\nmyval = foo"
+      seq = sequence "config_file_sequence"
 
-      allow(Puppet.features).to receive(:root?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
         with(user_config_file_default_location).
-        and_return(true).ordered
-      expect(@settings).to receive(:read_file).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
         with(user_config_file_default_location).
-        and_return(user_config_text).ordered
+        returns(user_config_text).in_sequence(seq)
 
       @settings.send(:parse_config_files)
       expect(@settings.set_by_config?(:myval)).to be_truthy
@@ -374,14 +379,14 @@ describe Puppet::Settings do
       @settings.define_settings :mysection,
           :one => { :default => "whah", :desc => "yay" },
           :two => { :default => "$one yay", :desc => "bah" }
-      expect(@settings).to receive(:unsafe_flush_cache)
+      @settings.expects(: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
-      expect(@settings).to receive(:flush_cache)
+      @settings.expects(:flush_cache)
       @settings.preferred_run_mode = :master
     end
 
@@ -392,7 +397,7 @@ describe Puppet::Settings do
     end
 
     it "should clear the list of used sections" do
-      expect(@settings).to receive(:clearused)
+      @settings.expects(:clearused)
       @settings[:myval] = "yay"
     end
 
@@ -418,7 +423,7 @@ describe Puppet::Settings do
             end
 
             it "should call the hook when value written" do
-              expect(@settings.setting(:hooker)).to receive(:handle).with("something").once
+              @settings.setting(:hooker).expects(:handle).with("something").once
               @settings[:hooker] = "something"
             end
           end
@@ -432,7 +437,7 @@ describe Puppet::Settings do
 
       describe "when nil" do
         it "should generate a warning" do
-          expect(Puppet).to receive(:warning)
+          Puppet.expects(:warning)
           @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => nil, :hook => lambda { |v| hook_values << v  }})
         end
         it "should use default" do
@@ -477,7 +482,7 @@ describe Puppet::Settings do
           app_defaults[:run_mode] = :user
           @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
 
-          expect(@settings.setting(:hooker)).to receive(:handle).with("yay").once
+          @settings.setting(:hooker).expects(:handle).with("yay").once
 
           @settings.initialize_app_defaults app_defaults
         end
@@ -552,7 +557,7 @@ describe Puppet::Settings do
           :four   => { :default => "$two $three FOUR", :desc => "d"},
           :five   => { :default => nil, :desc => "e" },
           :code   => { :default => "", :desc => "my code"}
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
     end
 
     it "should provide a mechanism for returning set values" do
@@ -609,7 +614,7 @@ describe Puppet::Settings do
 
     it "should not interpolate the value of the :code setting" do
       @code = @settings.setting(:code)
-      expect(@code).not_to receive(:munge)
+      @code.expects(:munge).never
 
       expect(@settings[:code]).to eq("")
     end
@@ -633,7 +638,7 @@ describe Puppet::Settings do
         :config => { :type => :file, :default => "/my/file", :desc => "a" },
         :one => { :default => "ONE", :desc => "a" },
         :two => { :default => "TWO", :desc => "b" }
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
       @settings.preferred_run_mode = :agent
     end
 
@@ -643,7 +648,7 @@ describe Puppet::Settings do
 
     it "should return values set on the cli before values set in the configuration file" do
       text = "[main]\none = fileval\n"
-      allow(@settings).to receive(:read_file).and_return(text)
+      @settings.stubs(:read_file).returns(text)
       @settings.handlearg("--one", "clival")
       @settings.send(:parse_config_files)
 
@@ -652,7 +657,7 @@ describe Puppet::Settings do
 
     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"
-      allow(@settings).to receive(:read_file).and_return(text)
+      @settings.stubs(:read_file).returns(text)
       @settings.send(:parse_config_files)
 
       expect(@settings[:one]).to eq("modeval")
@@ -660,7 +665,7 @@ describe Puppet::Settings do
 
     it "should not return values outside of its search path" do
       text = "[other]\none = oval\n"
-      allow(@settings).to receive(:read_file).and_return(text)
+      @settings.stubs(:read_file).returns(text)
       @settings.send(:parse_config_files)
       expect(@settings[:one]).to eq("ONE")
     end
@@ -679,9 +684,9 @@ 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
-        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)
+        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
 
         @settings.send(:parse_config_files)
       end
@@ -689,45 +694,10 @@ describe Puppet::Settings do
 
     describe "when not root" do
       it "should look for user config file default location if config settings haven't been overridden'" do
-        allow(Puppet.features).to receive(:root?).and_return(false)
+        Puppet.features.stubs(:root?).returns(false)
 
-        expect(Puppet::FileSystem).to receive(:exist?).with(user_config_file_default_location).and_return(false)
-
-        @settings.send(:parse_config_files)
-      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.send(:parse_config_files) }.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.send(:parse_config_files, 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.send(:parse_config_files)
-      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)
+        seq = sequence "load config files"
+        Puppet::FileSystem.expects(:exist?).with(user_config_file_default_location).returns(false).in_sequence(seq)
 
         @settings.send(:parse_config_files)
       end
@@ -737,8 +707,8 @@ describe Puppet::Settings do
   describe "when parsing its configuration" do
     before do
       @settings = Puppet::Settings.new
-      allow(@settings).to receive(:service_user_available?).and_return(true)
-      allow(@settings).to receive(:service_group_available?).and_return(true)
+      @settings.stubs(:service_user_available?).returns true
+      @settings.stubs(:service_group_available?).returns true
       @file = make_absolute("/some/file")
       @userconfig = make_absolute("/test/userconfigfile")
       @settings.define_settings :section, :user => { :default => "suser", :desc => "doc" }, :group => { :default => "sgroup", :desc => "doc" }
@@ -747,9 +717,9 @@ describe Puppet::Settings do
           :one => { :default => "ONE", :desc => "a" },
           :two => { :default => "$one TWO", :desc => "b" },
           :three => { :default => "$one $two THREE", :desc => "c" }
-      allow(@settings).to receive(:user_config_file).and_return(@userconfig)
-      allow(Puppet::FileSystem).to receive(:exist?).with(@file).and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).with(@userconfig).and_return(false)
+      @settings.stubs(:user_config_file).returns(@userconfig)
+      Puppet::FileSystem.stubs(:exist?).with(@file).returns true
+      Puppet::FileSystem.stubs(:exist?).with(@userconfig).returns false
     end
 
     it "should not ignore the report setting" do
@@ -761,27 +731,27 @@ describe Puppet::Settings do
         [puppetd]
           report=true
       CONF
-      expect(Puppet::FileSystem).to receive(:exist?).with(myfile).and_return(true)
-      expect(@settings).to receive(:read_file).and_return(text)
+      Puppet::FileSystem.expects(:exist?).with(myfile).returns(true)
+      @settings.expects(:read_file).returns(text)
       @settings.send(:parse_config_files)
       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")
+      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
 
-      expect(Puppet::FileSystem).to receive(:exist?).with(myfile).and_return(true)
+      Puppet::FileSystem.expects(:exist?).with(myfile).returns(true)
 
-      expect(Puppet::FileSystem).to receive(:read).with(myfile, :encoding => 'utf-8').and_return("[main]")
+      Puppet::FileSystem.expects(:read).with(myfile, :encoding => 'utf-8').returns "[main]"
 
       @settings.send(:parse_config_files)
     end
 
     it "should not try to parse non-existent files" do
-      expect(Puppet::FileSystem).to receive(:exist?).with(@file).and_return(false)
+      Puppet::FileSystem.expects(:exist?).with(@file).returns false
 
-      expect(File).not_to receive(:read).with(@file)
+      File.expects(:read).with(@file).never
 
       @settings.send(:parse_config_files)
     end
@@ -790,7 +760,7 @@ describe Puppet::Settings do
       text = "[main]
       one = fileval
       "
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
       @settings.send(:parse_config_files)
       expect(@settings[:one]).to eq("fileval")
     end
@@ -798,7 +768,7 @@ describe Puppet::Settings do
     #484 - this should probably be in the regression area
     it "should not throw an exception on unknown parameters" do
       text = "[main]\nnosuchparam = mval\n"
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
       expect { @settings.send(:parse_config_files) }.not_to raise_error
     end
 
@@ -807,7 +777,7 @@ describe Puppet::Settings do
       one = true
       two = false
       "
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
       @settings.send(:parse_config_files)
       expect(@settings[:one]).to eq(true)
       expect(@settings[:two]).to eq(false)
@@ -817,7 +787,7 @@ describe Puppet::Settings do
       text = "[main]
       one = 65
       "
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
       @settings.send(:parse_config_files)
       expect(@settings[:one]).to eq(65)
     end
@@ -860,7 +830,7 @@ describe Puppet::Settings do
       text = "[master]
       myfile = #{otherfile} {mode = 664}
       "
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
 
       # will start initialization as user
       expect(@settings.preferred_run_mode).to eq(:user)
@@ -891,7 +861,7 @@ describe Puppet::Settings do
       [agent]
       myfile = #{file} {mode = 664}
       "
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
 
       # will start initialization as user
       expect(@settings.preferred_run_mode).to eq(:user)
@@ -913,7 +883,7 @@ describe Puppet::Settings do
       text = "[main]
       mysetting = setval
       "
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
       @settings.send(:parse_config_files)
       expect(values).to eq(["setval"])
     end
@@ -927,7 +897,7 @@ describe Puppet::Settings do
       [main]
       mysetting = other
       "
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
       @settings.send(:parse_config_files)
       expect(values).to eq(["setval"])
     end
@@ -940,7 +910,7 @@ describe Puppet::Settings do
       text = "[main]
       mysetting = $base/setval
       "
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
       @settings.send(:parse_config_files)
       expect(values).to eq(["yay/setval"])
     end
@@ -962,7 +932,7 @@ describe Puppet::Settings do
       deferred=$confdir/goose
       EOD
 
-      allow(@settings).to receive(:read_file).and_return(text)
+      @settings.stubs(:read_file).returns(text)
       @settings.initialize_global_settings
 
       expect(hook_invoked).to be_falsey
@@ -987,7 +957,7 @@ describe Puppet::Settings do
       can_cause_problems=$confdir/goose
       EOD
 
-      allow(@settings).to receive(:read_file).and_return(text)
+      @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')
 
@@ -1000,7 +970,7 @@ describe Puppet::Settings do
       text = "[main]
       myarg =
       "
-      allow(@settings).to receive(:read_file).and_return(text)
+      @settings.stubs(:read_file).returns(text)
       @settings.send(:parse_config_files)
       expect(@settings[:myarg]).to eq("")
     end
@@ -1017,8 +987,8 @@ describe Puppet::Settings do
       }
 
       def assert_accessing_setting_is_deprecated(settings, setting)
-        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.")
+        Puppet.expects(:deprecation_warning).with("Accessing '#{setting}' as a setting is deprecated.")
+        Puppet.expects(: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
@@ -1045,7 +1015,7 @@ describe Puppet::Settings do
         end
 
         it "warns when set in puppet.conf" do
-          expect(Puppet).to receive(:deprecation_warning).with(/completely_deprecated_setting is deprecated\./, 'setting-completely_deprecated_setting')
+          Puppet.expects(:deprecation_warning).with(regexp_matches(/completely_deprecated_setting is deprecated\./), 'setting-completely_deprecated_setting')
 
           completely_deprecated_settings.parse_config(<<-CONF)
             completely_deprecated_setting='should warn'
@@ -1054,7 +1024,7 @@ describe Puppet::Settings do
         end
 
         it "warns when set on the commandline" do
-          expect(Puppet).to receive(:deprecation_warning).with(/completely_deprecated_setting is deprecated\./, 'setting-completely_deprecated_setting')
+          Puppet.expects(:deprecation_warning).with(regexp_matches(/completely_deprecated_setting is deprecated\./), 'setting-completely_deprecated_setting')
 
           args = ["--completely_deprecated_setting", "/some/value"]
           completely_deprecated_settings.send(:parse_global_options, args)
@@ -1079,7 +1049,7 @@ describe Puppet::Settings do
         end
 
         it "warns for a deprecated setting allowed on the command line set in puppet.conf" do
-          expect(Puppet).to receive(:deprecation_warning).with(/partially_deprecated_setting is deprecated in puppet\.conf/, 'puppet-conf-setting-partially_deprecated_setting')
+          Puppet.expects(:deprecation_warning).with(regexp_matches(/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
@@ -1087,7 +1057,7 @@ describe Puppet::Settings do
         end
 
         it "does not warn when manifest is set on command line" do
-          expect(Puppet).not_to receive(:deprecation_warning)
+          Puppet.expects(:deprecation_warning).never
 
           args = ["--partially_deprecated_setting", "/some/value"]
           partially_deprecated_settings.send(:parse_global_options, args)
@@ -1104,6 +1074,7 @@ 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
@@ -1116,13 +1087,13 @@ describe Puppet::Settings do
 
     context "running non-root without explicit config file" do
       before :each do
-        allow(Puppet.features).to receive(:root?).and_return(false)
-        expect(Puppet::FileSystem).to receive(:exist?).
+        Puppet.features.stubs(:root?).returns(false)
+        Puppet::FileSystem.expects(:exist?).
           with(user_config_file_default_location).
-          and_return(true).ordered
-        expect(@settings).to receive(:read_file).
+          returns(true).in_sequence(seq)
+        @settings.expects(:read_file).
           with(user_config_file_default_location).
-          and_return(user_config_text).ordered
+          returns(user_config_text).in_sequence(seq)
       end
 
       it "should return values from the user config file" do
@@ -1138,13 +1109,13 @@ describe Puppet::Settings do
 
     context "running as root without explicit config file" do
       before :each do
-        allow(Puppet.features).to receive(:root?).and_return(true)
-        expect(Puppet::FileSystem).to receive(:exist?).
+        Puppet.features.stubs(:root?).returns(true)
+        Puppet::FileSystem.expects(:exist?).
           with(main_config_file_default_location).
-          and_return(true).ordered
-        expect(@settings).to receive(:read_file).
+          returns(true).in_sequence(seq)
+        @settings.expects(:read_file).
           with(main_config_file_default_location).
-          and_return(main_config_text).ordered
+          returns(main_config_text).in_sequence(seq)
       end
 
       it "should return values from the main config file" do
@@ -1160,14 +1131,14 @@ describe Puppet::Settings do
 
     context "running with an explicit config file as a user (e.g. Apache + Passenger)" do
       before :each do
-        allow(Puppet.features).to receive(:root?).and_return(false)
+        Puppet.features.stubs(:root?).returns(false)
         @settings[:confdir] = File.dirname(main_config_file_default_location)
-        expect(Puppet::FileSystem).to receive(:exist?).
+        Puppet::FileSystem.expects(:exist?).
           with(main_config_file_default_location).
-          and_return(true).ordered
-        expect(@settings).to receive(:read_file).
+          returns(true).in_sequence(seq)
+        @settings.expects(:read_file).
           with(main_config_file_default_location).
-          and_return(main_config_text).ordered
+          returns(main_config_text).in_sequence(seq)
       end
 
       it "should return values from the main config file" do
@@ -1192,16 +1163,16 @@ describe Puppet::Settings do
           :one => { :default => "ONE", :desc => "a" },
           :two => { :default => "$one TWO", :desc => "b" },
           :three => { :default => "$one $two THREE", :desc => "c" }
-      allow(Puppet::FileSystem).to receive(:exist?).with(@file).and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).with(@userconfig).and_return(false)
-      allow(@settings).to receive(:user_config_file).and_return(@userconfig)
+      Puppet::FileSystem.stubs(:exist?).with(@file).returns true
+      Puppet::FileSystem.stubs(:exist?).with(@userconfig).returns false
+      @settings.stubs(:user_config_file).returns(@userconfig)
     end
 
     it "does not create the WatchedFile instance and should not parse if the file does not exist" do
-      expect(Puppet::FileSystem).to receive(:exist?).with(@file).and_return(false)
-      expect(Puppet::Util::WatchedFile).not_to receive(:new)
+      Puppet::FileSystem.expects(:exist?).with(@file).returns false
+      Puppet::Util::WatchedFile.expects(:new).never
 
-      expect(@settings).not_to receive(:parse_config_files)
+      @settings.expects(:parse_config_files).never
 
       @settings.reparse_config_files
     end
@@ -1209,38 +1180,38 @@ describe Puppet::Settings do
     context "and watched file exists" do
       before do
         @watched_file = Puppet::Util::WatchedFile.new(@file)
-        expect(Puppet::Util::WatchedFile).to receive(:new).with(@file).and_return(@watched_file)
+        Puppet::Util::WatchedFile.expects(:new).with(@file).returns @watched_file
       end
 
       it "uses a WatchedFile instance to determine if the file has changed" do
-        expect(@watched_file).to receive(:changed?)
+        @watched_file.expects(:changed?)
 
         @settings.reparse_config_files
       end
 
       it "does not reparse if the file has not changed" do
-        expect(@watched_file).to receive(:changed?).and_return(false)
+        @watched_file.expects(:changed?).returns false
 
-        expect(@settings).not_to receive(:parse_config_files)
+        @settings.expects(:parse_config_files).never
 
         @settings.reparse_config_files
       end
 
       it "reparses if the file has changed" do
-        expect(@watched_file).to receive(:changed?).and_return(true)
+        @watched_file.expects(:changed?).returns true
 
-        expect(@settings).to receive(:parse_config_files)
+        @settings.expects(:parse_config_files)
 
         @settings.reparse_config_files
       end
 
       it "replaces in-memory values with on-file values" do
-        allow(@watched_file).to receive(:changed?).and_return(true)
+        @watched_file.stubs(:changed?).returns(true)
         @settings[:one] = "init"
 
         # Now replace the value
         text = "[main]\none = disk-replace\n"
-        allow(@settings).to receive(:read_file).and_return(text)
+        @settings.stubs(:read_file).returns(text)
         @settings.reparse_config_files
         expect(@settings[:one]).to eq("disk-replace")
       end
@@ -1250,7 +1221,7 @@ describe Puppet::Settings do
       @settings.handlearg("--one", "clival")
 
       text = "[main]\none = on-disk\n"
-      allow(@settings).to receive(:read_file).and_return(text)
+      @settings.stubs(:read_file).returns(text)
       @settings.send(:parse_config_files)
 
       expect(@settings[:one]).to eq("clival")
@@ -1259,13 +1230,13 @@ describe Puppet::Settings do
     it "should remove in-memory values that are no longer set in the file" do
       # Init the value
       text = "[main]\none = disk-init\n"
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
       @settings.send(:parse_config_files)
       expect(@settings[:one]).to eq("disk-init")
 
       # Now replace the value
       text = "[main]\ntwo = disk-replace\n"
-      expect(@settings).to receive(:read_file).and_return(text)
+      @settings.expects(:read_file).returns(text)
       @settings.send(:parse_config_files)
 
       # The originally-overridden value should be replaced with the default
@@ -1278,13 +1249,13 @@ 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"
-      expect(@settings).to receive(:read_file).with(@file).and_return(text)
+      @settings.expects(:read_file).with(@file).returns(text)
       @settings.send(:parse_config_files)
       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"
-      expect(@settings).to receive(:read_file).with(@file).and_return(text)
+      @settings.expects(:read_file).with(@file).returns(text)
       @settings.send(:parse_config_files)
 
       # The originally-overridden value should not be replaced with the default
@@ -1302,7 +1273,7 @@ describe Puppet::Settings do
   describe "when creating a catalog" do
     before do
       @settings = Puppet::Settings.new
-      allow(@settings).to receive(:service_user_available?).and_return(true)
+      @settings.stubs(:service_user_available?).returns true
       @prefix = Puppet.features.posix? ? "" : "C:"
     end
 
@@ -1336,15 +1307,15 @@ describe Puppet::Settings do
 
     it "should ignore files whose :to_resource method returns nil" do
       @settings.define_settings :main, :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
-      expect(@settings.setting(:maindir)).to receive(:to_resource).and_return(nil)
+      @settings.setting(:maindir).expects(:to_resource).returns nil
 
-      expect_any_instance_of(Puppet::Resource::Catalog).not_to receive(:add_resource)
+      Puppet::Resource::Catalog.any_instance.expects(:add_resource).never
       @settings.to_catalog
     end
 
     describe "on Microsoft Windows", :if => Puppet::Util::Platform.windows? do
       before :each do
-        allow(Puppet.features).to receive(:root?).and_return(true)
+        Puppet.features.stubs(:root?).returns true
 
         @settings.define_settings :foo,
             :mkusers => { :type => :boolean, :default => true, :desc => "e" },
@@ -1393,7 +1364,7 @@ describe Puppet::Settings do
         envpath = "#{envdir}#{File::PATH_SEPARATOR}/some/other/envdir"
         @settings[:environmentpath] = envpath
         Dir.mkdir(envdir)
-        allow(Puppet.features).to receive(:root?).and_return(false)
+        Puppet.features.stubs(:root?).returns false
         catalog = @settings.to_catalog
         resource = catalog.resource('File', File.join(envdir, 'production'))
         expect(resource[:mode]).to eq('0750')
@@ -1406,9 +1377,9 @@ describe Puppet::Settings do
         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)
+        Puppet.features.stubs(:root?).returns true
+        @settings.stubs(:service_user_available?).returns true
+        @settings.stubs(:service_group_available?).returns true
         catalog = @settings.to_catalog
         resource = catalog.resource('File', File.join(envdir, 'production'))
         expect(resource[:mode]).to eq('0750')
@@ -1421,9 +1392,9 @@ describe Puppet::Settings do
         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)
+        Puppet.features.stubs(:root?).returns true
+        @settings.stubs(:service_user_available?).returns false
+        @settings.stubs(:service_group_available?).returns false
         catalog = @settings.to_catalog
         resource = catalog.resource('File', File.join(envdir, 'production'))
         expect(resource[:mode]).to eq('0750')
@@ -1464,9 +1435,9 @@ describe Puppet::Settings do
       end
 
       before do
-        allow(Puppet.features).to receive(:root?).and_return(true)
+        Puppet.features.stubs(:root?).returns true
         # stubbed to false, as Windows catalogs don't add users / groups
-        allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+        Puppet::Util::Platform.stubs(:windows?).returns false
 
         @settings.define_settings :foo,
             :mkusers => { :type => :boolean, :default => true, :desc => "e" },
@@ -1490,7 +1461,7 @@ describe Puppet::Settings do
       end
 
       it "should not add users or groups to the catalog if :mkusers not running as root" do
-        allow(Puppet.features).to receive(:root?).and_return(false)
+        Puppet.features.stubs(:root?).returns false
 
         catalog = @settings.to_catalog
         expect(catalog.resource(:user, "suser")).to be_nil
@@ -1498,7 +1469,7 @@ describe Puppet::Settings do
       end
 
       it "should not add users or groups to the catalog if :mkusers is not a valid setting" do
-        allow(Puppet.features).to receive(:root?).and_return(true)
+        Puppet.features.stubs(:root?).returns true
         settings = Puppet::Settings.new
         settings.define_settings :other, :otherdir => {:type => :directory, :default => "/otherdir", :desc => "a", :owner => "service", :group => "service"}
 
@@ -1509,8 +1480,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)
+        @settings.stubs(:service_user_available?).returns(false)
+        @settings.stubs(:service_group_available?).returns(false)
 
         catalog = @settings.to_catalog
         expect(catalog.resource(:user, "suser")).to be_nil
@@ -1534,7 +1505,7 @@ describe Puppet::Settings do
       end
 
       it "should not attempt to manage the root user" do
-        allow(Puppet.features).to receive(:root?).and_return(true)
+        Puppet.features.stubs(:root?).returns 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
@@ -1553,15 +1524,15 @@ describe Puppet::Settings do
           :maindir => { :type => :directory, :default => "/maindir", :desc => "a"},
           :seconddir => { :type => :directory, :default => "/seconddir", :desc => "a"}
 
-      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)
+      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
 
-      expect(@settings.setting(:maindir)).to receive(:to_resource).and_return(main)
-      expect(@settings.setting(:seconddir)).to receive(:to_resource).and_return(second)
+      @settings.setting(:maindir).expects(:to_resource).returns main
+      @settings.setting(:seconddir).expects(:to_resource).returns second
 
       expect(@settings.to_manifest.split("\n\n").sort).to eq(%w{maindir seconddir})
     end
@@ -1570,8 +1541,8 @@ describe Puppet::Settings do
   describe "when using sections of the configuration to manage the local host" do
     before do
       @settings = Puppet::Settings.new
-      allow(@settings).to receive(:service_user_available?).and_return(true)
-      allow(@settings).to receive(:service_group_available?).and_return(true)
+      @settings.stubs(:service_user_available?).returns true
+      @settings.stubs(:service_group_available?).returns true
       @settings.define_settings :main, :noop => { :default => false, :desc => "", :type => :boolean }
       @settings.define_settings :main,
           :maindir => { :type => :directory, :default => make_absolute("/maindir"), :desc => "a" },
@@ -1583,44 +1554,44 @@ describe Puppet::Settings do
     end
 
     it "should create a catalog with the specified sections" do
-      expect(@settings).to receive(:to_catalog).with(:main, :other).and_return(Puppet::Resource::Catalog.new("foo"))
+      @settings.expects(:to_catalog).with(:main, :other).returns Puppet::Resource::Catalog.new("foo")
       @settings.use(:main, :other)
     end
 
     it "should canonicalize the sections" do
-      expect(@settings).to receive(:to_catalog).with(:main, :other).and_return(Puppet::Resource::Catalog.new("foo"))
+      @settings.expects(:to_catalog).with(:main, :other).returns Puppet::Resource::Catalog.new("foo")
       @settings.use("main", "other")
     end
 
     it "should ignore sections that have already been used" do
-      expect(@settings).to receive(:to_catalog).with(:main).and_return(Puppet::Resource::Catalog.new("foo"))
+      @settings.expects(:to_catalog).with(:main).returns Puppet::Resource::Catalog.new("foo")
       @settings.use(:main)
-      expect(@settings).to receive(:to_catalog).with(:other).and_return(Puppet::Resource::Catalog.new("foo"))
+      @settings.expects(:to_catalog).with(:other).returns 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")
-      expect(@settings).to receive(:to_catalog).with(:main).and_return(@catalog)
+      @settings.expects(:to_catalog).with(:main).returns @catalog
 
-      expect(@catalog).to receive(:to_ral).and_return(@catalog)
+      @catalog.expects(:to_ral).returns @catalog
       @settings.use(:main)
     end
 
     it "should specify that it is not managing a host catalog" do
       catalog = Puppet::Resource::Catalog.new("foo")
-      expect(catalog).to receive(:apply)
-      expect(@settings).to receive(:to_catalog).and_return(catalog)
+      catalog.expects(:apply)
+      @settings.expects(:to_catalog).returns catalog
 
-      allow(catalog).to receive(:to_ral).and_return(catalog)
+      catalog.stubs(:to_ral).returns catalog
 
-      expect(catalog).to receive(:host_config=).with(false)
+      catalog.expects(:host_config=).with false
 
       @settings.use(:main)
     end
 
     it "should support a method for re-using all currently used sections" do
-      expect(@settings).to receive(:to_catalog).with(:main, :third).exactly(2).times.and_return(Puppet::Resource::Catalog.new("foo"))
+      @settings.expects(:to_catalog).with(:main, :third).times(2).returns Puppet::Resource::Catalog.new("foo")
 
       @settings.use(:main, :third)
       @settings.reuse
@@ -1628,13 +1599,13 @@ describe Puppet::Settings do
 
     it "should fail with an appropriate message if any resources fail" do
       @catalog = Puppet::Resource::Catalog.new("foo")
-      allow(@catalog).to receive(:to_ral).and_return(@catalog)
-      expect(@settings).to receive(:to_catalog).and_return(@catalog)
+      @catalog.stubs(:to_ral).returns @catalog
+      @settings.expects(:to_catalog).returns @catalog
 
-      @trans = double("transaction")
-      expect(@catalog).to receive(:apply).and_yield(@trans)
+      @trans = mock("transaction")
+      @catalog.expects(:apply).yields(@trans)
 
-      expect(@trans).to receive(:any_failed?).and_return(true)
+      @trans.expects(:any_failed?).returns(true)
 
       resource = Puppet::Type.type(:notify).new(:title => 'failed')
       status = Puppet::Resource::Status.new(resource)
@@ -1647,9 +1618,9 @@ describe Puppet::Settings do
       report = Puppet::Transaction::Report.new('apply')
       report.add_resource_status(status)
 
-      expect(@trans).to receive(:report).and_return(report)
+      @trans.expects(:report).returns report
 
-      expect(@settings).to receive(:raise).with(/My failure/)
+      @settings.expects(:raise).with(includes("My failure"))
       @settings.use(:whatever)
     end
   end
@@ -1658,10 +1629,10 @@ describe Puppet::Settings do
     before do
       @settings = Puppet::Settings.new
       #these are the magic default values
-      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)
+      @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)
     end
 
     describe "when checking print_config?" do
@@ -1670,17 +1641,17 @@ describe Puppet::Settings do
       end
 
       it "should return true when :configprint has a value" do
-        allow(@settings).to receive(:value).with(:configprint).and_return("something")
+        @settings.stubs(:value).with(:configprint).returns("something")
         expect(@settings.print_configs?).to be_truthy
       end
 
       it "should return true when :genconfig has a value" do
-        allow(@settings).to receive(:value).with(:genconfig).and_return(true)
+        @settings.stubs(:value).with(:genconfig).returns(true)
         expect(@settings.print_configs?).to be_truthy
       end
 
       it "should return true when :genmanifest has a value" do
-        allow(@settings).to receive(:value).with(:genmanifest).and_return(true)
+        @settings.stubs(:value).with(:genmanifest).returns(true)
         expect(@settings.print_configs?).to be_truthy
       end
     end
@@ -1688,87 +1659,87 @@ describe Puppet::Settings do
     describe "when printing configs" do
       describe "when :configprint has a value" do
         it "should call print_config_options" do
-          allow(@settings).to receive(:value).with(:configprint).and_return("something")
-          expect(@settings).to receive(:print_config_options)
+          @settings.stubs(:value).with(:configprint).returns("something")
+          @settings.expects(:print_config_options)
           @settings.print_configs
         end
 
         it "should get the value of the option using the environment" do
-          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.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")
           @settings.print_configs
         end
 
         it "should print the value of the option" do
-          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.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")
           @settings.print_configs
         end
 
         it "should print the value pairs if there are multiple options" do
-          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.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")
           @settings.print_configs
         end
 
         it "should return true after printing" do
-          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")
+          @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")
           expect(@settings.print_configs).to be_truthy
         end
 
         it "should return false if a config param is not found" do
-          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)
+          @settings.stubs :puts
+          @settings.stubs(:value).with(:configprint).returns("something")
+          @settings.stubs(:include?).with("something").returns(false)
           expect(@settings.print_configs).to be_falsey
         end
       end
 
       describe "when genconfig is true" do
         before do
-          allow(@settings).to receive(:puts)
+          @settings.stubs :puts
         end
 
         it "should call to_config" do
-          allow(@settings).to receive(:value).with(:genconfig).and_return(true)
-          expect(@settings).to receive(:to_config)
+          @settings.stubs(:value).with(:genconfig).returns(true)
+          @settings.expects(:to_config)
           @settings.print_configs
         end
 
         it "should return true from print_configs" do
-          allow(@settings).to receive(:value).with(:genconfig).and_return(true)
-          allow(@settings).to receive(:to_config)
+          @settings.stubs(:value).with(:genconfig).returns(true)
+          @settings.stubs(:to_config)
           expect(@settings.print_configs).to be_truthy
         end
       end
 
       describe "when genmanifest is true" do
         before do
-          allow(@settings).to receive(:puts)
+          @settings.stubs :puts
         end
 
         it "should call to_config" do
-          allow(@settings).to receive(:value).with(:genmanifest).and_return(true)
-          expect(@settings).to receive(:to_manifest)
+          @settings.stubs(:value).with(:genmanifest).returns(true)
+          @settings.expects(:to_manifest)
           @settings.print_configs
         end
 
         it "should return true from print_configs" do
-          allow(@settings).to receive(:value).with(:genmanifest).and_return(true)
-          allow(@settings).to receive(:to_manifest)
+          @settings.stubs(:value).with(:genmanifest).returns(true)
+          @settings.stubs(:to_manifest)
           expect(@settings.print_configs).to be_truthy
         end
       end
@@ -1783,8 +1754,8 @@ describe Puppet::Settings do
     end
 
     def a_user_type_for(username)
-      user = double('user')
-      expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: username)).and_return(user)
+      user = mock 'user'
+      Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == username }.returns user
       user
     end
 
@@ -1795,7 +1766,7 @@ describe Puppet::Settings do
     it "should return false if the user provider says the user is missing" do
       settings[:user] = "foo"
 
-      expect(a_user_type_for("foo")).to receive(:exists?).and_return(false)
+      a_user_type_for("foo").expects(:exists?).returns false
 
       expect(settings).not_to be_service_user_available
     end
@@ -1803,7 +1774,7 @@ describe Puppet::Settings do
     it "should return true if the user provider says the user is present" do
       settings[:user] = "foo"
 
-      expect(a_user_type_for("foo")).to receive(:exists?).and_return(true)
+      a_user_type_for("foo").expects(:exists?).returns true
 
       expect(settings).to be_service_user_available
     end
@@ -1811,7 +1782,7 @@ describe Puppet::Settings do
     it "caches the result of determining if the user is present" do
       settings[:user] = "foo"
 
-      expect(a_user_type_for("foo")).to receive(:exists?).and_return(true)
+      a_user_type_for("foo").expects(:exists?).returns true
       expect(settings).to be_service_user_available
 
       expect(settings).to be_service_user_available
@@ -1826,8 +1797,8 @@ describe Puppet::Settings do
     end
 
     def a_group_type_for(groupname)
-      group = double('group')
-      expect(Puppet::Type.type(:group)).to receive(:new).with(hash_including(name: groupname)).and_return(group)
+      group = mock 'group'
+      Puppet::Type.type(:group).expects(:new).with { |args| args[:name] == groupname }.returns group
       group
     end
 
@@ -1838,7 +1809,7 @@ describe Puppet::Settings do
     it "should return false if the group provider says the group is missing" do
       settings[:group] = "foo"
 
-      expect(a_group_type_for("foo")).to receive(:exists?).and_return(false)
+      a_group_type_for("foo").expects(:exists?).returns false
 
       expect(settings).not_to be_service_group_available
     end
@@ -1846,7 +1817,7 @@ describe Puppet::Settings do
     it "should return true if the group provider says the group is present" do
       settings[:group] = "foo"
 
-      expect(a_group_type_for("foo")).to receive(:exists?).and_return(true)
+      a_group_type_for("foo").expects(:exists?).returns true
 
       expect(settings).to be_service_group_available
     end
@@ -1854,7 +1825,7 @@ describe Puppet::Settings do
     it "caches the result of determining if the group is present" do
       settings[:group] = "foo"
 
-      expect(a_group_type_for("foo")).to receive(:exists?).and_return(true)
+      a_group_type_for("foo").expects(:exists?).returns true
       expect(settings).to be_service_group_available
 
       expect(settings).to be_service_group_available
@@ -1865,14 +1836,14 @@ describe Puppet::Settings do
     let(:settings) { Puppet::Settings.new }
 
     it "should get options from Puppet.settings.optparse_addargs" do
-      expect(settings).to receive(:optparse_addargs).and_return([])
+      settings.expects(:optparse_addargs).returns([])
 
       settings.send(:parse_global_options, [])
     end
 
     it "should add options to OptionParser" do
-      allow(settings).to receive(:optparse_addargs).and_return([["--option","-o", "Funny Option", :NONE]])
-      expect(settings).to receive(:handlearg).with("--option", true)
+      settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option", :NONE]])
+      settings.expects(:handlearg).with("--option", true)
       settings.send(:parse_global_options, ["--option"])
     end
 
@@ -1881,13 +1852,13 @@ describe Puppet::Settings do
     end
 
     it "should not pass an unrecognized option to handleargs" do
-      expect(settings).not_to receive(:handlearg).with("--topuppet", "value")
+      settings.expects(:handlearg).with("--topuppet", "value").never
       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
-      allow(settings).to receive(:optparse_addargs).and_return([["--option","-o", "Funny Option", :NONE]])
-      expect(settings).to receive(:handlearg).with("--option", true)
+      settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option", :NONE]])
+      settings.expects(:handlearg).with("--option", true)
       settings.send(:parse_global_options, ["--invalidoption", "--option"])
     end
 
@@ -1901,7 +1872,7 @@ describe Puppet::Settings do
 
     it "should set preferred run mode from --run_mode <foo> string without error" do
       args = ["--run_mode", "master"]
-      expect(settings).not_to receive(:handlearg).with("--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)
       expect(args.empty?).to eq(true)
@@ -1909,8 +1880,8 @@ describe Puppet::Settings do
 
     it "should set preferred run mode from --run_mode=<foo> string without error" do
       args = ["--run_mode=master"]
-      expect(settings).not_to receive(:handlearg).with("--run_mode", "master")
-      expect { settings.send(:parse_global_options, args) }.to_not raise_error
+      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)
       expect(args.empty?).to eq(true)
     end
@@ -1919,8 +1890,8 @@ describe Puppet::Settings do
   describe "default_certname" do
     describe "using hostname and domain" do
       before :each do
-        allow(Puppet::Settings).to receive(:hostname_fact).and_return("testhostname")
-        allow(Puppet::Settings).to receive(:domain_fact).and_return("domain.test.")
+        Puppet::Settings.stubs(:hostname_fact).returns("testhostname")
+        Puppet::Settings.stubs(:domain_fact).returns("domain.test.")
       end
 
       it "should use both to generate fqdn" do
@@ -1933,8 +1904,8 @@ describe Puppet::Settings do
 
     describe "using just hostname" do
       before :each do
-        allow(Puppet::Settings).to receive(:hostname_fact).and_return("testhostname")
-        allow(Puppet::Settings).to receive(:domain_fact).and_return("")
+        Puppet::Settings.stubs(:hostname_fact).returns("testhostname")
+        Puppet::Settings.stubs(:domain_fact).returns("")
       end
 
       it "should use only hostname to generate fqdn" do