puppet 7.27.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/parameter/boolean_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-require 'puppet'
-require 'puppet/parameter/boolean'
-
-describe Puppet::Parameter::Boolean do
-  let (:resource) { double('resource') }
-  describe "after initvars" do
-    before { described_class.initvars }
-    it "should have the correct value_collection" do
-      expect(described_class.value_collection.values.sort).to eq(
-          [:true, :false, :yes, :no].sort
-      )
-    end
-  end
-
-  describe "instances" do
-    subject { described_class.new(:resource => resource) }
-
-    [ true, :true, 'true', :yes, 'yes', 'TrUe', 'yEs' ].each do |arg|
-      it "should munge #{arg.inspect} as true" do
-        expect(subject.munge(arg)).to eq(true)
-      end
-    end
-    [ false, :false, 'false', :no, 'no', 'FaLSE', 'nO' ].each do |arg|
-      it "should munge #{arg.inspect} as false" do
-        expect(subject.munge(arg)).to eq(false)
-      end
-    end
-    [ nil, :undef, 'undef', '0', 0, '1', 1, 9284 ].each do |arg|
-      it "should fail to munge #{arg.inspect}" do
-        expect { subject.munge(arg) }.to raise_error Puppet::Error
-      end
-    end
-  end
-end

data/spec/unit/parameter/package_options_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/parameter/package_options'
-
-describe Puppet::Parameter::PackageOptions do
-  let (:resource) { double('resource') }
-  let (:param)    { described_class.new(:resource => resource) }
-  let (:arg)      { '/S' }
-  let (:key)      { 'INSTALLDIR' }
-  let (:value)    { 'C:/mydir' }
-
-  context '#munge' do
-    # The parser automatically converts single element arrays to just
-    # a single element, why it does this is beyond me. See 46252b5bb8
-    it 'should accept a string' do
-      expect(param.munge(arg)).to eq([arg])
-    end
-
-    it 'should accept a hash' do
-      expect(param.munge({key => value})).to eq([{key => value}])
-    end
-
-    it 'should accept an array of strings and hashes' do
-      munged = param.munge([arg, {key => value}, '/NCRC', {'CONF' => 'C:\datadir'}])
-      expect(munged).to eq([arg, {key => value}, '/NCRC', {'CONF' => 'C:\datadir'}])
-    end
-
-    it 'should quote strings' do
-      expect(param.munge('arg one')).to eq(["\"arg one\""])
-    end
-
-    it 'should quote hash pairs' do
-      munged = param.munge({'INSTALL DIR' => 'C:\Program Files'})
-      expect(munged).to eq([{"\"INSTALL DIR\"" => "\"C:\\Program Files\""}])
-    end
-
-    it 'should reject symbols' do
-      expect {
-        param.munge([:symbol])
-      }.to raise_error(Puppet::Error, /Expected either a string or hash of options/)
-    end
-  end
-end

data/spec/unit/parameter/path_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/parameter/path'
-
-[false, true].each do |arrays|
-  describe "Puppet::Parameter::Path with arrays #{arrays}" do
-    it_should_behave_like "all path parameters", :path, :array => arrays do
-      # The new type allows us a test that is guaranteed to go direct to our
-      # validation code, without passing through any "real type" overrides or
-      # whatever on the way.
-      Puppet::Type.newtype(:test_puppet_parameter_path) do
-        newparam(:path, :parent => Puppet::Parameter::Path, :arrays => arrays) do
-          isnamevar
-          accept_arrays arrays
-        end
-      end
-
-      def instance(path)
-        Puppet::Type.type(:test_puppet_parameter_path).new(:path => path)
-      end
-    end
-  end
-end

data/spec/unit/parameter/value_collection_spec.rb

