puppet 5.5.12 → 5.5.13

data/spec/unit/provider/mount_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/provider/mount'
@@ -10,169 +9,161 @@ describe Puppet::Provider::Mount do
 
     @name = "/"
 
-    @resource = stub 'resource'
-    @resource.stubs(:[]).with(:name).returns(@name)
+    @resource = double('resource')
+    allow(@resource).to receive(:[]).with(:name).and_return(@name)
 
-    @mounter.stubs(:resource).returns(@resource)
+    allow(@mounter).to receive(:resource).and_return(@resource)
   end
 
   describe Puppet::Provider::Mount, " when mounting" do
-
     before :each do
-      @mounter.stubs(:get).with(:ensure).returns(:mounted)
+      allow(@mounter).to receive(:get).with(:ensure).and_return(:mounted)
     end
 
     it "should use the 'mountcmd' method to mount" do
-      @mounter.stubs(:options).returns(nil)
-      @mounter.expects(:mountcmd)
+      allow(@mounter).to receive(:options).and_return(nil)
+      expect(@mounter).to receive(:mountcmd)
 
       @mounter.mount
     end
 
     it "should add the options following '-o' on MacOS if they exist and are not set to :absent" do
-      Facter.expects(:value).with(:kernel).returns 'Darwin'
-      @mounter.stubs(:options).returns("ro")
-      @mounter.expects(:mountcmd).with '-o', 'ro', '/'
+      expect(Facter).to receive(:value).with(:kernel).and_return('Darwin')
+      allow(@mounter).to receive(:options).and_return("ro")
+      expect(@mounter).to receive(:mountcmd).with('-o', 'ro', '/')
 
       @mounter.mount
     end
 
     it "should not explicitly pass mount options on systems other than MacOS" do
-      Facter.expects(:value).with(:kernel).returns 'HP-UX'
-      @mounter.stubs(:options).returns("ro")
-      @mounter.expects(:mountcmd).with '/'
+      expect(Facter).to receive(:value).with(:kernel).and_return('HP-UX')
+      allow(@mounter).to receive(:options).and_return("ro")
+      expect(@mounter).to receive(:mountcmd).with('/')
 
       @mounter.mount
     end
 
     it "should specify the filesystem name to the mount command" do
-      @mounter.stubs(:options).returns(nil)
-      @mounter.expects(:mountcmd).with { |*ary| ary[-1] == @name }
+      allow(@mounter).to receive(:options).and_return(nil)
+      expect(@mounter).to receive(:mountcmd) { |*ary| expect(ary[-1]).to eq(@name) }
 
       @mounter.mount
     end
 
     it "should update the :ensure state to :mounted if it was :unmounted before" do
-      @mounter.expects(:mountcmd)
-      @mounter.stubs(:options).returns(nil)
-      @mounter.expects(:get).with(:ensure).returns(:unmounted)
-      @mounter.expects(:set).with(:ensure => :mounted)
+      expect(@mounter).to receive(:mountcmd)
+      allow(@mounter).to receive(:options).and_return(nil)
+      expect(@mounter).to receive(:get).with(:ensure).and_return(:unmounted)
+      expect(@mounter).to receive(:set).with(:ensure => :mounted)
       @mounter.mount
     end
 
     it "should update the :ensure state to :ghost if it was :absent before" do
-      @mounter.expects(:mountcmd)
-      @mounter.stubs(:options).returns(nil)
-      @mounter.expects(:get).with(:ensure).returns(:absent)
-      @mounter.expects(:set).with(:ensure => :ghost)
+      expect(@mounter).to receive(:mountcmd)
+      allow(@mounter).to receive(:options).and_return(nil)
+      expect(@mounter).to receive(:get).with(:ensure).and_return(:absent)
+      expect(@mounter).to receive(:set).with(:ensure => :ghost)
       @mounter.mount
     end
-
   end
 
   describe Puppet::Provider::Mount, " when remounting" do
-
     context "if the resource supports remounting" do
       context "given explicit options on AIX" do
         it "should combine the options with 'remount'" do
