puppet 2.7.18 → 2.7.19

data/spec/unit/transaction_spec.rb

@@ -216,14 +216,14 @@ describe Puppet::Transaction do
       @transaction.eval_generate(resource)
 
       @filenames.each do |file|
-        @transaction.catalog.resource(:file, file).should be_a(Puppet::Type.type(:file))
+        @transaction.catalog.resource(:file, file).must be_a(Puppet::Type.type(:file))
       end
     end
 
     it "should add a sentinel whit for the resource" do
       @transaction.eval_generate(resource)
 
-      find_vertex(:whit, "completed_#{path}").should be_a(Puppet::Type.type(:whit))
+      find_vertex(:whit, "completed_#{path}").must be_a(Puppet::Type.type(:whit))
     end
 
     it "should replace dependencies on the resource with dependencies on the sentinel" do
@@ -558,7 +558,7 @@ describe Puppet::Transaction do
       transaction.add_dynamically_generated_resources
 
       generated.each do |res|
-        res.should be_tagged(generator.tags)
+        res.must be_tagged(generator.tags)
       end
     end
   end

data/spec/unit/type/cron_spec.rb

@@ -38,25 +38,25 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
 
     describe "ensure" do
       it "should support present as a value for ensure" do
-        proc { described_class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :ensure => :present) }.to_not raise_error
       end
 
       it "should support absent as a value for ensure" do
-        proc { described_class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :ensure => :present) }.to_not raise_error
       end
 
       it "should not support other values" do
-        proc { described_class.new(:name => 'foo', :ensure => :foo) }.should raise_error(Puppet::Error, /Invalid value/)
+        expect { described_class.new(:name => 'foo', :ensure => :foo) }.to raise_error(Puppet::Error, /Invalid value/)
       end
     end
 
     describe "minute" do
       it "should support absent" do
-        proc { described_class.new(:name => 'foo', :minute => 'absent') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => 'absent') }.to_not raise_error
       end
 
       it "should support *" do
-        proc { described_class.new(:name => 'foo', :minute => '*') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => '*') }.to_not raise_error
       end
 
       it "should translate absent to :absent" do
@@ -68,62 +68,62 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should support valid single values" do
-        proc { described_class.new(:name => 'foo', :minute => '0') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :minute => '1') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :minute => '59') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => '0') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => '1') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => '59') }.to_not raise_error
       end
 
       it "should not support non numeric characters" do
-        proc { described_class.new(:name => 'foo', :minute => 'z59') }.should raise_error(Puppet::Error, /z59 is not a valid minute/)
-        proc { described_class.new(:name => 'foo', :minute => '5z9') }.should raise_error(Puppet::Error, /5z9 is not a valid minute/)
-        proc { described_class.new(:name => 'foo', :minute => '59z') }.should raise_error(Puppet::Error, /59z is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => 'z59') }.to raise_error(Puppet::Error, /z59 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '5z9') }.to raise_error(Puppet::Error, /5z9 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '59z') }.to raise_error(Puppet::Error, /59z is not a valid minute/)
       end
 
       it "should not support single values out of range" do
 
-        proc { described_class.new(:name => 'foo', :minute => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid minute/)
-        proc { described_class.new(:name => 'foo', :minute => '60') }.should raise_error(Puppet::Error, /60 is not a valid minute/)
-        proc { described_class.new(:name => 'foo', :minute => '61') }.should raise_error(Puppet::Error, /61 is not a valid minute/)
-        proc { described_class.new(:name => 'foo', :minute => '120') }.should raise_error(Puppet::Error, /120 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '60') }.to raise_error(Puppet::Error, /60 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '61') }.to raise_error(Puppet::Error, /61 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '120') }.to raise_error(Puppet::Error, /120 is not a valid minute/)
       end
 
       it "should support valid multiple values" do
-        proc { described_class.new(:name => 'foo', :minute => ['0','1','59'] ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :minute => ['40','30','20'] ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :minute => ['10','30','20'] ) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => ['0','1','59'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => ['40','30','20'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => ['10','30','20'] ) }.to_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
-        proc { described_class.new(:name => 'foo', :minute => ['0','1','60'] ) }.should raise_error(Puppet::Error, /60 is not a valid minute/)
-        proc { described_class.new(:name => 'foo', :minute => ['0','120','59'] ) }.should raise_error(Puppet::Error, /120 is not a valid minute/)
-        proc { described_class.new(:name => 'foo', :minute => ['-1','1','59'] ) }.should raise_error(Puppet::Error, /-1 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => ['0','1','60'] ) }.to raise_error(Puppet::Error, /60 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => ['0','120','59'] ) }.to raise_error(Puppet::Error, /120 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => ['-1','1','59'] ) }.to raise_error(Puppet::Error, /-1 is not a valid minute/)
         # two invalid
