puppet 3.8.7 → 4.0.0

data/spec/unit/type/schedule_spec.rb

@@ -32,24 +32,24 @@ describe Puppet::Type.type(:schedule) do
 
   describe Puppet::Type.type(:schedule) do
     it "should apply to device" do
-      @schedule.must be_appliable_to_device
+      expect(@schedule).to be_appliable_to_device
     end
 
     it "should apply to host" do
-      @schedule.must be_appliable_to_host
+      expect(@schedule).to be_appliable_to_host
     end
 
     it "should default to :distance for period-matching" do
-      @schedule[:periodmatch].must == :distance
+      expect(@schedule[:periodmatch]).to eq(:distance)
     end
 
     it "should default to a :repeat of 1" do
-      @schedule[:repeat].must == 1
+      expect(@schedule[:repeat]).to eq(1)
     end
 
     it "should never match when the period is :never" do
       @schedule[:period] = :never
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
   end
 
@@ -58,21 +58,21 @@ describe Puppet::Type.type(:schedule) do
       period = period.to_sym
       it "should produce a #{period} schedule with the period set appropriately" do
         schedules = Puppet::Type.type(:schedule).mkdefaultschedules
-        schedules.find { |s| s[:name] == period.to_s and s[:period] == period }.must be_instance_of(Puppet::Type.type(:schedule))
+        expect(schedules.find { |s| s[:name] == period.to_s and s[:period] == period }).to be_instance_of(Puppet::Type.type(:schedule))
       end
     end
 
     it "should not produce default schedules when default_schedules is false"  do
       Puppet[:default_schedules] = false
       schedules = Puppet::Type.type(:schedule).mkdefaultschedules
-      schedules.must have_exactly(0).items
+      expect(schedules).to have_exactly(0).items
     end
 
     it "should produce a schedule named puppet with a period of hourly and a repeat of 2" do
       schedules = Puppet::Type.type(:schedule).mkdefaultschedules
-      schedules.find { |s|
+      expect(schedules.find { |s|
         s[:name] == "puppet" and s[:period] == :hourly and s[:repeat] == 2
-      }.must be_instance_of(Puppet::Type.type(:schedule))
+      }).to be_instance_of(Puppet::Type.type(:schedule))
     end
   end
 
@@ -83,32 +83,32 @@ describe Puppet::Type.type(:schedule) do
 
     it "should match when the start time is before the current time and the end time is after the current time" do
       @schedule[:range] = "10:59:50 - 11:00:10"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should not match when the start time is after the current time" do
       @schedule[:range] = "11:00:05 - 11:00:10"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should not match when the end time is previous to the current time" do
       @schedule[:range] = "10:59:50 - 10:59:55"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should not match the current time fails between an array of ranges" do
       @schedule[:range] = ["4-6", "20-23"]
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should match the lower array of ranges" do
       @schedule[:range] = ["9-11", "14-16"]
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should match the upper array of ranges" do
       @schedule[:range] = ["4-6", "11-12"]
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
   end
 
@@ -119,17 +119,17 @@ describe Puppet::Type.type(:schedule) do
 
     it "should match when just an hour is specified" do
       @schedule[:range] = "11-12"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should not match when the ending hour is the current hour" do
       @schedule[:range] = "10-11"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should not match when the ending minute is the current minute" do
       @schedule[:range] = "10:00 - 11:45"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
   end
 
@@ -140,22 +140,22 @@ describe Puppet::Type.type(:schedule) do
 
     it "should match when the current time is the start of the range using hours" do
       @schedule[:range] = "11 - 12"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should match when the current time is the end of the range using hours" do
       @schedule[:range] = "10 - 11"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should match when the current time is the start of the range using hours and minutes" do
       @schedule[:range] = "11:00 - 12:00"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should match when the current time is the end of the range using hours and minutes" do
       @schedule[:range] = "10:00 - 11:00"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
   end
 
@@ -166,22 +166,22 @@ describe Puppet::Type.type(:schedule) do
 
     it "should match when the current time is just past the start of the range using hours" do
       @schedule[:range] = "11 - 12"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should not match when the current time is just past the end of the range using hours" do
       @schedule[:range] = "10 - 11"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should match when the current time is just past the start of the range using hours and minutes" do
       @schedule[:range] = "11:00 - 12:00"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should not match when the current time is just past the end of the range using hours and minutes" do
       @schedule[:range] = "10:00 - 11:00"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
   end
 