-          @mounter.stubs(:info)
-          @mounter.stubs(:options).returns('ro')
-          @resource.stubs(:[]).with(:remounts).returns(:true)
-          Facter.expects(:value).with(:operatingsystem).returns 'AIX'
-          @mounter.expects(:mountcmd).with("-o", "ro,remount", @name)
+          allow(@mounter).to receive(:info)
+          allow(@mounter).to receive(:options).and_return('ro')
+          allow(@resource).to receive(:[]).with(:remounts).and_return(:true)
+          expect(Facter).to receive(:value).with(:operatingsystem).and_return('AIX')
+          expect(@mounter).to receive(:mountcmd).with("-o", "ro,remount", @name)
           @mounter.remount
         end
       end
 
       it "should use '-o remount'" do
-        @mounter.stubs(:info)
-        @resource.stubs(:[]).with(:remounts).returns(:true)
-        @mounter.expects(:mountcmd).with("-o", "remount", @name)
+        allow(@mounter).to receive(:info)
+        allow(@resource).to receive(:[]).with(:remounts).and_return(:true)
+        expect(@mounter).to receive(:mountcmd).with("-o", "remount", @name)
         @mounter.remount
       end
     end
 
     it "should mount with '-o update' on OpenBSD" do
-      @mounter.stubs(:info)
-      @mounter.stubs(:options)
-      @resource.stubs(:[]).with(:remounts).returns(false)
-      Facter.expects(:value).with(:operatingsystem).returns 'OpenBSD'
-      @mounter.expects(:mountcmd).with("-o", "update", @name)
+      allow(@mounter).to receive(:info)
+      allow(@mounter).to receive(:options)
+      allow(@resource).to receive(:[]).with(:remounts).and_return(false)
+      expect(Facter).to receive(:value).with(:operatingsystem).and_return('OpenBSD')
+      expect(@mounter).to receive(:mountcmd).with("-o", "update", @name)
       @mounter.remount
     end
 
     it "should unmount and mount if the resource does not specify it supports remounting" do
-      @mounter.stubs(:info)
-      @mounter.stubs(:options)
-      @resource.stubs(:[]).with(:remounts).returns(false)
-      Facter.expects(:value).with(:operatingsystem).returns 'AIX'
-      @mounter.expects(:mount)
-      @mounter.expects(:unmount)
+      allow(@mounter).to receive(:info)
+      allow(@mounter).to receive(:options)
+      allow(@resource).to receive(:[]).with(:remounts).and_return(false)
+      expect(Facter).to receive(:value).with(:operatingsystem).and_return('AIX')
+      expect(@mounter).to receive(:mount)
+      expect(@mounter).to receive(:unmount)
       @mounter.remount
     end
 
     it "should log that it is remounting" do
-      @resource.stubs(:[]).with(:remounts).returns(:true)
-      @mounter.stubs(:mountcmd)
-      @mounter.expects(:info).with("Remounting")
+      allow(@resource).to receive(:[]).with(:remounts).and_return(:true)
+      allow(@mounter).to receive(:mountcmd)
+      expect(@mounter).to receive(:info).with("Remounting")
       @mounter.remount
     end
   end
 
   describe Puppet::Provider::Mount, " when unmounting" do
-
     before :each do
-      @mounter.stubs(:get).with(:ensure).returns(:unmounted)
+      allow(@mounter).to receive(:get).with(:ensure).and_return(:unmounted)
     end
 
     it "should call the :umount command with the resource name" do
-      @mounter.expects(:umount).with(@name)
+      expect(@mounter).to receive(:umount).with(@name)
       @mounter.unmount
     end
 
     it "should update the :ensure state to :absent if it was :ghost before" do
-      @mounter.expects(:umount).with(@name).returns true
-      @mounter.expects(:get).with(:ensure).returns(:ghost)
-      @mounter.expects(:set).with(:ensure => :absent)
+      expect(@mounter).to receive(:umount).with(@name).and_return(true)
+      expect(@mounter).to receive(:get).with(:ensure).and_return(:ghost)
+      expect(@mounter).to receive(:set).with(:ensure => :absent)
       @mounter.unmount
     end
 
     it "should update the :ensure state to :unmounted if it was :mounted before" do
