puppet 5.5.12-x86-mingw32 → 5.5.13-x86-mingw32

data/spec/unit/type/stage_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:stage) do

data/spec/unit/type/tidy_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_bucket/dipper'
 
@@ -9,7 +8,7 @@ describe tidy do
 
   before do
     @basepath = make_absolute("/what/ever")
-    Puppet.settings.stubs(:use)
+    allow(Puppet.settings).to receive(:use)
   end
 
   context "when normalizing 'path' on windows", :if => Puppet.features.microsoft_windows? do
@@ -21,8 +20,8 @@ describe tidy do
 
   it "should use :lstat when stating a file" do
     path = '/foo/bar'
-    stat = mock 'stat'
-    Puppet::FileSystem.expects(:lstat).with(path).returns stat
+    stat = double('stat')
+    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stat)
 
     resource = tidy.new :path => path, :age => "1d"
 
@@ -135,32 +134,32 @@ describe tidy do
   describe "when tidying" do
     before do
       @tidy = Puppet::Type.type(:tidy).new :path => @basepath
-      @stat = stub 'stat', :ftype => "directory"
+      @stat = double('stat', :ftype => "directory")
       lstat_is(@basepath, @stat)
     end
 
     describe "and generating files" do
       it "should set the backup on the file if backup is set on the tidy instance" do
         @tidy[:backup] = "whatever"
-        Puppet::Type.type(:file).expects(:new).with { |args| args[:backup] == "whatever" }
+        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(backup: "whatever"))
 
         @tidy.mkfile(@basepath)
       end
 
       it "should set the file's path to the tidy's path" do
-        Puppet::Type.type(:file).expects(:new).with { |args| args[:path] == @basepath }
+        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(path: @basepath))
 
         @tidy.mkfile(@basepath)
       end
 
       it "should configure the file for deletion" do
-        Puppet::Type.type(:file).expects(:new).with { |args| args[:ensure] == :absent }
+        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(ensure: :absent))
 
         @tidy.mkfile(@basepath)
       end
 
       it "should force deletion on the file" do
-        Puppet::Type.type(:file).expects(:new).with { |args| args[:force] == true }
+        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(force: true))
 
         @tidy.mkfile(@basepath)
       end
@@ -174,16 +173,16 @@ describe tidy do
 
     describe "and recursion is not used" do
       it "should generate a file resource if the file should be tidied" do
-        @tidy.expects(:tidy?).with(@basepath).returns true
+        expect(@tidy).to receive(:tidy?).with(@basepath).and_return(true)
         file = Puppet::Type.type(:file).new(:path => @basepath+"/eh")
-        @tidy.expects(:mkfile).with(@basepath).returns file
+        expect(@tidy).to receive(:mkfile).with(@basepath).and_return(file)
 
         expect(@tidy.generate).to eq([file])
       end
 
       it "should do nothing if the file should not be tidied" do
-        @tidy.expects(:tidy?).with(@basepath).returns false
-        @tidy.expects(:mkfile).never
+        expect(@tidy).to receive(:tidy?).with(@basepath).and_return(false)
+        expect(@tidy).not_to receive(:mkfile)
 
         expect(@tidy.generate).to eq([])
       end
@@ -192,38 +191,38 @@ describe tidy do
     describe "and recursion is used" do
       before do
         @tidy[:recurse] = true
-        Puppet::FileServing::Fileset.any_instance.stubs(:stat).returns mock("stat")
+        allow_any_instance_of(Puppet::FileServing::Fileset).to receive(:stat).and_return(double("stat"))
         @fileset = Puppet::FileServing::Fileset.new(@basepath)
-        Puppet::FileServing::Fileset.stubs(:new).returns @fileset
+        allow(Puppet::FileServing::Fileset).to receive(:new).and_return(@fileset)
       end
 
       it "should use a Fileset for infinite recursion" do
-        Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true).returns @fileset
-        @fileset.expects(:files).returns %w{. one two}
-        @tidy.stubs(:tidy?).returns false
+        expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true).and_return(@fileset)
+        expect(@fileset).to receive(:files).and_return(%w{. one two})
+        allow(@tidy).to receive(:tidy?).and_return(false)
 
         @tidy.generate
       end
 
       it "should use a Fileset for limited recursion" do
         @tidy[:recurse] = 42