@@ -192,22 +192,22 @@ describe Puppet::Type.type(:schedule) do
 
     it "should not match when the current time is just before the start of the range using hours" do
       @schedule[:range] = "11 - 12"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should match when the current time is just before the end of the range using hours" do
       @schedule[:range] = "10 - 11"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should not match when the current time is just before the start of the range using hours and minutes" do
       @schedule[:range] = "11:00 - 12:00"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should match when the current time is just before the end of the range using hours and minutes" do
       @schedule[:range] = "10:00 - 11:00"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
   end
 
@@ -222,12 +222,12 @@ describe Puppet::Type.type(:schedule) do
 
     it "should match when the start time is before current time and the end time is the following day" do
       @schedule[:range] = "22:00:00 - 02:00:00"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should not match when the current time is outside the range" do
       @schedule[:range] = "23:30:00 - 21:00:00"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
   end
 
@@ -242,17 +242,17 @@ describe Puppet::Type.type(:schedule) do
 
     it "should match when the start time is the day before the current time and the end time is after the current time" do
       @schedule[:range] = "22:00:00 - 02:00:00"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should not match when the start time is after the current time" do
       @schedule[:range] = "02:00:00 - 00:30:00"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should not match when the end time is before the current time" do
       @schedule[:range] = "22:00:00 - 01:00:00"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
   end
 
@@ -265,15 +265,15 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match when the previous time was an hour ago" do
-      @schedule.must be_match(hour("-", 1))
+      expect(@schedule).to be_match(hour("-", 1))
     end
 
     it "should not match when the previous time was now" do
-      @schedule.must_not be_match(Time.now)
+      expect(@schedule).to_not be_match(Time.now)
     end
 
     it "should not match when the previous time was 59 minutes ago" do
-      @schedule.must_not be_match(min("-", 59))
+      expect(@schedule).to_not be_match(min("-", 59))
     end
   end
 
@@ -286,15 +286,15 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match when the previous time was one day ago" do
-      @schedule.must be_match(day("-", 1))
+      expect(@schedule).to be_match(day("-", 1))
     end
 
     it "should not match when the previous time is now" do
-      @schedule.must_not be_match(Time.now)
+      expect(@schedule).to_not be_match(Time.now)
     end
 
     it "should not match when the previous time was 23 hours ago" do
-      @schedule.must_not be_match(hour("-", 23))
+      expect(@schedule).to_not be_match(hour("-", 23))
     end
   end
 
@@ -307,15 +307,15 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match when the previous time was seven days ago" do
-      @schedule.must be_match(day("-", 7))
+      expect(@schedule).to be_match(day("-", 7))
     end
 
     it "should not match when the previous time was now" do
-      @schedule.must_not be_match(Time.now)
+      expect(@schedule).to_not be_match(Time.now)
     end
 
     it "should not match when the previous time was six days ago" do
-      @schedule.must_not be_match(day("-", 6))
+      expect(@schedule).to_not be_match(day("-", 6))
     end
   end
 
@@ -328,15 +328,15 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match when the previous time was 32 days ago" do
-      @schedule.must be_match(day("-", 32))
+      expect(@schedule).to be_match(day("-", 32))
     end
 
     it "should not match when the previous time was now" do
-      @schedule.must_not be_match(Time.now)
+      expect(@schedule).to_not be_match(Time.now)
     end
 
     it "should not match when the previous time was 27 days ago" do
-      @schedule.must_not be_match(day("-", 27))
+      expect(@schedule).to_not be_match(day("-", 27))
     end
   end
 
@@ -351,7 +351,7 @@ describe Puppet::Type.type(:schedule) do
       previous = Time.utc(2007, 12, 31, 23, 59, 0)
 
       Time.stubs(:now).returns(current)
-      @schedule.must be_match(previous)
+      expect(@schedule).to be_match(previous)
     end
 
     it "should not match if the times are 59 minutes apart and the current minute is 59" do
