puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 module Puppet::Util::Plist
@@ -5,11 +6,13 @@ end
 
 # We use this as a reasonable way to obtain all the support infrastructure.
 [:group].each do |type_for_this_round|
-  describe Puppet::Type.type(type_for_this_round).provider(:directoryservice) do
+  provider_class = Puppet::Type.type(type_for_this_round).provider(:directoryservice)
+
+  describe provider_class do
     before do
-      @resource = double("resource")
-      allow(@resource).to receive(:[]).with(:name)
-      @provider = described_class.new(@resource)
+      @resource = stub("resource")
+      @resource.stubs(:[]).with(:name)
+      @provider = provider_class.new(@resource)
     end
 
     it "[#6009] should handle nested arrays of members" do
@@ -17,18 +20,18 @@ end
       desired = ["foo", ["quux"], "qorp"]
       group   = 'example'
 
-      allow(@resource).to receive(:[]).with(:name).and_return(group)
-      allow(@resource).to receive(:[]).with(:auth_membership).and_return(true)
+      @resource.stubs(:[]).with(:name).returns(group)
+      @resource.stubs(:[]).with(:auth_membership).returns(true)
       @provider.instance_variable_set(:@property_value_cache_hash,
                                       { :members => current })
 
       %w{bar baz}.each do |del|
-        expect(@provider).to receive(:execute).once.
+        @provider.expects(:execute).once.
           with([:dseditgroup, '-o', 'edit', '-n', '.', '-d', del, group])
       end
 
       %w{quux qorp}.each do |add|
-        expect(@provider).to receive(:execute).once.
+        @provider.expects(:execute).once.
           with([:dseditgroup, '-o', 'edit', '-n', '.', '-a', add, group])
       end
 
@@ -37,121 +40,125 @@ end
   end
 end
 
