puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/scheduler/job_spec.rb

@@ -7,16 +7,16 @@ describe Puppet::Scheduler::Job do
   let(:job) { described_class.new(run_interval) }
 
   it "has a minimum run interval of 0" do
-    Puppet::Scheduler::Job.new(-1).run_interval.should == 0
+    expect(Puppet::Scheduler::Job.new(-1).run_interval).to eq(0)
   end
 
   describe "when not run yet" do
     it "is ready" do
-      job.ready?(2).should be
+      expect(job.ready?(2)).to be
     end
 
     it "gives the time to next run as 0" do
-      job.interval_to_next_from(2).should == 0
+      expect(job.interval_to_next_from(2)).to eq(0)
     end
   end
 
@@ -28,43 +28,43 @@ describe Puppet::Scheduler::Job do
     end
 
     it "is ready when the time is greater than the last run plus the interval" do
-      job.ready?(last_run + run_interval + 1).should be
+      expect(job.ready?(last_run + run_interval + 1)).to be
     end
 
     it "is ready when the time is equal to the last run plus the interval" do
-      job.ready?(last_run + run_interval).should be
+      expect(job.ready?(last_run + run_interval)).to be
     end
 
     it "is not ready when the time is less than the last run plus the interval" do
-      job.ready?(last_run + run_interval - 1).should_not be
+      expect(job.ready?(last_run + run_interval - 1)).not_to be
     end
 
     context "when calculating the next run" do
       it "returns the run interval if now == last run" do
-        job.interval_to_next_from(last_run).should == run_interval
+        expect(job.interval_to_next_from(last_run)).to eq(run_interval)
       end
 
       it "when time is between the last and next runs gives the remaining portion of the run_interval" do
         time_since_last_run = 2
         now = last_run + time_since_last_run
-        job.interval_to_next_from(now).should == run_interval - time_since_last_run
+        expect(job.interval_to_next_from(now)).to eq(run_interval - time_since_last_run)
       end
 
       it "when time is later than last+interval returns 0" do
         time_since_last_run = run_interval + 5
         now = last_run + time_since_last_run
-        job.interval_to_next_from(now).should == 0
+        expect(job.interval_to_next_from(now)).to eq(0)
       end
     end
   end
 
   it "starts enabled" do
-    job.enabled?.should be
+    expect(job.enabled?).to be
   end
 
   it "can be disabled" do
     job.disable
-    job.enabled?.should_not be
+    expect(job.enabled?).not_to be
   end
 
   it "has the job instance as a parameter" do
@@ -74,6 +74,6 @@ describe Puppet::Scheduler::Job do
     end
     job.run(5)
 
-    passed_job.should eql(job)
+    expect(passed_job).to eql(job)
   end
 end

data/spec/unit/scheduler/scheduler_spec.rb

@@ -44,7 +44,7 @@ describe Puppet::Scheduler::Scheduler do
 
     scheduler.run_loop([later_job, earlier_job])
 
-    timer.wait_for_calls.should == [2, 5]
+    expect(timer.wait_for_calls).to eq([2, 5])
   end
 
   it "ignores disabled jobs when calculating intervals" do
@@ -54,7 +54,7 @@ describe Puppet::Scheduler::Scheduler do
 
     scheduler.run_loop([enabled, disabled])
 
-    timer.wait_for_calls.should == [7]
+    expect(timer.wait_for_calls).to eq([7])
   end
 
   it "asks the timer to wait for the job interval" do
@@ -63,13 +63,13 @@ describe Puppet::Scheduler::Scheduler do
 
     scheduler.run_loop([job])
 
-    timer.wait_for_calls.should == [5]
+    expect(timer.wait_for_calls).to eq([5])
   end
 
   it "does not run when there are no jobs" do
     scheduler.run_loop([])
 
-    timer.wait_for_calls.should be_empty
+    expect(timer.wait_for_calls).to be_empty
   end
 
   it "does not run when there are only disabled jobs" do
@@ -78,7 +78,7 @@ describe Puppet::Scheduler::Scheduler do
 
     scheduler.run_loop([disabled_job])
 
