puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

data/spec/unit/type/resources_spec.rb

@@ -1,19 +1,19 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 resources = Puppet::Type.type(:resources)
 
 # There are still plenty of tests to port over from test/.
 describe resources do
-
   before :each do
     described_class.reset_system_users_max_uid!
   end
 
   context "when initializing" do
     it "should fail if the specified resource type does not exist" do
-      Puppet::Type.stubs(:type).with { |x| x.to_s.downcase == "resources"}.returns resources
-      Puppet::Type.expects(:type).with("nosuchtype").returns nil
+      allow(Puppet::Type).to receive(:type) do
+        expect(x.to_s.downcase).to eq("resources")
+      end.and_return(resources)
+      expect(Puppet::Type).to receive(:type).with("nosuchtype").and_return(nil)
       expect { resources.new :name => "nosuchtype" }.to raise_error(Puppet::Error)
     end
 
@@ -38,20 +38,20 @@ describe resources do
     end
 
     it "cannot be set to true for a resource type that does not accept ensure" do
-      instance.resource_type.stubs(:respond_to?).returns true
-      instance.resource_type.stubs(:validproperty?).returns false
+      allow(instance.resource_type).to receive(:respond_to?).and_return(true)
+      allow(instance.resource_type).to receive(:validproperty?).and_return(false)
       expect { instance[:purge] = 'yes' }.to raise_error Puppet::Error
     end
 
     it "cannot be set to true for a resource type that does not have instances" do
-      instance.resource_type.stubs(:respond_to?).returns false
-      instance.resource_type.stubs(:validproperty?).returns true
+      allow(instance.resource_type).to receive(:respond_to?).and_return(false)
+      allow(instance.resource_type).to receive(:validproperty?).and_return(true)
       expect { instance[:purge] = 'yes' }.to raise_error Puppet::Error
     end
 
     it "can be set to true for a resource type that has instances and can accept ensure" do
-      instance.resource_type.stubs(:respond_to?).returns true
-      instance.resource_type.stubs(:validproperty?).returns true
+      allow(instance.resource_type).to receive(:respond_to?).and_return(true)
+      allow(instance.resource_type).to receive(:validproperty?).and_return(true)
       expect { instance[:purge] = 'yes' }.to_not raise_error
     end
   end
@@ -61,7 +61,7 @@ describe resources do
       before do
         @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
         @res.catalog = Puppet::Resource::Catalog.new
-        Puppet::FileSystem.stubs(:exist?).with('/etc/login.defs').returns false
+        allow(Puppet::FileSystem).to receive(:exist?).with('/etc/login.defs').and_return(false)
       end
 
       it "should never purge hardcoded system users" do
@@ -73,14 +73,14 @@ describe resources do
       it "should not purge system users if unless_system_user => true" do
         user_hash = {:name => 'system_user', :uid => 125, :system => true}
         user = Puppet::Type.type(:user).new(user_hash)
-        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
         expect(@res.user_check(user)).to be_falsey
       end
 
       it "should purge non-system users if unless_system_user => true" do
         user_hash = {:name => 'system_user', :uid => described_class.system_users_max_uid + 1, :system => true}
         user = Puppet::Type.type(:user).new(user_hash)
-        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
         expect(@res.user_check(user)).to be_truthy
       end
 
@@ -89,7 +89,7 @@ describe resources do
         res.catalog = Puppet::Resource::Catalog.new
         user_hash = {:name => 'system_user', :uid => 500, :system => true}
         user = Puppet::Type.type(:user).new(user_hash)
-        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
         expect(res.user_check(user)).to be_falsey
       end
 
@@ -98,7 +98,7 @@ describe resources do
         res.catalog = Puppet::Resource::Catalog.new
         user_hash = {:name => 'Administrator', :uid => 'S-1-5-21-12345-500'}
         user = Puppet::Type.type(:user).new(user_hash)
-        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
         expect(res.user_check(user)).to be_falsey
       end
 
@@ -107,7 +107,7 @@ describe resources do
         res.catalog = Puppet::Resource::Catalog.new
         user_hash = {:name => 'other', :uid => 'S-1-5-21-12345-1001'}
         user = Puppet::Type.type(:user).new(user_hash)
-        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
         expect(res.user_check(user)).to be_truthy
       end
     end
@@ -115,10 +115,10 @@ describe resources do
     %w(FreeBSD OpenBSD).each do |os|
       context "on #{os}" do
         before :each do
