puppet 6.0.7-universal-darwin → 6.0.8-universal-darwin

data/spec/unit/rest/client_spec.rb

@@ -16,8 +16,8 @@ describe Puppet::Rest::Client do
                                    ConstantErrorValidator.new(
                                      error_string: 'foo'))
 
-      http.expects(:get_content).with(uri.to_s, query: nil, header: nil)
-        .raises(OpenSSL::OpenSSLError.new('certificate verify failed'))
+      expect(http).to receive(:get_content).with(uri.to_s, query: nil, header: nil)
+        .and_raise(OpenSSL::OpenSSLError.new('certificate verify failed'))
       expect{ client.get(uri) }.to raise_error do |error|
         expect(error).to be_a(Puppet::Error)
         expect(error.message).to include('foo')
@@ -30,8 +30,8 @@ describe Puppet::Rest::Client do
       client.instance_variable_set(:@verifier,
                                    ConstantErrorValidator.new(
                                      peer_certs: [cert]))
-      http.expects(:get_content).with(uri.to_s, query: nil, header: nil)
-        .raises(OpenSSL::OpenSSLError.new('hostname does not match with server certificate'))
+      expect(http).to receive(:get_content).with(uri.to_s, query: nil, header: nil)
+        .and_raise(OpenSSL::OpenSSLError.new('hostname does not match with server certificate'))
       expect { client.get(uri) }.to raise_error do |error|
         expect(error).to be_a(Puppet::Error)
         expect(error.message).to include("Server hostname 'foo.com' did not match")
@@ -40,58 +40,89 @@ describe Puppet::Rest::Client do
     end
 
     it 're-raises errors it does not understand' do
-      http.expects(:get_content).with(uri.to_s, query: nil, header: nil)
-        .raises(OpenSSL::OpenSSLError.new('other ssl error'))
+      expect(http).to receive(:get_content).with(uri.to_s, query: nil, header: nil)
+        .and_raise(OpenSSL::OpenSSLError.new('other ssl error'))
       expect{ client.get(uri) }.to raise_error do |error|
         expect(error).to be_a(OpenSSL::OpenSSLError)
         expect(error.message).to include('other ssl error')
       end
-
     end
   end
 
   context 'when creating a new client' do
-    let(:ssl_store) { mock('store') }
-    let(:ssl_config) { stub_everything('ssl config') }
-    let(:http) { stub_everything('http', :ssl_config => ssl_config) }
+    let(:ssl_store) { double('store') }
+    let(:ssl_config) do
+      double(
+        'ssl config',
+        :cert_store= => nil,
+        :verify_callback= => nil,
+        :verify_mode= => nil,
+      )
+    end
+    let(:http) do
+      double(
+        'http',
+        :connect_timeout= => nil,
+        :receive_timeout= => nil,
+        :ssl_config => ssl_config,
+        :tcp_keepalive= => nil,
+        :transparent_gzip_decompression= => nil,
+      )
+    end
 
     it 'initializes itself with basic defaults' do
-      HTTPClient.expects(:new).returns(http)
-      OpenSSL::X509::Store.stubs(:new).returns(ssl_store)
+      expect(HTTPClient).to receive(:new).and_return(http)
+      allow(OpenSSL::X509::Store).to receive(:new).and_return(ssl_store)
       # Configure connection with HTTP settings
       Puppet[:http_read_timeout] = 120
       Puppet[:http_connect_timeout] = 10
       Puppet[:http_debug] = true
 
-      http.expects(:connect_timeout=).with(10)
-      http.expects(:receive_timeout=).with(120)
-      http.expects(:debug_dev=).with($stderr)
+      expect(http).to receive(:connect_timeout=).with(10)
+      expect(http).to receive(:receive_timeout=).with(120)
+      expect(http).to receive(:debug_dev=).with($stderr)
 
       # Configure verify mode with SSL settings
-      ssl_config.expects(:cert_store=).with(ssl_store)
+      expect(ssl_config).to receive(:cert_store=).with(ssl_store)
       Puppet[:ssl_client_ca_auth] = '/fake/path'
       Puppet[:hostcert] = '/fake/cert/path'