-        proc { described_class.new(:name => 'foo', :minute => ['0','61','62'] ) }.should raise_error(Puppet::Error, /(61|62) is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => ['0','61','62'] ) }.to raise_error(Puppet::Error, /(61|62) is not a valid minute/)
         # all invalid
-        proc { described_class.new(:name => 'foo', :minute => ['-1','61','62'] ) }.should raise_error(Puppet::Error, /(-1|61|62) is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => ['-1','61','62'] ) }.to raise_error(Puppet::Error, /(-1|61|62) is not a valid minute/)
       end
 
       it "should support valid step syntax" do
-        proc { described_class.new(:name => 'foo', :minute => '*/2' ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :minute => '10-16/2' ) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => '*/2' ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => '10-16/2' ) }.to_not raise_error
       end
 
       it "should not support invalid steps" do
-        proc { described_class.new(:name => 'foo', :minute => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid minute/)
-        proc { described_class.new(:name => 'foo', :minute => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid minute/)
         # As it turns out cron does not complaining about steps that exceed the valid range
-        # proc { described_class.new(:name => 'foo', :minute => '*/120' ) }.should raise_error(Puppet::Error, /is not a valid minute/)
+        # expect { described_class.new(:name => 'foo', :minute => '*/120' ) }.to raise_error(Puppet::Error, /is not a valid minute/)
       end
     end
 
     describe "hour" do
       it "should support absent" do
-        proc { described_class.new(:name => 'foo', :hour => 'absent') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => 'absent') }.to_not raise_error
       end
 
       it "should support *" do
-        proc { described_class.new(:name => 'foo', :hour => '*') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '*') }.to_not raise_error
       end
 
       it "should translate absent to :absent" do
@@ -135,62 +135,62 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should support valid single values" do
-        proc { described_class.new(:name => 'foo', :hour => '0') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :hour => '11') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :hour => '12') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :hour => '13') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :hour => '23') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '0') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '11') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '12') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '13') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '23') }.to_not raise_error
       end
 
       it "should not support non numeric characters" do
-        proc { described_class.new(:name => 'foo', :hour => 'z15') }.should raise_error(Puppet::Error, /z15 is not a valid hour/)
-        proc { described_class.new(:name => 'foo', :hour => '1z5') }.should raise_error(Puppet::Error, /1z5 is not a valid hour/)
-        proc { described_class.new(:name => 'foo', :hour => '15z') }.should raise_error(Puppet::Error, /15z is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => 'z15') }.to raise_error(Puppet::Error, /z15 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '1z5') }.to raise_error(Puppet::Error, /1z5 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '15z') }.to raise_error(Puppet::Error, /15z is not a valid hour/)
       end
 
       it "should not support single values out of range" do
-        proc { described_class.new(:name => 'foo', :hour => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid hour/)
-        proc { described_class.new(:name => 'foo', :hour => '24') }.should raise_error(Puppet::Error, /24 is not a valid hour/)
-        proc { described_class.new(:name => 'foo', :hour => '120') }.should raise_error(Puppet::Error, /120 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '24') }.to raise_error(Puppet::Error, /24 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '120') }.to raise_error(Puppet::Error, /120 is not a valid hour/)
       end
 
       it "should support valid multiple values" do
-        proc { described_class.new(:name => 'foo', :hour => ['0','1','23'] ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :hour => ['5','16','14'] ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :hour => ['16','13','9'] ) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => ['0','1','23'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => ['5','16','14'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => ['16','13','9'] ) }.to_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
-        proc { described_class.new(:name => 'foo', :hour => ['0','1','24'] ) }.should raise_error(Puppet::Error, /24 is not a valid hour/)
-        proc { described_class.new(:name => 'foo', :hour => ['0','-1','5'] ) }.should raise_error(Puppet::Error, /-1 is not a valid hour/)
-        proc { described_class.new(:name => 'foo', :hour => ['-1','1','23'] ) }.should raise_error(Puppet::Error, /-1 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => ['0','1','24'] ) }.to raise_error(Puppet::Error, /24 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => ['0','-1','5'] ) }.to raise_error(Puppet::Error, /-1 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => ['-1','1','23'] ) }.to raise_error(Puppet::Error, /-1 is not a valid hour/)
         # two invalid