-        Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true, :recurselimit => 42).returns @fileset
-        @fileset.expects(:files).returns %w{. one two}
-        @tidy.stubs(:tidy?).returns false
+        expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true, :recurselimit => 42).and_return(@fileset)
+        expect(@fileset).to receive(:files).and_return(%w{. one two})
+        allow(@tidy).to receive(:tidy?).and_return(false)
 
         @tidy.generate
       end
 
       it "should generate a file resource for every file that should be tidied but not for files that should not be tidied" do
-        @fileset.expects(:files).returns %w{. one two}
+        expect(@fileset).to receive(:files).and_return(%w{. one two})
 
-        @tidy.expects(:tidy?).with(@basepath).returns true
-        @tidy.expects(:tidy?).with(@basepath+"/one").returns true
-        @tidy.expects(:tidy?).with(@basepath+"/two").returns false
+        expect(@tidy).to receive(:tidy?).with(@basepath).and_return(true)
+        expect(@tidy).to receive(:tidy?).with(@basepath+"/one").and_return(true)
+        expect(@tidy).to receive(:tidy?).with(@basepath+"/two").and_return(false)
 
         file = Puppet::Type.type(:file).new(:path => @basepath+"/eh")
-        @tidy.expects(:mkfile).with(@basepath).returns file
-        @tidy.expects(:mkfile).with(@basepath+"/one").returns file
+        expect(@tidy).to receive(:mkfile).with(@basepath).and_return(file)
+        expect(@tidy).to receive(:mkfile).with(@basepath+"/one").and_return(file)
 
         @tidy.generate
       end
@@ -234,7 +233,7 @@ describe tidy do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath, :recurse => 1
         @tidy[:matches] = %w{*foo* *bar*}
 
-        @stat = mock 'stat'
+        @stat = double('stat')
 
         @matcher = @tidy.parameter(:matches)
       end
@@ -258,7 +257,7 @@ describe tidy do
     describe "and determining whether a file is too old" do
       before do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath
-        @stat = stub 'stat'
+        @stat = double('stat')
 
         @tidy[:age] = "1s"
         @tidy[:type] = "mtime"
@@ -267,19 +266,19 @@ describe tidy do
 
       it "should use the age type specified" do
         @tidy[:type] = :ctime
-        @stat.expects(:ctime).returns(Time.now)
+        expect(@stat).to receive(:ctime).and_return(Time.now)
 
         @ager.tidy?(@basepath, @stat)
       end
 
       it "should return false if the file is more recent than the specified age" do
-        @stat.expects(:mtime).returns(Time.now)
+        expect(@stat).to receive(:mtime).and_return(Time.now)
 
         expect(@ager).not_to be_tidy(@basepath, @stat)
       end
 
       it "should return true if the file is older than the specified age" do
-        @stat.expects(:mtime).returns(Time.now - 10)
+        expect(@stat).to receive(:mtime).and_return(Time.now - 10)
 
         expect(@ager).to be_tidy(@basepath, @stat)
       end
@@ -288,26 +287,26 @@ describe tidy do
     describe "and determining whether a file is too large" do
       before do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath
-        @stat = stub 'stat', :ftype => "file"
+        @stat = double('stat', :ftype => "file")
 
         @tidy[:size] = "1kb"
         @sizer = @tidy.parameter(:size)
       end
 
       it "should return false if the file is smaller than the specified size" do
-        @stat.expects(:size).returns(4) # smaller than a kilobyte
+        expect(@stat).to receive(:size).and_return(4) # smaller than a kilobyte
 
         expect(@sizer).not_to be_tidy(@basepath, @stat)
       end
 
       it "should return true if the file is larger than the specified size" do
-        @stat.expects(:size).returns(1500) # larger than a kilobyte
+        expect(@stat).to receive(:size).and_return(1500) # larger than a kilobyte
 
         expect(@sizer).to be_tidy(@basepath, @stat)
       end
 
       it "should return true if the file is equal to the specified size" do
-        @stat.expects(:size).returns(1024)
+        expect(@stat).to receive(:size).and_return(1024)
 
         expect(@sizer).to be_tidy(@basepath, @stat)
       end
@@ -318,7 +317,7 @@ describe tidy do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath
         @catalog = Puppet::Resource::Catalog.new
         @tidy.catalog = @catalog
