puppet 5.3.4 → 6.29.0

data/spec/unit/functions/lookup_spec.rb

@@ -1,9 +1,9 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet_spec/files'
 require 'puppet/pops'
 require 'deep_merge/core'
+require 'hiera'
 
 describe "The lookup function" do
   include PuppetSpec::Compiler
@@ -37,8 +37,6 @@ describe "The lookup function" do
     }
   end
 
-  let(:ruby_dir_files) { {} }
-
   let(:logs) { [] }
   let(:scope_additions ) { {} }
   let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
@@ -57,11 +55,6 @@ describe "The lookup function" do
     code_dir
   end
 
-  let(:populated_ruby_dir) do
-    dir_contained_in(ruby_dir, ruby_dir_files)
-    ruby_dir
-  end
-
   let(:env_dir) do
     d = File.join(populated_code_dir, 'environments')
     Dir.mkdir(d)
@@ -121,10 +114,11 @@ describe "The lookup function" do
     nil
   end
 
-  def lookup(key, options = {}, explain = false)
+  def lookup(key, options = {}, explain = false, type = nil)
+    value_type = type ? ", #{type}" : ''
     nc_opts = options.empty? ? '' : ", #{Puppet::Pops::Types::TypeFormatter.string(options)}"
     keys = key.is_a?(Array) ? key : [key]
-    collect_notices(keys.map { |k| "notice(String(lookup('#{k}'#{nc_opts}), '%p'))" }.join("\n"), explain)
+    collect_notices(keys.map { |k| "notice(String(lookup('#{k}'#{value_type}#{nc_opts}), '%p'))" }.join("\n"), explain)
     if explain
       explanation
     else
@@ -811,9 +805,24 @@ describe "The lookup function" do
           YAML
         end
 
-        it 'fails lookup and reports a type mismatch' do
+        it 'fails lookup and reports parsing failed' do
           expect { lookup('a') }.to raise_error do |e|
-            expect(e.message).to match(/key 'a'.*data_hash function 'yaml_data'.*using location.*wrong type, expects Puppet::LookupValue, got Runtime/)
+            expect(e.message).to match(/Unable to parse .*: Tried to load unspecified class: Puppet::Graph::Key/)
+          end
+        end
+      end
+
+      context 'that contains a legal yaml hash with unexpected types' do
+        let(:common_yaml) do
+          <<-YAML.unindent
+          ---
+          a: 123
+          YAML
+        end
+
+        it 'fails lookup and reports a type mismatch' do
+          expect { lookup('a', {}, false, String) }.to raise_error do |e|
+            expect(e.message).to match(/Found value has wrong type, expects a String value, got Integer \(line: 1, column: \d+\)/)
           end
         end
       end
@@ -861,6 +870,46 @@ describe "The lookup function" do
       end
     end
 
+    context 'with lookup_options' do
+      let(:environment_files) do
+        {
+          env_name => {
+            'hiera.yaml' => <<-YAML.unindent,
+              ---
+              version: 5
+              YAML
+            'data' => {
+              'common.yaml' => common_yaml
+            }
+          }
+        }
+      end
+
+      context 'that are empty' do
+        let(:common_yaml) { <<-YAML.unindent }
+          lookup_options:
+          a: b
+          YAML
+
+        it 'ignores empty options' do
+          expect(lookup('a')).to eq("b")
+        end
+      end
+
+      context 'that contains a legal yaml hash with unexpected types' do
+        let(:common_yaml) { <<-YAML.unindent }
+          lookup_options:
+            :invalid_symbol
+          YAML
+
+        it 'fails lookup and reports a type mismatch' do
+          expect {
+            lookup('a')
+          }.to raise_error(Puppet::DataBinding::LookupError, /has wrong type, expects Puppet::LookupValue, got Runtime\[ruby, 'Symbol'\]/)
+        end
+      end
+    end
+
     context 'with lookup_options configured using patterns' do
       let(:mod_common) {
         <<-YAML.unindent
@@ -1010,6 +1059,30 @@ describe "The lookup function" do
         })
       end
 