-        proc { described_class.new(:name => 'foo', :hour => ['0','25','26'] ) }.should raise_error(Puppet::Error, /(25|26) is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => ['0','25','26'] ) }.to raise_error(Puppet::Error, /(25|26) is not a valid hour/)
         # all invalid
-        proc { described_class.new(:name => 'foo', :hour => ['-1','24','120'] ) }.should raise_error(Puppet::Error, /(-1|24|120) is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => ['-1','24','120'] ) }.to raise_error(Puppet::Error, /(-1|24|120) is not a valid hour/)
       end
 
       it "should support valid step syntax" do
-        proc { described_class.new(:name => 'foo', :hour => '*/2' ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :hour => '10-18/4' ) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '*/2' ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '10-18/4' ) }.to_not raise_error
       end
 
       it "should not support invalid steps" do
-        proc { described_class.new(:name => 'foo', :hour => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid hour/)
-        proc { described_class.new(:name => 'foo', :hour => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid hour/)
         # As it turns out cron does not complaining about steps that exceed the valid range
-        # proc { described_class.new(:name => 'foo', :hour => '*/26' ) }.should raise_error(Puppet::Error, /is not a valid hour/)
+        # expect { described_class.new(:name => 'foo', :hour => '*/26' ) }.to raise_error(Puppet::Error, /is not a valid hour/)
       end
     end
 
     describe "weekday" do
       it "should support absent" do
-        proc { described_class.new(:name => 'foo', :weekday => 'absent') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'absent') }.to_not raise_error
       end
 
       it "should support *" do
-        proc { described_class.new(:name => 'foo', :weekday => '*') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => '*') }.to_not raise_error
       end
 
       it "should translate absent to :absent" do
@@ -202,78 +202,78 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should support valid numeric weekdays" do
-        proc { described_class.new(:name => 'foo', :weekday => '0') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => '1') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => '6') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => '0') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => '1') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => '6') }.to_not raise_error
         # According to http://www.manpagez.com/man/5/crontab 7 is also valid (Sunday)
-        proc { described_class.new(:name => 'foo', :weekday => '7') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => '7') }.to_not raise_error
       end
 
       it "should support valid weekdays as words (long version)" do
-        proc { described_class.new(:name => 'foo', :weekday => 'Monday') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Tuesday') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Wednesday') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Thursday') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Friday') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Saturday') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Sunday') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Monday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Tuesday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Wednesday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Thursday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Friday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Saturday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Sunday') }.to_not raise_error
       end
 
       it "should support valid weekdays as words (3 character version)" do
-        proc { described_class.new(:name => 'foo', :weekday => 'Mon') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Tue') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Wed') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Thu') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Fri') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Sat') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => 'Sun') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Mon') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Tue') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Wed') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Thu') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Fri') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Sat') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Sun') }.to_not raise_error
       end
 
       it "should not support numeric values out of range" do
-        proc { described_class.new(:name => 'foo', :weekday => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid weekday/)
-        proc { described_class.new(:name => 'foo', :weekday => '8') }.should raise_error(Puppet::Error, /8 is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => '8') }.to raise_error(Puppet::Error, /8 is not a valid weekday/)
       end
 
       it "should not support invalid weekday names" do
-        proc { described_class.new(:name => 'foo', :weekday => 'Sar') }.should raise_error(Puppet::Error, /Sar is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => 'Sar') }.to raise_error(Puppet::Error, /Sar is not a valid weekday/)
       end
 
       it "should support valid multiple values" do
-        proc { described_class.new(:name => 'foo', :weekday => ['0','1','6'] ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => ['Mon','Wed','Friday'] ) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => ['0','1','6'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => ['Mon','Wed','Friday'] ) }.to_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
-        proc { described_class.new(:name => 'foo', :weekday => ['0','1','8'] ) }.should raise_error(Puppet::Error, /8 is not a valid weekday/)
-        proc { described_class.new(:name => 'foo', :weekday => ['Mon','Fii','Sat'] ) }.should raise_error(Puppet::Error, /Fii is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => ['0','1','8'] ) }.to raise_error(Puppet::Error, /8 is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => ['Mon','Fii','Sat'] ) }.to raise_error(Puppet::Error, /Fii is not a valid weekday/)
         # two invalid