-        @stat = stub 'stat', :ftype => "file"
+        @stat = double('stat', :ftype => "file")
         lstat_is(@basepath, @stat)
       end
 
@@ -343,7 +342,7 @@ describe tidy do
       end
 
       it "should not be tidied if it is a directory and rmdirs is set to false" do
-        stat = mock 'stat', :ftype => "directory"
+        stat = double('stat', :ftype => "directory")
         lstat_is(@basepath, stat)
 
         expect(@tidy).not_to be_tidy(@basepath)
@@ -354,7 +353,7 @@ describe tidy do
         @tidy[:matches] = "globs"
 
         matches = @tidy.parameter(:matches)
-        matches.expects(:tidy?).with(@basepath, @stat).returns false
+        expect(matches).to receive(:tidy?).with(@basepath, @stat).and_return(false)
         expect(@tidy).not_to be_tidy(@basepath)
       end
 
@@ -362,7 +361,7 @@ describe tidy do
         @tidy[:age] = "1d"
 
         ager = @tidy.parameter(:age)
-        ager.expects(:tidy?).with(@basepath, @stat).returns false
+        expect(ager).to receive(:tidy?).with(@basepath, @stat).and_return(false)
         expect(@tidy).not_to be_tidy(@basepath)
       end
 
@@ -370,7 +369,7 @@ describe tidy do
         @tidy[:size] = "1b"
 
         sizer = @tidy.parameter(:size)
-        sizer.expects(:tidy?).with(@basepath, @stat).returns false
+        expect(sizer).to receive(:tidy?).with(@basepath, @stat).and_return(false)
         expect(@tidy).not_to be_tidy(@basepath)
       end
 
@@ -378,8 +377,8 @@ describe tidy do
         @tidy[:size] = "1b"
         @tidy[:age] = "1d"
 
-        @tidy.parameter(:size).stubs(:tidy?).returns true
-        @tidy.parameter(:age).stubs(:tidy?).returns false
+        allow(@tidy.parameter(:size)).to receive(:tidy?).and_return(true)
+        allow(@tidy.parameter(:age)).to receive(:tidy?).and_return(false)
         expect(@tidy).to be_tidy(@basepath)
       end
 
@@ -387,8 +386,8 @@ describe tidy do
         @tidy[:size] = "1b"
         @tidy[:age] = "1d"
 
-        @tidy.parameter(:size).stubs(:tidy?).returns false
-        @tidy.parameter(:age).stubs(:tidy?).returns true
+        allow(@tidy.parameter(:size)).to receive(:tidy?).and_return(false)
+        allow(@tidy.parameter(:age)).to receive(:tidy?).and_return(true)
         expect(@tidy).to be_tidy(@basepath)
       end
 
@@ -400,10 +399,10 @@ describe tidy do
         @tidy[:recurse] = true
         @tidy[:rmdirs] = true
         fileset = Puppet::FileServing::Fileset.new(@basepath)
-        Puppet::FileServing::Fileset.expects(:new).returns fileset
-        fileset.expects(:files).returns %w{. one one/two}
+        expect(Puppet::FileServing::Fileset).to receive(:new).and_return(fileset)
+        expect(fileset).to receive(:files).and_return(%w{. one one/two})
 
-        @tidy.stubs(:tidy?).returns true
+        allow(@tidy).to receive(:tidy?).and_return(true)
 
         expect(@tidy.generate.collect { |r| r[:path] }).to eq([@basepath+"/one/two", @basepath+"/one", @basepath])
       end
@@ -412,10 +411,10 @@ describe tidy do
     it "should configure directories to require their contained files if rmdirs is enabled, so the files will be deleted first" do
       @tidy[:recurse] = true
       @tidy[:rmdirs] = true