-      @mounter.expects(:umount).with(@name).returns true
-      @mounter.expects(:get).with(:ensure).returns(:mounted)
-      @mounter.expects(:set).with(:ensure => :unmounted)
+      expect(@mounter).to receive(:umount).with(@name).and_return(true)
+      expect(@mounter).to receive(:get).with(:ensure).and_return(:mounted)
+      expect(@mounter).to receive(:set).with(:ensure => :unmounted)
       @mounter.unmount
     end
-
   end
 
   describe Puppet::Provider::Mount, " when determining if it is mounted" do
-
     it "should query the property_hash" do
-      @mounter.expects(:get).with(:ensure).returns(:mounted)
+      expect(@mounter).to receive(:get).with(:ensure).and_return(:mounted)
       @mounter.mounted?
     end
 
     it "should return true if prefetched value is :mounted" do
-      @mounter.stubs(:get).with(:ensure).returns(:mounted)
+      allow(@mounter).to receive(:get).with(:ensure).and_return(:mounted)
       @mounter.mounted? == true
     end
 
     it "should return true if prefetched value is :ghost" do
-      @mounter.stubs(:get).with(:ensure).returns(:ghost)
+      allow(@mounter).to receive(:get).with(:ensure).and_return(:ghost)
       @mounter.mounted? == true
     end
 
     it "should return false if prefetched value is :absent" do
-      @mounter.stubs(:get).with(:ensure).returns(:absent)
+      allow(@mounter).to receive(:get).with(:ensure).and_return(:absent)
       @mounter.mounted? == false
     end
 
     it "should return false if prefetched value is :unmounted" do
-      @mounter.stubs(:get).with(:ensure).returns(:unmounted)
+      allow(@mounter).to receive(:get).with(:ensure).and_return(:unmounted)
       @mounter.mounted? == false
     end
-
   end
-
 end

data/spec/unit/provider/naginator_spec.rb

@@ -1,44 +1,43 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/provider/naginator'
 
 describe Puppet::Provider::Naginator do
   before do
-    @resource_type = stub 'resource_type', :name => :nagios_test
+    @resource_type = double('resource_type', :name => :nagios_test)
     @class = Class.new(Puppet::Provider::Naginator)
 
-    @class.stubs(:resource_type).returns @resource_type
+    allow(@class).to receive(:resource_type).and_return(@resource_type)
   end
 
   it "should be able to look up the associated Nagios type" do
-    nagios_type = mock "nagios_type"
-    nagios_type.stubs :attr_accessor
-    Nagios::Base.expects(:type).with(:test).returns nagios_type
+    nagios_type = double("nagios_type")
+    allow(nagios_type).to receive(:attr_accessor)
+    expect(Nagios::Base).to receive(:type).with(:test).and_return(nagios_type)
 
     expect(@class.nagios_type).to equal(nagios_type)
   end
 
   it "should use the Nagios type to determine whether an attribute is valid" do
-    nagios_type = mock "nagios_type"
-    nagios_type.stubs :attr_accessor
-    Nagios::Base.expects(:type).with(:test).returns nagios_type
+    nagios_type = double("nagios_type")
+    allow(nagios_type).to receive(:attr_accessor)
+    expect(Nagios::Base).to receive(:type).with(:test).and_return(nagios_type)
 
-    nagios_type.expects(:parameters).returns [:foo, :bar]
+    expect(nagios_type).to receive(:parameters).and_return([:foo, :bar])
 
     expect(@class.valid_attr?(:test, :foo)).to be_truthy
   end
 
   it "should use Naginator to parse configuration snippets" do
-    parser = mock 'parser'
-    parser.expects(:parse).with("my text").returns "my instances"
-    Nagios::Parser.expects(:new).returns(parser)
+    parser = double('parser')
+    expect(parser).to receive(:parse).with("my text").and_return("my instances")
+    expect(Nagios::Parser).to receive(:new).and_return(parser)
 
     expect(@class.parse("my text")).to eq("my instances")
   end
 
   it "should join Nagios::Base records with '\\n' when asked to convert them to text" do