-        proc { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Sat'] ) }.should raise_error(Puppet::Error, /(Mos|Fii) is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Sat'] ) }.to raise_error(Puppet::Error, /(Mos|Fii) is not a valid weekday/)
         # all invalid
-        proc { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Saa'] ) }.should raise_error(Puppet::Error, /(Mos|Fii|Saa) is not a valid weekday/)
-        proc { described_class.new(:name => 'foo', :weekday => ['-1','8','11'] ) }.should raise_error(Puppet::Error, /(-1|8|11) is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Saa'] ) }.to raise_error(Puppet::Error, /(Mos|Fii|Saa) is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => ['-1','8','11'] ) }.to raise_error(Puppet::Error, /(-1|8|11) is not a valid weekday/)
       end
 
       it "should support valid step syntax" do
-        proc { described_class.new(:name => 'foo', :weekday => '*/2' ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :weekday => '0-4/2' ) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => '*/2' ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => '0-4/2' ) }.to_not raise_error
       end
 
       it "should not support invalid steps" do
-        proc { described_class.new(:name => 'foo', :weekday => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid weekday/)
-        proc { described_class.new(:name => 'foo', :weekday => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid weekday/)
         # As it turns out cron does not complaining about steps that exceed the valid range
-        # proc { described_class.new(:name => 'foo', :weekday => '*/9' ) }.should raise_error(Puppet::Error, /is not a valid weekday/)
+        # expect { described_class.new(:name => 'foo', :weekday => '*/9' ) }.to raise_error(Puppet::Error, /is not a valid weekday/)
       end
     end
 
     describe "month" do
       it "should support absent" do
-        proc { described_class.new(:name => 'foo', :month => 'absent') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'absent') }.to_not raise_error
       end
 
       it "should support *" do
-        proc { described_class.new(:name => 'foo', :month => '*') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :month => '*') }.to_not raise_error
       end
 
       it "should translate absent to :absent" do
@@ -285,95 +285,95 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should support valid numeric values" do
-        proc { described_class.new(:name => 'foo', :month => '1') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => '12') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :month => '1') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => '12') }.to_not raise_error
       end
 
       it "should support valid months as words" do
-        proc { described_class.new(:name => 'foo', :month => 'January') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'February') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'March') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'April') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'May') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'June') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'July') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'August') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'September') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'October') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'November') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'December') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'January') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'February') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'March') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'April') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'May') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'June') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'July') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'August') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'September') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'October') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'November') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'December') }.to_not raise_error
       end
 
       it "should support valid months as words (3 character short version)" do
-        proc { described_class.new(:name => 'foo', :month => 'Jan') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'Feb') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'Mar') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'Apr') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'May') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'Jun') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'Jul') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'Aug') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'Sep') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'Oct') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'Nov') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => 'Dec') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Jan') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Feb') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Mar') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Apr') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'May') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Jun') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Jul') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Aug') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Sep') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Oct') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Nov') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => 'Dec') }.to_not raise_error
       end
 
       it "should not support numeric values out of range" do
-        proc { described_class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid month/)
-        proc { described_class.new(:name => 'foo', :month => '0') }.should raise_error(Puppet::Error, /0 is not a valid month/)
-        proc { described_class.new(:name => 'foo', :month => '13') }.should raise_error(Puppet::Error, /13 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '0') }.to raise_error(Puppet::Error, /0 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '13') }.to raise_error(Puppet::Error, /13 is not a valid month/)
       end
 
       it "should not support words that are not valid months" do
-        proc { described_class.new(:name => 'foo', :month => 'Jal') }.should raise_error(Puppet::Error, /Jal is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => 'Jal') }.to raise_error(Puppet::Error, /Jal is not a valid month/)
       end
 
       it "should not support single values out of range" do
 
-        proc { described_class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid month/)
-        proc { described_class.new(:name => 'foo', :month => '60') }.should raise_error(Puppet::Error, /60 is not a valid month/)
-        proc { described_class.new(:name => 'foo', :month => '61') }.should raise_error(Puppet::Error, /61 is not a valid month/)
-        proc { described_class.new(:name => 'foo', :month => '120') }.should raise_error(Puppet::Error, /120 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '60') }.to raise_error(Puppet::Error, /60 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '61') }.to raise_error(Puppet::Error, /61 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '120') }.to raise_error(Puppet::Error, /120 is not a valid month/)
       end
 
       it "should support valid multiple values" do