-      ssl_config.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+      expect(ssl_config).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
 
       Puppet::Rest::Client.new(ssl_context: Puppet::Rest::SSLContext.new(OpenSSL::SSL::VERIFY_NONE))
     end
 
     it 'uses a given client and SSL store when provided' do
-      ssl_config.expects(:cert_store=).with(ssl_store)
+      expect(ssl_config).to receive(:cert_store=).with(ssl_store)
       Puppet::Rest::Client.new(client: http,
                                ssl_context: Puppet::Rest::SSLContext.new(OpenSSL::SSL::VERIFY_PEER, ssl_store))
     end
 
     it 'configures a receive timeout when provided' do
-      http.expects(:receive_timeout=).with(10)
+      expect(http).to receive(:receive_timeout=).with(10)
       Puppet::Rest::Client.new(ssl_context: Puppet::Rest::SSLContext.new(OpenSSL::SSL::VERIFY_NONE),
                                client: http, receive_timeout: 10)
     end
   end
 
-  context 'when making requests' do
-    let(:ssl_config) { stub_everything('ssl config') }
-    let(:http) { stub_everything('http', :ssl_config => ssl_config) }
+  context 'when making requests', focus: true do
+    let(:ssl_config) do
+      double(
+        'ssl config',
+        :cert_store= => nil,
+        :verify_callback= => nil,
+        :verify_mode= => nil,
+      )
+    end
+    let(:http) do
+      double(
+        'http',
+        :connect_timeout= => nil,
+        :receive_timeout= => nil,
+        :ssl_config => ssl_config,
+        :tcp_keepalive= => nil,
+        :transparent_gzip_decompression= => nil,
+      )
+    end
     let(:client) { Puppet::Rest::Client.new(ssl_context: Puppet::Rest::SSLContext.new(OpenSSL::SSL::VERIFY_NONE), client: http) }
     let(:url) { 'https://myserver.com:555/data' }
 
@@ -101,15 +132,15 @@ describe Puppet::Rest::Client do
         header = { 'Accept' => 'text/plain' }
         response_string = ''
         chunk_processing = lambda { |chunk| response_string = chunk }
-        http.expects(:get_content).with(url, { query: query, header: header }).yields('response')
+        expect(http).to receive(:get_content).with(url, { query: query, header: header }).and_yield('response')
         client.get(url, query: query, header: header, &chunk_processing)
         expect(response_string).to eq('response')
       end
 
       it 'throws an exception when the response to the GET is not OK' do
-        fake_response = mock('resp', :status => HTTP::Status::BAD_REQUEST)
-        http.expects(:get_content).with(url, query: nil, header: nil)
-            .raises(HTTPClient::BadResponseError.new('failed request', fake_response))
+        fake_response = double('resp', :status => HTTP::Status::BAD_REQUEST)
+        expect(http).to receive(:get_content).with(url, query: nil, header: nil)
+            .and_raise(HTTPClient::BadResponseError.new('failed request', fake_response))
         expect { client.get(url) }.to raise_error do |error|
           expect(error.message).to eq('failed request')
           expect(error.response).to be_a(Puppet::Rest::Response)
@@ -125,7 +156,7 @@ describe Puppet::Rest::Client do
         body = 'send to server'
         query = { 'environment' => 'production' }
         header = { 'Accept' => 'text/plain' }
-        http.expects(:put).with(url, { body: body, query: query, header: header })
+        expect(http).to receive(:put).with(url, { body: body, query: query, header: header })
         client.put(url, body: body, query: query, header: header)
       end
 

data/spec/unit/rest/route_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/rest/route'
 
 describe Puppet::Rest::Route do
   describe '#with_base_url'do
-    let(:dns_resolver) { stub_everything('dns resolver') }
+    let(:dns_resolver) { double('dns resolver') }
 
     context 'when not using SRV records' do
       before :each do
