puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/functions/index_spec.rb

@@ -1,184 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-require 'shared_behaviours/iterative_functions'
-
-describe 'the index function' do
-  include PuppetSpec::Compiler
-
-  context "should be callable on Array with" do
-    it 'a lambda to compute match' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        $n = $a.index |$v| { $v == 2 }
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "1")['ensure']).to eq('present')
-    end
-
-    it 'a lambda taking two arguments to compute match' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [6,6,6]
-        $n = $a.index |$i, $v| { $i == 2 }
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "2")['ensure']).to eq('present')
-    end
-
-    it 'a given value' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        $n = $a.index(3)
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "2")['ensure']).to eq('present')
-    end
-  end
-
-  context "should be callable on Hash with" do
-    it 'a lambda to compute match' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $h = {1 => 10, 2 => 20, 3 => 30 }
-        $n = $h.index |$v| { $v == 20 }
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "2")['ensure']).to eq('present')
-    end
-
-    it 'a lambda taking two arguments to compute match' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $h = {1 => 10, 2 => 20, 3 => 30 }
-        $n = $h.index |$k, $v| { $k == 3 }
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "3")['ensure']).to eq('present')
-    end
-
-    it 'a given value' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $h = {1 => 10, 2 => 20, 3 => 30 }
-        $n = $h.index(20)
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "2")['ensure']).to eq('present')
-    end
-  end
-
-  context "should be callable on String with" do
-    it 'a lambda to compute match' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $s = "foobarfuu"
-        $n = $s.index |$v| { $v == 'o' }
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "1")['ensure']).to eq('present')
-    end
-
-    it 'a lambda taking two arguments to compute match' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $s = "foobarfuu"
-        $n = $s.index |$i, $v| { $i == 2 }
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "2")['ensure']).to eq('present')
-    end
-
-    it 'a given value returns index of first found substring given as a string' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $s = "foobarfuu"
-        $n = $s.index('fu')
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "6")['ensure']).to eq('present')
-    end
-
-    it 'a given value returns index of first found substring given as a regexp' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $s = "foobarfuub"
-        $n = $s.index(/f(oo|uu)b/)
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "0")['ensure']).to eq('present')
-    end
-  end
-
-  context "should be callable on an iterable" do
-    it 'for example a reverse_each' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        $n = $a.reverse_each.index |$v| { $v == 1 }
-        file { "$n": ensure => present }
-      MANIFEST
-      expect(catalog.resource(:file, "2")['ensure']).to eq('present')
-    end
-  end
-
-  context 'stops iteration when result is known' do
-    it 'true when boolean true is found' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        $n = $a.index |$i, $v| { if $i == 0 { true } else { fail("unwanted") } }
-        file { "$n": ensure => present }
-      MANIFEST
-
-      expect(catalog.resource(:file, "0")['ensure']).to eq('present')
-    end
-  end
-
-  context 'returns undef when value is not found' do
-    it 'when using array and a lambda' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        $n = $a.index |$v| { $v == 'blue' }
-        file { "test": ensure => if $n =~ Undef { present } else {absent} }
-      MANIFEST
-      expect(catalog.resource(:file, "test")['ensure']).to eq('present')
-    end
-
-    it 'when using array and a value' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        $n = $a.index('blue')
-        file { "test": ensure => if $n =~ Undef { present } else {absent} }
-      MANIFEST
-      expect(catalog.resource(:file, "test")['ensure']).to eq('present')
-    end
-
-    it 'when using a hash and a lambda' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $h = {1 => 10, 2 => 20, 3 => 30}
-        $n = $h.index |$v| { $v == 'blue' }
-        file { "test": ensure => if $n =~ Undef { present } else {absent} }
-      MANIFEST
-      expect(catalog.resource(:file, "test")['ensure']).to eq('present')
-    end
-
-    it 'when using a hash and a value' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $h = {1 => 10, 2 => 20, 3 => 30}
-        $n = $h.index('blue')
-        file { "test": ensure => if $n =~ Undef { present } else {absent} }
-      MANIFEST
-      expect(catalog.resource(:file, "test")['ensure']).to eq('present')
-    end
-
-    it 'when using a String and a lambda' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $s = "foobarfuub"
-        $n = $s.index() |$v| { false }
-        file { "test": ensure => if $n =~ Undef { present } else {absent} }
-      MANIFEST
-      expect(catalog.resource(:file, "test")['ensure']).to eq('present')
-    end
-
-    it 'when using a String and a value' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $s = "foobarfuub"
-        $n = $s.index('banana')
-        file { "test": ensure => if $n =~ Undef { present } else {absent} }
-      MANIFEST
-      expect(catalog.resource(:file, "test")['ensure']).to eq('present')
-    end
-  end
-end