-    @class.expects(:header).returns "myheader\n"
+    expect(@class).to receive(:header).and_return("myheader\n")
 
     expect(@class.to_file([:one, :two])).to eq("myheader\none\ntwo")
   end

data/spec/unit/provider/nameservice/directoryservice_spec.rb

@@ -7,8 +7,8 @@ end
 [:group].each do |type_for_this_round|
   describe Puppet::Type.type(type_for_this_round).provider(:directoryservice) do
     before do
-      @resource = stub("resource")
-      @resource.stubs(:[]).with(:name)
+      @resource = double("resource")
+      allow(@resource).to receive(:[]).with(:name)
       @provider = described_class.new(@resource)
     end
 
@@ -17,18 +17,18 @@ end
       desired = ["foo", ["quux"], "qorp"]
       group   = 'example'
 
-      @resource.stubs(:[]).with(:name).returns(group)
-      @resource.stubs(:[]).with(:auth_membership).returns(true)
+      allow(@resource).to receive(:[]).with(:name).and_return(group)
+      allow(@resource).to receive(:[]).with(:auth_membership).and_return(true)
       @provider.instance_variable_set(:@property_value_cache_hash,
                                       { :members => current })
 
       %w{bar baz}.each do |del|
-        @provider.expects(:execute).once.
+        expect(@provider).to receive(:execute).once.
           with([:dseditgroup, '-o', 'edit', '-n', '.', '-d', del, group])
       end
 
       %w{quux qorp}.each do |add|
-        @provider.expects(:execute).once.
+        expect(@provider).to receive(:execute).once.
           with([:dseditgroup, '-o', 'edit', '-n', '.', '-a', add, group])
       end
 
@@ -40,13 +40,13 @@ end
 describe Puppet::Provider::NameService::DirectoryService do
   context '.single_report' do
     it 'should use plist data' do
