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

data/spec/unit/type/resources_spec.rb

@@ -1,19 +1,27 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
+# A type and provider that can be purged
+Puppet::Type.newtype(:purgeable_test) do
+  ensurable
+  newparam(:name) {}
+end
+Puppet::Type.type(:purgeable_test).provide(:purgeable_test) do
+end
+
 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
-      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)
+      Puppet::Type.stubs(:type).with { |x| x.to_s.downcase == "resources"}.returns resources
+      Puppet::Type.expects(:type).with("nosuchtype").returns nil
       expect { resources.new :name => "nosuchtype" }.to raise_error(Puppet::Error)
     end
 
@@ -38,20 +46,20 @@ describe resources do
     end
 
     it "cannot be set to true for a resource type that does not accept ensure" do
-      allow(instance.resource_type).to receive(:respond_to?).and_return(true)
-      allow(instance.resource_type).to receive(:validproperty?).and_return(false)
+      instance.resource_type.stubs(:respond_to?).returns true
+      instance.resource_type.stubs(:validproperty?).returns 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
-      allow(instance.resource_type).to receive(:respond_to?).and_return(false)
-      allow(instance.resource_type).to receive(:validproperty?).and_return(true)
+      instance.resource_type.stubs(:respond_to?).returns false
+      instance.resource_type.stubs(:validproperty?).returns 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
-      allow(instance.resource_type).to receive(:respond_to?).and_return(true)
-      allow(instance.resource_type).to receive(:validproperty?).and_return(true)
+      instance.resource_type.stubs(:respond_to?).returns true
+      instance.resource_type.stubs(:validproperty?).returns true
       expect { instance[:purge] = 'yes' }.to_not raise_error
     end
   end
@@ -61,7 +69,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
-        allow(Puppet::FileSystem).to receive(:exist?).with('/etc/login.defs').and_return(false)
+        Puppet::FileSystem.stubs(:exist?).with('/etc/login.defs').returns false
       end
 
       it "should never purge hardcoded system users" do
@@ -73,14 +81,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)
-        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+        user.stubs(:retrieve_resource).returns 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)
-        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
         expect(@res.user_check(user)).to be_truthy
       end
 
@@ -89,36 +97,18 @@ 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)
-        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 Windows system users" do
-        res = Puppet::Type.type(:resources).new :name => :user, :purge => true
-        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)
-        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
         expect(res.user_check(user)).to be_falsey
       end
-
-      it "should not purge Windows system users" do
-        res = Puppet::Type.type(:resources).new :name => :user, :purge => true
-        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)
-        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
 
     %w(FreeBSD OpenBSD).each do |os|
       context "on #{os}" do
         before :each do
-          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)
+          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
           @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
           @res.catalog = Puppet::Resource::Catalog.new
         end
@@ -126,14 +116,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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns 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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
           expect(@res.user_check(user)).to be_truthy
         end
       end
@@ -141,8 +131,8 @@ describe resources do
 
     context 'with login.defs present' do
       before :each do
-        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 ')
+        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 ')
         @res = Puppet::Type.type(:resources).new :name => :user, :purge => true, :unless_system_user => true
         @res.catalog = Puppet::Resource::Catalog.new
       end
@@ -150,14 +140,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)
-        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+        user.stubs(:retrieve_resource).returns 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)
-        allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
         expect(@res.user_check(user)).to be_truthy
       end
     end
@@ -172,16 +162,17 @@ 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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns 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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns 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
@@ -193,14 +184,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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns 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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
           expect(@res.user_check(user)).to be_falsey
         end
       end
@@ -214,14 +205,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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns 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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
           expect(@res.user_check(user)).to be_falsey
         end
       end
@@ -235,100 +226,107 @@ 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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns 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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns 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)
-          allow(user).to receive(:retrieve_resource).and_return(Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash))
+          user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
           expect(@res.user_check(user)).to be_truthy
         end
       end
+
     end
   end
 
   context "#generate" do
     before do
-      @host1 = Puppet::Type.type(:host).new(:name => 'localhost', :ip => '127.0.0.1')
+      @purgee = Puppet::Type.type(:purgeable_test).new(:name => 'localhost')
       @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 => 'purgeable_test')