@@ -359,7 +359,7 @@ describe Puppet::Type.type(:schedule) do
       previous = Time.utc(2009, 2, 1, 12, 0, 0)
 
       Time.stubs(:now).returns(current)
-      @schedule.must_not be_match(previous)
+      expect(@schedule).to_not be_match(previous)
     end
   end
 
@@ -376,7 +376,7 @@ describe Puppet::Type.type(:schedule) do
       previous = current - 60
 
       Time.stubs(:now).returns(current)
-      @schedule.must be_match(previous)
+      expect(@schedule).to be_match(previous)
     end
 
     it "should not match if the times are 23 hours and 58 minutes apart and the current hour is 23 and the current minute is 59" do
@@ -388,7 +388,7 @@ describe Puppet::Type.type(:schedule) do
       now = previous + (23 * 3600) + (59 * 60)
 
       Time.stubs(:now).returns(now)
-      @schedule.must_not be_match(previous)
+      expect(@schedule).to_not be_match(previous)
     end
   end
 
@@ -403,7 +403,7 @@ describe Puppet::Type.type(:schedule) do
       Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "nov", 6, 23, 59, 59) # Sat
 
-      @schedule.must be_match(previous)
+      expect(@schedule).to be_match(previous)
     end
 
     it "should not match if the previous time is after the most recent Saturday" do
@@ -411,7 +411,7 @@ describe Puppet::Type.type(:schedule) do
       Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "nov", 7, 0, 0, 0) # Sunday
 
-      @schedule.must_not be_match(previous)
+      expect(@schedule).to_not be_match(previous)
     end
   end
 
@@ -426,7 +426,7 @@ describe Puppet::Type.type(:schedule) do
       Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "oct", 31, 23, 59, 59)
 
-      @schedule.must be_match(previous)
+      expect(@schedule).to be_match(previous)
     end
 
     it "should not match when the previous time is after the last day of last month" do
@@ -434,7 +434,7 @@ describe Puppet::Type.type(:schedule) do
       Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "nov", 1, 0, 0, 0)
 
-      @schedule.must_not be_match(previous)
+      expect(@schedule).to_not be_match(previous)
     end
   end
 
@@ -448,17 +448,17 @@ describe Puppet::Type.type(:schedule) do
 
     it "should fail if the periodmatch is 'number'" do
       @schedule[:periodmatch] = :number
-      proc { @schedule[:repeat] = 2 }.must 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
       previous = Time.now - (3600 * 13)
-      @schedule.must be_match(previous)
+      expect(@schedule).to be_match(previous)
     end
 
     it "should not match if the previous run was closer than the distance divided by the repeat" do
       previous = Time.now - (3600 * 11)
-      @schedule.must_not be_match(previous)
+      expect(@schedule).to_not be_match(previous)
     end
   end
 
@@ -469,76 +469,76 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should raise an error if the weekday is 'Someday'" do
-      proc { @schedule[:weekday] = "Someday" }.should raise_error(Puppet::Error)
+      expect { @schedule[:weekday] = "Someday" }.to raise_error(Puppet::Error)
     end
 
     it "should raise an error if the weekday is '7'" do
-      proc { @schedule[:weekday] = "7" }.should raise_error(Puppet::Error)
+      expect { @schedule[:weekday] = "7" }.to raise_error(Puppet::Error)
     end
 
     it "should accept all full weekday names as valid values" do
-      proc { @schedule[:weekday] = ['Sunday', 'Monday', 'Tuesday', 'Wednesday',
-          'Thursday', 'Friday', 'Saturday'] }.should_not raise_error
+      expect { @schedule[:weekday] = ['Sunday', 'Monday', 'Tuesday', 'Wednesday',
+          'Thursday', 'Friday', 'Saturday'] }.not_to raise_error
     end
 
     it "should accept all short weekday names as valid values" do
-      proc { @schedule[:weekday] = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu',
-          'Fri', 'Sat'] }.should_not raise_error
+      expect { @schedule[:weekday] = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu',
+          'Fri', 'Sat'] }.not_to raise_error
     end
 
     it "should match if the weekday is 'Monday'" do
       @schedule[:weekday] = "Monday"