-      fileset = mock 'fileset'
-      Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true).returns fileset
-      fileset.expects(:files).returns %w{. one two one/subone two/subtwo one/subone/ssone}
-      @tidy.stubs(:tidy?).returns true
+      fileset = double('fileset')
+      expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true).and_return(fileset)
+      expect(fileset).to receive(:files).and_return(%w{. one two one/subone two/subtwo one/subone/ssone})
+      allow(@tidy).to receive(:tidy?).and_return(true)
 
       result = @tidy.generate.inject({}) { |hash, res| hash[res[:path]] = res; hash }
       {
@@ -434,10 +433,10 @@ describe tidy do
     it "should configure directories to require their contained files in sorted order" do
       @tidy[:recurse] = true
       @tidy[:rmdirs] = true
-      fileset = mock 'fileset'
-      Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true).returns fileset
-      fileset.expects(:files).returns %w{. a a/2 a/1 a/3}
-      @tidy.stubs(:tidy?).returns true
+      fileset = double('fileset')
+      expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true).and_return(fileset)
+      expect(fileset).to receive(:files).and_return(%w{. a a/2 a/1 a/3})
+      allow(@tidy).to receive(:tidy?).and_return(true)
 
       result = @tidy.generate.inject({}) { |hash, res| hash[res[:path]] = res; hash }
       expect(result[@basepath + '/a'][:require].collect{|a| a.name[('File//a/' + @basepath).length..-1]}.join()).to eq('321')
@@ -447,10 +446,10 @@ describe tidy do
       @tidy[:recurse] = true
       @tidy[:noop] = true
 
-      fileset = mock 'fileset'
-      Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true).returns fileset
-      fileset.expects(:files).returns %w{. a a/2 a/1 a/3}
-      @tidy.stubs(:tidy?).returns true
+      fileset = double('fileset')
+      expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true).and_return(fileset)
+      expect(fileset).to receive(:files).and_return(%w{. a a/2 a/1 a/3})
+      allow(@tidy).to receive(:tidy?).and_return(true)
 
       result = @tidy.generate.inject({}) { |hash, res| hash[res[:path]] = res; hash }
 
@@ -459,10 +458,10 @@ describe tidy do
   end
 
   def lstat_is(path, stat)
-    Puppet::FileSystem.stubs(:lstat).with(path).returns(stat)
+    allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stat)
   end
 
   def lstat_raises(path, error_class)
-    Puppet::FileSystem.expects(:lstat).with(path).raises Errno::ENOENT
+    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_raise(Errno::ENOENT)
   end
 end

data/spec/unit/type/user_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 # encoding: UTF-8
 require 'spec_helper'
 
@@ -13,7 +12,7 @@ describe Puppet::Type.type(:user) do
       def flush; end
       def self.instances; []; end
     end
-    described_class.stubs(:defaultprovider).returns @provider_class
+    allow(described_class).to receive(:defaultprovider).and_return(@provider_class)
   end
 
   it "should be able to create an instance" do
@@ -65,12 +64,12 @@ describe Puppet::Type.type(:user) do
     end
 
     it "cannot be set to true for a provider that does not manage homedirs" do
-      provider.class.stubs(:manages_homedir?).returns false
+      allow(provider.class).to receive(:manages_homedir?).and_return(false)
       expect { instance[:managehome] = 'yes' }.to raise_error(Puppet::Error, /can not manage home directories/)
     end
 
     it "can be set to true for a provider that does manage homedirs" do
-      provider.class.stubs(:manages_homedir?).returns true
+      allow(provider.class).to receive(:manages_homedir?).and_return(true)
       instance[:managehome] = 'yes'
     end
   end
@@ -127,8 +126,8 @@ describe Puppet::Type.type(:user) do
     end
 
     it "should set all values to :absent if the user is absent" do
-      @user.property(:ensure).expects(:retrieve).returns :absent
-      @user.property(:uid).expects(:retrieve).never
+      expect(@user.property(:ensure)).to receive(:retrieve).and_return(:absent)
+      expect(@user.property(:uid)).not_to receive(:retrieve)
       expect(@user.retrieve[@user.property(:uid)]).to eq(:absent)
     end
 
@@ -148,13 +147,13 @@ describe Puppet::Type.type(:user) do
 
     it "should call :create on the provider when asked to sync to the :present state" do
       @provider = @provider_class.new(:name => 'foo', :ensure => :absent)
-      @provider.expects(:create)
+      expect(@provider).to receive(:create)
       described_class.new(:name => 'foo', :ensure => :present, :provider => @provider).parameter(:ensure).sync
     end
 
     it "should call :delete on the provider when asked to sync to the :absent state" do
       @provider = @provider_class.new(:name => 'foo', :ensure => :present)
-      @provider.expects(:delete)
+      expect(@provider).to receive(:delete)
       described_class.new(:name => 'foo', :ensure => :absent, :provider => @provider).parameter(:ensure).sync
     end
 