-        proc { described_class.new(:name => 'foo', :month => ['1','9','12'] ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => ['Jan','March','Jul'] ) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :month => ['1','9','12'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => ['Jan','March','Jul'] ) }.to_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
-        proc { described_class.new(:name => 'foo', :month => ['0','1','12'] ) }.should raise_error(Puppet::Error, /0 is not a valid month/)
-        proc { described_class.new(:name => 'foo', :month => ['1','13','10'] ) }.should raise_error(Puppet::Error, /13 is not a valid month/)
-        proc { described_class.new(:name => 'foo', :month => ['Jan','Feb','Jxx'] ) }.should raise_error(Puppet::Error, /Jxx is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => ['0','1','12'] ) }.to raise_error(Puppet::Error, /0 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => ['1','13','10'] ) }.to raise_error(Puppet::Error, /13 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => ['Jan','Feb','Jxx'] ) }.to raise_error(Puppet::Error, /Jxx is not a valid month/)
         # two invalid
-        proc { described_class.new(:name => 'foo', :month => ['Jan','Fex','Jux'] ) }.should raise_error(Puppet::Error, /(Fex|Jux) is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => ['Jan','Fex','Jux'] ) }.to raise_error(Puppet::Error, /(Fex|Jux) is not a valid month/)
         # all invalid
-        proc { described_class.new(:name => 'foo', :month => ['-1','0','13'] ) }.should raise_error(Puppet::Error, /(-1|0|13) is not a valid month/)
-        proc { described_class.new(:name => 'foo', :month => ['Jax','Fex','Aux'] ) }.should raise_error(Puppet::Error, /(Jax|Fex|Aux) is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => ['-1','0','13'] ) }.to raise_error(Puppet::Error, /(-1|0|13) is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => ['Jax','Fex','Aux'] ) }.to raise_error(Puppet::Error, /(Jax|Fex|Aux) is not a valid month/)
       end
 
       it "should support valid step syntax" do
-        proc { described_class.new(:name => 'foo', :month => '*/2' ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :month => '1-12/3' ) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :month => '*/2' ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => '1-12/3' ) }.to_not raise_error
       end
 
       it "should not support invalid steps" do
-        proc { described_class.new(:name => 'foo', :month => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid month/)
-        proc { described_class.new(:name => 'foo', :month => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid month/)
         # As it turns out cron does not complaining about steps that exceed the valid range
-        # proc { described_class.new(:name => 'foo', :month => '*/13' ) }.should raise_error(Puppet::Error, /is not a valid month/)
+        # expect { described_class.new(:name => 'foo', :month => '*/13' ) }.to raise_error(Puppet::Error, /is not a valid month/)
       end
     end
 
     describe "monthday" do
       it "should support absent" do
-        proc { described_class.new(:name => 'foo', :monthday => 'absent') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => 'absent') }.to_not raise_error
       end
 
       it "should support *" do
-        proc { described_class.new(:name => 'foo', :monthday => '*') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => '*') }.to_not raise_error
       end
 
       it "should translate absent to :absent" do
@@ -385,76 +385,76 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should support valid single values" do
-        proc { described_class.new(:name => 'foo', :monthday => '1') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :monthday => '30') }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :monthday => '31') }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => '1') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => '30') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => '31') }.to_not raise_error
       end
 
       it "should not support non numeric characters" do
-        proc { described_class.new(:name => 'foo', :monthday => 'z23') }.should raise_error(Puppet::Error, /z23 is not a valid monthday/)
-        proc { described_class.new(:name => 'foo', :monthday => '2z3') }.should raise_error(Puppet::Error, /2z3 is not a valid monthday/)
-        proc { described_class.new(:name => 'foo', :monthday => '23z') }.should raise_error(Puppet::Error, /23z is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => 'z23') }.to raise_error(Puppet::Error, /z23 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '2z3') }.to raise_error(Puppet::Error, /2z3 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '23z') }.to raise_error(Puppet::Error, /23z is not a valid monthday/)
       end
 
       it "should not support single values out of range" do
-        proc { described_class.new(:name => 'foo', :monthday => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid monthday/)
-        proc { described_class.new(:name => 'foo', :monthday => '0') }.should raise_error(Puppet::Error, /0 is not a valid monthday/)
-        proc { described_class.new(:name => 'foo', :monthday => '32') }.should raise_error(Puppet::Error, /32 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '0') }.to raise_error(Puppet::Error, /0 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '32') }.to raise_error(Puppet::Error, /32 is not a valid monthday/)
       end
 
       it "should support valid multiple values" do