-      @schedule.match?.should be_true
+      expect(@schedule.match?).to be_truthy
     end
 
     it "should match if the weekday is 'Mon'" do
       @schedule[:weekday] = "Mon"
-      @schedule.match?.should be_true
+      expect(@schedule.match?).to be_truthy
     end
 
     it "should match if the weekday is '1'" do
       @schedule[:weekday] = "1"
-      @schedule.match?.should be_true
+      expect(@schedule.match?).to be_truthy
     end
 
     it "should not match if the weekday is Tuesday" do
       @schedule[:weekday] = "Tuesday"
-      @schedule.should_not be_match
+      expect(@schedule).not_to be_match
     end
 
     it "should match if weekday is ['Sun', 'Mon']" do
       @schedule[:weekday] = ["Sun", "Mon"]
-      @schedule.match?.should be_true
+      expect(@schedule.match?).to be_truthy
     end
 
     it "should not match if weekday is ['Sun', 'Tue']" do
       @schedule[:weekday] = ["Sun", "Tue"]
-      @schedule.should_not be_match
+      expect(@schedule).not_to be_match
     end
 
     it "should match if the weekday is 'Monday'" do
       @schedule[:weekday] = "Monday"
-      @schedule.match?.should be_true
+      expect(@schedule.match?).to be_truthy
     end
 
     it "should match if the weekday is 'Mon'" do
       @schedule[:weekday] = "Mon"
-      @schedule.match?.should be_true
+      expect(@schedule.match?).to be_truthy
     end
 
     it "should match if the weekday is '1'" do
       @schedule[:weekday] = "1"
-      @schedule.match?.should be_true
+      expect(@schedule.match?).to be_truthy
     end
 
     it "should not match if the weekday is Tuesday" do
       @schedule[:weekday] = "Tuesday"
-      @schedule.should_not be_match
+      expect(@schedule).not_to be_match
     end
 
     it "should match if weekday is ['Sun', 'Mon']" do
       @schedule[:weekday] = ["Sun", "Mon"]
-      @schedule.match?.should be_true
+      expect(@schedule.match?).to be_truthy
     end
   end
 
@@ -551,25 +551,25 @@ describe Puppet::Type.type(:schedule) do
     it "should match when the range and day of week matches" do
       @schedule[:range] = "22:00:00 - 02:00:00"
       @schedule[:weekday] = "Thursday"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should not match when the range doesn't match even if the day-of-week matches" do
       @schedule[:range] = "23:30:00 - 21:00:00"
       @schedule[:weekday] = "Thursday"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should not match when day-of-week doesn't match even if the range matches (1 day later)" do
       @schedule[:range] = "22:00:00 - 01:00:00"
       @schedule[:weekday] = "Friday"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should not match when day-of-week doesn't match even if the range matches (1 day earlier)" do
       @schedule[:range] = "22:00:00 - 01:00:00"
       @schedule[:weekday] = "Wednesday"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
   end
 
@@ -583,25 +583,25 @@ describe Puppet::Type.type(:schedule) do
     it "should match when the range matches and the day of week should match" do
       @schedule[:range] = "22:00:00 - 02:00:00"
       @schedule[:weekday] = "Wednesday"
-      @schedule.must be_match
+      expect(@schedule).to be_match
     end
 
     it "should not match when the range does not match and the day of week should match" do
       @schedule[:range] = "22:00:00 - 01:00:00"
       @schedule[:weekday] = "Thursday"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should not match when the range matches but the day-of-week does not (1 day later)" do
       @schedule[:range] = "22:00:00 - 02:00:00"
       @schedule[:weekday] = "Thursday"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
 
     it "should not match when the range matches but the day-of-week does not (1 day later)" do
       @schedule[:range] = "22:00:00 - 02:00:00"
       @schedule[:weekday] = "Tuesday"
-      @schedule.must_not be_match
+      expect(@schedule).to_not be_match
     end
   end
 end

data/spec/unit/type/scheduled_task_spec.rb

@@ -4,29 +4,29 @@ require 'spec_helper'
 describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_windows? do
 
   it 'should use name as the namevar' do