-describe Puppet::Provider::NameService::DirectoryService do
-  context '.single_report' do
-    it 'should use plist data' do
-      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']
-      )
-      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
+describe 'DirectoryService.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(
+      ['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)
+
+    Puppet::Provider::NameService::DirectoryService.single_report('resource_name')
   end
+end
 
-  context '.get_exec_preamble' do
-    it 'should use plist data' do
-      allow(Puppet::Provider::NameService::DirectoryService).to receive(:get_ds_path).and_return('Users')
+describe 'DirectoryService.get_exec_preamble' do
+  it 'should use plist data' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
 
-      expect(Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list')).to include("-plist")
-    end
+    expect(Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list')).to include("-plist")
   end
+end
 
-  context 'password behavior' do
-    # The below is a binary plist containing a ShadowHashData key which CONTAINS
-    # another binary plist. The nested binary plist contains a 'SALTED-SHA512'
-    # key that contains a base64 encoded salted-SHA512 password hash...
-    let (:binary_plist) { "bplist00\324\001\002\003\004\005\006\a\bXCRAM-MD5RNT]SALTED-SHA512[RECOVERABLEO\020 \231k2\3360\200GI\201\355J\216\202\215y\243\001\206J\300\363\032\031\022\006\2359\024\257\217<\361O\020\020F\353\at\377\277\226\276c\306\254\031\037J(\235O\020D\335\006{\3744g@\377z\204\322\r\332t\021\330\n\003\246K\223\356\034!P\261\305t\035\346\352p\206\003n\247MMA\310\301Z<\366\246\023\0161W3\340\357\000\317T\t\301\311+\204\246L7\276\370\320*\245O\021\002\000k\024\221\270x\353\001\237\346D}\377?\265]\356+\243\v[\350\316a\340h\376<\322\266\327\016\306n\272r\t\212A\253L\216\214\205\016\241 [\360/\335\002#\\A\372\241a\261\346\346\\\251\330\312\365\016\n\341\017\016\225&;\322\\\004*\ru\316\372\a \362?8\031\247\231\030\030\267\315\023\v\343{@\227\301s\372h\212\000a\244&\231\366\nt\277\2036,\027bZ+\223W\212g\333`\264\331N\306\307\362\257(^~ b\262\247&\231\261t\341\231%\244\247\203eOt\365\271\201\273\330\350\363C^A\327F\214!\217hgf\e\320k\260n\315u~\336\371M\t\235k\230S\375\311\303\240\351\037d\273\321y\335=K\016`_\317\230\2612_\023K\036\350\v\232\323Y\310\317_\035\227%\237\v\340\023\016\243\233\025\306:\227\351\370\364x\234\231\266\367\016w\275\333-\351\210}\375x\034\262\272kRuHa\362T/F!\347B\231O`K\304\037'k$$\245h)e\363\365mT\b\317\\2\361\026\351\254\375Jl1~\r\371\267\352\2322I\341\272\376\243^Un\266E7\230[VocUJ\220N\2116D/\025f=\213\314\325\vG}\311\360\377DT\307m\261&\263\340\272\243_\020\271rG^BW\210\030l\344\0324\335\233\300\023\272\225Im\330\n\227*Yv[\006\315\330y'\a\321\373\273A\240\305F{S\246I#/\355\2425\031\031GGF\270y\n\331\004\023G@\331\000\361\343\350\264$\032\355_\210y\000\205\342\375\212q\024\004\026W:\205 \363v?\035\270L-\270=\022\323\2003\v\336\277\t\237\356\374\n\267n\003\367\342\330;\371S\326\016`B6@Njm>\240\021%\336\345\002(P\204Yn\3279l\0228\264\254\304\2528t\372h\217\347sA\314\345\245\337)]\000\b\000\021\000\032\000\035\000+\0007\000Z\000m\000\264\000\000\000\000\000\000\002\001\000\000\000\000\000\000\000\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\270" }
+describe 'DirectoryService password behavior' do
+  # The below is a binary plist containing a ShadowHashData key which CONTAINS
+  # another binary plist. The nested binary plist contains a 'SALTED-SHA512'
+  # key that contains a base64 encoded salted-SHA512 password hash...
+  let (:binary_plist) { "bplist00\324\001\002\003\004\005\006\a\bXCRAM-MD5RNT]SALTED-SHA512[RECOVERABLEO\020 \231k2\3360\200GI\201\355J\216\202\215y\243\001\206J\300\363\032\031\022\006\2359\024\257\217<\361O\020\020F\353\at\377\277\226\276c\306\254\031\037J(\235O\020D\335\006{\3744g@\377z\204\322\r\332t\021\330\n\003\246K\223\356\034!P\261\305t\035\346\352p\206\003n\247MMA\310\301Z<\366\246\023\0161W3\340\357\000\317T\t\301\311+\204\246L7\276\370\320*\245O\021\002\000k\024\221\270x\353\001\237\346D}\377?\265]\356+\243\v[\350\316a\340h\376<\322\266\327\016\306n\272r\t\212A\253L\216\214\205\016\241 [\360/\335\002#\\A\372\241a\261\346\346\\\251\330\312\365\016\n\341\017\016\225&;\322\\\004*\ru\316\372\a \362?8\031\247\231\030\030\267\315\023\v\343{@\227\301s\372h\212\000a\244&\231\366\nt\277\2036,\027bZ+\223W\212g\333`\264\331N\306\307\362\257(^~ b\262\247&\231\261t\341\231%\244\247\203eOt\365\271\201\273\330\350\363C^A\327F\214!\217hgf\e\320k\260n\315u~\336\371M\t\235k\230S\375\311\303\240\351\037d\273\321y\335=K\016`_\317\230\2612_\023K\036\350\v\232\323Y\310\317_\035\227%\237\v\340\023\016\243\233\025\306:\227\351\370\364x\234\231\266\367\016w\275\333-\351\210}\375x\034\262\272kRuHa\362T/F!\347B\231O`K\304\037'k$$\245h)e\363\365mT\b\317\\2\361\026\351\254\375Jl1~\r\371\267\352\2322I\341\272\376\243^Un\266E7\230[VocUJ\220N\2116D/\025f=\213\314\325\vG}\311\360\377DT\307m\261&\263\340\272\243_\020\271rG^BW\210\030l\344\0324\335\233\300\023\272\225Im\330\n\227*Yv[\006\315\330y'\a\321\373\273A\240\305F{S\246I#/\355\2425\031\031GGF\270y\n\331\004\023G@\331\000\361\343\350\264$\032\355_\210y\000\205\342\375\212q\024\004\026W:\205 \363v?\035\270L-\270=\022\323\2003\v\336\277\t\237\356\374\n\267n\003\367\342\330;\371S\326\016`B6@Njm>\240\021%\336\345\002(P\204Yn\3279l\0228\264\254\304\2528t\372h\217\347sA\314\345\245\337)]\000\b\000\021\000\032\000\035\000+\0007\000Z\000m\000\264\000\000\000\000\000\000\002\001\000\000\000\000\000\000\000\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\270" }
 
-    # The below is a base64 encoded salted-SHA512 password hash.
-    let (:pw_string) { "\335\006{\3744g@\377z\204\322\r\332t\021\330\n\003\246K\223\356\034!P\261\305t\035\346\352p\206\003n\247MMA\310\301Z<\366\246\023\0161W3\340\357\000\317T\t\301\311+\204\246L7\276\370\320*\245" }
+  # The below is a base64 encoded salted-SHA512 password hash.
+  let (:pw_string) { "\335\006{\3744g@\377z\204\322\r\332t\021\330\n\003\246K\223\356\034!P\261\305t\035\346\352p\206\003n\247MMA\310\301Z<\366\246\023\0161W3\340\357\000\317T\t\301\311+\204\246L7\276\370\320*\245" }
 
-    # The below is a salted-SHA512 password hash in hex.
-    let (:sha512_hash) { 'dd067bfc346740ff7a84d20dda7411d80a03a64b93ee1c2150b1c5741de6ea7086036ea74d4d41c8c15a3cf6a6130e315733e0ef00cf5409c1c92b84a64c37bef8d02aa5' }
+  # The below is a salted-SHA512 password hash in hex.
+  let (:sha512_hash) { 'dd067bfc346740ff7a84d20dda7411d80a03a64b93ee1c2150b1c5741de6ea7086036ea74d4d41c8c15a3cf6a6130e315733e0ef00cf5409c1c92b84a64c37bef8d02aa5' }
 
-    let :plist_path do
-      '/var/db/dslocal/nodes/Default/users/jeff.plist'
-    end
+  let :plist_path do
+    '/var/db/dslocal/nodes/Default/users/jeff.plist'
+  end
 
-    let :ds_provider do
-      described_class
-    end
+  let :ds_provider do
+    Puppet::Provider::NameService::DirectoryService
+  end
 
-    let :shadow_hash_data do
-      {'ShadowHashData' => [binary_plist]}
-    end
+  let :shadow_hash_data do
+    {'ShadowHashData' => [binary_plist]}
+  end
 
-    it 'should execute convert_binary_to_hash once when getting the password' do
-      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
+  subject do
+    Puppet::Provider::NameService::DirectoryService
+  end
 
-    it 'should fail if a salted-SHA512 password hash is not passed in' do
-      expect {
-        described_class.set_password('jeff', 'uid', 'badpassword')
-      }.to raise_error(RuntimeError, /OS X 10.7 requires a Salted SHA512 hash password of 136 characters./)
-    end
+  it 'should execute convert_binary_to_hash once when getting the password' do
+    subject.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)
+    subject.get_password('uid', 'jeff')
+  end
 
-    it 'should convert xml-to-binary and binary-to-xml when setting the pw on >= 10.7' do
-      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 'should fail if a salted-SHA512 password hash is not passed in' do
+    expect {
+      subject.set_password('jeff', 'uid', 'badpassword')
+    }.to raise_error(RuntimeError, /OS X 10.7 requires a Salted SHA512 hash password of 136 characters./)
+  end
 
-    it '[#13686] should handle an empty ShadowHashData field in the users plist' do
-      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
+  it 'should convert xml-to-binary and binary-to-xml when setting the pw on >= 10.7' do
+    subject.expects(:convert_binary_to_hash).returns({'SALTED-SHA512' => pw_string})
+    subject.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)
+    subject.set_password('jeff', 'uid', sha512_hash)
   end
 
-  context '(#4855) directoryservice group resource failure' do
-    let :provider_class do
-      Puppet::Type.type(:group).provider(:directoryservice)
-    end
+  it '[#13686] should handle an empty ShadowHashData field in the users plist' do
+    subject.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)
+    subject.set_password('jeff', 'uid', sha512_hash)
+  end
+end
 