-          Facter.stubs(:value).with(:kernel).returns(os)
-          Facter.stubs(:value).with(:operatingsystem).returns(os)
-          Facter.stubs(:value).with(:osfamily).returns(os)
-          Puppet::FileSystem.stubs(:exist?).with('/etc/login.defs').returns false
+          allow(Facter).to receive(:value).with(:kernel).and_return(os)
+          allow(Facter).to receive(:value).with(:operatingsystem).and_return(os)
+          allow(Facter).to receive(:value).with(:osfamily).and_return(os)
+          allow(Puppet::FileSystem).to receive(:exist?).with('/etc/login.defs').and_return(false)
           @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
           @res.catalog = Puppet::Resource::Catalog.new
         end
@@ -126,14 +126,14 @@ describe resources do
         it "should not purge system users under 1000" do
           user_hash = {:name => 'system_user', :uid => 999}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_falsey
         end
 
         it "should purge users over 999" do
           user_hash = {:name => 'system_user', :uid => 1000}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_truthy
         end
       end
@@ -141,8 +141,8 @@ describe resources do
 
     context 'with login.defs present' do
       before :each do
-        Puppet::FileSystem.expects(:exist?).with('/etc/login.defs').returns true
-        Puppet::FileSystem.expects(:each_line).with('/etc/login.defs').yields(' UID_MIN         1234 # UID_MIN comment ')
+        expect(Puppet::FileSystem).to receive(:exist?).with('/etc/login.defs').and_return(true)
+        expect(Puppet::FileSystem).to receive(:each_line).with('/etc/login.defs').and_yield(' UID_MIN         1234 # UID_MIN comment ')
         @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
         @res.catalog = Puppet::Resource::Catalog.new
       end
@@ -150,14 +150,14 @@ describe resources do
       it 'should not purge a system user' do
         user_hash = {:name => 'system_user', :uid => 1233}
         user = Puppet::Type.type(:user).new(user_hash)
-        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
         expect(@res.user_check(user)).to be_falsey
       end
 
       it 'should purge a non-system user' do
         user_hash = {:name => 'system_user', :uid => 1234}
         user = Puppet::Type.type(:user).new(user_hash)
-        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
         expect(@res.user_check(user)).to be_truthy
       end
     end
@@ -172,17 +172,16 @@ describe resources do
         it "should purge uids that are not in a specified array" do
           user_hash = {:name => 'special_user', :uid => 25_000}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_truthy
         end
 
         it "should not purge uids that are in a specified array" do
           user_hash = {:name => 'special_user', :uid => 15000}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_falsey
         end
-
       end
 
       context "with a single integer uid" do
@@ -194,14 +193,14 @@ describe resources do
         it "should purge uids that are not specified" do
           user_hash = {:name => 'special_user', :uid => 25_000}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_truthy
         end
 
         it "should not purge uids that are specified" do
           user_hash = {:name => 'special_user', :uid => 15_000}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_falsey
         end
       end
@@ -215,14 +214,14 @@ describe resources do
         it "should purge uids that are not specified" do
           user_hash = {:name => 'special_user', :uid => 25_000}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_truthy
         end
 
         it "should not purge uids that are specified" do
           user_hash = {:name => 'special_user', :uid => 15_000}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_falsey
         end
       end
@@ -236,25 +235,24 @@ describe resources do
         it "should not purge ids in the range" do
           user_hash = {:name => 'special_user', :uid => 15_000}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_falsey
         end
 
         it "should not purge specified ids" do
           user_hash = {:name => 'special_user', :uid => 16_666}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_falsey
         end
 
         it "should purge unspecified ids" do
           user_hash = {:name => 'special_user', :uid => 17_000}
           user = Puppet::Type.type(:user).new(user_hash)
-          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
           expect(@res.user_check(user)).to be_truthy
         end
       end
-
     end
   end
 
@@ -264,73 +262,73 @@ describe resources do
       @catalog = Puppet::Resource::Catalog.new
     end
 
-      context "when dealing with non-purging resources" do
-        before do
-          @resources = Puppet::Type.type(:resources).new(:name => 'host')
-        end
+    context "when dealing with non-purging resources" do
+      before do
+        @resources = Puppet::Type.type(:resources).new(:name => 'host')
+      end
 
-        it "should not generate any resource" do
-          expect(@resources.generate).to be_empty
-        end
+      it "should not generate any resource" do
+        expect(@resources.generate).to be_empty
       end
+    end
 