-    described_class.new(
+    expect(described_class.new(
       :title   => 'Foo',
       :command => 'C:\Windows\System32\notepad.exe'
-    ).name.must == 'Foo'
+    ).name).to eq('Foo')
   end
 
   describe 'when setting the command' do
     it 'should accept an absolute path to the command' do
-      described_class.new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe')[:command].should == 'C:\Windows\System32\notepad.exe'
+      expect(described_class.new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe')[:command]).to eq('C:\Windows\System32\notepad.exe')
     end
 
     it 'should convert forward slashes to backslashes' do
-      described_class.new(
+      expect(described_class.new(
         :name      => 'Test Task',
         :command   => 'C:/Windows/System32/notepad.exe'
-      )[:command].should == 'C:\Windows\System32\notepad.exe'
+      )[:command]).to eq('C:\Windows\System32\notepad.exe')
     end
 
     it 'should normalize backslashes' do
-      described_class.new(
+      expect(described_class.new(
         :name      => 'Test Task',
         :command   => 'C:\Windows\\System32\\\\notepad.exe'
-      )[:command].should == 'C:\Windows\System32\notepad.exe'
+      )[:command]).to eq('C:\Windows\System32\notepad.exe')
     end
 
     it 'should fail if the path to the command is not absolute' do
@@ -41,18 +41,18 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
 
   describe 'when setting the command arguments' do
     it 'should accept a string' do
-      described_class.new(
+      expect(described_class.new(
         :name      => 'Test Task',
         :command   => 'C:\Windows\System32\notepad.exe',
         :arguments => '/a /b /c'
-      )[:arguments].should == '/a /b /c'
+      )[:arguments]).to eq('/a /b /c')
     end
 
     it 'should allow not specifying any command arguments' do
-      described_class.new(
+      expect(described_class.new(
         :name    => 'Test Task',
         :command => 'C:\Windows\System32\notepad.exe'
-      )[:arguments].should_not be
+      )[:arguments]).not_to be
     end
   end
 
@@ -61,11 +61,11 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
 
   describe 'when setting the working directory' do
     it 'should accept an absolute path to the working directory' do
-      described_class.new(
+      expect(described_class.new(
         :name        => 'Test Task',
         :command     => 'C:\Windows\System32\notepad.exe',
         :working_dir => 'C:\Windows\System32'
-      )[:working_dir].should == 'C:\Windows\System32'
+      )[:working_dir]).to eq('C:\Windows\System32')
     end
 
     it 'should fail if the path to the working directory is not absolute' do
@@ -82,10 +82,10 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
     end
 
     it 'should allow not specifying any working directory' do
-      described_class.new(
+      expect(described_class.new(
         :name    => 'Test Task',
         :command => 'C:\Windows\System32\notepad.exe'
-      )[:working_dir].should_not be
+      )[:working_dir]).not_to be
     end
   end
 

data/spec/unit/type/selboolean_spec.rb

@@ -4,12 +4,12 @@ require 'spec_helper'
 describe Puppet::Type.type(:selboolean), "when validating attributes" do
   [:name, :persistent].each do |param|
     it "should have a #{param} parameter" do
-      Puppet::Type.type(:selboolean).attrtype(param).should == :param
+      expect(Puppet::Type.type(:selboolean).attrtype(param)).to eq(:param)
     end
   end
 
   it "should have a value property" do
-    Puppet::Type.type(:selboolean).attrtype(:value).should == :property
+    expect(Puppet::Type.type(:selboolean).attrtype(:value)).to eq(:property)
   end
 end
 

data/spec/unit/type/selmodule_spec.rb

@@ -4,13 +4,13 @@ require 'spec_helper'
 describe Puppet::Type.type(:selmodule), "when validating attributes" do
   [:name, :selmoduledir, :selmodulepath].each do |param|
     it "should have a #{param} parameter" do
-      Puppet::Type.type(:selmodule).attrtype(param).should == :param
+      expect(Puppet::Type.type(:selmodule).attrtype(param)).to eq(:param)
     end
   end
 
   [:ensure, :syncversion].each do |param|
     it "should have a #{param} property" do
-      Puppet::Type.type(:selmodule).attrtype(param).should == :property
+      expect(Puppet::Type.type(:selmodule).attrtype(param)).to eq(:property)
     end
   end
 end