-        proc { described_class.new(:name => 'foo', :monthday => ['1','23','31'] ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :monthday => ['31','23','1'] ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :monthday => ['1','31','23'] ) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => ['1','23','31'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => ['31','23','1'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => ['1','31','23'] ) }.to_not raise_error
       end
 
       it "should not support multiple values if at least one is invalid" do
         # one invalid
-        proc { described_class.new(:name => 'foo', :monthday => ['1','23','32'] ) }.should raise_error(Puppet::Error, /32 is not a valid monthday/)
-        proc { described_class.new(:name => 'foo', :monthday => ['-1','12','23'] ) }.should raise_error(Puppet::Error, /-1 is not a valid monthday/)
-        proc { described_class.new(:name => 'foo', :monthday => ['13','32','30'] ) }.should raise_error(Puppet::Error, /32 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => ['1','23','32'] ) }.to raise_error(Puppet::Error, /32 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => ['-1','12','23'] ) }.to raise_error(Puppet::Error, /-1 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => ['13','32','30'] ) }.to raise_error(Puppet::Error, /32 is not a valid monthday/)
         # two invalid
-        proc { described_class.new(:name => 'foo', :monthday => ['-1','0','23'] ) }.should raise_error(Puppet::Error, /(-1|0) is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => ['-1','0','23'] ) }.to raise_error(Puppet::Error, /(-1|0) is not a valid monthday/)
         # all invalid
-        proc { described_class.new(:name => 'foo', :monthday => ['-1','0','32'] ) }.should raise_error(Puppet::Error, /(-1|0|32) is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => ['-1','0','32'] ) }.to raise_error(Puppet::Error, /(-1|0|32) is not a valid monthday/)
       end
 
       it "should support valid step syntax" do
-        proc { described_class.new(:name => 'foo', :monthday => '*/2' ) }.should_not raise_error
-        proc { described_class.new(:name => 'foo', :monthday => '10-16/2' ) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => '*/2' ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => '10-16/2' ) }.to_not raise_error
       end
 
       it "should not support invalid steps" do
-        proc { described_class.new(:name => 'foo', :monthday => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid monthday/)
-        proc { described_class.new(:name => 'foo', :monthday => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid monthday/)
         # As it turns out cron does not complaining about steps that exceed the valid range
-        # proc { described_class.new(:name => 'foo', :monthday => '*/32' ) }.should raise_error(Puppet::Error, /is not a valid monthday/)
+        # expect { described_class.new(:name => 'foo', :monthday => '*/32' ) }.to raise_error(Puppet::Error, /is not a valid monthday/)
       end
     end
 
     describe "environment" do
       it "it should accept an :environment that looks like a path" do
-        lambda do
+        expect do
           described_class.new(:name => 'foo',:environment => 'PATH=/bin:/usr/bin:/usr/sbin')
-        end.should_not raise_error
+        end.to_not raise_error
       end
 
       it "should not accept environment variables that do not contain '='" do
-        lambda do
+        expect do
           described_class.new(:name => 'foo',:environment => 'INVALID')
-        end.should raise_error(Puppet::Error, /Invalid environment setting "INVALID"/)
+        end.to raise_error(Puppet::Error, /Invalid environment setting "INVALID"/)
       end
 
       it "should accept empty environment variables that do not contain '='" do
-        lambda do
+        expect do
           described_class.new(:name => 'foo',:environment => 'MAILTO=')
-        end.should_not raise_error(Puppet::Error)
+        end.to_not raise_error(Puppet::Error)
       end
 
       it "should accept 'absent'" do
-        lambda do
+        expect do
           described_class.new(:name => 'foo',:environment => 'absent')
-        end.should_not raise_error(Puppet::Error)
+        end.to_not raise_error(Puppet::Error)
       end
 
     end
@@ -481,7 +481,7 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
 
   it "should require a command when adding an entry" do
     entry = described_class.new(:name => "test_entry", :ensure => :present)
-    expect { entry.value(:command) }.should raise_error(Puppet::Error, /No command/)
+    expect { entry.value(:command) }.to raise_error(Puppet::Error, /No command/)
   end
 
   it "should not require a command when removing an entry" do