@@ -81,8 +81,8 @@ describe Puppet::Rest::Route do
           Puppet.settings[:use_srv_records] = true
           Puppet.settings[:srv_domain]      = 'example.com'
 
-          @dns_mock = mock('dns')
-          Resolv::DNS.expects(:new).returns(@dns_mock)
+          @dns_mock = double('dns')
+          expect(Resolv::DNS).to receive(:new).and_return(@dns_mock)
 
           @port = 7502
           @target = 'example.com'
@@ -90,9 +90,9 @@ describe Puppet::Rest::Route do
           record.instance_variable_set(:@ttl, 10)
           @srv_records = [record]
 
-          @dns_mock.expects(:getresources).
+          expect(@dns_mock).to receive(:getresources).
             with("_x-puppet-test_service._tcp.example.com", Resolv::DNS::Resource::IN::SRV).
-            returns(@srv_records)
+            and_return(@srv_records)
         end
 
         it "yields a URL using the server and port from the SRV record" do

data/spec/unit/scheduler/job_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/scheduler'
 

data/spec/unit/scheduler/scheduler_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/scheduler'
 

data/spec/unit/scheduler/splay_job_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/scheduler'
 
@@ -29,7 +28,7 @@ describe Puppet::Scheduler::SplayJob do
 
   it "is not immediately ready if splayed" do
     job.start_time = start_time
-    job.expects(:splay).returns(6)
+    expect(job).to receive(:splay).and_return(6)
     expect(job.ready?(start_time)).not_to be
   end
 end

data/spec/unit/settings/array_setting_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/settings'
 require 'puppet/settings/array_setting'
 
 describe Puppet::Settings::ArraySetting do
-  subject { described_class.new(:settings => stub('settings'), :desc => "test") }
+  subject { described_class.new(:settings => double('settings'), :desc => "test") }
 
   it "is of type :array" do
     expect(subject.type).to eq :array

data/spec/unit/settings/autosign_setting_spec.rb

@@ -6,11 +6,11 @@ require 'puppet/type/file'
 
 describe Puppet::Settings::AutosignSetting do
   let(:settings) do
-    s = stub('settings')
-    s.stubs(:[]).with(:mkusers).returns true
-    s.stubs(:[]).with(:user).returns 'puppet'
-    s.stubs(:[]).with(:group).returns 'puppet'
-    s.stubs(:[]).with(:manage_internal_file_permissions).returns true
+    s = double('settings')
+    allow(s).to receive(:[]).with(:mkusers).and_return(true)
+    allow(s).to receive(:[]).with(:user).and_return('puppet')
+    allow(s).to receive(:[]).with(:group).and_return('puppet')
+    allow(s).to receive(:[]).with(:manage_internal_file_permissions).and_return(true)
     s
   end
 
@@ -74,9 +74,9 @@ describe Puppet::Settings::AutosignSetting do
   describe "converting the setting to a resource" do
     it "converts the file path to a file resource", :if => !Puppet::Util::Platform.windows? do
       path = File.expand_path('/path/to/autosign.conf')
-      settings.stubs(:value).with('autosign', nil, false).returns(path)
-      Puppet::FileSystem.stubs(:exist?).with(path).returns true
-      Puppet.features.expects(:root?).returns(true)
+      allow(settings).to receive(:value).with('autosign', nil, false).and_return(path)
+      allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+      expect(Puppet.features).to receive(:root?).and_return(true)
 
       setting.mode = '0664'
       setting.owner = 'service'
@@ -92,7 +92,7 @@ describe Puppet::Settings::AutosignSetting do
     end
 
     it "returns nil when the setting is a boolean" do
-      settings.stubs(:value).with('autosign', nil, false).returns 'true'
+      allow(settings).to receive(:value).with('autosign', nil, false).and_return('true')
 
       setting.mode = '0664'
       setting.owner = 'service'

data/spec/unit/settings/certificate_revocation_setting_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/settings'
 require 'puppet/settings/certificate_revocation_setting'
 
 describe Puppet::Settings::CertificateRevocationSetting do