-      context "when the catalog contains a purging resource" do
-        before do
-          @resources = Puppet::Type.type(:resources).new(:name => 'host', :purge => true)
-          @purgeable_resource = Puppet::Type.type(:host).new(:name => 'localhost', :ip => '127.0.0.1')
-          @catalog.add_resource @resources
-        end
+    context "when the catalog contains a purging resource" do
+      before do
+        @resources = Puppet::Type.type(:resources).new(:name => 'host', :purge => true)
+        @purgeable_resource = Puppet::Type.type(:host).new(:name => 'localhost', :ip => '127.0.0.1')
+        @catalog.add_resource @resources
+      end
 
-        it "should not generate a duplicate of that resource" do
-          Puppet::Type.type(:host).stubs(:instances).returns [@host1]
-          @catalog.add_resource @host1
-          expect(@resources.generate.collect { |r| r.ref }).not_to include(@host1.ref)
-        end
+      it "should not generate a duplicate of that resource" do
+        allow(Puppet::Type.type(:host)).to receive(:instances).and_return([@host1])
+        @catalog.add_resource @host1
+        expect(@resources.generate.collect { |r| r.ref }).not_to include(@host1.ref)
+      end
 
-        it "should not include the skipped system users" do
-          res = Puppet::Type.type(:resources).new :name => :user, :purge => true
-          res.catalog = Puppet::Resource::Catalog.new
+      it "should not include the skipped system users" do
+        res = Puppet::Type.type(:resources).new :name => :user, :purge => true
+        res.catalog = Puppet::Resource::Catalog.new
 
-          root = Puppet::Type.type(:user).new(:name => "root")
-          Puppet::Type.type(:user).expects(:instances).returns [ root ]
+        root = Puppet::Type.type(:user).new(:name => "root")
+        expect(Puppet::Type.type(:user)).to receive(:instances).and_return([root])
 
-          list = res.generate
+        list = res.generate
 
-          names = list.collect { |r| r[:name] }
-          expect(names).not_to be_include("root")
-        end
+        names = list.collect { |r| r[:name] }
+        expect(names).not_to be_include("root")
+      end
 
-        context "when generating a purgeable resource" do
-          it "should be included in the generated resources" do
-            Puppet::Type.type(:host).stubs(:instances).returns [@purgeable_resource]
-            expect(@resources.generate.collect { |r| r.ref }).to include(@purgeable_resource.ref)
-          end
+      context "when generating a purgeable resource" do
+        it "should be included in the generated resources" do
+          allow(Puppet::Type.type(:host)).to receive(:instances).and_return([@purgeable_resource])
+          expect(@resources.generate.collect { |r| r.ref }).to include(@purgeable_resource.ref)
         end
+      end
 
-        context "when the instance's do not have an ensure property" do
-          it "should not be included in the generated resources" do
-            @no_ensure_resource = Puppet::Type.type(:exec).new(:name => "#{File.expand_path('/usr/bin/env')} echo")
-            Puppet::Type.type(:host).stubs(:instances).returns [@no_ensure_resource]
-            expect(@resources.generate.collect { |r| r.ref }).not_to include(@no_ensure_resource.ref)
-          end
+      context "when the instance's do not have an ensure property" do
+        it "should not be included in the generated resources" do
+          @no_ensure_resource = Puppet::Type.type(:exec).new(:name => "#{File.expand_path('/usr/bin/env')} echo")
+          allow(Puppet::Type.type(:host)).to receive(:instances).and_return([@no_ensure_resource])
+          expect(@resources.generate.collect { |r| r.ref }).not_to include(@no_ensure_resource.ref)
         end
+      end
 
-        context "when the instance's ensure property does not accept absent" do
-          it "should not be included in the generated resources" do
-            @no_absent_resource = Puppet::Type.type(:service).new(:name => 'foobar')
-            Puppet::Type.type(:host).stubs(:instances).returns [@no_absent_resource]
-            expect(@resources.generate.collect { |r| r.ref }).not_to include(@no_absent_resource.ref)
-          end
+      context "when the instance's ensure property does not accept absent" do
+        it "should not be included in the generated resources" do
+          @no_absent_resource = Puppet::Type.type(:service).new(:name => 'foobar')
+          allow(Puppet::Type.type(:host)).to receive(:instances).and_return([@no_absent_resource])
+          expect(@resources.generate.collect { |r| r.ref }).not_to include(@no_absent_resource.ref)
         end
+      end
 