-    let :group_members do
-      ['root','jeff']
-    end
+describe '(#4855) directoryservice group resource failure' do
+  let :provider_class do
+    Puppet::Type.type(:group).provider(:directoryservice)
+  end
 
-    let :user_account do
-      ['root']
-    end
+  let :group_members do
+    ['root','jeff']
+  end
 
-    let :stub_resource do
-      double('resource')
-    end
+  let :user_account do
+    ['root']
+  end
 
-    subject do
-      provider_class.new(stub_resource)
-    end
+  let :stub_resource do
+    stub('resource')
+  end
 
-    before :each do
-      @resource = double("resource")
-      allow(@resource).to receive(:[]).with(:name)
-      @provider = provider_class.new(@resource)
-    end
+  subject do
+    provider_class.new(stub_resource)
+  end
 
-    it 'should delete a group member if the user does not exist' do
-      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
+  before :each do
+    @resource = stub("resource")
+    @resource.stubs(:[]).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'])
+    subject.remove_unwanted_members(group_members, user_account)
   end
 end
+

data/spec/unit/provider/nameservice_spec.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 require 'puppet/provider/nameservice'
 require 'puppet/etc'
@@ -132,7 +134,7 @@ describe Puppet::Provider::NameService do
 
   describe "#section" do
     it "should raise an error if resource_type has not been set" do