-  subject { described_class.new(:settings => stub('settings'), :desc => "test") }
+  subject { described_class.new(:settings => double('settings'), :desc => "test") }
 
   it "is of type :certificate_revocation" do
     expect(subject.type).to eq :certificate_revocation

data/spec/unit/settings/config_file_spec.rb

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

data/spec/unit/settings/directory_setting_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
@@ -15,18 +14,14 @@ describe Puppet::Settings::DirectorySetting do
 
   describe "when being converted to a resource" do
     before do
-      @settings = mock 'settings'
+      @settings = double('settings')
       @dir = Puppet::Settings::DirectorySetting.new(
           :settings => @settings, :desc => "eh", :name => :mydir, :section => "mysect")
-      @settings.stubs(:value).with(:mydir).returns @basepath
+      allow(@settings).to receive(:value).with(:mydir).and_return(@basepath)
     end
 
     it "should return :directory as its type" do
       expect(@dir.type).to eq(:directory)
     end
-
-
-
   end
 end
-

data/spec/unit/settings/duration_setting_spec.rb

@@ -1,11 +1,10 @@
-#!/usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
 require 'puppet/settings/duration_setting'
 
 describe Puppet::Settings::DurationSetting do
-  subject { described_class.new(:settings => mock('settings'), :desc => "test") }
+  subject { described_class.new(:settings => double('settings'), :desc => "test") }
 
   describe "when munging the setting" do
     it "should return the same value if given an integer" do

data/spec/unit/settings/enum_setting_spec.rb

@@ -19,7 +19,7 @@ describe Puppet::Settings::EnumSetting do
   end
 
   def enum_setting_allowing(*values)
-    Puppet::Settings::EnumSetting.new(:settings => mock('settings'),
+    Puppet::Settings::EnumSetting.new(:settings => double('settings'),
                                       :name => "testing",
                                       :desc => "description of testing",
                                       :values => values)

data/spec/unit/settings/environment_conf_spec.rb

@@ -5,14 +5,14 @@ describe Puppet::Settings::EnvironmentConf do
 
   def setup_environment_conf(config, conf_hash)
     conf_hash.each do |setting,value|
-      config.expects(:setting).with(setting).returns(
-        mock('setting', :value => value)
+      expect(config).to receive(:setting).with(setting).and_return(
+        double('setting', :value => value)
       )
     end
   end
 
   context "with config" do
-    let(:config) { stub('config') }
+    let(:config) { double('config') }
     let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, ["/global/modulepath"]) }
 
     it "reads a modulepath from config and does not include global_module_path" do
@@ -91,12 +91,10 @@ describe Puppet::Settings::EnvironmentConf do
   end
 
   describe "with disable_per_environment_manifest" do
-
-    let(:config) { stub('config') }
+    let(:config) { double('config') }
     let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, ["/global/modulepath"]) }
 
     context "set true" do
-
       before(:each) do
         Puppet[:default_manifest] = File.expand_path('/default/manifest')
         Puppet[:disable_per_environment_manifest] = true

data/spec/unit/settings/file_setting_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
@@ -19,13 +18,13 @@ describe Puppet::Settings::FileSetting do
         :service_group_available? => false
       }.merge(wanted_values)
 
-      settings = mock("settings")
+      settings = double("settings")
 
-      settings.stubs(:[]).with(:user).returns real_values[:user]
-      settings.stubs(:[]).with(:group).returns real_values[:group]
-      settings.stubs(:[]).with(:mkusers).returns real_values[:mkusers]
-      settings.stubs(:service_user_available?).returns real_values[:service_user_available?]
-      settings.stubs(:service_group_available?).returns real_values[:service_group_available?]
+      allow(settings).to receive(:[]).with(:user).and_return(real_values[:user])
+      allow(settings).to receive(:[]).with(:group).and_return(real_values[:group])
+      allow(settings).to receive(:[]).with(:mkusers).and_return(real_values[:mkusers])
+      allow(settings).to receive(:service_user_available?).and_return(real_values[:service_user_available?])
+      allow(settings).to receive(:service_group_available?).and_return(real_values[:service_group_available?])
 
       settings
     end