@@ -1,160 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/parameter'
-
-describe Puppet::Parameter::ValueCollection do
-  before do
-    @collection = Puppet::Parameter::ValueCollection.new
-  end
-
-  it "should have a method for defining new values" do
-    expect(@collection).to respond_to(:newvalues)
-  end
-
-  it "should have a method for adding individual values" do
-    expect(@collection).to respond_to(:newvalue)
-  end
-
-  it "should be able to retrieve individual values" do
-    value = @collection.newvalue(:foo)
-    expect(@collection.value(:foo)).to equal(value)
-  end
-
-  it "should be able to add an individual value with a block" do
-    @collection.newvalue(:foo) { raise "testing" }
-    expect(@collection.value(:foo).block).to be_instance_of(Proc)
-  end
-
-  it "should be able to add values that are empty strings" do
-    expect { @collection.newvalue('') }.to_not raise_error
-  end
-
-  it "should be able to add values that are empty strings" do
-    value = @collection.newvalue('')
-    expect(@collection.match?('')).to equal(value)
-  end
-
-  describe "when adding a value with a block" do
-    it "should set the method name to 'set_' plus the value name" do
-      value = @collection.newvalue(:myval) { raise "testing" }
-      expect(value.method).to eq("set_myval")
-    end
-  end
-
-  it "should be able to add an individual value with options" do
-    value = @collection.newvalue(:foo, :method => 'set_myval')
-    expect(value.method).to eq('set_myval')
-  end
-
-  it "should have a method for validating a value" do
-    expect(@collection).to respond_to(:validate)
-  end
-
-  it "should have a method for munging a value" do
-    expect(@collection).to respond_to(:munge)
-  end
-
-  it "should be able to generate documentation when it has both values and regexes" do
-    @collection.newvalues :foo, "bar", %r{test}
-    expect(@collection.doc).to be_instance_of(String)
-  end
-
-  it "should correctly generate documentation for values" do
-    @collection.newvalues :foo
-    expect(@collection.doc).to be_include("Valid values are `foo`")
-  end
-
-  it "should correctly generate documentation for regexes" do
-    @collection.newvalues %r{\w+}
-    expect(@collection.doc).to be_include("Values can match `/\\w+/`")
-  end
-
-  it "should be able to find the first matching value" do
-    @collection.newvalues :foo, :bar
-    expect(@collection.match?("foo")).to be_instance_of(Puppet::Parameter::Value)
-  end
-
-  it "should be able to match symbols" do
-    @collection.newvalues :foo, :bar
-    expect(@collection.match?(:foo)).to be_instance_of(Puppet::Parameter::Value)
-  end
-
-  it "should be able to match symbols when a regex is provided" do
-    @collection.newvalues %r{.}
-    expect(@collection.match?(:foo)).to be_instance_of(Puppet::Parameter::Value)
-  end
-
-  it "should be able to match values using regexes" do
-    @collection.newvalues %r{.}
-    expect(@collection.match?("foo")).not_to be_nil
-  end
-
-  it "should prefer value matches to regex matches" do
-    @collection.newvalues %r{.}, :foo
-    expect(@collection.match?("foo").name).to eq(:foo)
-  end
-
-  describe "when validating values" do
-    it "should do nothing if no values or regexes have been defined" do
-      @collection.validate("foo")
-    end
-
-    it "should fail if the value is not a defined value or alias and does not match a regex" do
-      @collection.newvalues :foo
-      expect { @collection.validate("bar") }.to raise_error(ArgumentError)
-    end
-
-    it "should succeed if the value is one of the defined values" do
-      @collection.newvalues :foo
-      expect { @collection.validate(:foo) }.to_not raise_error
-    end
-
-    it "should succeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
-      @collection.newvalues :foo
-      expect { @collection.validate("foo") }.to_not raise_error
-    end
-
-    it "should succeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
-      @collection.newvalues "foo"
-      expect { @collection.validate(:foo) }.to_not raise_error
-    end
-
-    it "should succeed if the value is one of the defined aliases" do
-      @collection.newvalues :foo
-      @collection.aliasvalue :bar, :foo
-      expect { @collection.validate("bar") }.to_not raise_error
-    end
-
-    it "should succeed if the value matches one of the regexes" do
-      @collection.newvalues %r{\d}
-      expect { @collection.validate("10") }.to_not raise_error
-    end
-  end
-
-  describe "when munging values" do
-    it "should do nothing if no values or regexes have been defined" do
-      expect(@collection.munge("foo")).to eq("foo")
-    end
-
-    it "should return return any matching defined values" do
-      @collection.newvalues :foo, :bar
-      expect(@collection.munge("foo")).to eq(:foo)
-    end
-
-    it "should return any matching aliases" do
-      @collection.newvalues :foo
-      @collection.aliasvalue :bar, :foo
-      expect(@collection.munge("bar")).to eq(:foo)
-    end
-
-    it "should return the value if it matches a regex" do
-      @collection.newvalues %r{\w}
-      expect(@collection.munge("bar")).to eq("bar")
-    end
-
-    it "should return the value if no other option is matched" do
-      @collection.newvalues :foo
-      expect(@collection.munge("bar")).to eq("bar")
-    end
-  end
-end