+      context 'and lookup_options is empty' do
+        let(:mod_common) { <<-YAML.unindent }
+          lookup_options:
+          mod::a: b
+          YAML
+
+        it 'ignores empty options' do
+          expect(lookup('mod::a')).to eq("b")
+        end
+      end
+
+      context 'and lookup_options contains a legal hash with unexpected types' do
+        let(:mod_common) { <<-YAML.unindent }
+          lookup_options:
+            :invalid_symbol
+          YAML
+
+        it 'fails lookup and reports a type mismatch' do
+          expect {
+            lookup('mod::a')
+          }.to raise_error(Puppet::DataBinding::LookupError, /has wrong type, expects Puppet::LookupValue, got Runtime\[ruby, 'Symbol'\]/)
+        end
+      end
+
       context 'and patterns in module are not limited to module keys' do
         let(:mod_common) {
           <<-YAML.unindent
@@ -1482,7 +1555,7 @@ describe "The lookup function" do
         expect(lookup('x')).to eql('value x (from environment)')
       end
 
-      context 'obtained using /dev/null', :unless => Puppet.features.microsoft_windows? do
+      context 'obtained using /dev/null', :unless => Puppet::Util::Platform.windows? do
         let(:code_dir_files) { {} }
 
         it 'uses a Hiera version 3 defaults' do
@@ -1555,42 +1628,16 @@ describe "The lookup function" do
         }
       end
 
-      let(:ruby_dir_files) do
-        {
-          'hiera' => {
-            'backend' => {
-              'custom_backend.rb' => <<-RUBY.unindent,
-            class Hiera::Backend::Custom_backend
-              def lookup(key, scope, order_override, resolution_type, context)
-                case key
-                when 'hash_c'
-                  { 'hash_ca' => { 'cad' => 'value hash_c.hash_ca.cad (from global custom)' }}
-                when 'hash'
-                  { 'array' => [ 'x5,x6' ] }
-                when 'array'
-                  [ 'x5,x6' ]
-                when 'datasources'
-                  Hiera::Backend.datasources(scope, order_override) { |source| source }
-                when 'dotted.key'
-                  'custom backend received request for dotted.key value'
-                else
-                  throw :no_such_key
-                end
-              end
-            end
-            RUBY
-            'other_backend.rb' => <<-RUBY.unindent,
-            class Hiera::Backend::Other_backend
-              def lookup(key, scope, order_override, resolution_type, context)
-                value = Hiera::Config[:other][key.to_sym]
-                throw :no_such_key if value.nil?
-                value
-              end
-            end
-            RUBY
-            }
-          }
-        }
+      before(:all) do
+        $LOAD_PATH.unshift(my_fixture_dir)
+      end
+
+      after(:all) do
+        if Kernel.const_defined?(:Hiera) && Hiera.const_defined?(:Backend)
+          Hiera::Backend.send(:remove_const, :Custom_backend) if Hiera::Backend.const_defined?(:Custom_backend)
+          Hiera::Backend.send(:remove_const, :Other_backend) if Hiera::Backend.const_defined?(:Other_backend)
+        end
+        $LOAD_PATH.shift
       end
 
       before(:each) do
@@ -1600,19 +1647,8 @@ describe "The lookup function" do
       end
 
       around(:each) do |example|
-        # Faking the load path to enable 'require' to load from 'ruby_stuff'. It removes the need for a static fixture
-        # for the custom backend
-        $LOAD_PATH.unshift(populated_ruby_dir)
-        begin
-          Puppet.override(:environments => environments, :current_environment => env) do
-            example.run
-          end
-        ensure
-          if Kernel.const_defined?(:Hiera) && Hiera.const_defined?(:Backend)
-            Hiera::Backend.send(:remove_const, :Custom_backend) if Hiera::Backend.const_defined?(:Custom_backend)
-            Hiera::Backend.send(:remove_const, :Other_backend) if Hiera::Backend.const_defined?(:Other_backend)
-          end
-          $LOAD_PATH.shift
+        Puppet.override(:environments => environments, :current_environment => env) do
+          example.run
         end
       end
 