-      expect(described_class).to receive(:resource_type).and_return(nil)
+      described_class.expects(:resource_type).returns nil
       expect { described_class.section }.to raise_error Puppet::Error, 'Cannot determine Etc section without a resource type'
     end
 
@@ -151,15 +153,15 @@ describe Puppet::Provider::NameService do
 
   describe "#listbyname" do
     it "should be deprecated" do
-      expect(Puppet).to receive(:deprecation_warning).with(/listbyname is deprecated/)
+      Puppet.expects(:deprecation_warning).with(regexp_matches(/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)
-      expect(Puppet::Etc).to receive(:setpwent)
-      allow(Puppet::Etc).to receive(:getpwent).and_return(*users)
-      expect(Puppet::Etc).to receive(:endpwent)
+      Puppet::Etc.expects(:setpwent)
+      Puppet::Etc.stubs(:getpwent).returns(*users)
+      Puppet::Etc.expects(:endpwent)
       expect(described_class.listbyname).to eq(%w{root foo})
     end
 
@@ -170,7 +172,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
-        allow(Etc).to receive(:getpwent).and_return(*utf_8_mixed_users)
+        Etc.stubs(:getpwent).returns(*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
@@ -179,7 +181,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
-        allow(Etc).to receive(:getpwent).and_return(*latin_1_mixed_users)
+        Etc.stubs(:getpwent).returns(*latin_1_mixed_users)
         result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
           described_class.listbyname
         end
@@ -187,20 +189,20 @@ describe Puppet::Provider::NameService do
       end
     end
 
-    it "should return a list of groups if resource_type is group", :unless => Puppet.features.microsoft_windows? do
+    it "should return a list of groups if resource_type is group", :unless => Puppet::Util::Platform.windows? do
       described_class.resource_type = Puppet::Type.type(:group)
-      expect(Puppet::Etc).to receive(:setgrent)
-      allow(Puppet::Etc).to receive(:getgrent).and_return(*groups)
-      expect(Puppet::Etc).to receive(:endgrent)
+      Puppet::Etc.expects(:setgrent)
+      Puppet::Etc.stubs(:getgrent).returns(*groups)
+      Puppet::Etc.expects(: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)
-      expect(Puppet::Etc).to receive(:setpwent)
-      allow(Puppet::Etc).to receive(:getpwent).and_return(*users)
-      expect(Puppet::Etc).to receive(:endpwent)
+      Puppet::Etc.expects(:setpwent)
+      Puppet::Etc.stubs(:getpwent).returns(*users)
+      Puppet::Etc.expects(:endpwent)
       described_class.listbyname {|x| yield_results << x }
       expect(yield_results).to eq(%w{root foo})
     end
@@ -211,7 +213,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
-      allow(Etc).to receive(:getpwent).and_return(*utf_8_mixed_users)
+      Etc.stubs(:getpwent).returns(*utf_8_mixed_users)
       result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
         described_class.instances
       end
@@ -226,7 +228,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
-      allow(Etc).to receive(:getpwent).and_return(*latin_1_mixed_users)
+      Etc.stubs(:getpwent).returns(*latin_1_mixed_users)
       result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
         described_class.instances
       end
@@ -242,8 +244,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 ]
-      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)
+      Etc.stubs(:getpwent).returns(*users)
+      described_class.expects(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
       described_class.instances
     end
   end
@@ -276,19 +278,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
-      allow(described_class).to receive(:section).and_return('foo')
+      described_class.stubs(:section).returns '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
-      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')
+      Puppet::Etc.expects(:send).with(:getfoonam, 'bob').returns fakeetcobject
+      provider.expects(:info2hash).with(fakeetcobject).returns(: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
-      expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'bob').and_raise(ArgumentError, "can't find bob")
-      expect(provider).not_to receive(:info2hash)
+      Puppet::Etc.expects(:send).with(:getfoonam, 'bob').raises(ArgumentError, "can't find bob")
+      provider.expects(:info2hash).never
       expect(provider.getinfo(true)).to be_nil
     end
 
@@ -297,13 +299,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)
-      expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'original_foo')
+      Puppet::Etc.expects(: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)
-      expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'foo')
+      Puppet::Etc.expects(:send).with(:getfoonam, 'foo')
       provider_instance.getinfo(true)
     end
   end
