puppet 3.5.0.rc1-x86-mingw32

data/spec/unit/run_spec.rb

@@ -0,0 +1,175 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/agent'
+require 'puppet/run'
+
+describe Puppet::Run do
+  before do
+    @runner = Puppet::Run.new
+  end
+
+  it "should indirect :run" do
+    Puppet::Run.indirection.name.should == :run
+  end
+
+  it "should use a configurer agent as its agent" do
+    agent = mock 'agent'
+    Puppet::Agent.expects(:new).with(Puppet::Configurer, anything).returns agent
+
+    @runner.agent.should equal(agent)
+  end
+
+  it "should accept options at initialization" do
+    expect do
+      Puppet::Run.new(
+        :background => true,
+        :tags => 'tag',
+        :ignoreschedules => false,
+        :pluginsync => true)
+    end.not_to raise_error
+  end
+
+  it "should not accept arbitrary options" do
+    lambda { Puppet::Run.new(:foo => true) }.should raise_error(ArgumentError)
+  end
+
+  it "should default to running in the foreground" do
+    Puppet::Run.new.should_not be_background
+  end
+
+  it "should default to its options being an empty hash" do
+    Puppet::Run.new.options.should == {}
+  end
+
+  it "should accept :tags for the agent" do
+    Puppet::Run.new(:tags => "foo").options[:tags].should == "foo"
+  end
+
+  it "should accept :ignoreschedules for the agent" do
+    Puppet::Run.new(:ignoreschedules => true).options[:ignoreschedules].should be_true
+  end
+
+  it "should accept an option to configure it to run in the background" do
+    Puppet::Run.new(:background => true).should be_background
+  end
+
+  it "should retain the background option" do
+    Puppet::Run.new(:background => true).options[:background].should be_nil
+  end
+
+  describe "when asked to run" do
+    before do
+      @agent = stub 'agent', :run => nil, :running? => false
+      @runner.stubs(:agent).returns @agent
+    end
+
+    it "should run its agent" do
+      agent = stub 'agent2', :running? => false
+      @runner.stubs(:agent).returns agent
+
+      agent.expects(:run)
+
+      @runner.run
+    end
+
+    it "should pass any of its options on to the agent" do
+      @runner.stubs(:options).returns(:foo => :bar)
+      @agent.expects(:run).with(:foo => :bar)
+
+      @runner.run
+    end
+
+    it "should log its run using the provided options" do
+      @runner.expects(:log_run)
+
+      @runner.run
+    end
+
+    it "should set its status to 'already_running' if the agent is already running" do
+      @agent.expects(:running?).returns true
+
+      @runner.run
+
+      @runner.status.should == "running"
+    end
+
+    it "should set its status to 'success' if the agent is run" do
+      @agent.expects(:running?).returns false
+
+      @runner.run
+
+      @runner.status.should == "success"
+    end
+
+    it "should run the agent in a thread if asked to run it in the background" do
+      Thread.expects(:new)
+
+      @runner.expects(:background?).returns true
+
+      @agent.expects(:run).never # because our thread didn't yield
+
+      @runner.run
+    end
+
+    it "should run the agent directly if asked to run it in the foreground" do
+      Thread.expects(:new).never
+
+      @runner.expects(:background?).returns false
+      @agent.expects(:run)
+
+      @runner.run
+    end
+  end
+
+  describe ".from_data_hash" do
+    it "should read from a hash that represents the 'options' to initialize" do
+      options = {
+        "tags" => "whatever",
+        "background" => true,
+        "ignoreschedules" => false,
+      }
+      run = Puppet::Run.from_data_hash(options)
+
+      run.options.should == {
+        :tags => "whatever",
+        :pluginsync => Puppet[:pluginsync],
+        :ignoreschedules => false,
+      }
+      run.background.should be_true
+    end
+
+    it "should read from a hash that follows the actual object structure" do
+      hash = {"background" => true,
+              "options" => {
+                "pluginsync" => true,
+                "tags" => [],
+                "ignoreschedules" => false},
+              "status" => "success"}
+      run = Puppet::Run.from_data_hash(hash)
+
+      run.options.should == {
+        :pluginsync => true,
+        :tags => [],
+        :ignoreschedules => false
+      }
+      run.background.should be_true
+      run.status.should == 'success'
+    end
+
+    it "should round trip through pson" do
+      run = Puppet::Run.new(
+        :tags => ['a', 'b', 'c'],
+        :ignoreschedules => true,
+        :pluginsync => false,
+        :background => true
+      )
+      run.instance_variable_set(:@status, true)
+
+      tripped = Puppet::Run.convert_from(:pson, run.render(:pson))
+
+      tripped.options.should == run.options
+      tripped.status.should == run.status
+      tripped.background.should == run.background
+    end
+  end
+end

