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

data/spec/unit/provider/user/pw_spec.rb

@@ -1,113 +1,96 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
-require 'open3'
 
-RSpec::Matchers.define_negated_matcher :excluding, :include
+provider_class = Puppet::Type.type(:user).provider(:pw)
 
-describe Puppet::Type.type(:user).provider(:pw) do
+describe provider_class do
   let :resource do
     Puppet::Type.type(:user).new(:name => "testuser", :provider => :pw)
   end
 
-  context "when creating users" do
+  describe "when creating users" do
     let :provider do
       prov = resource.provider
-      expect(prov).to receive(:exists?).and_return(nil)
+      prov.expects(:exists?).returns nil
       prov
     end
 
     it "should run pw with no additional flags when no properties are given" do
-      expect(provider.addcmd).to eq([described_class.command(:pw), "useradd", "testuser"])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "useradd", "testuser"], kind_of(Hash))
+      expect(provider.addcmd).to eq([provider_class.command(:pw), "useradd", "testuser"])
+      provider.expects(:execute).with([provider_class.command(:pw), "useradd", "testuser"], kind_of(Hash))
       provider.create
     end
 
     it "should use -o when allowdupe is enabled" do
       resource[:allowdupe] = true
-      expect(provider).to receive(:execute).with(include("-o"), kind_of(Hash))
+      provider.expects(:execute).with(includes("-o"), kind_of(Hash))
       provider.create
     end
 
     it "should use -c with the correct argument when the comment property is set" do
       resource[:comment] = "Testuser Name"