data/spec/unit/parameter/value_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/parameter'
-
-describe Puppet::Parameter::Value do
-  it "should require a name" do
-    expect { Puppet::Parameter::Value.new }.to raise_error(ArgumentError)
-  end
-
-  it "should set its name" do
-    expect(Puppet::Parameter::Value.new(:foo).name).to eq(:foo)
-  end
-
-  it "should support regexes as names" do
-    expect { Puppet::Parameter::Value.new(%r{foo}) }.not_to raise_error
-  end
-
-  it "should mark itself as a regex if its name is a regex" do
-    expect(Puppet::Parameter::Value.new(%r{foo})).to be_regex
-  end
-
-  it "should always convert its name to a symbol if it is not a regex" do
-    expect(Puppet::Parameter::Value.new("foo").name).to eq(:foo)
-    expect(Puppet::Parameter::Value.new(true).name).to eq(:true)
-  end
-
-  it "should support adding aliases" do
-    expect(Puppet::Parameter::Value.new("foo")).to respond_to(:alias)
-  end
-
-  it "should be able to return its aliases" do
-    value = Puppet::Parameter::Value.new("foo")
-    value.alias("bar")
-    value.alias("baz")
-    expect(value.aliases).to eq([:bar, :baz])
-  end
-
-  [:block, :method, :event, :required_features].each do |attr|
-    it "should support a #{attr} attribute" do
-      value = Puppet::Parameter::Value.new("foo")
-      expect(value).to respond_to(attr.to_s + "=")
-      expect(value).to respond_to(attr)
-    end
-  end
-
-  it "should always return events as symbols" do
-    value = Puppet::Parameter::Value.new("foo")
-    value.event = "foo_test"
-    expect(value.event).to eq(:foo_test)
-  end
-
-  describe "when matching" do
-    describe "a regex" do
-      it "should return true if the regex matches the value" do
-        expect(Puppet::Parameter::Value.new(/\w/)).to be_match("foo")
-      end
-
-      it "should return false if the regex does not match the value" do
-        expect(Puppet::Parameter::Value.new(/\d/)).not_to be_match("foo")
-      end
-    end
-
-    describe "a non-regex" do
-      it "should return true if the value, converted to a symbol, matches the name" do
-        expect(Puppet::Parameter::Value.new("foo")).to be_match("foo")
-        expect(Puppet::Parameter::Value.new(:foo)).to be_match(:foo)
-        expect(Puppet::Parameter::Value.new(:foo)).to be_match("foo")
-        expect(Puppet::Parameter::Value.new("foo")).to be_match(:foo)
-      end
-
-      it "should return false if the value, converted to a symbol, does not match the name" do
-        expect(Puppet::Parameter::Value.new(:foo)).not_to be_match(:bar)
-      end
-
-      it "should return true if any of its aliases match" do
-        value = Puppet::Parameter::Value.new("foo")
-        value.alias("bar")
-        expect(value).to be_match("bar")
-      end
-    end
-  end
-end

data/spec/unit/parameter_spec.rb