data/spec/unit/scheduler/job_spec.rb

@@ -0,0 +1,79 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/scheduler'
+
+describe Puppet::Scheduler::Job do
+  let(:run_interval) { 10 }
+  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
+  end
+
+  describe "when not run yet" do
+    it "is ready" do
+      job.ready?(2).should be
+    end
+
+    it "gives the time to next run as 0" do
+      job.interval_to_next_from(2).should == 0
+    end
+  end
+
+  describe "when run at least once" do
+    let(:last_run) { 50 }
+
+    before(:each) do
+      job.run(last_run)
+    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
+    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
+    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
+    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
+      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
+      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
+      end
+    end
+  end
+
+  it "starts enabled" do
+    job.enabled?.should be
+  end
+
+  it "can be disabled" do
+    job.disable
+    job.enabled?.should_not be
+  end
+
+  it "has the job instance as a parameter" do
+    passed_job = nil
+    job = Puppet::Scheduler::Job.new(run_interval) do |j|
+      passed_job = j
+    end
+    job.run(5)
+
+    passed_job.should eql(job)
+  end
+end

data/spec/unit/scheduler/scheduler_spec.rb

@@ -0,0 +1,116 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/scheduler'
+
+describe Puppet::Scheduler::Scheduler do
+  let(:now) { 183550 }
+  let(:timer) { MockTimer.new(now) }
+
+  class MockTimer
+    attr_reader :wait_for_calls
+
+    def initialize(start=1729)
+      @now = start
+      @wait_for_calls = []
+    end
+
+    def wait_for(seconds)
+      @wait_for_calls << seconds
+      @now += seconds
+    end
+
+    def now
+      @now
+    end
+  end
+
+  def one_time_job(interval)
+    Puppet::Scheduler::Job.new(interval) { |j| j.disable }
+  end
+
+  def disabled_job(interval)
+    job = Puppet::Scheduler::Job.new(interval) { |j| j.disable }
+    job.disable
+    job
+  end
+
+  let(:scheduler) { Puppet::Scheduler::Scheduler.new(timer) }
+
+  it "uses the minimum interval" do
+    later_job = one_time_job(7)
+    earlier_job = one_time_job(2)
+    later_job.last_run = now
+    earlier_job.last_run = now
+
+    scheduler.run_loop([later_job, earlier_job])
+
+    timer.wait_for_calls.should == [2, 5]
+  end
+
+  it "ignores disabled jobs when calculating intervals" do
+    enabled = one_time_job(7)
+    enabled.last_run = now
+    disabled = disabled_job(2)
+
+    scheduler.run_loop([enabled, disabled])
+
+    timer.wait_for_calls.should == [7]
+  end
+
+  it "asks the timer to wait for the job interval" do
+    job = one_time_job(5)
+    job.last_run = now
+
+    scheduler.run_loop([job])
+
+    timer.wait_for_calls.should == [5]
+  end
+
+  it "does not run when there are no jobs" do
+    scheduler.run_loop([])
+
+    timer.wait_for_calls.should be_empty
+  end
+
+  it "does not run when there are only disabled jobs" do
+    disabled_job = Puppet::Scheduler::Job.new(0)
+    disabled_job.disable
+
+    scheduler.run_loop([disabled_job])
+
+    timer.wait_for_calls.should be_empty
+  end
+
+  it "stops running when there are no more enabled jobs" do
+    disabling_job = Puppet::Scheduler::Job.new(0) do |j|
+      j.disable
+    end
+
+    scheduler.run_loop([disabling_job])
+
+    timer.wait_for_calls.size.should == 1
+  end
+
+  it "marks the start of the run loop" do
+    disabled_job = Puppet::Scheduler::Job.new(0)
+
+    disabled_job.disable
+
+    scheduler.run_loop([disabled_job])
+
+    disabled_job.start_time.should == now
+  end
+
+  it "calculates the next interval from the start of a job" do
+    countdown = 2
+    slow_job = Puppet::Scheduler::Job.new(10) do |job|
+      timer.wait_for(3)
+      countdown -= 1
+      job.disable if countdown == 0
+    end
+
+    scheduler.run_loop([slow_job])
+
+    timer.wait_for_calls.should == [0, 3, 7, 3]
+  end
+end