-      Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
-      Puppet::Provider::NameService::DirectoryService.stubs(:list_all_present).returns(
+      allow(Puppet::Provider::NameService::DirectoryService).to receive(:get_ds_path).and_return('Users')
+      allow(Puppet::Provider::NameService::DirectoryService).to receive(:list_all_present).and_return(
         ['root', 'user1', 'user2', 'resource_name']
       )
-      Puppet::Provider::NameService::DirectoryService.stubs(:generate_attribute_hash)
-      Puppet::Provider::NameService::DirectoryService.stubs(:execute)
-      Puppet::Provider::NameService::DirectoryService.expects(:parse_dscl_plist_data)
+      allow(Puppet::Provider::NameService::DirectoryService).to receive(:generate_attribute_hash)
+      allow(Puppet::Provider::NameService::DirectoryService).to receive(:execute)
+      expect(Puppet::Provider::NameService::DirectoryService).to receive(:parse_dscl_plist_data)
 
       Puppet::Provider::NameService::DirectoryService.single_report('resource_name')
     end
@@ -54,7 +54,7 @@ describe Puppet::Provider::NameService::DirectoryService do
 
   context '.get_exec_preamble' do
     it 'should use plist data' do
-      Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+      allow(Puppet::Provider::NameService::DirectoryService).to receive(:get_ds_path).and_return('Users')
 
       expect(Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list')).to include("-plist")
     end
@@ -85,9 +85,9 @@ describe Puppet::Provider::NameService::DirectoryService do
     end
 
     it 'should execute convert_binary_to_hash once when getting the password' do
-      described_class.expects(:convert_binary_to_hash).returns({'SALTED-SHA512' => pw_string})
-      Puppet::FileSystem.expects(:exist?).with(plist_path).once.returns(true)
-      Puppet::Util::Plist.expects(:read_plist_file).returns(shadow_hash_data)
+      expect(described_class).to receive(:convert_binary_to_hash).and_return({'SALTED-SHA512' => pw_string})
+      expect(Puppet::FileSystem).to receive(:exist?).with(plist_path).once.and_return(true)
+      expect(Puppet::Util::Plist).to receive(:read_plist_file).and_return(shadow_hash_data)
       described_class.get_password('uid', 'jeff')
     end
 
@@ -98,19 +98,19 @@ describe Puppet::Provider::NameService::DirectoryService do
     end
 
     it 'should convert xml-to-binary and binary-to-xml when setting the pw on >= 10.7' do
-      described_class.expects(:convert_binary_to_hash).returns({'SALTED-SHA512' => pw_string})
-      described_class.expects(:convert_hash_to_binary).returns(binary_plist)
-      Puppet::FileSystem.expects(:exist?).with(plist_path).once.returns(true)
-      Puppet::Util::Plist.expects(:read_plist_file).returns(shadow_hash_data)
-      Puppet::Util::Plist.expects(:write_plist_file).with(shadow_hash_data, plist_path, :binary)
+      expect(described_class).to receive(:convert_binary_to_hash).and_return({'SALTED-SHA512' => pw_string})
+      expect(described_class).to receive(:convert_hash_to_binary).and_return(binary_plist)
+      expect(Puppet::FileSystem).to receive(:exist?).with(plist_path).once.and_return(true)
+      expect(Puppet::Util::Plist).to receive(:read_plist_file).and_return(shadow_hash_data)
+      expect(Puppet::Util::Plist).to receive(:write_plist_file).with(shadow_hash_data, plist_path, :binary)
       described_class.set_password('jeff', 'uid', sha512_hash)
     end
 
     it '[#13686] should handle an empty ShadowHashData field in the users plist' do
-      described_class.expects(:convert_hash_to_binary).returns(binary_plist)
-      Puppet::FileSystem.expects(:exist?).with(plist_path).once.returns(true)
-      Puppet::Util::Plist.expects(:read_plist_file).returns({'ShadowHashData' => nil})
-      Puppet::Util::Plist.expects(:write_plist_file)
+      expect(described_class).to receive(:convert_hash_to_binary).and_return(binary_plist)
+      expect(Puppet::FileSystem).to receive(:exist?).with(plist_path).once.and_return(true)
+      expect(Puppet::Util::Plist).to receive(:read_plist_file).and_return({'ShadowHashData' => nil})
+      expect(Puppet::Util::Plist).to receive(:write_plist_file)
       described_class.set_password('jeff', 'uid', sha512_hash)
     end
   end
@@ -129,7 +129,7 @@ describe Puppet::Provider::NameService::DirectoryService do
     end
 
     let :stub_resource do
-      stub('resource')
+      double('resource')
     end
 
     subject do
@@ -137,21 +137,20 @@ describe Puppet::Provider::NameService::DirectoryService do
     end
 
     before :each do
-      @resource = stub("resource")
-      @resource.stubs(:[]).with(:name)
+      @resource = double("resource")
+      allow(@resource).to receive(:[]).with(:name)
       @provider = provider_class.new(@resource)
     end
 
     it 'should delete a group member if the user does not exist' do
-      stub_resource.stubs(:[]).with(:name).returns('fake_group')
-      stub_resource.stubs(:name).returns('fake_group')
-      subject.expects(:execute).with([:dseditgroup, '-o', 'edit', '-n', '.',
-                                    '-d', 'jeff',
-                                    'fake_group']).raises(Puppet::ExecutionFailure,
-                                    'it broke')
-      subject.expects(:execute).with([:dscl, '.', '-delete',
-                                    '/Groups/fake_group', 'GroupMembership',
-                                    'jeff'])
+      allow(stub_resource).to receive(:[]).with(:name).and_return('fake_group')
+      allow(stub_resource).to receive(:name).and_return('fake_group')
+      expect(subject).to receive(:execute).with([:dseditgroup, '-o', 'edit', '-n', '.',
+                                                '-d', 'jeff',
+                                                'fake_group']).and_raise(Puppet::ExecutionFailure, 'it broke')
+      expect(subject).to receive(:execute).with([:dscl, '.', '-delete',
+                                                '/Groups/fake_group', 'GroupMembership',
+                                                'jeff'])
       subject.remove_unwanted_members(group_members, user_account)
     end
   end

data/spec/unit/provider/nameservice_spec.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet/provider/nameservice'
 require 'puppet/etc'
@@ -134,7 +132,7 @@ describe Puppet::Provider::NameService do
 
   describe "#section" do
     it "should raise an error if resource_type has not been set" do
-      described_class.expects(:resource_type).returns nil
+      expect(described_class).to receive(:resource_type).and_return(nil)
       expect { described_class.section }.to raise_error Puppet::Error, 'Cannot determine Etc section without a resource type'
     end
 
@@ -153,15 +151,15 @@ describe Puppet::Provider::NameService do
 
   describe "#listbyname" do
     it "should be deprecated" do
-      Puppet.expects(:deprecation_warning).with(regexp_matches(/listbyname is deprecated/))
+      expect(Puppet).to receive(:deprecation_warning).with(/listbyname is deprecated/)
       described_class.listbyname
     end
 
     it "should return a list of users if resource_type is user" do
       described_class.resource_type = Puppet::Type.type(:user)
-      Puppet::Etc.expects(:setpwent)
-      Puppet::Etc.stubs(:getpwent).returns(*users)
-      Puppet::Etc.expects(:endpwent)
+      expect(Puppet::Etc).to receive(:setpwent)
+      allow(Puppet::Etc).to receive(:getpwent).and_return(*users)
+      expect(Puppet::Etc).to receive(:endpwent)
       expect(described_class.listbyname).to eq(%w{root foo})
     end
 
@@ -172,7 +170,7 @@ describe Puppet::Provider::NameService do
       # the same name on disk, but each name is stored on disk in a different
       # encoding
       it "should return names with invalid byte sequences replaced with '?'" do
-        Etc.stubs(:getpwent).returns(*utf_8_mixed_users)
+        allow(Etc).to receive(:getpwent).and_return(*utf_8_mixed_users)
         expect(invalid_utf_8_jose).to_not be_valid_encoding
         result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
           described_class.listbyname
@@ -181,7 +179,7 @@ describe Puppet::Provider::NameService do
       end
 
       it "should return names in their original encoding/bytes if they would not be valid UTF-8" do
-        Etc.stubs(:getpwent).returns(*latin_1_mixed_users)
+        allow(Etc).to receive(:getpwent).and_return(*latin_1_mixed_users)
         result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
           described_class.listbyname
         end
@@ -191,18 +189,18 @@ describe Puppet::Provider::NameService do
 
     it "should return a list of groups if resource_type is group", :unless => Puppet.features.microsoft_windows? do
       described_class.resource_type = Puppet::Type.type(:group)
-      Puppet::Etc.expects(:setgrent)
-      Puppet::Etc.stubs(:getgrent).returns(*groups)
-      Puppet::Etc.expects(:endgrent)
+      expect(Puppet::Etc).to receive(:setgrent)
+      allow(Puppet::Etc).to receive(:getgrent).and_return(*groups)
+      expect(Puppet::Etc).to receive(:endgrent)
       expect(described_class.listbyname).to eq(%w{root bin})
     end
 
     it "should yield if a block given" do
       yield_results = []
       described_class.resource_type = Puppet::Type.type(:user)
-      Puppet::Etc.expects(:setpwent)
-      Puppet::Etc.stubs(:getpwent).returns(*users)
-      Puppet::Etc.expects(:endpwent)
+      expect(Puppet::Etc).to receive(:setpwent)
+      allow(Puppet::Etc).to receive(:getpwent).and_return(*users)
+      expect(Puppet::Etc).to receive(:endpwent)
       described_class.listbyname {|x| yield_results << x }
       expect(yield_results).to eq(%w{root foo})
     end
@@ -213,7 +211,7 @@ describe Puppet::Provider::NameService do
       # These two tests simulate an environment where there are two users with
       # the same name on disk, but each name is stored on disk in a different
       # encoding
-      Etc.stubs(:getpwent).returns(*utf_8_mixed_users)
+      allow(Etc).to receive(:getpwent).and_return(*utf_8_mixed_users)
       result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
         described_class.instances
       end
@@ -228,7 +226,7 @@ describe Puppet::Provider::NameService do
     end
 
     it "should have object names in their original encoding/bytes if they would not be valid UTF-8" do
-      Etc.stubs(:getpwent).returns(*latin_1_mixed_users)
+      allow(Etc).to receive(:getpwent).and_return(*latin_1_mixed_users)
       result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
         described_class.instances
       end
@@ -244,8 +242,8 @@ describe Puppet::Provider::NameService do
 
     it "should pass the Puppet::Etc :canonical_name Struct member to the constructor" do
       users = [ Struct::Passwd.new(invalid_utf_8_jose, invalid_utf_8_jose, 1002, 2000), nil ]
-      Etc.stubs(:getpwent).returns(*users)
-      described_class.expects(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
+      allow(Etc).to receive(:getpwent).and_return(*users)
+      expect(described_class).to receive(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
       described_class.instances
     end
   end
@@ -278,19 +276,19 @@ describe Puppet::Provider::NameService do
   describe "getinfo" do
     before :each do
       # with section=foo we'll call Etc.getfoonam instead of getpwnam or getgrnam
-      described_class.stubs(:section).returns 'foo'
+      allow(described_class).to receive(:section).and_return('foo')
       resource # initialize the resource so our provider has a @resource instance variable
     end
 
     it "should return a hash if we can retrieve something" do
-      Puppet::Etc.expects(:send).with(:getfoonam, 'bob').returns fakeetcobject
-      provider.expects(:info2hash).with(fakeetcobject).returns(:foo => 'fooval', :bar => 'barval')
+      expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'bob').and_return(fakeetcobject)
+      expect(provider).to receive(:info2hash).with(fakeetcobject).and_return(:foo => 'fooval', :bar => 'barval')
       expect(provider.getinfo(true)).to eq({:foo => 'fooval', :bar => 'barval'})
     end
 
     it "should return nil if we cannot retrieve anything" do
-      Puppet::Etc.expects(:send).with(:getfoonam, 'bob').raises(ArgumentError, "can't find bob")
-      provider.expects(:info2hash).never
+      expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'bob').and_raise(ArgumentError, "can't find bob")
+      expect(provider).not_to receive(:info2hash)
       expect(provider.getinfo(true)).to be_nil
     end
 
@@ -299,13 +297,13 @@ describe Puppet::Provider::NameService do
     # again if needed
     it "should use the instance's @canonical_name to query the system" do
       provider_instance = described_class.new(:name => 'foo', :canonical_name => 'original_foo', :ensure => :present)
-      Puppet::Etc.expects(:send).with(:getfoonam, 'original_foo')
+      expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'original_foo')
       provider_instance.getinfo(true)
     end
 
     it "should use the instance's name instead of canonical_name if not supplied during instantiation" do
       provider_instance = described_class.new(:name => 'foo', :ensure => :present)
-      Puppet::Etc.expects(:send).with(:getfoonam, 'foo')
+      expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'foo')
       provider_instance.getinfo(true)
     end
   end