@@ -317,9 +319,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
-      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)
+      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.info2hash(fakeetcobject)).to eq({ :foo => 'fooval', :bar => 'barval' })
     end
   end
@@ -349,11 +351,11 @@ describe Puppet::Provider::NameService do
 
   describe "exists?" do
     it "should return true if we can retrieve anything" do
-      expect(provider).to receive(:getinfo).with(true).and_return(:foo => 'fooval', :bar => 'barval')
+      provider.expects(:getinfo).with(true).returns(:foo => 'fooval', :bar => 'barval')
       expect(provider).to be_exists
     end
     it "should return false if we cannot retrieve anything" do
-      expect(provider).to receive(:getinfo).with(true).and_return(nil)
+      provider.expects(:getinfo).with(true).returns nil
       expect(provider).not_to be_exists
     end
   end
@@ -362,18 +364,18 @@ describe Puppet::Provider::NameService do
     before(:each) {described_class.resource_type = faketype }
 
     it "should return the correct getinfo value" do
-      expect(provider).to receive(:getinfo).with(false).and_return(:foo => 'fooval', :bar => 'barval')
+      provider.expects(:getinfo).with(false).returns(: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})
-      expect(provider).to receive(:getinfo).with(false).and_return(:foo => 200, :bar => 500)
+      provider.expects(:getinfo).with(false).returns(:foo => 200, :bar => 500)
       expect(provider.get(:bar)).to eq(250)
     end
 
     it "should return nil if getinfo cannot retrieve the value" do
-      expect(provider).to receive(:getinfo).with(false).and_return(:foo => 'fooval', :bar => 'barval')
+      provider.expects(:getinfo).with(false).returns(:foo => 'fooval', :bar => 'barval')
       expect(provider.get(:no_such_key)).to be_nil
     end
 
@@ -390,21 +392,21 @@ describe Puppet::Provider::NameService do
     end
 
     it "should execute the modify command on valid values" do
-      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.expects(:modifycmd).with(:foo, 100).returns ['/bin/modify', '-f', '100' ]
+      provider.expects(:execute).with(['/bin/modify', '-f', '100'], has_entry(: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})
-      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.expects(:modifycmd).with(:foo, 200).returns(['/bin/modify', '-f', '200' ])
+      provider.expects(:execute).with(['/bin/modify', '-f', '200'], has_entry(:custom_environment, {}))
       provider.set(:foo, 100)
     end
 
     it "should fail if the modify command fails" do
-      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")
+      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.set(:foo, 100) }.to raise_error Puppet::Error, /Could not set foo/
     end
   end