@@ -120,16 +119,16 @@ describe Puppet::Settings::FileSetting do
   end
 
   it "should be able to be converted into a resource" do
-    expect(FileSetting.new(:settings => mock("settings"), :desc => "eh")).to respond_to(:to_resource)
+    expect(FileSetting.new(:settings => double("settings"), :desc => "eh")).to respond_to(:to_resource)
   end
 
   describe "when being converted to a resource" do
     before do
       @basepath = make_absolute("/somepath")
-      @settings = mock 'settings'
+      @settings = double('settings')
       @file = Puppet::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :myfile, :section => "mysect")
-      @file.stubs(:create_files?).returns true
-      @settings.stubs(:value).with(:myfile, nil, false).returns @basepath
+      allow(@file).to receive(:create_files?).and_return(true)
+      allow(@settings).to receive(:value).with(:myfile, nil, false).and_return(@basepath)
     end
 
     it "should return :file as its type" do
@@ -137,29 +136,29 @@ describe Puppet::Settings::FileSetting do
     end
 
     it "should skip non-existent files if 'create_files' is not enabled" do
-      @file.expects(:create_files?).returns false
-      @file.expects(:type).returns :file
-      Puppet::FileSystem.expects(:exist?).with(@basepath).returns false
+      expect(@file).to receive(:create_files?).and_return(false)
+      expect(@file).to receive(:type).and_return(:file)
+      expect(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(false)
       expect(@file.to_resource).to be_nil
     end
 
     it "should manage existent files even if 'create_files' is not enabled" do
-      @file.expects(:create_files?).returns false
-      @file.expects(:type).returns :file
-      Puppet::FileSystem.stubs(:exist?)
-      Puppet::FileSystem.expects(:exist?).with(@basepath).returns true
+      expect(@file).to receive(:create_files?).and_return(false)
+      expect(@file).to receive(:type).and_return(:file)
+      allow(Puppet::FileSystem).to receive(:exist?)
+      expect(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(true)
       expect(@file.to_resource).to be_instance_of(Puppet::Resource)
     end
 
     describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should skip files in /dev" do
-        @settings.stubs(:value).with(:myfile, nil, false).returns "/dev/file"
+        allow(@settings).to receive(:value).with(:myfile, nil, false).and_return("/dev/file")
         expect(@file.to_resource).to be_nil
       end
     end
 
     it "should skip files whose paths are not strings" do
-      @settings.stubs(:value).with(:myfile, nil, false).returns :foo
+      allow(@settings).to receive(:value).with(:myfile, nil, false).and_return(:foo)
       expect(@file.to_resource).to be_nil
     end
 
@@ -176,7 +175,7 @@ describe Puppet::Settings::FileSetting do
     end
 
     it "should fully qualified returned files if necessary (#795)" do
-      @settings.stubs(:value).with(:myfile, nil, false).returns "myfile"
+      allow(@settings).to receive(:value).with(:myfile, nil, false).and_return("myfile")
       path = File.expand_path('myfile')
       expect(@file.to_resource.title).to eq(path)
     end
@@ -198,82 +197,81 @@ describe Puppet::Settings::FileSetting do
     it "should not set the mode on a the file if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
 
-      @file.stubs(:mode).returns(0755)
+      allow(@file).to receive(:mode).and_return(0755)
 
       expect(@file.to_resource[:mode]).to eq(nil)
     end
 
     it "should set the owner if running as root and the owner is provided" do
       Puppet[:manage_internal_file_permissions] = true
-      Puppet.features.expects(:root?).returns true
-      Puppet::Util::Platform.stubs(:windows?).returns false
-      @file.stubs(:owner).returns "foo"
+      expect(Puppet.features).to receive(:root?).and_return(true)
+      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+      allow(@file).to receive(:owner).and_return("foo")
 
       expect(@file.to_resource[:owner]).to eq("foo")
     end
 
     it "should not set the owner if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
-      Puppet.features.stubs(:root?).returns true
-      @file.stubs(:owner).returns "foo"
+      allow(Puppet.features).to receive(:root?).and_return(true)
+      allow(@file).to receive(:owner).and_return("foo")
 
       expect(@file.to_resource[:owner]).to eq(nil)
     end
 
     it "should set the group if running as root and the group is provided" do
       Puppet[:manage_internal_file_permissions] = true
-      Puppet.features.expects(:root?).returns true
-      Puppet::Util::Platform.stubs(:windows?).returns false
-      @file.stubs(:group).returns "foo"
+      expect(Puppet.features).to receive(:root?).and_return(true)
+      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+      allow(@file).to receive(:group).and_return("foo")
 
       expect(@file.to_resource[:group]).to eq("foo")
     end
 
     it "should not set the group if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
-      Puppet.features.stubs(:root?).returns true
-      @file.stubs(:group).returns "foo"
+      allow(Puppet.features).to receive(:root?).and_return(true)
+      allow(@file).to receive(:group).and_return("foo")
 
       expect(@file.to_resource[:group]).to eq(nil)
     end
 
-
     it "should not set owner if not running as root" do
       Puppet[:manage_internal_file_permissions] = true
-      Puppet.features.expects(:root?).returns false
-      Puppet::Util::Platform.stubs(:windows?).returns false
-      @file.stubs(:owner).returns "foo"
+      expect(Puppet.features).to receive(:root?).and_return(false)
+      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+      allow(@file).to receive(:owner).and_return("foo")
 
       expect(@file.to_resource[:owner]).to be_nil
     end
 
     it "should not set group if not running as root" do
       Puppet[:manage_internal_file_permissions] = true
-      Puppet.features.expects(:root?).returns false
-      Puppet::Util::Platform.stubs(:windows?).returns false
-      @file.stubs(:group).returns "foo"
+      expect(Puppet.features).to receive(:root?).and_return(false)
+      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+      allow(@file).to receive(:group).and_return("foo")
 
       expect(@file.to_resource[:group]).to be_nil
     end
 
     describe "on Microsoft Windows systems" do
       before :each do
-        Puppet::Util::Platform.stubs(:windows?).returns true
+        allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
       end
 
       it "should not set owner" do
-        @file.stubs(:owner).returns "foo"
+        allow(@file).to receive(:owner).and_return("foo")
         expect(@file.to_resource[:owner]).to be_nil
       end
 
       it "should not set group" do
-        @file.stubs(:group).returns "foo"
+        allow(@file).to receive(:group).and_return("foo")
         expect(@file.to_resource[:group]).to be_nil
       end
     end
 
     it "should set :ensure to the file type" do
-      @file.expects(:type).returns :directory
+      expect(@file).to receive(:type).and_return(:directory)
       expect(@file.to_resource[:ensure]).to eq(:directory)
     end
 
@@ -286,7 +284,7 @@ describe Puppet::Settings::FileSetting do
     end
 
     it "should tag the resource with the settings section" do
-      @file.expects(:section).returns "mysect"
+      expect(@file).to receive(:section).and_return("mysect")
       expect(@file.to_resource).to be_tagged("mysect")
     end
 
@@ -305,7 +303,7 @@ describe Puppet::Settings::FileSetting do
 
   describe "#munge" do
     it 'does not expand the path of the special value :memory: so we can set dblocation to an in-memory database' do
-      filesetting = FileSetting.new(:settings => mock("settings"), :desc => "eh")
+      filesetting = FileSetting.new(:settings => double("settings"), :desc => "eh")
       expect(filesetting.munge(':memory:')).to eq(':memory:')
     end
   end
@@ -316,7 +314,7 @@ describe Puppet::Settings::FileSetting do
     end
 
     let(:setting) do
-      settings = mock("settings", :value => path)
+      settings = double("settings", :value => path)
       FileSetting.new(:name => :mysetting, :desc => "creates a file", :settings => settings)
     end