@@ -319,9 +317,9 @@ describe Puppet::Provider::NameService do
       # expect two method invocations because info2hash calls the method
       # twice if the Struct responds to the propertyname (our fake Struct
       # provides values for :foo and :bar) TODO: Fix that
-      provider.expects(:posixmethod).with(:foo).returns(:foo).twice
-      provider.expects(:posixmethod).with(:bar).returns(:bar).twice
-      provider.expects(:posixmethod).with(:ensure).returns :ensure
+      expect(provider).to receive(:posixmethod).with(:foo).and_return(:foo).twice
+      expect(provider).to receive(:posixmethod).with(:bar).and_return(:bar).twice
+      expect(provider).to receive(:posixmethod).with(:ensure).and_return(:ensure)
       expect(provider.info2hash(fakeetcobject)).to eq({ :foo => 'fooval', :bar => 'barval' })
     end
   end
@@ -351,11 +349,11 @@ describe Puppet::Provider::NameService do
 
   describe "exists?" do
     it "should return true if we can retrieve anything" do
-      provider.expects(:getinfo).with(true).returns(:foo => 'fooval', :bar => 'barval')
+      expect(provider).to receive(:getinfo).with(true).and_return(:foo => 'fooval', :bar => 'barval')
       expect(provider).to be_exists
     end
     it "should return false if we cannot retrieve anything" do