-    timer.wait_for_calls.should be_empty
+    expect(timer.wait_for_calls).to be_empty
   end
 
   it "stops running when there are no more enabled jobs" do
@@ -88,7 +88,7 @@ describe Puppet::Scheduler::Scheduler do
 
     scheduler.run_loop([disabling_job])
 
-    timer.wait_for_calls.size.should == 1
+    expect(timer.wait_for_calls.size).to eq(1)
   end
 
   it "marks the start of the run loop" do
@@ -98,7 +98,7 @@ describe Puppet::Scheduler::Scheduler do
 
     scheduler.run_loop([disabled_job])
 
-    disabled_job.start_time.should == now
+    expect(disabled_job.start_time).to eq(now)
   end
 
   it "calculates the next interval from the start of a job" do
@@ -111,6 +111,6 @@ describe Puppet::Scheduler::Scheduler do
 
     scheduler.run_loop([slow_job])
 
-    timer.wait_for_calls.should == [0, 3, 7, 3]
+    expect(timer.wait_for_calls).to eq([0, 3, 7, 3])
   end
 end

data/spec/unit/scheduler/splay_job_spec.rb

@@ -11,25 +11,25 @@ describe Puppet::Scheduler::SplayJob do
 
   it "does not apply a splay after the first run" do
     job.run(last_run)
-    job.interval_to_next_from(last_run).should == run_interval
+    expect(job.interval_to_next_from(last_run)).to eq(run_interval)
   end
 
   it "calculates the first run splayed from the start time" do
     job.start_time = start_time
 
-    job.interval_to_next_from(start_time).should == job.splay
+    expect(job.interval_to_next_from(start_time)).to eq(job.splay)
   end
 
   it "interval to the next run decreases as time advances" do
     time_passed = 3
     job.start_time = start_time
 
-    job.interval_to_next_from(start_time + time_passed).should == job.splay - time_passed
+    expect(job.interval_to_next_from(start_time + time_passed)).to eq(job.splay - time_passed)
   end
 
   it "is not immediately ready if splayed" do
     job.start_time = start_time
     job.expects(:splay).returns(6)
-    job.ready?(start_time).should_not be
+    expect(job.ready?(start_time)).not_to be
   end
 end

data/spec/unit/semver_spec.rb

@@ -3,37 +3,39 @@ require 'semver'
 
 describe SemVer do
 
-  describe 'MAX should be +Infinity' do
-    SemVer::MAX.major.infinite?.should == 1
+  describe 'MAX' do
+    it 'should be +Infinity' do
+      expect(SemVer::MAX.major.infinite?).to eq(1)
+    end
   end
 
   describe '::valid?' do
     it 'should validate basic version strings' do
       %w[ 0.0.0 999.999.999 v0.0.0 v999.999.999 ].each do |vstring|
-        SemVer.valid?(vstring).should be_true
+        expect(SemVer.valid?(vstring)).to be_truthy
       end
     end
 
     it 'should validate special version strings' do
       %w[ 0.0.0-foo 999.999.999-bar v0.0.0-a v999.999.999-beta ].each do |vstring|
-        SemVer.valid?(vstring).should be_true
+        expect(SemVer.valid?(vstring)).to be_truthy
       end
     end
 
     it 'should fail to validate invalid version strings' do
       %w[ nope 0.0foo 999.999 x0.0.0 z.z.z 1.2.3beta 1.x.y ].each do |vstring|
-        SemVer.valid?(vstring).should be_false
+        expect(SemVer.valid?(vstring)).to be_falsey
       end
     end
   end
 
   describe '::pre' do
     it 'should append a dash when no dash appears in the string' do
-      SemVer.pre('1.2.3').should == '1.2.3-'
+      expect(SemVer.pre('1.2.3')).to eq('1.2.3-')
     end
 
     it 'should not append a dash when a dash appears in the string' do
-      SemVer.pre('1.2.3-a').should == '1.2.3-a'
+      expect(SemVer.pre('1.2.3-a')).to eq('1.2.3-a')
     end
   end
 