+        end
 
-      it "should not generate any resource" do
-        expect(@resources.generate).to be_empty
+        it "should not generate any resource" do
+          expect(@resources.generate).to be_empty
+        end
       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 => 'purgeable_test', :purge => true)
+          @purgeable_resource = Puppet::Type.type(:purgeable_test).new(:name => 'localhost')
+          @catalog.add_resource @resources
+        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 generate a duplicate of that resource" do
+          Puppet::Type.type(:purgeable_test).stubs(:instances).returns [@purgee]
+          @catalog.add_resource @purgee
+          expect(@resources.generate.collect { |r| r.ref }).not_to include(@purgee.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")
-        expect(Puppet::Type.type(:user)).to receive(:instances).and_return([root])
+          root = Puppet::Type.type(:user).new(:name => "root")
+          Puppet::Type.type(:user).expects(:instances).returns [ 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
-          allow(Puppet::Type.type(:host)).to receive(:instances).and_return([@purgeable_resource])
-          expect(@resources.generate.collect { |r| r.ref }).to include(@purgeable_resource.ref)
+        context "when generating a purgeable resource" do
+          it "should be included in the generated resources" do
+            Puppet::Type.type(:purgeable_test).stubs(:instances).returns [@purgeable_resource]
+            expect(@resources.generate.collect { |r| r.ref }).to include(@purgeable_resource.ref)
+          end
         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")
-          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)
+        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(:purgeable_test).stubs(:instances).returns [@no_ensure_resource]
+            expect(@resources.generate.collect { |r| r.ref }).not_to include(@no_ensure_resource.ref)
+          end
         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')
-          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)
+        context "when the instance's ensure property does not accept absent" do
+          it "should not be included in the generated resources" do
+            # We have a :confine block that calls execute in our upstart provider, which fails
+            # on jruby. Thus, we stub it out here since we don't care to do any assertions on it.
+            # This is only an issue if you're running these unit tests on a platform where upstart
+            # is a default provider, like Ubuntu trusty.
+            Puppet::Util::Execution.stubs(:execute)
+
+            @no_absent_resource = Puppet::Type.type(:service).new(:name => 'foobar')
+            Puppet::Type.type(:purgeable_test).stubs(:instances).returns [@no_absent_resource]
+            expect(@resources.generate.collect { |r| r.ref }).not_to include(@no_absent_resource.ref)
+          end
         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')
-          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)
+        context "when checking the instance fails" do
+          it "should not be included in the generated resources" do
+            @purgeable_resource = Puppet::Type.type(:purgeable_test).new(:name => 'foobar')
+            Puppet::Type.type(:purgeable_test).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
         end
       end
-    end
   end
 end

data/spec/unit/type/schedule_spec.rb

@@ -1,6 +1,8 @@
+#! /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)
@@ -17,11 +19,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
 
@@ -76,7 +78,7 @@ describe Puppet::Type.type(:schedule) do
 
   describe Puppet::Type.type(:schedule), "when matching ranges" do
     before do
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
+      Time.stubs(:now).returns(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
@@ -105,14 +107,14 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match the upper array of ranges" do
-      @schedule[:range] = ["4-6", "11-12"]
+      @schedule[:range] = ["11:30 - 6", "11-12"]
       expect(@schedule).to be_match
     end
   end
 
   describe Puppet::Type.type(:schedule), "when matching ranges with abbreviated time specifications" do
     before do
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 45, 59))
+      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 45, 59))
     end
 
     it "should match when just an hour is specified" do