-      provider.expects(:getinfo).with(true).returns nil
+      expect(provider).to receive(:getinfo).with(true).and_return(nil)
       expect(provider).not_to be_exists
     end
   end
@@ -364,18 +362,18 @@ describe Puppet::Provider::NameService do
     before(:each) {described_class.resource_type = faketype }
 
     it "should return the correct getinfo value" do
-      provider.expects(:getinfo).with(false).returns(:foo => 'fooval', :bar => 'barval')
+      expect(provider).to receive(:getinfo).with(false).and_return(:foo => 'fooval', :bar => 'barval')
       expect(provider.get(:bar)).to eq('barval')
     end
 
     it "should unmunge the value first" do
       described_class.options(:bar, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
-      provider.expects(:getinfo).with(false).returns(:foo => 200, :bar => 500)
+      expect(provider).to receive(:getinfo).with(false).and_return(:foo => 200, :bar => 500)
       expect(provider.get(:bar)).to eq(250)
     end
 
     it "should return nil if getinfo cannot retrieve the value" do
-      provider.expects(:getinfo).with(false).returns(:foo => 'fooval', :bar => 'barval')
+      expect(provider).to receive(:getinfo).with(false).and_return(:foo => 'fooval', :bar => 'barval')
       expect(provider.get(:no_such_key)).to be_nil
     end
 
@@ -392,21 +390,21 @@ describe Puppet::Provider::NameService do
     end
 
     it "should execute the modify command on valid values" do
-      provider.expects(:modifycmd).with(:foo, 100).returns ['/bin/modify', '-f', '100' ]
-      provider.expects(:execute).with(['/bin/modify', '-f', '100'], has_entry(:custom_environment, {}))
+      expect(provider).to receive(:modifycmd).with(:foo, 100).and_return(['/bin/modify', '-f', '100' ])
+      expect(provider).to receive(:execute).with(['/bin/modify', '-f', '100'], hash_including(custom_environment: {}))
       provider.set(:foo, 100)
     end
 
     it "should munge the value first" do
       described_class.options(:foo, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
-      provider.expects(:modifycmd).with(:foo, 200).returns(['/bin/modify', '-f', '200' ])
-      provider.expects(:execute).with(['/bin/modify', '-f', '200'], has_entry(:custom_environment, {}))
+      expect(provider).to receive(:modifycmd).with(:foo, 200).and_return(['/bin/modify', '-f', '200' ])
+      expect(provider).to receive(:execute).with(['/bin/modify', '-f', '200'], hash_including(custom_environment: {}))
       provider.set(:foo, 100)
     end
 
     it "should fail if the modify command fails" do
-      provider.expects(:modifycmd).with(:foo, 100).returns(['/bin/modify', '-f', '100' ])
-      provider.expects(:execute).with(['/bin/modify', '-f', '100'], kind_of(Hash)).raises(Puppet::ExecutionFailure, "Execution of '/bin/modify' returned 1: some_failure")
+      expect(provider).to receive(:modifycmd).with(:foo, 100).and_return(['/bin/modify', '-f', '100' ])
+      expect(provider).to receive(:execute).with(['/bin/modify', '-f', '100'], kind_of(Hash)).and_raise(Puppet::ExecutionFailure, "Execution of '/bin/modify' returned 1: some_failure")
       expect { provider.set(:foo, 100) }.to raise_error Puppet::Error, /Could not set foo/
     end
   end