@@ -212,27 +211,27 @@ describe Puppet::Type.type(:user) do
       end
 
       it "should return true if any of the specified groups are equal to the current integer" do
-        Puppet::Util.expects(:gid).with("foo").returns 300
-        Puppet::Util.expects(:gid).with("bar").returns 500
+        expect(Puppet::Util).to receive(:gid).with("foo").and_return(300)
+        expect(Puppet::Util).to receive(:gid).with("bar").and_return(500)
         expect(described_class.new(:name => 'baz', :gid => [ 'foo', 'bar' ]).parameter(:gid)).to be_safe_insync(500)
       end
 
       it "should return false if none of the specified groups are equal to the current integer" do
-        Puppet::Util.expects(:gid).with("foo").returns 300
-        Puppet::Util.expects(:gid).with("bar").returns 500
+        expect(Puppet::Util).to receive(:gid).with("foo").and_return(300)
+        expect(Puppet::Util).to receive(:gid).with("bar").and_return(500)
         expect(described_class.new(:name => 'baz', :gid => [ 'foo', 'bar' ]).parameter(:gid)).to_not be_safe_insync(700)
       end
     end
 
     describe "when syncing" do
       it "should use the first found, specified group as the desired value and send it to the provider" do
-        Puppet::Util.expects(:gid).with("foo").returns nil
-        Puppet::Util.expects(:gid).with("bar").returns 500
+        expect(Puppet::Util).to receive(:gid).with("foo").and_return(nil)
+        expect(Puppet::Util).to receive(:gid).with("bar").and_return(500)
 
         @provider = @provider_class.new(:name => 'foo')
         resource = described_class.new(:name => 'foo', :provider => @provider, :gid => [ 'foo', 'bar' ])
 
-        @provider.expects(:gid=).with 500
+        expect(@provider).to receive(:gid=).with(500)
         resource.parameter(:gid).sync
       end
     end
@@ -257,7 +256,6 @@ describe Puppet::Type.type(:user) do
     end
 
     describe "when testing is in sync" do
-
       before :each do
         # the useradd provider uses a single string to represent groups and so does Puppet::Property::List when converting to should values
         @provider = @provider_class.new(:name => 'foo', :groups => 'a,b,e,f')
@@ -366,7 +364,7 @@ describe Puppet::Type.type(:user) do
         # useradd subclasses nameservice and thus inherits #comments_insync?
         user = described_class.new(:name => 'foo', :comment => @value, :provider => :useradd)
         comment_property = user.properties.find {|p| p.name == :comment}
-        user.provider.expects(:comments_insync?)
+        expect(user.provider).to receive(:comments_insync?)
         comment_property.insync?('bar')
       end
 
@@ -374,6 +372,7 @@ describe Puppet::Type.type(:user) do
         let(:is) { "\u2603" }
         let(:should) { "\u06FF" }
         let(:comment_property) { @user.properties.find { |p| p.name == :comment } }
+
         context "given is and should strings with incompatible encoding" do
           it "should return a formatted string" do
             is.force_encoding(Encoding::ASCII_8BIT)
@@ -409,7 +408,7 @@ describe Puppet::Type.type(:user) do
       Puppet::Resource::Catalog.new :testing do |conf|
         [testuser, testrole].each { |resource| conf.add_resource resource }
       end
-      Puppet::Type::User::ProviderDirectoryservice.stubs(:get_macosx_version_major).returns "10.5"
+      allow(Puppet::Type::User::ProviderDirectoryservice).to receive(:get_macosx_version_major).and_return("10.5")
 
       rel = testuser.autorequire[0]
       expect(rel.source.ref).to eq(testrole.ref)
@@ -431,15 +430,15 @@ describe Puppet::Type.type(:user) do
         def check_valid_shell; end
       end
 
-      described_class.stubs(:defaultprovider).returns @shell_provider_class
+      allow(described_class).to receive(:defaultprovider).and_return(@shell_provider_class)
     end
 
     it "should call :check_valid_shell on the provider when changing shell value" do
       @provider = @shell_provider_class.new(:name => 'foo', :shell => '/bin/bash', :ensure => :present)
