RubyGems - puppet - Versions diffs - 7.27.0-x86-mingw32 → 7.29.0-x86-mingw32 - Mend

puppet 7.27.0-x86-mingw32 → 7.29.0-x86-mingw32

Files changed (1286) hide show

data/spec/unit/scheduler/job_spec.rb DELETED Viewed

@@ -1,78 +0,0 @@
-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
-    expect(Puppet::Scheduler::Job.new(-1).run_interval).to eq(0)
-  end
-  describe "when not run yet" do
-    it "is ready" do
-      expect(job.ready?(2)).to be
-    end
-    it "gives the time to next run as 0" do
-      expect(job.interval_to_next_from(2)).to eq(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
-      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
-      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
-      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
-        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
-        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
-        expect(job.interval_to_next_from(now)).to eq(0)
-      end
-    end
-  end
-  it "starts enabled" do
-    expect(job.enabled?).to be
-  end
-  it "can be disabled" do
-    job.disable
-    expect(job.enabled?).not_to 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)
-    expect(passed_job).to eql(job)
-  end
-end

data/spec/unit/scheduler/scheduler_spec.rb DELETED Viewed

@@ -1,115 +0,0 @@
-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])
-    expect(timer.wait_for_calls).to eq([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])
-    expect(timer.wait_for_calls).to eq([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])
-    expect(timer.wait_for_calls).to eq([5])
-  end
-  it "does not run when there are no jobs" do
-    scheduler.run_loop([])
-    expect(timer.wait_for_calls).to 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])
-    expect(timer.wait_for_calls).to 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])
-    expect(timer.wait_for_calls.size).to eq(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])
-    expect(disabled_job.start_time).to eq(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])
-    expect(timer.wait_for_calls).to eq([0, 3, 7, 3])
-  end
-end

data/spec/unit/scheduler/splay_job_spec.rb DELETED Viewed

@@ -1,34 +0,0 @@
-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)
-    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
-    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
-    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
-    expect(job).to receive(:splay).and_return(6)
-    expect(job.ready?(start_time)).not_to be
-  end
-end

data/spec/unit/settings/array_setting_spec.rb DELETED Viewed

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require 'puppet/settings'
-require 'puppet/settings/array_setting'
-describe Puppet::Settings::ArraySetting do
-  subject { described_class.new(:settings => double('settings'), :desc => "test") }
-  it "is of type :array" do
-    expect(subject.type).to eq :array
-  end
-  describe "munging the value" do
-    describe "when given a string" do
-      it "splits multiple values into an array" do
-        expect(subject.munge("foo,bar")).to eq %w[foo bar]
-      end
-      it "strips whitespace between elements" do
-        expect(subject.munge("foo , bar")).to eq %w[foo bar]
-      end
-      it "creates an array when one item is given" do
-        expect(subject.munge("foo")).to eq %w[foo]
-      end
-    end
-    describe "when given an array" do
-      it "returns the array" do
-        expect(subject.munge(%w[foo])).to eq %w[foo]
-      end
-    end
-    it "raises an error when given an unexpected object type" do
-        expect {
-          subject.munge({:foo => 'bar'})
-        }.to raise_error(ArgumentError, "Expected an Array or String, got a Hash")
-    end
-  end
-end

data/spec/unit/settings/autosign_setting_spec.rb DELETED Viewed