-      expect(provider).to receive(:execute).with(include("-c").and(include("Testuser Name")), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-c"), includes("Testuser Name")), kind_of(Hash))
       provider.create
     end
 
     it "should use -e with the correct argument when the expiry property is set" do
       resource[:expiry] = "2010-02-19"
-      expect(provider).to receive(:execute).with(include("-e").and(include("19-02-2010")), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-e"), includes("19-02-2010")), kind_of(Hash))
       provider.create
     end
 
     it "should use -e 00-00-0000 if the expiry property has to be removed" do
       resource[:expiry] = :absent
-      expect(provider).to receive(:execute).with(include("-e").and(include("00-00-0000")), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-e"), includes("00-00-0000")), kind_of(Hash))
       provider.create
     end
 
     it "should use -g with the correct argument when the gid property is set" do
       resource[:gid] = 12345
-      expect(provider).to receive(:execute).with(include("-g").and(include(12345)), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-g"), includes(12345)), kind_of(Hash))
       provider.create
     end
 
     it "should use -G with the correct argument when the groups property is set" do
       resource[:groups] = "group1"
-      expect(provider).to receive(:execute).with(include("-G").and(include("group1")), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-G"), includes("group1")), kind_of(Hash))
       provider.create
     end
 
     it "should use -G with all the given groups when the groups property is set to an array" do
       resource[:groups] = ["group1", "group2"]
-      expect(provider).to receive(:execute).with(include("-G").and(include("group1,group2")), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-G"), includes("group1,group2")), kind_of(Hash))
       provider.create
     end
 
     it "should use -d with the correct argument when the home property is set" do
       resource[:home] = "/home/testuser"
-      expect(provider).to receive(:execute).with(include("-d").and(include("/home/testuser")), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-d"), includes("/home/testuser")), kind_of(Hash))
       provider.create
     end
 
     it "should use -m when the managehome property is enabled" do
       resource[:managehome] = true
-      expect(provider).to receive(:execute).with(include("-m"), kind_of(Hash))
+      provider.expects(:execute).with(includes("-m"), kind_of(Hash))
       provider.create
     end
 
     it "should call the password set function with the correct argument when the password property is set" do
       resource[:password] = "*"
-      expect(provider).to receive(:execute)
-      expect(provider).to receive(:password=).with("*")
-      provider.create
-    end
-
-    it "should call execute with sensitive true when the password property is set" do
-      Puppet::Util::Log.level = :debug
-      resource[:password] = "abc123"
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: true))
-      popen = double("popen", :puts => nil, :close => nil)
-      expect(Open3).to receive(:popen3).and_return(popen)
-      expect(popen).to receive(:puts).with("abc123")
-      provider.create
-      expect(@logs).not_to be_any {|log| log.level == :debug and log.message =~ /abc123/}
-    end
-
-    it "should call execute with sensitive false when a non-sensitive property is set" do
-      resource[:managehome] = true
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: false))
+      provider.expects(:execute)
+      provider.expects(:password=).with("*")
       provider.create
     end
 
     it "should use -s with the correct argument when the shell property is set" do
       resource[:shell] = "/bin/sh"
-      expect(provider).to receive(:execute).with(include("-s").and(include("/bin/sh")), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-s"), includes("/bin/sh")), kind_of(Hash))
       provider.create
     end
 
     it "should use -u with the correct argument when the uid property is set" do
       resource[:uid] = 12345
-      expect(provider).to receive(:execute).with(include("-u").and(include(12345)), kind_of(Hash))
+      provider.expects(:execute).with(all_of(includes("-u"), includes(12345)), kind_of(Hash))
       provider.create
     end
 
@@ -115,18 +98,18 @@ describe Puppet::Type.type(:user).provider(:pw) do
     it "should not use -p when a password is given" do
       resource[:password] = "*"
       expect(provider.addcmd).not_to include("-p")
-      expect(provider).to receive(:password=)
-      expect(provider).to receive(:execute).with(excluding("-p"), kind_of(Hash))
+      provider.expects(:password=)
+      provider.expects(:execute).with(Not(includes("-p")), kind_of(Hash))
       provider.create
     end
   end
 
-  context "when deleting users" do
+  describe "when deleting users" do
     it "should run pw with no additional flags" do
       provider = resource.provider
-      expect(provider).to receive(:exists?).and_return(true)
-      expect(provider.deletecmd).to eq([described_class.command(:pw), "userdel", "testuser"])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "userdel", "testuser"], hash_including(custom_environment: {}))
+      provider.expects(:exists?).returns true
+      expect(provider.deletecmd).to eq([provider_class.command(:pw), "userdel", "testuser"])
+      provider.expects(:execute).with([provider_class.command(:pw), "userdel", "testuser"], has_entry(:custom_environment, {}))
       provider.delete
     end
 
@@ -135,116 +118,97 @@ describe Puppet::Type.type(:user).provider(:pw) do
     # have an explicit test.
     it "should not use -r when managehome is not set" do
       provider = resource.provider
-      expect(provider).to receive(:exists?).and_return(true)
+      provider.expects(:exists?).returns true
       resource[:managehome] = false
-      expect(provider).to receive(:execute).with(excluding("-r"), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(Not(includes("-r")), has_entry(:custom_environment, {}))
       provider.delete
     end
 
     it "should use -r when managehome is set" do
       provider = resource.provider
-      expect(provider).to receive(:exists?).and_return(true)
+      provider.expects(:exists?).returns true
       resource[:managehome] = true
-      expect(provider).to receive(:execute).with(include("-r"), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(includes("-r"), has_entry(:custom_environment, {}))
       provider.delete
     end
   end
 
-  context "when modifying users" do
+  describe "when modifying users" do
     let :provider do
       resource.provider
     end
 
     it "should run pw with the correct arguments" do
-      expect(provider.modifycmd("uid", 12345)).to eq([described_class.command(:pw), "usermod", "testuser", "-u", 12345])
-      expect(provider).to receive(:execute).with([described_class.command(:pw), "usermod", "testuser", "-u", 12345], hash_including(custom_environment: {}))
+      expect(provider.modifycmd("uid", 12345)).to eq([provider_class.command(:pw), "usermod", "testuser", "-u", 12345])
+      provider.expects(:execute).with([provider_class.command(:pw), "usermod", "testuser", "-u", 12345], has_entry(:custom_environment, {}))
       provider.uid = 12345
     end
 
     it "should use -c with the correct argument when the comment property is changed" do
       resource[:comment] = "Testuser Name"
-      expect(provider).to receive(:execute).with(include("-c").and(include("Testuser New Name")), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(all_of(includes("-c"), includes("Testuser New Name")), has_entry(:custom_environment, {}))
       provider.comment = "Testuser New Name"
     end
 
     it "should use -e with the correct argument when the expiry property is changed" do
       resource[:expiry] = "2010-02-19"
-      expect(provider).to receive(:execute).with(include("-e").and(include("19-02-2011")), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(all_of(includes("-e"), includes("19-02-2011")), has_entry(:custom_environment, {}))
       provider.expiry = "2011-02-19"
     end
 
     it "should use -e with the correct argument when the expiry property is removed" do
       resource[:expiry] = :absent
-      expect(provider).to receive(:execute).with(include("-e").and(include("00-00-0000")), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(all_of(includes("-e"), includes("00-00-0000")), has_entry(:custom_environment, {}))
       provider.expiry = :absent
     end
 
     it "should use -g with the correct argument when the gid property is changed" do
       resource[:gid] = 12345
-      expect(provider).to receive(:execute).with(include("-g").and(include(54321)), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(all_of(includes("-g"), includes(54321)), has_entry(:custom_environment, {}))
       provider.gid = 54321
     end
 
     it "should use -G with the correct argument when the groups property is changed" do
       resource[:groups] = "group1"
-      expect(provider).to receive(:execute).with(include("-G").and(include("group2")), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(all_of(includes("-G"), includes("group2")), has_entry(:custom_environment, {}))
       provider.groups = "group2"
     end
 
     it "should use -G with all the given groups when the groups property is changed with an array" do
       resource[:groups] = ["group1", "group2"]
-      expect(provider).to receive(:execute).with(include("-G").and(include("group3,group4")), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(all_of(includes("-G"), includes("group3,group4")), has_entry(:custom_environment, {}))
       provider.groups = "group3,group4"
     end
 
     it "should use -d with the correct argument when the home property is changed" do
       resource[:home] = "/home/testuser"
-      expect(provider).to receive(:execute).with(include("-d").and(include("/newhome/testuser")), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(all_of(includes("-d"), includes("/newhome/testuser")), has_entry(:custom_environment, {}))
       provider.home = "/newhome/testuser"
     end
 
     it "should use -m and -d with the correct argument when the home property is changed and managehome is enabled" do
       resource[:home] = "/home/testuser"
       resource[:managehome] = true
-      expect(provider).to receive(:execute).with(include("-d").and(include("/newhome/testuser")).and(include("-m")), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(all_of(includes("-d"), includes("/newhome/testuser"), includes("-m")), has_entry(:custom_environment, {}))
       provider.home = "/newhome/testuser"
     end
 
     it "should call the password set function with the correct argument when the password property is changed" do
       resource[:password] = "*"
-      expect(provider).to receive(:password=).with("!")
+      provider.expects(:password=).with("!")
       provider.password = "!"
     end
 
     it "should use -s with the correct argument when the shell property is changed" do
       resource[:shell] = "/bin/sh"
-      expect(provider).to receive(:execute).with(include("-s").and(include("/bin/tcsh")), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(all_of(includes("-s"), includes("/bin/tcsh")), has_entry(:custom_environment, {}))
       provider.shell = "/bin/tcsh"
     end
 
     it "should use -u with the correct argument when the uid property is changed" do
       resource[:uid] = 12345
-      expect(provider).to receive(:execute).with(include("-u").and(include(54321)), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(all_of(includes("-u"), includes(54321)), has_entry(:custom_environment, {}))
       provider.uid = 54321
     end
-
-    it "should print a debug message with sensitive data redacted when the password property is set" do
-      Puppet::Util::Log.level = :debug
-      resource[:password] = "*"
-      popen = double("popen", :puts => nil, :close => nil)
-      expect(Open3).to receive(:popen3).and_return(popen)
-      expect(popen).to receive(:puts).with("abc123")
-      provider.password = "abc123"
-
-      expect(@logs).not_to be_any {|log| log.level == :debug and log.message =~ /abc123/}
-     end
-
-    it "should call execute with sensitive false when a non-sensitive property is set" do
-      Puppet::Util::Log.level = :debug
-      resource[:home] = "/home/testuser"
-      resource[:managehome] = true
-      expect(provider).to receive(:execute).with(kind_of(Array), hash_including(sensitive: false))
-      provider.home = "/newhome/testuser"
-    end
   end
 end

data/spec/unit/provider/user/user_role_add_spec.rb

@@ -2,129 +2,129 @@ require 'spec_helper'
 require 'puppet_spec/files'
 require 'tempfile'
 
-describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet::Util::Platform.windows? do
   include PuppetSpec::Files
   let(:resource) { Puppet::Type.type(:user).new(:name => 'myuser', :managehome => false, :allowdupe => false) }
   let(:provider) { described_class.new(resource) }
 
   before do
-    allow(resource).to receive(:should).and_return("fakeval")
-    allow(resource).to receive(:should).with(:keys).and_return(Hash.new)
-    allow(resource).to receive(:[]).and_return("fakeval")
+    resource.stubs(:should).returns "fakeval"
+    resource.stubs(:should).with(:keys).returns Hash.new
+    resource.stubs(:[]).returns "fakeval"
   end
 
+
   describe "#command" do
     before do
-      klass = double("provider")
-      allow(klass).to receive(:superclass)
-      allow(klass).to receive(:command).with(:foo).and_return("userfoo")
-      allow(klass).to receive(:command).with(:role_foo).and_return("rolefoo")
-      allow(provider).to receive(:class).and_return(klass)
+      klass = stub("provider")
+      klass.stubs(:command).with(:foo).returns("userfoo")
+      klass.stubs(:command).with(:role_foo).returns("rolefoo")
+      provider.stubs(:class).returns(klass)
     end
 
     it "should use the command if not a role and ensure!=role" do
-      allow(provider).to receive(:is_role?).and_return(false)
-      allow(provider).to receive(:exists?).and_return(false)
-      allow(resource).to receive(:[]).with(:ensure).and_return(:present)
-      allow(provider.class).to receive(:foo)
+      provider.stubs(:is_role?).returns(false)
+      provider.stubs(:exists?).returns(false)
+      resource.stubs(:[]).with(:ensure).returns(:present)
+      provider.class.stubs(:foo)
       expect(provider.command(:foo)).to eq("userfoo")
     end
 
     it "should use the role command when a role" do
-      allow(provider).to receive(:is_role?).and_return(true)
+      provider.stubs(:is_role?).returns(true)
       expect(provider.command(:foo)).to eq("rolefoo")
     end
 
     it "should use the role command when !exists and ensure=role" do
-      allow(provider).to receive(:is_role?).and_return(false)
-      allow(provider).to receive(:exists?).and_return(false)
-      allow(resource).to receive(:[]).with(:ensure).and_return(:role)
+      provider.stubs(:is_role?).returns(false)
+      provider.stubs(:exists?).returns(false)
+      resource.stubs(:[]).with(:ensure).returns(:role)
       expect(provider.command(:foo)).to eq("rolefoo")
     end
   end
 
   describe "#transition" do
     it "should return the type set to whatever is passed in" do
-      expect(provider).to receive(:command).with(:modify).and_return("foomod")
+      provider.expects(:command).with(:modify).returns("foomod")
       provider.transition("bar").include?("type=bar")
     end
   end
 
   describe "#create" do
     before do
-      allow(provider).to receive(:password=)
+      provider.stubs(:password=)
     end
 
     it "should use the add command when the user is not a role" do
-      allow(provider).to receive(:is_role?).and_return(false)
-      expect(provider).to receive(:addcmd).and_return("useradd")
-      expect(provider).to receive(:run).at_least(:once)
+      provider.stubs(:is_role?).returns(false)
+      provider.expects(:addcmd).returns("useradd")
+      provider.expects(:run).at_least_once
       provider.create
     end
 
     it "should use transition(normal) when the user is a role" do
-      allow(provider).to receive(:is_role?).and_return(true)
-      expect(provider).to receive(:transition).with("normal")
-      expect(provider).to receive(:run)
+      provider.stubs(:is_role?).returns(true)
+      provider.expects(:transition).with("normal")
+      provider.expects(:run)
       provider.create
     end
 
     it "should set password age rules" do
       resource = Puppet::Type.type(:user).new :name => "myuser", :password_min_age => 5, :password_max_age => 10, :password_warn_days => 15, :provider => :user_role_add
       provider = described_class.new(resource)
-      allow(provider).to receive(:user_attributes)
-      allow(provider).to receive(:execute)
-      expect(provider).to receive(:execute).with([anything, "-n", 5, "-x", 10, '-w', 15, "myuser"])
+      provider.stubs(:user_attributes)
+      provider.stubs(:execute)
+      provider.expects(:execute).with { |cmd, *args| args == ["-n", 5, "-x", 10, '-w', 15, "myuser"] }
       provider.create
     end
   end
 
   describe "#destroy" do
     it "should use the delete command if the user exists and is not a role" do
-      allow(provider).to receive(:exists?).and_return(true)
-      allow(provider).to receive(:is_role?).and_return(false)
-      expect(provider).to receive(:deletecmd)
-      expect(provider).to receive(:run)
+      provider.stubs(:exists?).returns(true)
+      provider.stubs(:is_role?).returns(false)
+      provider.expects(:deletecmd)
+      provider.expects(:run)
       provider.destroy
     end
 
     it "should use the delete command if the user is a role" do
-      allow(provider).to receive(:exists?).and_return(true)
-      allow(provider).to receive(:is_role?).and_return(true)
-      expect(provider).to receive(:deletecmd)
-      expect(provider).to receive(:run)
+      provider.stubs(:exists?).returns(true)
+      provider.stubs(:is_role?).returns(true)
+      provider.expects(:deletecmd)
+      provider.expects(:run)
       provider.destroy
     end
   end
 
   describe "#create_role" do
     it "should use the transition(role) if the user exists" do
-      allow(provider).to receive(:exists?).and_return(true)
-      allow(provider).to receive(:is_role?).and_return(false)
-      expect(provider).to receive(:transition).with("role")
-      expect(provider).to receive(:run)
+      provider.stubs(:exists?).returns(true)
+      provider.stubs(:is_role?).returns(false)
+      provider.expects(:transition).with("role")
+      provider.expects(:run)
       provider.create_role
     end
 
     it "should use the add command when role doesn't exists" do
-      allow(provider).to receive(:exists?).and_return(false)
-      expect(provider).to receive(:addcmd)
-      expect(provider).to receive(:run)
+      provider.stubs(:exists?).returns(false)
+      provider.expects(:addcmd)
+      provider.expects(:run)
       provider.create_role
     end
   end
 
   describe "with :allow_duplicates" do
     before do
-      allow(resource).to receive(:allowdupe?).and_return(true)
-      allow(provider).to receive(:is_role?).and_return(false)
-      allow(provider).to receive(:execute)
-      allow(resource).to receive(:system?).and_return(false)
-      expect(provider).to receive(:execute).with(include("-o"), any_args)
+      resource.stubs(:allowdupe?).returns true
+      provider.stubs(:is_role?).returns(false)
+      provider.stubs(:execute)
+      resource.stubs(:system?).returns false
+      provider.expects(:execute).with { |args| args.include?("-o") }
     end
 
     it "should add -o when the user is being created" do
-      allow(provider).to receive(:password=)
+      provider.stubs(:password=)
       provider.create
     end
 
@@ -137,14 +137,14 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.fe
     context "#send" do
       describe "when getting #{val}" do
         it "should get the user_attributes" do
-          expect(provider).to receive(:user_attributes)
+          provider.expects(:user_attributes)
           provider.send(val)
         end
 
         it "should get the #{val} attribute" do
-          attributes = double("attributes")
-          expect(attributes).to receive(:[]).with(val)
-          allow(provider).to receive(:user_attributes).and_return(attributes)
+          attributes = mock("attributes")
+          attributes.expects(:[]).with(val)
+          provider.stubs(:user_attributes).returns(attributes)
           provider.send(val)
         end
       end
@@ -153,33 +153,33 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.fe
 
   describe "#keys" do
     it "should get the user_attributes" do
-      expect(provider).to receive(:user_attributes)
+      provider.expects(:user_attributes)
       provider.keys
     end
 
     it "should call removed_managed_attributes" do
-      allow(provider).to receive(:user_attributes).and_return({ :type => "normal", :foo => "something" })
-      expect(provider).to receive(:remove_managed_attributes)
+      provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
+      provider.expects(:remove_managed_attributes)
       provider.keys
     end
 
     it "should removed managed attribute (type, auths, roles, etc)" do
-      allow(provider).to receive(:user_attributes).and_return({ :type => "normal", :foo => "something" })
+      provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
       expect(provider.keys).to eq({ :foo => "something" })
     end
   end
 
   describe "#add_properties" do
     it "should call build_keys_cmd" do
-      allow(resource).to receive(:should).and_return("")
-      expect(resource).to receive(:should).with(:keys).and_return({ :foo => "bar" })
-      expect(provider).to receive(:build_keys_cmd).and_return([])
+      resource.stubs(:should).returns ""
+      resource.expects(:should).with(:keys).returns({ :foo => "bar" })
+      provider.expects(:build_keys_cmd).returns([])
       provider.add_properties
     end
 
     it "should add the elements of the keys hash to an array" do
-      allow(resource).to receive(:should).and_return("")
-      expect(resource).to receive(:should).with(:keys).and_return({ :foo => "bar"})
+      resource.stubs(:should).returns ""
+      resource.expects(:should).with(:keys).returns({ :foo => "bar"})
       expect(provider.add_properties).to eq(["-K", "foo=bar"])
     end
   end
@@ -192,57 +192,57 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.fe
 
   describe "#keys=" do
     before do
-      allow(provider).to receive(:is_role?).and_return(false)
+      provider.stubs(:is_role?).returns(false)
     end
 
     it "should run a command" do
-      expect(provider).to receive(:run)
+      provider.expects(:run)
       provider.keys=({})
     end
 
     it "should build the command" do
-      allow(resource).to receive(:[]).with(:name).and_return("someuser")
-      allow(provider).to receive(:command).and_return("usermod")
-      expect(provider).to receive(:build_keys_cmd).and_return(["-K", "foo=bar"])
-      expect(provider).to receive(:run).with(["usermod", "-K", "foo=bar", "someuser"], "modify attribute key pairs")
+      resource.stubs(:[]).with(:name).returns("someuser")
+      provider.stubs(:command).returns("usermod")
+      provider.expects(:build_keys_cmd).returns(["-K", "foo=bar"])
+      provider.expects(:run).with(["usermod", "-K", "foo=bar", "someuser"], "modify attribute key pairs")
       provider.keys=({})
     end
   end
 
   describe "#password" do
     before do
-      @array = double("array")
+      @array = mock "array"
     end
 
     it "should readlines of /etc/shadow" do
-      expect(File).to receive(:readlines).with("/etc/shadow").and_return([])
+      File.expects(:readlines).with("/etc/shadow").returns([])
       provider.password
     end
 
     it "should reject anything that doesn't start with alpha numerics" do
-      expect(@array).to receive(:reject).and_return([])
-      allow(File).to receive(:readlines).with("/etc/shadow").and_return(@array)
+      @array.expects(:reject).returns([])
+      File.stubs(:readlines).with("/etc/shadow").returns(@array)
       provider.password
     end
 
     it "should collect splitting on ':'" do
-      allow(@array).to receive(:reject).and_return(@array)
-      expect(@array).to receive(:collect).and_return([])
-      allow(File).to receive(:readlines).with("/etc/shadow").and_return(@array)
+      @array.stubs(:reject).returns(@array)
+      @array.expects(:collect).returns([])
+      File.stubs(:readlines).with("/etc/shadow").returns(@array)
       provider.password
     end
 
     it "should find the matching user" do
-      allow(resource).to receive(:[]).with(:name).and_return("username")
-      allow(@array).to receive(:reject).and_return(@array)
-      allow(@array).to receive(:collect).and_return([["username", "hashedpassword"], ["someoneelse", "theirpassword"]])
-      allow(File).to receive(:readlines).with("/etc/shadow").and_return(@array)
+      resource.stubs(:[]).with(:name).returns("username")
+      @array.stubs(:reject).returns(@array)
+      @array.stubs(:collect).returns([["username", "hashedpassword"], ["someoneelse", "theirpassword"]])
+      File.stubs(:readlines).with("/etc/shadow").returns(@array)
       expect(provider.password).to eq("hashedpassword")
     end
 
     it "should get the right password" do
-      allow(resource).to receive(:[]).with(:name).and_return("username")
-      allow(File).to receive(:readlines).with("/etc/shadow").and_return(["#comment", "   nonsense", "  ", "username:hashedpassword:stuff:foo:bar:::", "other:pword:yay:::"])
+      resource.stubs(:[]).with(:name).returns("username")
+      File.stubs(:readlines).with("/etc/shadow").returns(["#comment", "   nonsense", "  ", "username:hashedpassword:stuff:foo:bar:::", "other:pword:yay:::"])
       expect(provider.password).to eq("hashedpassword")
     end
   end
@@ -251,7 +251,7 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.fe
     let(:path) { tmpfile('etc-shadow') }
 
     before :each do
-      allow(provider).to receive(:target_file_path).and_return(path)
+      provider.stubs(:target_file_path).returns(path)
     end
 
     def write_fixture(content)
@@ -267,7 +267,7 @@ FIXTURE
     end
 
     it "should only update the target user" do
-      expect(Date).to receive(:today).and_return(Date.new(2011,12,07))
+      Date.expects(:today).returns Date.new(2011,12,07)
       write_fixture <<FIXTURE
 before:seriously:15315:0:99999:7:::
 fakeval:seriously:15315:0:99999:7:::
@@ -297,7 +297,7 @@ FIXTURE
     end
 
     it "should update the lastchg field" do
-      expect(Date).to receive(:today).and_return(Date.new(2013,5,12)) # 15837 days after 1970-01-01
+      Date.expects(:today).returns Date.new(2013,5,12) # 15837 days after 1970-01-01
       write_fixture <<FIXTURE
 before:seriously:15315:0:99999:7:::
 fakeval:seriously:15629:0:99999:7:::
@@ -316,58 +316,58 @@ EOT
 
   describe "#shadow_entry" do
     it "should return the line for the right user" do
-      allow(File).to receive(:readlines).and_return(["someuser:!:10:5:20:7:1::\n", "fakeval:*:20:10:30:7:2::\n", "testuser:*:30:15:40:7:3::\n"])
+      File.stubs(:readlines).returns(["someuser:!:10:5:20:7:1::\n", "fakeval:*:20:10:30:7:2::\n", "testuser:*:30:15:40:7:3::\n"])
       expect(provider.shadow_entry).to eq(["fakeval", "*", "20", "10", "30", "7", "2", "", ""])
     end
   end
 
   describe "#password_max_age" do
     it "should return a maximum age number" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345:0:50::::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345:0:50::::\n"])
       expect(provider.password_max_age).to eq("50")
     end
 
     it "should return -1 for no maximum" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::\n"])
       expect(provider.password_max_age).to eq(-1)
     end
 
     it "should return -1 for no maximum when failed attempts are present" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::3\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::3\n"])
       expect(provider.password_max_age).to eq(-1)
     end
   end
 
   describe "#password_min_age" do
     it "should return a minimum age number" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345:10:50::::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345:10:50::::\n"])
       expect(provider.password_min_age).to eq("10")
     end
 
     it "should return -1 for no minimum" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::\n"])
       expect(provider.password_min_age).to eq(-1)
     end
 
     it "should return -1 for no minimum when failed attempts are present" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::3\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::3\n"])
       expect(provider.password_min_age).to eq(-1)
     end
   end
 
   describe "#password_warn_days" do
     it "should return a warn days number" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345:10:50:30:::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345:10:50:30:::\n"])
       expect(provider.password_warn_days).to eq("30")
     end
 
     it "should return -1 for no warn days" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::\n"])
       expect(provider.password_warn_days).to eq(-1)
     end
 
     it "should return -1 for no warn days when failed attempts are present" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::3\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::3\n"])
       expect(provider.password_warn_days).to eq(-1)
     end
   end