-      @provider.expects(:check_valid_shell)
+      expect(@provider).to receive(:check_valid_shell)
       resource = described_class.new(:name => 'foo', :shell => '/bin/zsh', :provider => @provider)
-      Puppet::Util::Storage.stubs(:load)
-      Puppet::Util::Storage.stubs(:store)
+      allow(Puppet::Util::Storage).to receive(:load)
+      allow(Puppet::Util::Storage).to receive(:store)
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource resource
       catalog.apply
@@ -447,10 +446,10 @@ describe Puppet::Type.type(:user) do
 
     it "should call :check_valid_shell on the provider when changing ensure from present to absent" do
       @provider = @shell_provider_class.new(:name => 'foo', :shell => '/bin/bash', :ensure => :absent)
-      @provider.expects(:check_valid_shell)
+      expect(@provider).to receive(:check_valid_shell)
       resource = described_class.new(:name => 'foo', :shell => '/bin/zsh', :provider => @provider)
-      Puppet::Util::Storage.stubs(:load)
-      Puppet::Util::Storage.stubs(:store)
+      allow(Puppet::Util::Storage).to receive(:load)
+      allow(Puppet::Util::Storage).to receive(:store)
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource resource
       catalog.apply
@@ -468,12 +467,15 @@ describe Puppet::Type.type(:user) do
       it "should accept true" do
         described_class.new(:name => "a", :home => "/tmp", :purge_ssh_keys => true)
       end
+
       it "should accept the ~ wildcard" do
         described_class.new(:name => "a", :home => "/tmp", :purge_ssh_keys => "~/keys")
       end
+
       it "should accept the %h wildcard" do
         described_class.new(:name => "a", :home => "/tmp", :purge_ssh_keys => "%h/keys")
       end
+
       it "raises when given a relative path" do
         expect {
           described_class.new(:name => "a", :home => "/tmp", :purge_ssh_keys => "keys")
@@ -487,11 +489,13 @@ describe Puppet::Type.type(:user) do
           described_class.new(:name => "a", :purge_ssh_keys => true)
         }.to raise_error(Puppet::Error, /purge_ssh_keys can only be true for users with a defined home directory/)
       end
+
       it "should not accept the ~ wildcard" do
         expect {
           described_class.new(:name => "a", :purge_ssh_keys => "~/keys")
         }.to raise_error(Puppet::Error, /meta character ~ or %h only allowed for users with a defined home directory/)
       end
+
       it "should not accept the %h wildcard" do
         expect {
           described_class.new(:name => "a", :purge_ssh_keys => "%h/keys")
@@ -503,18 +507,21 @@ describe Puppet::Type.type(:user) do
       let(:paths) do
         [ "/dev/null", "/tmp/keyfile" ].map { |path| File.expand_path(path) }
       end
+
       subject do
         res = described_class.new(:name => "test", :purge_ssh_keys => paths)
         res.catalog = Puppet::Resource::Catalog.new
         res
       end
+
       it "should not just return from generate" do
-        subject.expects :find_unmanaged_keys
+        expect(subject).to receive(:find_unmanaged_keys)
         subject.generate
       end
+
       it "should check each keyfile for readability" do
         paths.each do |path|
-          File.expects(:readable?).with(path)
+          expect(File).to receive(:readable?).with(path)
         end
         subject.generate
       end
@@ -526,27 +533,34 @@ describe Puppet::Type.type(:user) do
         res.catalog = Puppet::Resource::Catalog.new
         res
       end
+
       context "when purging is disabled" do
         let(:purge_param) { false }
+
         its(:generate) { should be_empty }
       end
+
       context "when purging is enabled" do
         let(:purge_param) { my_fixture('authorized_keys') }
         let(:resources) { subject.generate }
+
         it "should contain a resource for each key" do
           names = resources.collect { |res| res.name }
           expect(names).to include("key1 name")
           expect(names).to include("keyname2")
         end
+
         it "should not include keys in comment lines" do
           names = resources.collect { |res| res.name }
           expect(names).not_to include("keyname3")
         end
+
         it "should generate names for unnamed keys" do
           names = resources.collect { |res| res.name }
           fixture_path = File.join(my_fixture_dir, 'authorized_keys')
           expect(names).to include("#{fixture_path}:unnamed-1")
         end
+
         it "should each have a value for the user property" do
           expect(resources.map { |res|
             res[:user]