@@ -1,104 +0,0 @@
-require 'spec_helper'
-require 'puppet/settings'
-require 'puppet/settings/autosign_setting'
-describe Puppet::Settings::AutosignSetting do
-  let(:settings) do
-    s = double('settings')
-    allow(s).to receive(:[]).with(:mkusers).and_return(true)
-    allow(s).to receive(:[]).with(:user).and_return('puppet')
-    allow(s).to receive(:[]).with(:group).and_return('puppet')
-    allow(s).to receive(:[]).with(:manage_internal_file_permissions).and_return(true)
-    s
-  end
-  let(:setting) { described_class.new(:name => 'autosign', :section => 'section', :settings => settings, :desc => "test") }
-  it "is of type :file" do
-    expect(setting.type).to eq :file
-  end
-  describe "when munging the setting" do
-    it "passes boolean values through" do
-      expect(setting.munge(true)).to eq true
-      expect(setting.munge(false)).to eq false
-    end
-    it "converts nil to false" do
-      expect(setting.munge(nil)).to eq false
-    end
-    it "munges string 'true' to boolean true" do
-      expect(setting.munge('true')).to eq true
-    end
-    it "munges string 'false' to boolean false" do
-      expect(setting.munge('false')).to eq false
-    end
-    it "passes absolute paths through" do
-      path = File.expand_path('/path/to/autosign.conf')
-      expect(setting.munge(path)).to eq path
-    end
-    it "fails if given anything else" do
-      cases = [1.0, 'sometimes', 'relative/autosign.conf']
-      cases.each do |invalid|
-        expect {
-          setting.munge(invalid)
-        }.to raise_error Puppet::Settings::ValidationError, /Invalid autosign value/
-      end
-    end
-  end
-  describe "setting additional setting values" do
-    it "can set the file mode" do
-      setting.mode = '0664'
-      expect(setting.mode).to eq '0664'
-    end
-    it "can set the file owner" do
-      setting.owner = 'service'
-      expect(setting.owner).to eq 'puppet'
-    end
-    it "can set the file group" do
-      setting.group = 'service'
-      expect(setting.group).to eq 'puppet'
-    end
-  end
-  describe "converting the setting to a resource" do
-    it "converts the file path to a file resource", :if => !Puppet::Util::Platform.windows? do
-      path = File.expand_path('/path/to/autosign.conf')
-      allow(settings).to receive(:value).with('autosign', nil, false).and_return(path)
-      allow(Puppet::FileSystem).to receive(:exist?).and_call_original
-      allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-      expect(Puppet.features).to receive(:root?).and_return(true)
-      setting.mode = '0664'
-      setting.owner = 'service'
-      setting.group = 'service'
-      resource = setting.to_resource
-      expect(resource.title).to eq path
-      expect(resource[:ensure]).to eq :file
-      expect(resource[:mode]).to eq '664'
-      expect(resource[:owner]).to eq 'puppet'
-      expect(resource[:group]).to eq 'puppet'
-    end
-    it "returns nil when the setting is a boolean" do
-      allow(settings).to receive(:value).with('autosign', nil, false).and_return('true')
-      setting.mode = '0664'
-      setting.owner = 'service'
-      setting.group = 'service'
-      expect(setting.to_resource).to be_nil
-    end
-  end
-end

data/spec/unit/settings/certificate_revocation_setting_spec.rb DELETED Viewed

@@ -1,37 +0,0 @@
-require 'spec_helper'
-require 'puppet/settings'
-require 'puppet/settings/certificate_revocation_setting'
-describe Puppet::Settings::CertificateRevocationSetting do
-  subject { described_class.new(:settings => double('settings'), :desc => "test") }
-  it "is of type :certificate_revocation" do
-    expect(subject.type).to eq :certificate_revocation
-  end
-  describe "munging the value" do
-    ['true', true, 'chain'].each do |setting|
-      it "munges #{setting.inspect} to :chain" do
-        expect(subject.munge(setting)).to eq :chain
-      end
-    end
-    it "munges 'leaf' to :leaf" do
-      expect(subject.munge("leaf")).to eq :leaf
-    end
-    ['false', false, nil].each do |setting|
-      it "munges #{setting.inspect} to false" do
-        expect(subject.munge(setting)).to eq false
-      end
-    end
-    it "raises an error when given an unexpected object type" do
-        expect {
-          subject.munge(1)
-        }.to raise_error(Puppet::Settings::ValidationError, "Invalid certificate revocation value 1: must be one of 'true', 'chain', 'leaf', or 'false'")
-    end
-  end
-end

data/spec/unit/settings/config_file_spec.rb DELETED Viewed