data/spec/unit/functions/inline_epp_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-
-describe "the inline_epp function" do
-  include PuppetSpec::Files
-  include PuppetSpec::Compiler
-
-  let :node     do Puppet::Node.new('localhost') end
-  let :compiler do Puppet::Parser::Compiler.new(node) end
-  let :scope    do Puppet::Parser::Scope.new(compiler) end
-
-  context "when accessing scope variables as $ variables" do
-    it "looks up the value from the scope" do
-      scope["what"] = "are belong"
-      expect(eval_template("all your base <%= $what %> to us")).to eq("all your base are belong to us")
-    end
-
-    it "get nil accessing a variable that does not exist" do
-      expect(eval_template("<%= $kryptonite == undef %>")).to eq("true")
-    end
-
-    it "get nil accessing a variable that is undef" do
-      scope['undef_var'] = :undef
-      expect(eval_template("<%= $undef_var == undef %>")).to eq("true")
-    end
-
-    it "gets shadowed variable if args are given" do
-      scope['phantom'] = 'of the opera'
-      expect(eval_template_with_args("<%= $phantom == dragos %>", 'phantom' => 'dragos')).to eq("true")
-    end
-
-    it "gets shadowed variable if args are given and parameters are specified" do
-      scope['x'] = 'wrong one'
-      expect(eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct')).to eq("true")
-    end
-
-    it "raises an error if required variable is not given" do
-      scope['x'] = 'wrong one'
-      expect {
-        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", {})
-      }.to raise_error(/expects a value for parameter 'x'/)
-    end
-
-    it 'raises an error if unexpected arguments are given' do
-      scope['x'] = 'wrong one'
-      expect {
-        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct', 'y' => 'surplus')
-      }.to raise_error(/has no parameter named 'y'/)
-    end
-  end
-
-  context "when given an empty template" do
-     it "allows the template file to be empty" do
-       expect(eval_template("")).to eq("")
-     end
-
-    it "allows the template to have empty body after parameters" do
-      expect(eval_template_with_args("<%-|$x|%>", 'x'=>1)).to eq("")
-    end
-  end
-
-  it "renders a block expression" do
-    expect(eval_template_with_args("<%= { $y = $x $x + 1} %>", 'x' => 2)).to eq("3")
-  end
-
-  # although never a problem with epp
-  it "is not interfered with by having a variable named 'string' (#14093)" do
-    scope['string'] = "this output should not be seen"
-    expect(eval_template("some text that is static")).to eq("some text that is static")
-  end
-
-  it "has access to a variable named 'string' (#14093)" do
-    scope['string'] = "the string value"
-    expect(eval_template("string was: <%= $string %>")).to eq("string was: the string value")
-  end
-
-  context "when using Sensitive" do
-    it "returns an unwrapped sensitive value as a String" do
-      expect(eval_and_collect_notices(<<~END)).to eq(["opensesame"])
-        notice(inline_epp("<%= Sensitive('opensesame').unwrap %>"))
-      END
-    end
-
-    it "rewraps a sensitive value" do
-      # note entire result is redacted, not just sensitive part
-      expect(eval_and_collect_notices(<<~END)).to eq(["Sensitive [value redacted]"])
-        notice(inline_epp("This is sensitive <%= Sensitive('opensesame') %>"))
-      END
-    end
-
-    it "can be double wrapped" do
-      catalog = compile_to_catalog(<<~END)
-        notify { 'title':
-          message => Sensitive(inline_epp("<%= Sensitive('opensesame') %>"))
-        }
-      END
-      expect(catalog.resource(:notify, 'title')['message']).to eq('opensesame')
-    end
-  end
-
-  def eval_template_with_args(content, args_hash)
-    epp_function.call(scope, content, args_hash)
-  end
-
-  def eval_template(content)
-    epp_function.call(scope, content)
-  end
-
-  def epp_function()
-    scope.compiler.loaders.public_environment_loader.load(:function, 'inline_epp')
-  end
-
-end

data/spec/unit/functions/join_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the join function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'joins an array with empty string delimiter if delimiter is not given' do
-    expect(compile_to_catalog("notify { join([1,2,3]): }")).to have_resource('Notify[123]')
-  end
-
-  it 'joins an array with given string delimiter' do
-    expect(compile_to_catalog("notify { join([1,2,3],'x'): }")).to have_resource('Notify[1x2x3]')
-  end
-
-  it 'results in empty string if array is empty' do
-    expect(compile_to_catalog('notify { "x${join([])}y": }')).to have_resource('Notify[xy]')
-  end
-
-  it 'flattens nested arrays' do
-    expect(compile_to_catalog("notify { join([1,2,[3,4]]): }")).to have_resource('Notify[1234]')
-  end
-
-  it 'does not flatten arrays nested in hashes' do
-    expect(compile_to_catalog("notify { join([1,2,{a => [3,4]}]): }")).to have_resource('Notify[12{"a"=>[3, 4]}]')
-  end
-
-  it 'formats nil/undef as empty string' do
-    expect(compile_to_catalog('notify { join([undef, undef], "x"): }')).to have_resource('Notify[x]')
-  end
-end

data/spec/unit/functions/keys_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the keys function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'returns the keys in the hash in the order they appear in a hash iteration' do
-    expect(compile_to_catalog(<<-'SRC'.unindent)).to have_resource('Notify[apples & oranges]')
-        $k = {'apples' => 1, 'oranges' => 2}.keys
-        notify { "${k[0]} & ${k[1]}": }
-      SRC
-  end
-
-  it 'returns an empty array for an empty hash' do
-    expect(compile_to_catalog(<<-'SRC'.unindent)).to have_resource('Notify[0]')
-        $v = {}.keys.reduce(0) |$m, $v| { $m+1 }
-        notify { "${v}": }
-      SRC
-  end
-
-  it 'includes an undef key if one is present in the hash' do
-    expect(compile_to_catalog(<<-'SRC'.unindent)).to have_resource('Notify[Undef]')
-        $types = {undef => 1}.keys.map |$v| { $v.type }
-        notify { "${types[0]}": }
-      SRC
-  end
-
-end

data/spec/unit/functions/length_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the length function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  context 'for an array it' do
-    it 'returns 0 when empty' do
-      expect(compile_to_catalog("notify { String(length([])): }")).to have_resource('Notify[0]')
-    end
-
-    it 'returns number of elements when not empty' do
-      expect(compile_to_catalog("notify { String(length([1, 2, 3])): }")).to have_resource('Notify[3]')
-    end
-  end
-
-  context 'for a hash it' do
-    it 'returns 0 empty' do
-      expect(compile_to_catalog("notify { String(length({})): }")).to have_resource('Notify[0]')
-    end
-
-    it 'returns number of elements when not empty' do
-      expect(compile_to_catalog("notify { String(length({1=>1,2=>2})): }")).to have_resource('Notify[2]')
-    end
-  end
-
-  context 'for a string it' do
-    it 'returns 0 when empty' do
-      expect(compile_to_catalog("notify { String(length('')): }")).to have_resource('Notify[0]')
-    end
-
-    it 'returns number of characters when not empty' do
-      # note the multibyte characters - åäö each taking two bytes in UTF-8
-      expect(compile_to_catalog('notify { String(length("\u00e5\u00e4\u00f6")): }')).to have_resource('Notify[3]')
-    end
-  end
-
-  context 'for a binary it' do
-    it 'returns 0 when empty' do
-      expect(compile_to_catalog("notify { String(length(Binary(''))): }")).to have_resource('Notify[0]')
-    end
-
-    it 'returns number of bytes when not empty' do
-      expect(compile_to_catalog("notify { String(length(Binary('b25l'))): }")).to have_resource('Notify[3]')
-    end
-  end
-end

data/spec/unit/functions/lest_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the lest function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'calls a lambda passing no argument' do
-    expect(compile_to_catalog("lest(undef) || { notify { testing: } }")).to have_resource('Notify[testing]')
-  end
-
-  it 'produces what lambda returns if value is undef' do
-    expect(compile_to_catalog("notify{ lest(undef) || { testing }: }")).to have_resource('Notify[testing]')
-  end
-
-  it 'does not call lambda if argument is not undef' do
-    expect(compile_to_catalog('lest(1) || { notify { "failed": } }')).to_not have_resource('Notify[failed]')
-  end
-
-  it 'produces given argument if given not undef' do
-    expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test_yay_ing]')
-    notify{ "test${lest('_yay_') || { '_oh_no_' }}ing": }
-    SOURCE
-  end
-
-  it 'errors when lambda wants too many args' do
-    expect do
-      compile_to_catalog('lest(1) |$x| { }')
-    end.to raise_error(/'lest' block expects no arguments, got 1/m)
-  end
-
-end