@@ -59,33 +61,33 @@ describe SemVer do
 
     it 'should match exact versions by string' do
       @versions.each do |version|
-        SemVer.find_matching(version, @versions).should == version
+        expect(SemVer.find_matching(version, @versions)).to eq(version)
       end
     end
 
     it 'should return nil if no versions match' do
       %w[ 3.0.0 2.0.0-rc2 1.0.0-alpha ].each do |v|
-        SemVer.find_matching(v, @versions).should be_nil
+        expect(SemVer.find_matching(v, @versions)).to be_nil
       end
     end
 
     it 'should find the greatest match for partial versions' do
-      SemVer.find_matching('1.0', @versions).should == 'v1.0.1'
-      SemVer.find_matching('1.1', @versions).should == 'v1.1.4'
-      SemVer.find_matching('1', @versions).should   == 'v1.2.1'
-      SemVer.find_matching('2', @versions).should   == 'v2.0.0-rc1'
-      SemVer.find_matching('2.1', @versions).should == nil
+      expect(SemVer.find_matching('1.0', @versions)).to eq('v1.0.1')
+      expect(SemVer.find_matching('1.1', @versions)).to eq('v1.1.4')
+      expect(SemVer.find_matching('1', @versions)).to   eq('v1.2.1')
+      expect(SemVer.find_matching('2', @versions)).to   eq('v2.0.0-rc1')
+      expect(SemVer.find_matching('2.1', @versions)).to eq(nil)
     end
 
 
     it 'should find the greatest match for versions with placeholders' do
-      SemVer.find_matching('1.0.x', @versions).should == 'v1.0.1'
-      SemVer.find_matching('1.1.x', @versions).should == 'v1.1.4'
-      SemVer.find_matching('1.x', @versions).should   == 'v1.2.1'
-      SemVer.find_matching('1.x.x', @versions).should == 'v1.2.1'
-      SemVer.find_matching('2.x', @versions).should   == 'v2.0.0-rc1'
-      SemVer.find_matching('2.x.x', @versions).should == 'v2.0.0-rc1'
-      SemVer.find_matching('2.1.x', @versions).should == nil
+      expect(SemVer.find_matching('1.0.x', @versions)).to eq('v1.0.1')
+      expect(SemVer.find_matching('1.1.x', @versions)).to eq('v1.1.4')
+      expect(SemVer.find_matching('1.x', @versions)).to   eq('v1.2.1')
+      expect(SemVer.find_matching('1.x.x', @versions)).to eq('v1.2.1')
+      expect(SemVer.find_matching('2.x', @versions)).to   eq('v2.0.0-rc1')
+      expect(SemVer.find_matching('2.x.x', @versions)).to eq('v2.0.0-rc1')
+      expect(SemVer.find_matching('2.1.x', @versions)).to eq(nil)
     end
   end
 
@@ -116,7 +118,7 @@ describe SemVer do
       }
 
       tests.each do |vstring, expected|
-        SemVer[vstring].should == expected
+        expect(SemVer[vstring]).to eq(expected)
       end
     end
 
@@ -185,7 +187,7 @@ describe SemVer do
       suitability.each do |arguments, expected|
         range, vstring = arguments
         actual = SemVer[range] === SemVer.new(vstring)
-        actual.should == expected
+        expect(actual).to eq(expected)
       end
     end
   end
@@ -197,18 +199,18 @@ describe SemVer do
 
     it 'should populate the appropriate fields for a basic version string' do
       version = SemVer.new('1.2.3')
-      version.major.should   == 1
-      version.minor.should   == 2
-      version.tiny.should    == 3
-      version.special.should == ''
+      expect(version.major).to   eq(1)
+      expect(version.minor).to   eq(2)
+      expect(version.tiny).to    eq(3)
+      expect(version.special).to eq('')
     end
 
     it 'should populate the appropriate fields for a special version string' do
       version = SemVer.new('3.4.5-beta6')