@@ -133,7 +135,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
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 00, 00))
+      Time.stubs(:now).returns(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
@@ -159,7 +161,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
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 00, 01))
+      Time.stubs(:now).returns(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
@@ -185,7 +187,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
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 10, 59, 59))
+      Time.stubs(:now).returns(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
@@ -215,7 +217,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.
-      allow(Time).to receive(:now).and_return(Time.local(2011, "mar", 31, 22, 30, 0))
+      Time.stubs(:now).returns(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
@@ -235,7 +237,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.
-      allow(Time).to receive(:now).and_return(Time.local(2011, "mar", 31, 1, 30, 0))
+      Time.stubs(:now).returns(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
@@ -259,7 +261,7 @@ describe Puppet::Type.type(:schedule) do
       @schedule[:period] = :hourly
       @schedule[:periodmatch] = :distance
 
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
+      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should match when the previous time was an hour ago" do
@@ -280,7 +282,7 @@ describe Puppet::Type.type(:schedule) do
       @schedule[:period] = :daily
       @schedule[:periodmatch] = :distance
 
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
+      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should match when the previous time was one day ago" do
@@ -301,7 +303,7 @@ describe Puppet::Type.type(:schedule) do
       @schedule[:period] = :weekly
       @schedule[:periodmatch] = :distance
 
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
+      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should match when the previous time was seven days ago" do
@@ -322,7 +324,7 @@ describe Puppet::Type.type(:schedule) do
       @schedule[:period] = :monthly
       @schedule[:periodmatch] = :distance
 
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
+      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should match when the previous time was 32 days ago" do
@@ -348,7 +350,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)
 
-      allow(Time).to receive(:now).and_return(current)
+      Time.stubs(:now).returns(current)
       expect(@schedule).to be_match(previous)
     end
 
@@ -356,7 +358,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)
 
-      allow(Time).to receive(:now).and_return(current)
+      Time.stubs(:now).returns(current)
       expect(@schedule).to_not be_match(previous)
     end
   end
@@ -373,7 +375,7 @@ describe Puppet::Type.type(:schedule) do
       # Now set the previous time to one minute before that
       previous = current - 60
 
-      allow(Time).to receive(:now).and_return(current)
+      Time.stubs(:now).returns(current)
       expect(@schedule).to be_match(previous)
     end
 
@@ -385,7 +387,7 @@ describe Puppet::Type.type(:schedule) do
       # Set the current time to 23:59
       now = previous + (23 * 3600) + (59 * 60)
 
-      allow(Time).to receive(:now).and_return(now)
+      Time.stubs(:now).returns(now)
       expect(@schedule).to_not be_match(previous)
     end
   end
@@ -398,7 +400,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
-      allow(Time).to receive(:now).and_return(now)
+      Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "nov", 6, 23, 59, 59) # Sat
 
       expect(@schedule).to be_match(previous)
@@ -406,7 +408,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
-      allow(Time).to receive(:now).and_return(now)
+      Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "nov", 7, 0, 0, 0) # Sunday
 
       expect(@schedule).to_not be_match(previous)
@@ -421,7 +423,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)
-      allow(Time).to receive(:now).and_return(now)
+      Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "oct", 31, 23, 59, 59)
 
       expect(@schedule).to be_match(previous)
@@ -429,7 +431,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)
-      allow(Time).to receive(:now).and_return(now)
+      Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "nov", 1, 0, 0, 0)
 
       expect(@schedule).to_not be_match(previous)
@@ -441,14 +443,12 @@ describe Puppet::Type.type(:schedule) do
       @schedule[:period] = :daily
       @schedule[:repeat] = 2
 
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
+      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should fail if the periodmatch is 'number'" do
       @schedule[:periodmatch] = :number
-      expect {
-        @schedule[:repeat] = 2
-      }.to raise_error(Puppet::Error)
+      expect(proc { @schedule[:repeat] = 2 }).to raise_error(Puppet::Error)
     end
 
     it "should match if the previous run was further away than the distance divided by the repeat" do
@@ -465,7 +465,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
-      allow(Time).to receive(:now).and_return(Time.local(2011, "may", 23, 11, 0, 0))
+      Time.stubs(:now).returns(Time.local(2011, "may", 23, 11, 0, 0))
     end
 
     it "should raise an error if the weekday is 'Someday'" do
@@ -559,7 +559,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.
-      allow(Time).to receive(:now).and_return(Time.local(2011, "mar", 31, 22, 30, 0))
+      Time.stubs(:now).returns(Time.local(2011, "mar", 31, 22, 30, 0))
     end
 
     it "should match when the range and day of week matches" do
@@ -591,7 +591,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.
-      allow(Time).to receive(:now).and_return(Time.local(2011, "mar", 31, 1, 30, 0))
+      Time.stubs(:now).returns(Time.local(2011, "mar", 31, 1, 30, 0))
     end
 
     it "should match when the range matches and the day of week should match" do