-        context "when checking the instance fails" do
-          it "should not be included in the generated resources" do
-            @purgeable_resource = Puppet::Type.type(:host).new(:name => 'foobar')
-            Puppet::Type.type(:host).stubs(:instances).returns [@purgeable_resource]
-            @resources.expects(:check).with(@purgeable_resource).returns(false)
-            expect(@resources.generate.collect { |r| r.ref }).not_to include(@purgeable_resource.ref)
-          end
+      context "when checking the instance fails" do
+        it "should not be included in the generated resources" do
+          @purgeable_resource = Puppet::Type.type(:host).new(:name => 'foobar')
+          allow(Puppet::Type.type(:host)).to receive(:instances).and_return([@purgeable_resource])
+          expect(@resources).to receive(:check).with(@purgeable_resource).and_return(false)
+          expect(@resources.generate.collect { |r| r.ref }).not_to include(@purgeable_resource.ref)
         end
       end
+    end
   end
 end

data/spec/unit/type/schedule_spec.rb

@@ -1,8 +1,6 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 module ScheduleTesting
-
   def diff(unit, incr, method, count)
     diff = Time.now.to_i.send(method, incr * count)
     Time.at(diff)
@@ -19,11 +17,11 @@ module ScheduleTesting
   def min(method, count)
     diff(:min, 60, method, count)
   end
-
 end
 
 describe Puppet::Type.type(:schedule) do
   include ScheduleTesting
+
   before :each do
     Puppet[:ignoreschedules] = false
 
@@ -78,7 +76,7 @@ describe Puppet::Type.type(:schedule) do
 
   describe Puppet::Type.type(:schedule), "when matching ranges" do
     before do
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should match when the start time is before the current time and the end time is after the current time" do
@@ -114,7 +112,7 @@ describe Puppet::Type.type(:schedule) do
 
   describe Puppet::Type.type(:schedule), "when matching ranges with abbreviated time specifications" do
     before do
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 45, 59))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 45, 59))
     end
 
     it "should match when just an hour is specified" do
@@ -135,7 +133,7 @@ describe Puppet::Type.type(:schedule) do
 
   describe Puppet::Type.type(:schedule), "when matching ranges with abbreviated time specifications, edge cases part 1" do
     before do
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 00, 00))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 00, 00))
     end
 
     it "should match when the current time is the start of the range using hours" do
@@ -161,7 +159,7 @@ describe Puppet::Type.type(:schedule) do
 
   describe Puppet::Type.type(:schedule), "when matching ranges with abbreviated time specifications, edge cases part 2" do
     before do
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 00, 01))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 00, 01))
     end
 
     it "should match when the current time is just past the start of the range using hours" do
@@ -187,7 +185,7 @@ describe Puppet::Type.type(:schedule) do
 
   describe Puppet::Type.type(:schedule), "when matching ranges with abbreviated time specifications, edge cases part 3" do
     before do
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 10, 59, 59))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 10, 59, 59))
     end
 
     it "should not match when the current time is just before the start of the range using hours" do
@@ -217,7 +215,7 @@ describe Puppet::Type.type(:schedule) do
       # advancing the day properly when we push the ending limit out a day.
       # For example, adding 1 to 31 would throw an error instead of advancing
       # the date.
-      Time.stubs(:now).returns(Time.local(2011, "mar", 31, 22, 30, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "mar", 31, 22, 30, 0))
     end
 
     it "should match when the start time is before current time and the end time is the following day" do
@@ -237,7 +235,7 @@ describe Puppet::Type.type(:schedule) do
       # advancing the day properly when we push the ending limit out a day.
       # For example, adding 1 to 31 would throw an error instead of advancing
       # the date.
-      Time.stubs(:now).returns(Time.local(2011, "mar", 31, 1, 30, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "mar", 31, 1, 30, 0))
     end
 
     it "should match when the start time is the day before the current time and the end time is after the current time" do
@@ -261,7 +259,7 @@ describe Puppet::Type.type(:schedule) do
       @schedule[:period] = :hourly
       @schedule[:periodmatch] = :distance
 
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should match when the previous time was an hour ago" do
@@ -282,7 +280,7 @@ describe Puppet::Type.type(:schedule) do
       @schedule[:period] = :daily
       @schedule[:periodmatch] = :distance
 
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should match when the previous time was one day ago" do
@@ -303,7 +301,7 @@ describe Puppet::Type.type(:schedule) do
       @schedule[:period] = :weekly
       @schedule[:periodmatch] = :distance
 
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should match when the previous time was seven days ago" do
@@ -324,7 +322,7 @@ describe Puppet::Type.type(:schedule) do
       @schedule[:period] = :monthly
       @schedule[:periodmatch] = :distance
 
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should match when the previous time was 32 days ago" do
@@ -350,7 +348,7 @@ describe Puppet::Type.type(:schedule) do
       current = Time.utc(2008, 1, 1, 0, 0, 0)
       previous = Time.utc(2007, 12, 31, 23, 59, 0)
 