-      version.major.should   == 3
-      version.minor.should   == 4
-      version.tiny.should    == 5
-      version.special.should == '-beta6'
+      expect(version.major).to   eq(3)
+      expect(version.minor).to   eq(4)
+      expect(version.tiny).to    eq(5)
+      expect(version.special).to eq('-beta6')
     end
   end
 
@@ -217,25 +219,25 @@ describe SemVer do
 
     describe 'should match against' do
       describe 'literal version strings' do
-        it { should be_matched_by('1.2.3-beta') }
+        it { is_expected.to be_matched_by('1.2.3-beta') }
 
-        it { should_not be_matched_by('1.2.3-alpha') }
-        it { should_not be_matched_by('1.2.4-beta') }
-        it { should_not be_matched_by('1.3.3-beta') }
-        it { should_not be_matched_by('2.2.3-beta') }
+        it { is_expected.not_to be_matched_by('1.2.3-alpha') }
+        it { is_expected.not_to be_matched_by('1.2.4-beta') }
+        it { is_expected.not_to be_matched_by('1.3.3-beta') }
+        it { is_expected.not_to be_matched_by('2.2.3-beta') }
       end
 
       describe 'partial version strings' do
-        it { should be_matched_by('1.2.3') }
-        it { should be_matched_by('1.2') }
-        it { should be_matched_by('1') }
+        it { is_expected.to be_matched_by('1.2.3') }
+        it { is_expected.to be_matched_by('1.2') }
+        it { is_expected.to be_matched_by('1') }
       end
 
       describe 'version strings with placeholders' do
-        it { should be_matched_by('1.2.x') }
-        it { should be_matched_by('1.x.3') }
-        it { should be_matched_by('1.x.x') }
-        it { should be_matched_by('1.x') }
+        it { is_expected.to be_matched_by('1.2.x') }
+        it { is_expected.to be_matched_by('1.x.3') }
+        it { is_expected.to be_matched_by('1.x.x') }
+        it { is_expected.to be_matched_by('1.x') }
       end
     end
   end
@@ -243,61 +245,61 @@ describe SemVer do
   describe 'comparisons' do
     describe 'against a string' do
       it 'should just work' do
-        SemVer.new('1.2.3').should == '1.2.3'
+        expect(SemVer.new('1.2.3')).to eq('1.2.3')
       end
     end
 
     describe 'against a symbol' do
       it 'should just work' do
-        SemVer.new('1.2.3').should == :'1.2.3'
+        expect(SemVer.new('1.2.3')).to eq(:'1.2.3')
       end
     end
 
     describe 'on a basic version (v1.2.3)' do
       subject { SemVer.new('v1.2.3') }
 
-      it { should == SemVer.new('1.2.3') }
+      it { is_expected.to eq(SemVer.new('1.2.3')) }
 
       # Different major versions
-      it { should > SemVer.new('0.2.3') }
-      it { should < SemVer.new('2.2.3') }
+      it { is_expected.to be > SemVer.new('0.2.3') }
+      it { is_expected.to be < SemVer.new('2.2.3') }
 
       # Different minor versions
-      it { should > SemVer.new('1.1.3') }
-      it { should < SemVer.new('1.3.3') }
+      it { is_expected.to be > SemVer.new('1.1.3') }
+      it { is_expected.to be < SemVer.new('1.3.3') }
 
       # Different tiny versions
-      it { should > SemVer.new('1.2.2') }
-      it { should < SemVer.new('1.2.4') }
+      it { is_expected.to be > SemVer.new('1.2.2') }
+      it { is_expected.to be < SemVer.new('1.2.4') }
 
       # Against special versions
-      it { should > SemVer.new('1.2.3-beta') }
-      it { should < SemVer.new('1.2.4-beta') }
+      it { is_expected.to be > SemVer.new('1.2.3-beta') }
+      it { is_expected.to be < SemVer.new('1.2.4-beta') }
     end
 
     describe 'on a special version (v1.2.3-beta)' do
       subject { SemVer.new('v1.2.3-beta') }
 
-      it { should == SemVer.new('1.2.3-beta') }
+      it { is_expected.to eq(SemVer.new('1.2.3-beta')) }
 
       # Same version, final release