@@ -1835,6 +1871,7 @@ describe "The lookup function" do
                 a_ref: "A reference to %{hiera('a')}"
                 b_ref: "A reference to %{hiera('b')}"
                 c_ref: "%{alias('c')}"
+                :symbol: "A symbol"
                 YAML
             }
           end
@@ -2072,7 +2109,7 @@ describe "The lookup function" do
         end
 
         it 'provides a sensible error message when the hocon library is not loaded' do
-          Puppet.features.stubs(:hocon?).returns(false)
+          allow(Puppet.features).to receive(:hocon?).and_return(false)
 
           expect { lookup('a') }.to raise_error do |e|
             expect(e.message).to match(/Lookup using Hocon data_hash function is not supported without hocon library/)
@@ -2806,9 +2843,29 @@ describe "The lookup function" do
           mod_a::f:
             a:
               a: value mod_a::f.a.a (from module)
+          mod_a::to_array1: 'hello'
+          mod_a::to_array2: 'hello'
+          mod_a::to_int: 'bananas'
+          mod_a::to_bad_type: 'pyjamas'
+          mod_a::undef_value: null
           lookup_options:
             mod_a::e:
               merge: deep
+            mod_a::to_array1:
+              merge: deep
+              convert_to: "Array"
+            mod_a::to_array2:
+              convert_to:
+                - "Array"
+                - true
+            mod_a::to_int:
+              convert_to: "Integer"
+            mod_a::to_bad_type:
+              convert_to: "ComicSans"
+            mod_a::undef_value:
+              convert_to:
+                - "Array"
+                - true
           YAML
 
 
@@ -2896,6 +2953,38 @@ describe "The lookup function" do
           expect(lookup('mod_a::d')).to eql('a' => 'value mod_a::d.a (from module)')
         end
 
+        context "and conversion via convert_to" do
+          it 'converts with a single data type value' do
+            expect(lookup('mod_a::to_array1')).to eql(['h', 'e', 'l', 'l', 'o'])
+          end
+
+          it 'converts with an array of arguments to the convert_to call' do
+            expect(lookup('mod_a::to_array2')).to eql(['hello'])
+          end
+
+          it 'converts an undef/nil value that has convert_to option' do
+            expect(lookup('mod_a::undef_value')).to eql([nil])
+          end
+
+          it 'errors if a convert_to lookup_option cannot be performed because value does not match type' do
+            expect{lookup('mod_a::to_int')}.to raise_error(/The convert_to lookup_option for key 'mod_a::to_int' raised error.*The string 'bananas' cannot be converted to Integer/)
+          end
+
+          it 'errors if a convert_to lookup_option cannot be performed because type does not exist' do
+            expect{lookup('mod_a::to_bad_type')}.to raise_error(/The convert_to lookup_option for key 'mod_a::to_bad_type' raised error.*Creation of new instance of type 'TypeReference\['ComicSans'\]' is not supported/)
+          end
+
+          it 'adds explanation that conversion took place with a type' do
+            explanation = explain('mod_a::to_array1')
+            expect(explanation).to include('Applying convert_to lookup_option with arguments [Array]')
+          end
+
+          it 'adds explanation that conversion took place with a type and arguments' do
+            explanation = explain('mod_a::to_array2')
+            expect(explanation).to include('Applying convert_to lookup_option with arguments [Array, true]')
+          end
+        end
+
         it 'the default hierarchy lookup is included in the explain output' do
           explanation = explain('mod_a::c')
           expect(explanation).to match(/Searching default_hierarchy of module "mod_a".+Original path: "defaults.yaml"/m)
@@ -3057,6 +3146,19 @@ describe "The lookup function" do
 
       let(:env_data) { data_files }
 