data/spec/unit/functions/logging_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-describe 'the log function' do
-  include PuppetSpec::Compiler
-
-  def collect_logs(code)
-    Puppet[:code] = code
-    Puppet[:environment_timeout] = 10
-    node = Puppet::Node.new('logtest')
-    compiler = Puppet::Parser::Compiler.new(node)
-    node.environment.check_for_reparse
-    logs = []
-    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-      compiler.compile
-    end
-    logs
-  end
-
-  def expect_log(code, log_level, message)
-    logs = collect_logs(code)
-
-    # There's a chance that additional messages could have been
-    # added during code compilation like debug messages from
-    # Facter. This happened on Appveyor when the Appveyor image
-    # failed to resolve the domain fact. Since these messages are
-    # not relevant to our test, and since they can (possibly) be
-    # injected at any location in our logs array, it is good enough
-    # to assert that our desired log _is_ included in the logs array
-    # instead of trying to figure out _where_ it is included.
-    expect(logs).to include(satisfy { |log| log.level == log_level && log.message == message })
-  end
-
-  before(:each) do
-    Puppet[:log_level] = 'debug'
-  end
-
-  Puppet::Util::Log.levels.each do |level|
-    context "for log level '#{level}'" do
-      it 'can be called' do
-        expect_log("#{level.to_s}('yay')", level, 'yay')
-      end
-
-      it 'joins multiple arguments using space' do
-        # Not using the evaluator would result in yay {"a"=>"b", "c"=>"d"}
-        expect_log("#{level.to_s}('a', 'b', 3)", level, 'a b 3')
-      end
-
-      it 'uses the evaluator to format output' do
-        # Not using the evaluator would result in yay {"a"=>"b", "c"=>"d"}
-        expect_log("#{level.to_s}('yay', {a => b, c => d})", level, 'yay {a => b, c => d}')
-      end
-
-      it 'returns undef value' do
-        logs = collect_logs("notice(type(#{level.to_s}('yay')))")
-        expect(logs.size).to eql(2)
-        expect(logs[1].level).to eql(:notice)
-        expect(logs[1].message).to eql('Undef')
-      end
-    end
-  end
-end