-      Time.stubs(:now).returns(current)
+      allow(Time).to receive(:now).and_return(current)
       expect(@schedule).to be_match(previous)
     end
 
@@ -358,7 +356,7 @@ describe Puppet::Type.type(:schedule) do
       current = Time.utc(2009, 2, 1, 12, 59, 0)
       previous = Time.utc(2009, 2, 1, 12, 0, 0)
 
-      Time.stubs(:now).returns(current)
+      allow(Time).to receive(:now).and_return(current)
       expect(@schedule).to_not be_match(previous)
     end
   end
@@ -375,7 +373,7 @@ describe Puppet::Type.type(:schedule) do
       # Now set the previous time to one minute before that
       previous = current - 60
 
-      Time.stubs(:now).returns(current)
+      allow(Time).to receive(:now).and_return(current)
       expect(@schedule).to be_match(previous)
     end
 
@@ -387,7 +385,7 @@ describe Puppet::Type.type(:schedule) do
       # Set the current time to 23:59
       now = previous + (23 * 3600) + (59 * 60)
 
-      Time.stubs(:now).returns(now)
+      allow(Time).to receive(:now).and_return(now)
       expect(@schedule).to_not be_match(previous)
     end
   end
@@ -400,7 +398,7 @@ describe Puppet::Type.type(:schedule) do
 
     it "should match if the previous time is prior to the most recent Sunday" do
       now = Time.utc(2010, "nov", 11, 0, 0, 0) # Thursday
-      Time.stubs(:now).returns(now)
+      allow(Time).to receive(:now).and_return(now)
       previous = Time.utc(2010, "nov", 6, 23, 59, 59) # Sat
 
       expect(@schedule).to be_match(previous)
@@ -408,7 +406,7 @@ describe Puppet::Type.type(:schedule) do
 
     it "should not match if the previous time is after the most recent Saturday" do
       now = Time.utc(2010, "nov", 11, 0, 0, 0) # Thursday
-      Time.stubs(:now).returns(now)
+      allow(Time).to receive(:now).and_return(now)
       previous = Time.utc(2010, "nov", 7, 0, 0, 0) # Sunday
 
       expect(@schedule).to_not be_match(previous)
@@ -423,7 +421,7 @@ describe Puppet::Type.type(:schedule) do
 
     it "should match when the previous time is prior to the first day of this month" do
       now = Time.utc(2010, "nov", 8, 00, 59, 59)
-      Time.stubs(:now).returns(now)
+      allow(Time).to receive(:now).and_return(now)
       previous = Time.utc(2010, "oct", 31, 23, 59, 59)
 
       expect(@schedule).to be_match(previous)
@@ -431,7 +429,7 @@ describe Puppet::Type.type(:schedule) do
 
     it "should not match when the previous time is after the last day of last month" do
       now = Time.utc(2010, "nov", 8, 00, 59, 59)
-      Time.stubs(:now).returns(now)
+      allow(Time).to receive(:now).and_return(now)
       previous = Time.utc(2010, "nov", 1, 0, 0, 0)
 
       expect(@schedule).to_not be_match(previous)
@@ -443,7 +441,7 @@ describe Puppet::Type.type(:schedule) do
       @schedule[:period] = :daily
       @schedule[:repeat] = 2
 
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should fail if the periodmatch is 'number'" do
@@ -465,7 +463,7 @@ describe Puppet::Type.type(:schedule) do
   describe Puppet::Type.type(:schedule), "when matching days of the week" do
     before do
       # 2011-05-23 is a Monday
-      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should raise an error if the weekday is 'Someday'" do
@@ -559,7 +557,7 @@ describe Puppet::Type.type(:schedule) do
   describe Puppet::Type.type(:schedule), "when matching days of week and ranges spanning days, day 1" do
     before do
       # Test with ranges and days-of-week both set. 2011-03-31 was a Thursday.
-      Time.stubs(:now).returns(Time.local(2011, "mar", 31, 22, 30, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "mar", 31, 22, 30, 0))
     end
 
     it "should match when the range and day of week matches" do
@@ -591,7 +589,7 @@ describe Puppet::Type.type(:schedule) do
     before do
       # 2011-03-31 was a Thursday. As the end-time of a day spanning match, that means
       # we need to match on Wednesday.
-      Time.stubs(:now).returns(Time.local(2011, "mar", 31, 1, 30, 0))
+      allow(Time).to receive(:now).and_return(Time.local(2011, "mar", 31, 1, 30, 0))
     end
 
     it "should match when the range matches and the day of week should match" do