data/spec/unit/scheduler/splay_job_spec.rb

@@ -0,0 +1,35 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/scheduler'
+
+describe Puppet::Scheduler::SplayJob do
+  let(:run_interval) { 10 }
+  let(:last_run) { 50 }
+  let(:splay_limit) { 5 }
+  let(:start_time) { 23 }
+  let(:job) { described_class.new(run_interval, splay_limit) }
+
+  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
+  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
+  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
+  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
+  end
+end

data/spec/unit/semver_spec.rb

@@ -0,0 +1,303 @@
+require 'spec_helper'
+require 'semver'
+
+describe SemVer do
+
+  describe 'MAX should be +Infinity' do
+    SemVer::MAX.major.infinite?.should == 1
+  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
+      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
+      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
+      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-'
+    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'
+    end
+  end
+
+  describe '::find_matching' do
+    before :all do
+      @versions = %w[
+        0.0.1
+        0.0.2
+        1.0.0-rc1
+        1.0.0-rc2
+        1.0.0
+        1.0.1
+        1.1.0
+        1.1.1
+        1.1.2
+        1.1.3
+        1.1.4
+        1.2.0
+        1.2.1
+        2.0.0-rc1
+      ].map { |v| SemVer.new(v) }
+    end
+
+    it 'should match exact versions by string' do
+      @versions.each do |version|
+        SemVer.find_matching(version, @versions).should == 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
+      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
+    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
+    end
+  end
+
+  describe '::[]' do
+    it "should produce expected ranges" do
+      tests = {
+        '1.2.3-alpha'          => SemVer.new('v1.2.3-alpha')  ..  SemVer.new('v1.2.3-alpha'),
+        '1.2.3'                => SemVer.new('v1.2.3-')       ..  SemVer.new('v1.2.3'),
+        '>1.2.3-alpha'         => SemVer.new('v1.2.3-alpha-') ..  SemVer::MAX,
+        '>1.2.3'               => SemVer.new('v1.2.4-')       ..  SemVer::MAX,
+        '<1.2.3-alpha'         => SemVer::MIN                 ... SemVer.new('v1.2.3-alpha'),
+        '<1.2.3'               => SemVer::MIN                 ... SemVer.new('v1.2.3-'),
+        '>=1.2.3-alpha'        => SemVer.new('v1.2.3-alpha')  ..  SemVer::MAX,
+        '>=1.2.3'              => SemVer.new('v1.2.3-')       ..  SemVer::MAX,
+        '<=1.2.3-alpha'        => SemVer::MIN                 ..  SemVer.new('v1.2.3-alpha'),
+        '<=1.2.3'              => SemVer::MIN                 ..  SemVer.new('v1.2.3'),
+        '>1.2.3-a <1.2.3-b'    => SemVer.new('v1.2.3-a-')     ... SemVer.new('v1.2.3-b'),
+        '>1.2.3 <1.2.5'        => SemVer.new('v1.2.4-')       ... SemVer.new('v1.2.5-'),
+        '>=1.2.3-a <= 1.2.3-b' => SemVer.new('v1.2.3-a')      ..  SemVer.new('v1.2.3-b'),
+        '>=1.2.3 <=1.2.5'      => SemVer.new('v1.2.3-')       ..  SemVer.new('v1.2.5'),
+        '1.2.3-a - 2.3.4-b'    => SemVer.new('v1.2.3-a')      ..  SemVer.new('v2.3.4-b'),
+        '1.2.3 - 2.3.4'        => SemVer.new('v1.2.3-')       ..  SemVer.new('v2.3.4'),
+        '~1.2.3'               => SemVer.new('v1.2.3-')       ... SemVer.new('v1.3.0-'),
+        '~1.2'                 => SemVer.new('v1.2.0-')       ... SemVer.new('v2.0.0-'),
+        '~1'                   => SemVer.new('v1.0.0-')       ... SemVer.new('v2.0.0-'),
+        '1.2.x'                => SemVer.new('v1.2.0')        ... SemVer.new('v1.3.0-'),
+        '1.x'                  => SemVer.new('v1.0.0')        ... SemVer.new('v2.0.0-'),
+      }
+
+      tests.each do |vstring, expected|
+        SemVer[vstring].should == expected
+      end
+    end
+
+    it "should suit up" do
+      suitability = {
+        [ '1.2.3',         'v1.2.2' ] => false,
+        [ '>=1.2.3',       'v1.2.2' ] => false,
+        [ '<=1.2.3',       'v1.2.2' ] => true,
+        [ '>= 1.2.3',      'v1.2.2' ] => false,
+        [ '<= 1.2.3',      'v1.2.2' ] => true,
+        [ '1.2.3 - 1.2.4', 'v1.2.2' ] => false,
+        [ '~1.2.3',        'v1.2.2' ] => false,
+        [ '~1.2',          'v1.2.2' ] => true,
+        [ '~1',            'v1.2.2' ] => true,
+        [ '1.2.x',         'v1.2.2' ] => true,
+        [ '1.x',           'v1.2.2' ] => true,
+
+        [ '1.2.3',         'v1.2.3-alpha' ] => true,
+        [ '>=1.2.3',       'v1.2.3-alpha' ] => true,
+        [ '<=1.2.3',       'v1.2.3-alpha' ] => true,
+        [ '>= 1.2.3',      'v1.2.3-alpha' ] => true,
+        [ '<= 1.2.3',      'v1.2.3-alpha' ] => true,
+        [ '>1.2.3',        'v1.2.3-alpha' ] => false,
+        [ '<1.2.3',        'v1.2.3-alpha' ] => false,
+        [ '> 1.2.3',       'v1.2.3-alpha' ] => false,
+        [ '< 1.2.3',       'v1.2.3-alpha' ] => false,
+        [ '1.2.3 - 1.2.4', 'v1.2.3-alpha' ] => true,
+        [ '1.2.3 - 1.2.4', 'v1.2.4-alpha' ] => true,
+        [ '1.2.3 - 1.2.4', 'v1.2.5-alpha' ] => false,
+        [ '~1.2.3',        'v1.2.3-alpha' ] => true,
+        [ '~1.2.3',        'v1.3.0-alpha' ] => false,
+        [ '~1.2',          'v1.2.3-alpha' ] => true,
+        [ '~1.2',          'v2.0.0-alpha' ] => false,
+        [ '~1',            'v1.2.3-alpha' ] => true,
+        [ '~1',            'v2.0.0-alpha' ] => false,
+        [ '1.2.x',         'v1.2.3-alpha' ] => true,
+        [ '1.2.x',         'v1.3.0-alpha' ] => false,
+        [ '1.x',           'v1.2.3-alpha' ] => true,
+        [ '1.x',           'v2.0.0-alpha' ] => false,
+
+        [ '1.2.3',         'v1.2.3' ] => true,
+        [ '>=1.2.3',       'v1.2.3' ] => true,
+        [ '<=1.2.3',       'v1.2.3' ] => true,
+        [ '>= 1.2.3',      'v1.2.3' ] => true,
+        [ '<= 1.2.3',      'v1.2.3' ] => true,
+        [ '1.2.3 - 1.2.4', 'v1.2.3' ] => true,
+        [ '~1.2.3',        'v1.2.3' ] => true,
+        [ '~1.2',          'v1.2.3' ] => true,
+        [ '~1',            'v1.2.3' ] => true,
+        [ '1.2.x',         'v1.2.3' ] => true,
+        [ '1.x',           'v1.2.3' ] => true,
+
+        [ '1.2.3',         'v1.2.4' ] => false,
+        [ '>=1.2.3',       'v1.2.4' ] => true,
+        [ '<=1.2.3',       'v1.2.4' ] => false,
+        [ '>= 1.2.3',      'v1.2.4' ] => true,
+        [ '<= 1.2.3',      'v1.2.4' ] => false,
+        [ '1.2.3 - 1.2.4', 'v1.2.4' ] => true,
+        [ '~1.2.3',        'v1.2.4' ] => true,
+        [ '~1.2',          'v1.2.4' ] => true,
+        [ '~1',            'v1.2.4' ] => true,
+        [ '1.2.x',         'v1.2.4' ] => true,
+        [ '1.x',           'v1.2.4' ] => true,
+      }
+
+      suitability.each do |arguments, expected|
+        range, vstring = arguments
+        actual = SemVer[range] === SemVer.new(vstring)
+        actual.should == expected
+      end
+    end
+  end
+
+  describe 'instantiation' do
+    it 'should raise an exception when passed an invalid version string' do
+      expect { SemVer.new('invalidVersion') }.to raise_exception ArgumentError
+    end
+
+    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 == ''
+    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'
+    end
+  end
+
+  describe '#matched_by?' do
+    subject { SemVer.new('v1.2.3-beta') }
+
+    describe 'should match against' do
+      describe 'literal version strings' do
+        it { should 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') }
+      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') }
+      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') }
+      end
+    end
+  end
+
+  describe 'comparisons' do
+    describe 'against a string' do
+      it 'should just work' do
+        SemVer.new('1.2.3').should == '1.2.3'
+      end
+    end
+
+    describe 'against a symbol' do
+      it 'should just work' do
+        SemVer.new('1.2.3').should == :'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') }
+
+      # Different major versions
+      it { should > SemVer.new('0.2.3') }
+      it { should < SemVer.new('2.2.3') }
+
+      # Different minor versions
+      it { should > SemVer.new('1.1.3') }
+      it { should < SemVer.new('1.3.3') }
+
+      # Different tiny versions
+      it { should > SemVer.new('1.2.2') }
+      it { should < SemVer.new('1.2.4') }
+
+      # Against special versions
+      it { should > SemVer.new('1.2.3-beta') }
+      it { should < 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') }
+
+      # Same version, final release
+      it { should < SemVer.new('1.2.3') }
+
+      # Different major versions
+      it { should > SemVer.new('0.2.3') }
+      it { should < SemVer.new('2.2.3') }
+
+      # Different minor versions
+      it { should > SemVer.new('1.1.3') }
+      it { should < SemVer.new('1.3.3') }
+
+      # Different tiny versions
+      it { should > SemVer.new('1.2.2') }
+      it { should < SemVer.new('1.2.4') }
+
+      # Against special versions
+      it { should > SemVer.new('1.2.3-alpha') }
+      it { should < SemVer.new('1.2.3-beta2') }
+    end
+  end
+end