@@ -1,272 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/parameter'
-
-describe Puppet::Parameter do
-  before do
-    @class = Class.new(Puppet::Parameter) do
-      @name = :foo
-    end
-    @class.initvars
-    @resource = double('resource')
-    allow(@resource).to receive(:expects)
-    allow(@resource).to receive(:pathbuilder)
-    @parameter = @class.new :resource => @resource
-  end
-
-  it "should create a value collection" do
-    @class = Class.new(Puppet::Parameter)
-    expect(@class.value_collection).to be_nil
-    @class.initvars
-    expect(@class.value_collection).to be_instance_of(Puppet::Parameter::ValueCollection)
-  end
-
-  it "should return its name as a string when converted to a string" do
-    expect(@parameter.to_s).to eq(@parameter.name.to_s)
-  end
-
-  [:line, :file, :version].each do |data|
-    it "should return its resource's #{data} as its #{data}" do
-      expect(@resource).to receive(data).and_return("foo")
-      expect(@parameter.send(data)).to eq("foo")
-    end
-  end
-
-  it "should return the resource's tags plus its name as its tags" do
-    expect(@resource).to receive(:tags).and_return(%w{one two})
-    expect(@parameter.tags).to eq(%w{one two foo})
-  end
-
-  it "should have a path" do
-    expect(@parameter.path).to eq("//foo")
-  end
-
-  describe "when returning the value" do
-    it "should return nil if no value is set" do
-      expect(@parameter.value).to be_nil
-    end
-
-    it "should validate the value" do
-      expect(@parameter).to receive(:validate).with("foo")
-      @parameter.value = "foo"
-    end
-
-    it "should munge the value and use any result as the actual value" do
-      expect(@parameter).to receive(:munge).with("foo").and_return("bar")
-      @parameter.value = "foo"
-      expect(@parameter.value).to eq("bar")
-    end
-
-    it "should unmunge the value when accessing the actual value" do
-      @parameter.class.unmunge do |value| value.to_sym end
-      @parameter.value = "foo"
-      expect(@parameter.value).to eq(:foo)
-    end
-
-    it "should return the actual value by default when unmunging" do
-      expect(@parameter.unmunge("bar")).to eq("bar")
-    end
-
-    it "should return any set value" do
-      @parameter.value = "foo"
-      expect(@parameter.value).to eq("foo")
-    end
-  end
-
-  describe "when validating values" do
-    it "should do nothing if no values or regexes have been defined" do
-      @parameter.validate("foo")
-    end
-
-    it "should catch abnormal failures thrown during validation" do
-      @class.validate { |v| raise "This is broken" }
-      expect { @parameter.validate("eh") }.to raise_error(Puppet::DevError)
-    end
-
-    it "should fail if the value is not a defined value or alias and does not match a regex" do
-      @class.newvalues :foo
-      expect { @parameter.validate("bar") }.to raise_error(Puppet::Error)
-    end
-
-    it "should succeed if the value is one of the defined values" do
-      @class.newvalues :foo
-      expect { @parameter.validate(:foo) }.to_not raise_error
-    end
-
-    it "should succeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
-      @class.newvalues :foo
-      expect { @parameter.validate("foo") }.to_not raise_error
-    end
-
-    it "should succeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
-      @class.newvalues "foo"
-      expect { @parameter.validate(:foo) }.to_not raise_error
-    end
-
-    it "should succeed if the value is one of the defined aliases" do
-      @class.newvalues :foo
-      @class.aliasvalue :bar, :foo
-      expect { @parameter.validate("bar") }.to_not raise_error
-    end
-
-    it "should succeed if the value matches one of the regexes" do
-      @class.newvalues %r{\d}
-      expect { @parameter.validate("10") }.to_not raise_error
-    end
-  end
-
-  describe "when munging values" do
-    it "should do nothing if no values or regexes have been defined" do
-      expect(@parameter.munge("foo")).to eq("foo")
-    end
-
-    it "should catch abnormal failures thrown during munging" do
-      @class.munge { |v| raise "This is broken" }
-      expect { @parameter.munge("eh") }.to raise_error(Puppet::DevError)
-    end
-
-    it "should return return any matching defined values" do
-      @class.newvalues :foo, :bar
-      expect(@parameter.munge("foo")).to eq(:foo)
-    end
-
-    it "should return any matching aliases" do
-      @class.newvalues :foo
-      @class.aliasvalue :bar, :foo
-      expect(@parameter.munge("bar")).to eq(:foo)
-    end
-
-    it "should return the value if it matches a regex" do
-      @class.newvalues %r{\w}
-      expect(@parameter.munge("bar")).to eq("bar")
-    end
-
-    it "should return the value if no other option is matched" do
-      @class.newvalues :foo
-      expect(@parameter.munge("bar")).to eq("bar")
-    end
-  end
-
-  describe "when logging" do
-    it "should use its resource's log level and the provided message" do
-      expect(@resource).to receive(:[]).with(:loglevel).and_return(:notice)
-      expect(@parameter).to receive(:send_log).with(:notice, "mymessage")
-      @parameter.log "mymessage"
-    end
-  end
-
-  describe ".format_value_for_display" do
-    it 'should format strings appropriately' do
-      expect(described_class.format_value_for_display('foo')).to eq("'foo'")
-    end
-
-    it 'should format numbers appropriately' do
-      expect(described_class.format_value_for_display(1)).to eq('1')
-    end
-
-    it 'should format symbols appropriately' do
-      expect(described_class.format_value_for_display(:bar)).to eq("'bar'")
-    end
-
-    it 'should format arrays appropriately' do
-      expect(described_class.format_value_for_display([1, 'foo', :bar])).to eq("[1, 'foo', 'bar']")
-    end
-
-    it 'should format hashes appropriately' do
-      expect(described_class.format_value_for_display(
-        {1 => 'foo', :bar => 2, 'baz' => :qux}
-      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
-        {
-          1 => 'foo',
-          'bar' => 2,
-          'baz' => 'qux'
-        }
-      RUBY
-    end
-
-    it 'should format arrays with nested data appropriately' do
-      expect(described_class.format_value_for_display(
-        [1, 'foo', :bar, [1, 2, 3], {1 => 2, 3 => 4}]
-      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
-        [1, 'foo', 'bar',
-          [1, 2, 3],
-          {
-            1 => 2,
-            3 => 4
-          }]
-      RUBY
-    end
-
-    it 'should format hashes with nested data appropriately' do
-      expect(described_class.format_value_for_display(
-        {1 => 'foo', :bar => [2, 3, 4], 'baz' => {:qux => 1, :quux => 'two'}}
-      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
-        {
-          1 => 'foo',
-          'bar' => [2, 3, 4],
-          'baz' => {
-            'qux' => 1,
-            'quux' => 'two'
-          }
-        }
-       RUBY
-    end
-
-    it 'should format hashes with nested Objects appropriately' do
-      tf = Puppet::Pops::Types::TypeFactory
-      type = tf.object({'name' => 'MyType', 'attributes' => { 'qux' => tf.integer, 'quux' => tf.string }})
-      expect(described_class.format_value_for_display(
-        {1 => 'foo', 'bar' => type.create(1, 'one'), 'baz' => type.create(2, 'two')}
-      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
-        {
-          1 => 'foo',
-          'bar' => MyType({
-            'qux' => 1,
-            'quux' => 'one'
-          }),
-          'baz' => MyType({
-            'qux' => 2,
-            'quux' => 'two'
-          })
-        }
-      RUBY
-    end
-
-    it 'should format Objects with nested Objects appropriately' do
-      tf = Puppet::Pops::Types::TypeFactory
-      inner_type = tf.object({'name' => 'MyInnerType', 'attributes' => { 'qux' => tf.integer, 'quux' => tf.string }})
-      outer_type = tf.object({'name' => 'MyOuterType', 'attributes' => { 'x' => tf.string, 'inner' => inner_type }})
-      expect(described_class.format_value_for_display(
-        {'bar' => outer_type.create('a', inner_type.create(1, 'one')), 'baz' => outer_type.create('b', inner_type.create(2, 'two'))}
-      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
-        {
-          'bar' => MyOuterType({
-            'x' => 'a',
-            'inner' => MyInnerType({
-              'qux' => 1,
-              'quux' => 'one'
-            })
-          }),
-          'baz' => MyOuterType({
-            'x' => 'b',
-            'inner' => MyInnerType({
-              'qux' => 2,
-              'quux' => 'two'
-            })
-          })
-        }
-      RUBY
-    end
-  end
-
-  describe 'formatting messages' do
-    it "formats messages as-is when the parameter is not sensitive" do
-      expect(@parameter.format("hello %s", "world")).to eq("hello world")
-    end
-
-    it "formats messages with redacted values when the parameter is not sensitive" do
-      @parameter.sensitive = true
-      expect(@parameter.format("hello %s", "world")).to eq("hello [redacted]")
-    end
-  end
-end

data/spec/unit/parser/ast/block_expression_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'puppet/parser/ast/block_expression'
-
-describe 'Puppet::Parser::AST::BlockExpression' do
-  class StackDepthAST < Puppet::Parser::AST
-    attr_reader :call_depth
-    def evaluate(*options)
-      @call_depth = caller.length
-    end
-  end
-
-  NO_SCOPE = nil
-
-  def depth_probe
-    StackDepthAST.new
-  end
-
-  def sequence_probe(name)
-    probe = double("Sequence Probe #{name}")
-    expect(probe).to receive(:safeevaluate).ordered
-    probe
-  end
-
-  def block_of(children)
-    Puppet::Parser::AST::BlockExpression.new(:children => children)
-  end
-
-  def assert_all_at_same_depth(*probes)
-    depth0 = probes[0].call_depth
-    probes.drop(1).each do |p|
-      expect(p.call_depth).to eq(depth0)
-    end
-  end
-
-  it "evaluates all its children at the same stack depth" do
-    depth_probes = [depth_probe, depth_probe]
-    expr = block_of(depth_probes)
-
-    expr.evaluate(NO_SCOPE)
-
-    assert_all_at_same_depth(*depth_probes)
-  end
-
-  it "evaluates sequenced children at the same stack depth" do
-    depth1 = depth_probe
-    depth2 = depth_probe
-    depth3 = depth_probe
-
-    expr1 = block_of([depth1])
-    expr2 = block_of([depth2])
-    expr3 = block_of([depth3])
-
-    expr1.sequence_with(expr2).sequence_with(expr3).evaluate(NO_SCOPE)
-
-    assert_all_at_same_depth(depth1, depth2, depth3)
-  end
-
-  it "evaluates sequenced children in order" do
-    expr1 = block_of([sequence_probe("Step 1")])
-    expr2 = block_of([sequence_probe("Step 2")])
-    expr3 = block_of([sequence_probe("Step 3")])
-
-    expr1.sequence_with(expr2).sequence_with(expr3).evaluate(NO_SCOPE)
-  end
-end
-