+      context 'with unencryptable eyaml' do
+        let(:data_files) do
+          {
+            'common.eyaml' => <<-YAML.unindent
+              key_with_invalid_eyaml: ENC[PKCS7,INVALID]
+              YAML
+          }
+        end
+
+        it 'fails and reports error with ENC value, key being looked up and filename' do
+          expect { lookup('key_with_invalid_eyaml') }.to raise_error(Puppet::DataBinding::LookupError, /hiera-eyaml backend error decrypting ENC\[PKCS7,INVALID\] when looking up key_with_invalid_eyaml in .*common\.eyaml\. Error was/)
+        end
+      end
       context 'and a module using eyaml with different options' do
 
         let(:private_module_key) do

data/spec/unit/functions/lstrip_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the lstrip function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'removes leading whitepsace' do
+    expect(compile_to_catalog("notify { String(\"\t\n abc \".lstrip == 'abc '): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns the value if Numeric' do
+    expect(compile_to_catalog("notify { String(42.lstrip == 42): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns lstripped version of each entry in an array' do
+    expect(compile_to_catalog("notify { String([' a ', ' b ', ' c '].lstrip == ['a ', 'b ', 'c ']): }")).to have_resource('Notify[true]')
+  end
+
+  it 'returns lstripped version of each entry in an Iterator' do
+    expect(compile_to_catalog("notify { String([' a', ' b', ' c'].reverse_each.lstrip == ['c', 'b', 'a']): }")).to have_resource('Notify[true]')
+  end
+
+  it 'errors when given a a nested Array' do
+    expect { compile_to_catalog("['a', 'b', ['c']].lstrip")}.to raise_error(/'lstrip' parameter 'arg' expects a value of type Numeric, String, or Iterable/)
+  end
+
+end

data/spec/unit/functions/match_spec.rb

@@ -4,14 +4,13 @@ require 'puppet/loaders'
 
 describe 'the match function' do
 
-  before(:all) do
+  before(:each) do
     loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
     Puppet.push_context({:loaders => loaders}, "test-examples")
   end
 
-  after(:all) do
-    Puppet::Pops::Loaders.clear
-    Puppet::pop_context()
+  after(:each) do
+    Puppet.pop_context()
   end
 
   let(:func) do
@@ -41,6 +40,15 @@ describe 'the match function' do
     it "matches string and type #{pattern} with captures" do
       expect(func.call({}, 'abc123', type(pattern))).to eql(['abc123', 'abc', '123'])
     end
+
+    it "matches string with an alias type for #{pattern} with captures" do
+      expect(func.call({}, 'abc123', alias_type("MyAlias", type(pattern)))).to eql(['abc123', 'abc', '123'])
+    end
+
+    it "matches string with a  matching variant type for #{pattern} with captures" do
+      expect(func.call({}, 'abc123', variant_type(type(pattern)))).to eql(['abc123', 'abc', '123'])
+    end
+
   end
 
   it 'matches an array of strings and yields a map of the result' do
@@ -51,6 +59,15 @@ describe 'the match function' do
     expect{func.call({}, 'abc123', type('Regexp'))}.to raise_error(ArgumentError, /Given Regexp Type has no regular expression/)
   end
 
+  def variant_type(*t)
+    Puppet::Pops::Types::PVariantType.new(t)
+  end
+
+  def alias_type(name, t)
+    # Create an alias using a nil AST (which is never used because it is given a type as resolution)
+    Puppet::Pops::Types::PTypeAliasType.new(name, nil, t)
+  end
+
   def type(s)
     Puppet::Pops::Types::TypeParser.singleton.parse(s)
   end

data/spec/unit/functions/max_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the max function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  let(:logs) { [] }
+  let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
+  it 'errors if not give at least one argument' do
+    expect{ compile_to_catalog("max()") }.to raise_error(/Wrong number of arguments need at least one/)
+  end
+
+  context 'compares numbers' do
+    { [0, 1]    => 1,
+      [-1, 0]   => 0,
+      [-1.0, 0] => 0,
+    }.each_pair do |values, expected|
+      it "called as max(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        expect(compile_to_catalog("notify { String( max(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+      end
+    end
+  end
+
+  context 'compares strings that are not numbers without deprecation warning' do
+    it "string as number is deprecated" do
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        expect(compile_to_catalog("notify { String( max('a', 'b') == 'b'): }")).to have_resource("Notify[true]")
+      end
+      expect(warnings).to_not include(/auto conversion of .* is deprecated/)
+    end
+  end
+
+  context 'compares strings as numbers if possible and issues deprecation warning' do
+    {
+      [20, "'100'"]     => "'100'",
+      ["'20'", "'100'"] => "'100'",
+      ["'20'", 100]     => "100",
+      [20, "'100x'"]    => "20",
+      ["20", "'100x'"]  => "20",
+      ["'20x'", 100]    => "'20x'",
+    }.each_pair do |values, expected|
+      it "called as max(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( max(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+
+    {
+      [20, "'1e2'"] => "'1e2'",
+      [20, "'1E2'"] => "'1E2'",
+      [20, "'10_0'"] => "'10_0'",
+      [20, "'100.0'"] => "'100.0'",
+    }.each_pair do |values, expected|
+      it "called as max(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( max(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+
+  end
+
+  context 'compares all except numeric and string by conversion to string and issues deprecation warning' do
+    {
+      [[20], "'a'"]                  => "'a'",            # after since '[' is before 'a'
+      ["{'a' => 10}", "'a'"]         => "{'a' => 10}",    # after since '{' is after 'a'
+      [false, 'fal']                 => "false",          # the boolean since text 'false' is longer
+      ['/b/', "'(?-mix:c)'"]         => "'(?-mix:c)'",    # because regexp to_s is a (?-mix:b) string
+      ["Timestamp(1)", "'1980 a.d'"] => "'1980 a.d'",     # because timestamp to_s is a date-time string here starting with 1970
+      ["Semver('2.0.0')", "Semver('10.0.0')"] => "Semver('2.0.0')", # "10.0.0" is lexicographically before "2.0.0"
+    }.each_pair do |values, expected|
+      it "called as max(#{values[0]}, #{values[1]}) results in the value #{expected} and issues deprecation warning" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( max(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+  end
+
+  it "accepts a lambda that takes over the comparison (here avoiding the string as number conversion)" do
+    src = <<-SRC
+      $val = max("2", "10") |$a, $b| { compare($a, $b) }
+      notify { String( $val == "2"): }
+    SRC
+    expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+  end
+
+  context 'compares entries in a single array argument as if they were splatted as individual args' do
+    {
+      [1,2,3] => 3,
+      ["1", "2","3"] => "'3'",
+      [1, "2", 3] => 3,
+    }.each_pair do |value, expected|
+      it "called as max(#{value}) results in the value #{expected}" do
+        src = "notify { String( max(#{value}) == #{expected}): }"
+        expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+      end
+    end
+
+    {
+      [1,2,3] => 3,
+      ["10","2","3"] => "'3'",
+      [1,"x",3] => "'x'",
+    }.each_pair do |value, expected|
+      it "called as max(#{value}) with a lambda using compare() results in the value #{expected}" do
+        src = <<-"SRC"
+        function s_after_n($a,$b) {
+          case [$a, $b] {
+            [String, Numeric]: { 1 }
+            [Numeric, String]: { -1 }
+            default: { compare($a, $b) }
+          }
+        }
+        notify { String( max(#{value}) |$a,$b| {s_after_n($a,$b) } == #{expected}): }
+        SRC
+        expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+      end
+    end
+
+  end
+end

data/spec/unit/functions/min_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the min function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  let(:logs) { [] }
+  let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
+  it 'errors if not give at least one argument' do
+    expect{ compile_to_catalog("min()") }.to raise_error(/Wrong number of arguments need at least one/)
+  end
+
+  context 'compares numbers' do
+    { [0, 1]    => 0,
+      [-1, 0]   => -1,
+      [-1.0, 0] => -1.0,
+    }.each_pair do |values, expected|
+      it "called as min(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        expect(compile_to_catalog("notify { String( min(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+      end
+    end
+  end
+
+  context 'compares strings that are not numbers without deprecation warning' do
+    it "string as number is deprecated" do
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        expect(compile_to_catalog("notify { String( min('a', 'b') == 'a'): }")).to have_resource("Notify[true]")
+      end
+      expect(warnings).to_not include(/auto conversion of .* is deprecated/)
+    end
+  end
+
+  context 'compares strings as numbers if possible and outputs deprecation warning' do
+    {
+      [20, "'100'"] => 20,
+      ["'20'", "'100'"] => "'20'",
+      ["'20'", 100] => "'20'",
+      [20, "'100x'"] => "'100x'",
+      ["20", "'100x'"] => "'100x'",
+      ["'20x'", 100] => 100,
+    }.each_pair do |values, expected|
+      it "called as min(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( min(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+
+    {
+      [20, "'1e2'"] => 20,
+      [20, "'1E2'"] => 20,
+      [20, "'10_0'"] => 20,
+      [20, "'100.0'"] => 20,
+    }.each_pair do |values, expected|
+      it "called as min(#{values[0]}, #{values[1]}) results in the value #{expected}" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( min(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+
+  end
+
+  context 'compares all except numeric and string by conversion to string (and issues deprecation warning)' do
+    {
+      [[20], "'a'"]                  => [20],             # before since '[' is before 'a'
+      ["{'a' => 10}", "'|a'"]         => "{'a' => 10}",   # before since '{' is before '|'
+      [false, 'fal']                 => "'fal'",          # 'fal' before since shorter than 'false'
+      ['/b/', "'(?-mix:a)'"]         => "'(?-mix:a)'",    # because regexp to_s is a (?-mix:b) string
+      ["Timestamp(1)", "'1556 a.d'"] => "'1556 a.d'",     # because timestamp to_s is a date-time string here starting with 1970
+      ["Semver('2.0.0')", "Semver('10.0.0')"] => "Semver('10.0.0')", # "10.0.0" is lexicographically before "2.0.0"
+    }.each_pair do |values, expected|
+      it "called as min(#{values[0]}, #{values[1]}) results in the value #{expected} and issues deprecation warning" do
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          expect(compile_to_catalog("notify { String( min(#{values[0]}, #{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
+        end
+        expect(warnings).to include(/auto conversion of .* is deprecated/)
+      end
+    end
+  end
+
+  it "accepts a lambda that takes over the comparison (here avoiding the string as number conversion)" do
+    src = <<-SRC
+      $val = min("2", "10") |$a, $b| { compare($a, $b) }
+      notify { String( $val == "10"): }
+    SRC
+    expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+  end
+
+  context 'compares entries in a single array argument as if they were splatted as individual args' do
+    {
+      [1,2,3] => 1,
+      ["1", "2","3"] => "'1'",
+      [1,"2",3] => 1,
+    }.each_pair do |value, expected|
+      it "called as max(#{value}) results in the value #{expected}" do
+        src = "notify { String( min(#{value}) == #{expected}): }"
+        expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+      end
+    end
+
+    {
+      [1,2,3] => 1,
+      ["10","2","3"] => "'10'",
+      [1,"x",3] => "'x'",
+    }.each_pair do |value, expected|
+      it "called as max(#{value}) with a lambda using compare() results in the value #{expected}" do
+        src = <<-"SRC"
+        function n_after_s($a,$b) {
+          case [$a, $b] {
+            [String, Numeric]: { -1 }
+            [Numeric, String]: { 1 }
+            default: { compare($a, $b) }
+          }
+        }
+        notify { String( min(#{value}) |$a,$b| {n_after_s($a,$b) } == #{expected}): }
+        SRC
+        expect(compile_to_catalog(src)).to have_resource("Notify[true]")
+      end
+    end
+
+  end
+end