@@ -1,147 +0,0 @@
-require 'spec_helper'
-require 'puppet/settings/config_file'
-describe Puppet::Settings::ConfigFile do
-  NOTHING = {}
-  def the_parse_of(*lines)
-    config.parse_file(filename, lines.join("\n"))
-  end
-  let(:identity_transformer) { Proc.new { |value| value } }
-  let(:config) { Puppet::Settings::ConfigFile.new(identity_transformer) }
-  let(:filename) { "a/fake/filename.conf" }
-  Conf = Puppet::Settings::ConfigFile::Conf
-  Section = Puppet::Settings::ConfigFile::Section
-  Meta = Puppet::Settings::ConfigFile::Meta
-  NO_META = Puppet::Settings::ConfigFile::NO_META
-  it "interprets an empty file to contain a main section with no entries" do
-    result = the_parse_of("")
-    expect(result).to eq(Conf.new.with_section(Section.new(:main)))
-  end
-  it "interprets an empty main section the same as an empty file" do
-    expect(the_parse_of("")).to eq(config.parse_file(filename, "[main]"))
-  end
-  it "places an entry in no section in main" do
-    result = the_parse_of("var = value")
-    expect(result).to eq(Conf.new.with_section(Section.new(:main).with_setting(:var, "value", NO_META)))
-  end
-  it "places an entry after a section header in that section" do
-    result = the_parse_of("[agent]", "var = value")
-    expect(result).to eq(Conf.new.
-                         with_section(Section.new(:main)).
-                         with_section(Section.new(:agent).
-                                      with_setting(:var, "value", NO_META)))
-  end
-  it "does not include trailing whitespace in the value" do
-    result = the_parse_of("var = value\t ")
-    expect(result).to eq(Conf.new.
-                         with_section(Section.new(:main).
-                                      with_setting(:var, "value", NO_META)))
-  end
-  it "does not include leading whitespace in the name" do
-    result = the_parse_of("  \t var=value")
-    expect(result).to eq(Conf.new.
-                         with_section(Section.new(:main).
-                                      with_setting(:var, "value", NO_META)))
-  end
-  it "skips lines that are commented out" do
-    result = the_parse_of("#var = value")
-    expect(result).to eq(Conf.new.with_section(Section.new(:main)))
-  end
-  it "skips lines that are entirely whitespace" do
-    result = the_parse_of("   \t ")
-    expect(result).to eq(Conf.new.with_section(Section.new(:main)))
-  end
-  it "errors when a line is not a known form" do
-    expect { the_parse_of("unknown") }.to raise_error Puppet::Settings::ParseError, /Could not match line/
-  end
-  it "errors providing correct line number when line is not a known form" do
-    multi_line_config = <<-EOF
-[main]
-foo=bar
-badline
-    EOF
-    expect { the_parse_of(multi_line_config) }.to(
-        raise_error(Puppet::Settings::ParseError, /Could not match line/) do |exception|
-          expect(exception.line).to eq(3)
-        end
-      )
-  end
-  it "stores file meta information in the _meta section" do
-    result = the_parse_of("var = value { owner = me, group = you, mode = 0666 }")
-    expect(result).to eq(Conf.new.with_section(Section.new(:main).
-                                               with_setting(:var, "value",
-                                                            Meta.new("me", "you", "0666"))))
-  end
-  it "errors when there is unknown meta information" do
-    expect { the_parse_of("var = value { unknown = no }") }.
-      to raise_error ArgumentError, /Invalid file option 'unknown'/
-  end
-  it "errors when the mode is not numeric" do
-    expect { the_parse_of("var = value { mode = no }") }.
-      to raise_error ArgumentError, "File modes must be numbers"
-  end
-  it "errors when the options are not key-value pairs" do
-    expect { the_parse_of("var = value { mode }") }.
-      to raise_error ArgumentError, "Could not parse 'value { mode }'"
-  end
-  it "may specify legal sections" do
-    text = <<-EOF
-      [legal]
-      a = 'b'
-      [illegal]
-      one = 'e'
-      two = 'f'
-    EOF
-    expect { config.parse_file(filename, text, [:legal]) }.
-      to raise_error Puppet::Error,
-        /Illegal section 'legal' in config file at \(file: #{filename}, line: 1\)/
-  end
-  it "transforms values with the given function" do
-    config = Puppet::Settings::ConfigFile.new(Proc.new { |value| value + " changed" })
-    result = config.parse_file(filename, "var = value")
-    expect(result).to eq(Conf.new.
-                            with_section(Section.new(:main).
-                                         with_setting(:var, "value changed", NO_META)))
-  end
-  it "accepts non-UTF8 encoded text" do
-    result = the_parse_of("var = value".encode("UTF-16LE"))
-    expect(result).to eq(Conf.new.
-                           with_section(Section.new(:main).
-                                          with_setting(:var, "value", NO_META)))
-  end
-end

data/spec/unit/settings/directory_setting_spec.rb DELETED Viewed

@@ -1,27 +0,0 @@
-require 'spec_helper'
-require 'puppet/settings'
-require 'puppet/settings/directory_setting'
-describe Puppet::Settings::DirectorySetting do
-  DirectorySetting = Puppet::Settings::DirectorySetting
-  include PuppetSpec::Files
-  before do
-    @basepath = make_absolute("/somepath")
-  end
-  describe "when being converted to a resource" do
-    before do
-      @settings = double('settings')
-      @dir = Puppet::Settings::DirectorySetting.new(
-          :settings => @settings, :desc => "eh", :name => :mydir, :section => "mysect")
-      allow(@settings).to receive(:value).with(:mydir).and_return(@basepath)
-    end
-    it "should return :directory as its type" do
-      expect(@dir.type).to eq(:directory)
-    end
-  end
-end

data/spec/unit/settings/duration_setting_spec.rb DELETED Viewed

@@ -1,48 +0,0 @@
-require 'spec_helper'
-require 'puppet/settings'
-require 'puppet/settings/duration_setting'
-describe Puppet::Settings::DurationSetting do
-  subject { described_class.new(:settings => double('settings'), :desc => "test") }
-  describe "when munging the setting" do
-    it "should return the same value if given an integer" do
-      expect(subject.munge(5)).to eq(5)
-    end
-    it "should return the same value if given nil" do
-      expect(subject.munge(nil)).to be_nil
-    end
-    it "should return an integer if given a decimal string" do
-      expect(subject.munge("12")).to eq(12)
-    end
-    it "should fail if given anything but a well-formed string, integer, or nil" do
-      [ '', 'foo', '2 d', '2d ', true, Time.now, 8.3, [] ].each do |value|
-        expect { subject.munge(value) }.to raise_error(Puppet::Settings::ValidationError)
-      end
-    end
-    it "should parse strings with units of 'y', 'd', 'h', 'm', or 's'" do
-      # Note: the year value won't jive with most methods of calculating
-      # year due to the Julian calandar having 365.25 days in a year
-      {
-        '3y' => 94608000,
-        '3d' => 259200,
-        '3h' => 10800,
-        '3m' => 180,
-        '3s' => 3
-      }.each do |value, converted_value|
-        # subject.munge(value).should == converted_value
-        expect(subject.munge(value)).to eq(converted_value)
-      end
-    end
-    # This is to support the `filetimeout` setting
-    it "should allow negative values" do
-      expect(subject.munge(-1)).to eq(-1)
-    end
-  end
-end

data/spec/unit/settings/enum_setting_spec.rb DELETED Viewed

@@ -1,27 +0,0 @@
-require 'spec_helper'
-require 'puppet/settings'
-describe Puppet::Settings::EnumSetting do
-  it "allows a configured value" do
-    setting = enum_setting_allowing("allowed")
-    expect(setting.munge("allowed")).to eq("allowed")
-  end
-  it "disallows a value that is not configured" do
-    setting = enum_setting_allowing("allowed", "also allowed")
-    expect do
-      setting.munge("disallowed")
-    end.to raise_error(Puppet::Settings::ValidationError,
-                       "Invalid value 'disallowed' for parameter testing. Allowed values are 'allowed', 'also allowed'")
-  end
-  def enum_setting_allowing(*values)
-    Puppet::Settings::EnumSetting.new(:settings => double('settings'),
-                                      :name => "testing",
-                                      :desc => "description of testing",
-                                      :values => values)
-  end
-end