-      it { should < SemVer.new('1.2.3') }
+      it { is_expected.to be < SemVer.new('1.2.3') }
 
       # Different major versions
-      it { should > SemVer.new('0.2.3') }
-      it { should < SemVer.new('2.2.3') }
+      it { is_expected.to be > SemVer.new('0.2.3') }
+      it { is_expected.to be < SemVer.new('2.2.3') }
 
       # Different minor versions
-      it { should > SemVer.new('1.1.3') }
-      it { should < SemVer.new('1.3.3') }
+      it { is_expected.to be > SemVer.new('1.1.3') }
+      it { is_expected.to be < SemVer.new('1.3.3') }
 
       # Different tiny versions
-      it { should > SemVer.new('1.2.2') }
-      it { should < SemVer.new('1.2.4') }
+      it { is_expected.to be > SemVer.new('1.2.2') }
+      it { is_expected.to be < SemVer.new('1.2.4') }
 
       # Against special versions
-      it { should > SemVer.new('1.2.3-alpha') }
-      it { should < SemVer.new('1.2.3-beta2') }
+      it { is_expected.to be > SemVer.new('1.2.3-alpha') }
+      it { is_expected.to be < SemVer.new('1.2.3-beta2') }
     end
   end
 end

data/spec/unit/settings/autosign_setting_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 require 'puppet/settings'
 require 'puppet/settings/autosign_setting'
+require 'puppet/type/file'
 
 describe Puppet::Settings::AutosignSetting do
   let(:settings) do

data/spec/unit/settings/config_file_spec.rb

@@ -26,7 +26,7 @@ describe Puppet::Settings::ConfigFile do
   end
 
   it "interprets an empty main section the same as an empty file" do
-    the_parse_of("").should == config.parse_file(filename, "[main]")
+    expect(the_parse_of("")).to eq(config.parse_file(filename, "[main]"))
   end
 
   it "places an entry in no section in main" do
@@ -36,11 +36,11 @@ describe Puppet::Settings::ConfigFile do
   end
 
   it "places an entry after a section header in that section" do
-    result = the_parse_of("[section]", "var = value")
+    result = the_parse_of("[agent]", "var = value")
 
     expect(result).to eq(Conf.new.
                          with_section(Section.new(:main)).
-                         with_section(Section.new(:section).
+                         with_section(Section.new(:agent).
                                       with_setting(:var, "value", NO_META)))
   end
 
@@ -112,45 +112,18 @@ badline
       to raise_error ArgumentError, "Could not parse 'value { mode }'"
   end
 
-  it "errors when an application_defaults section is created" do
-    expect { the_parse_of("[application_defaults]") }.
-      to raise_error Puppet::Error,
-        "Illegal section 'application_defaults' in config file #{filename} at line 1"
-  end
+  it "may specify legal sections" do
+    text = <<-EOF
+      [legal]
+      a = 'b'
+      [illegal]
+      one = 'e'
+      two = 'f'
+    EOF
 
-  it "errors when a global_defaults section is created" do
-    expect { the_parse_of("[main]\n[global_defaults]") }.
+    expect { config.parse_file(filename, text, [:legal]) }.
       to raise_error Puppet::Error,
-        "Illegal section 'global_defaults' in config file #{filename} at line 2"
-  end
-
-  it "issues a single deprecation warning when any section other than main, master, agent or user is parsed" do
-    text = "[legacy]
-    one = 'e'
-    two = 'f'
-    [also_deprecated]
-    one = 'g'
-    "
-
-    config.parse_file(filename, text)
-
-    expect(@logs.map(&:message).grep(/Sections other than/)).to have_exactly(1).item
-  end
-
-  it "does not issue a deprecation warning for main, master, agent or user sections" do
-    text = "[main]
-    one = 'a'
-    [master]
-    one = 'b'
-    [agent]
-    one = 'c'
-    [user]
-    one = 'd'
-    "
-
-    Puppet.expects(:deprecation_warning).never
-
-    config.parse_file(filename, text)
+        /Illegal section 'legal' in config file #{filename} at line 1/
   end
 
   it "transforms values with the given function" do