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

data/spec/unit/functions/assert_type_spec.rb

@@ -1,97 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet/loaders'
-require 'puppet_spec/compiler'
-
-describe 'the assert_type function' do
-  include PuppetSpec::Compiler
-
-  after(:all) { Puppet::Pops::Loaders.clear }
-
-  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
-  let(:func) { loaders.puppet_system_loader.load(:function, 'assert_type') }
-
-  it 'asserts compliant type by returning the value' do
-    expect(func.call({}, type(String), 'hello world')).to eql('hello world')
-  end
-
-  it 'accepts type given as a String' do
-    expect(func.call({}, 'String', 'hello world')).to eql('hello world')
-  end
-
-  it 'asserts non compliant type by raising an error' do
-    expect do
-      func.call({}, type(Integer), 'hello world')
-    end.to raise_error(Puppet::Pops::Types::TypeAssertionError, /expects an Integer value, got String/)
-  end
-
-  it 'checks that first argument is a type' do
-    expect do
-      func.call({}, 10, 10)
-    end.to raise_error(ArgumentError, "The function 'assert_type' was called with arguments it does not accept. It expects one of:
-  (Type type, Any value, Callable[Type, Type] block?)
-    rejected: parameter 'type' expects a Type value, got Integer
-  (String type_string, Any value, Callable[Type, Type] block?)
-    rejected: parameter 'type_string' expects a String value, got Integer")
-  end
-
-  it 'allows the second arg to be undef/nil)' do
-    expect do
-      func.call({}, optional(String), nil)
-    end.to_not raise_error
-  end
-
-  it 'can be called with a callable that receives a specific type' do
-    expected, actual, actual2 = func.call({}, 'Optional[String]', 1) { |expctd, actul| [expctd, actul, actul] }
-    expect(expected.to_s).to eql('Optional[String]')
-    expect(actual.to_s).to eql('Integer[1, 1]')
-    expect(actual2.to_s).to eql('Integer[1, 1]')
-  end
-
-  def optional(type_ref)
-    Puppet::Pops::Types::TypeFactory.optional(type(type_ref))
-  end
-
-  def type(type_ref)
-    Puppet::Pops::Types::TypeFactory.type_of(type_ref)
-  end
-
-  it 'can validate a resource type' do
-    expect(eval_and_collect_notices("assert_type(Type[Resource], File['/tmp/test']) notice('ok')")).to eq(['ok'])
-  end
-
-  it 'can validate a type alias' do
-    code = <<-CODE
-      type UnprivilegedPort = Integer[1024,65537]
-      assert_type(UnprivilegedPort, 5432)
-      notice('ok')
-    CODE
-    expect(eval_and_collect_notices(code)).to eq(['ok'])
-  end
-
-  it 'can validate a type alias passed as a String' do
-    code = <<-CODE
-      type UnprivilegedPort = Integer[1024,65537]
-      assert_type('UnprivilegedPort', 5432)
-      notice('ok')
-    CODE
-    expect(eval_and_collect_notices(code)).to eq(['ok'])
-  end
-
-  it 'can validate and fail using a type alias' do
-    code = <<-CODE
-      type UnprivilegedPort = Integer[1024,65537]
-      assert_type(UnprivilegedPort, 345)
-      notice('ok')
-    CODE
-    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expects an UnprivilegedPort = Integer\[1024, 65537\] value, got Integer\[345, 345\]/)
-  end
-
-  it 'will use infer_set to report detailed information about complex mismatches' do
-    code = <<-CODE
-      assert_type(Struct[{a=>Integer,b=>Boolean}], {a=>hej,x=>s})
-    CODE
-    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error,
-      /entry 'a' expects an Integer value, got String.*expects a value for key 'b'.*unrecognized key 'x'/m)
-  end
-end

data/spec/unit/functions/binary_file_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-require 'puppet_spec/files'
-
-describe 'the binary_file function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-  include PuppetSpec::Files
-
-  def with_file_content(content)
-    path = tmpfile('find-file-function')
-    file = File.new(path, 'wb')
-    file.sync = true
-    file.print content
-    yield path
-  end
-
-  it 'reads an existing absolute file' do
-    with_file_content('one') do |one|
-      # Note that Binary to String produced Base64 encoded version of 'one' which is 'b23l'
-      expect(compile_to_catalog("notify { String(binary_file('#{one}')):}")).to have_resource("Notify[b25l]")
-    end
-  end
-
-  it 'errors on non existing files' do
-    expect do
-      with_file_content('one') do |one|
-        compile_to_catalog("notify { binary_file('#{one}/nope'):}")
-      end
-    end.to raise_error(/The given file '.+\/nope' does not exist/)
-  end
-
-  it 'reads an existing file in a module' do
-    with_file_content('binary_data') do |name|
-      mod = double('module')
-      allow(mod).to receive(:file).with('myfile').and_return(name)
-      Puppet[:code] = "notify { String(binary_file('mymod/myfile')):}"
-      node = Puppet::Node.new('localhost')
-      compiler = Puppet::Parser::Compiler.new(node)
-      allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
-      # Note that the Binary to string produces Base64 encoded version of 'binary_data' which is 'YmluYXJ5X2RhdGE='
-      expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[YmluYXJ5X2RhdGE=]")
-    end
-  end
-end

data/spec/unit/functions/break_spec.rb

@@ -1,207 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the break function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  context  do
-    it 'breaks iteration as if at end of input in a map for an array' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[1, 2]]')
-          function please_break() {
-            [1,2,3].map |$x| { if $x == 3 { break() } $x }
-          }
-          notify { String(please_break()): }
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in a map for a hash' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[1, 2]]')
-          function please_break() {
-            {'a' => 1, 'b' => 2, 'c' => 3}.map |$x, $y| { if $y == 3 { break() } $y }
-          }
-          notify { String(please_break()): }
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in a reduce for an array' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[6]')
-          function please_break() {
-            [1,2,3,4].reduce |$memo, $x| { if $x == 4 { break() } $memo + $x }
-          }
-          notify { String(please_break()): }
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in a reduce for a hash' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource("Notify[['abc', 6]]")
-          function please_break() {
-            {'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4}.reduce |$memo, $x| {
-	      if $x[1] == 4 { break() }
-              $string = "${memo[0]}${x[0]}"
-              $number = $memo[1] + $x[1]
-	      [$string, $number]
-	    }
-          }
-          notify { String(please_break()): }
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in an each for an array' do
-      expect(compile_to_catalog(<<-CODE)).to_not have_resource('Notify[3]')
-          function please_break() {
-            [1,2,3].each |$x| { if $x == 3 { break() } notify { "$x": } }
-          }
-          please_break()
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in an each for a hash' do
-      expect(compile_to_catalog(<<-CODE)).to_not have_resource('Notify[3]')
-          function please_break() {
-            {'a' => 1, 'b' => 2, 'c' => 3}.each |$x, $y| { if $y == 3 { break() } notify { "$y": } }
-          }
-          please_break()
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in a reverse_each' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[2]')
-          function please_break() {
-            [1,2,3].reverse_each |$x| { if $x == 1 { break() } notify { "$x": } }
-          }
-          please_break()
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in a map for a hash' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[1, 2]]')
-          function please_break() {
-            {'a' => 1, 'b' => 2, 'c' => 3}.map |$x, $y| { if $y == 3 { break() } $y }
-          }
-          notify { String(please_break()): }
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in a reduce for an array' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[6]')
-          function please_break() {
-            [1,2,3,4].reduce |$memo, $x| { if $x == 4 { break() } $memo + $x }
-          }
-          notify { String(please_break()): }
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in a reduce for a hash' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource("Notify[['abc', 6]]")
-          function please_break() {
-            {'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4}.reduce |$memo, $x| {
-              if $x[1] == 4 { break() }
-              $string = "${memo[0]}${x[0]}"
-              $number = $memo[1] + $x[1]
-              [$string, $number]
-            }
-          }
-          notify { String(please_break()): }
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in an each for an array' do
-      expect(compile_to_catalog(<<-CODE)).to_not have_resource('Notify[3]')
-          function please_break() {
-            [1,2,3].each |$x| { if $x == 3 { break() } notify { "$x": } }
-          }
-          please_break()
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in an each for a hash' do
-      expect(compile_to_catalog(<<-CODE)).to_not have_resource('Notify[3]')
-          function please_break() {
-            {'a' => 1, 'b' => 2, 'c' => 3}.each |$x, $y| { if $y == 3 { break() } notify { "$y": } }
-          }
-          please_break()
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in a reverse_each' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[2]')
-          function please_break() {
-            [1,2,3].reverse_each |$x| { if $x == 1 { break() } notify { "$x": } }
-          }
-          please_break()
-        CODE
-    end
-
-    it 'does not provide early exit from a class' do
-      # A break would semantically mean that the class should not be included - as if the
-      # iteration over class names should stop. That is too magic and should
-      # be done differently by the user.
-      #
-      expect do
-        compile_to_catalog(<<-CODE)
-          class does_break {
-            notice 'a'
-            if 1 == 1 { break() } # avoid making next line statically unreachable
-            notice 'b'
-          }
-          include(does_break)
-        CODE
-      end.to raise_error(/break\(\) from context where this is illegal \(file: unknown, line: 3\) on node.*/)
-    end
-
-    it 'does not provide early exit from a define' do
-      # A break would semantically mean that the resource should not be created - as if the
-      # iteration over resource titles should stop. That is too magic and should
-      # be done differently by the user.
-      #
-      expect do
-        compile_to_catalog(<<-CODE)
-          define does_break {
-            notice 'a'
-            if 1 == 1 { break() } # avoid making next line statically unreachable
-            notice 'b'
-          }
-            does_break { 'no_you_cannot': }
-        CODE
-      end.to raise_error(/break\(\) from context where this is illegal \(file: unknown, line: 3\) on node.*/)
-    end
-
-    it 'can be called when nested in a function to make that function behave as a break' do
-      # This allows functions like break_when(...) to be implemented by calling break() conditionally
-      #
-      expect(eval_and_collect_notices(<<-CODE)).to eql(['[100]'])
-        function nested_break($x) {
-          if $x == 2 { break() } else { $x * 100 }
-        }
-        function example() {
-          [1,2,3].map |$x| { nested_break($x)  }
-        }
-        notice example()
-        CODE
-    end
-
-    it 'can not be called nested from top scope' do
-      expect do
-        compile_to_catalog(<<-CODE)
-          # line 1
-          # line 2
-          $result = with(1) |$x| { with($x) |$x| {break() }}
-          notice $result
-        CODE
-      end.to raise_error(/break\(\) from context where this is illegal \(file: unknown, line: 3\) on node.*/)
-    end
-
-    it 'can not be called from top scope' do
-      expect do
-        compile_to_catalog(<<-CODE)
-          # line 1
-          # line 2
-          break()
-        CODE
-      end.to raise_error(/break\(\) from context where this is illegal \(file: unknown, line: 3\) on node.*/)
-    end
-  end
-end

data/spec/unit/functions/call_spec.rb

@@ -1,131 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-require 'matchers/resource'
-
-describe 'the call method' do
-  include PuppetSpec::Compiler
-  include PuppetSpec::Files
-  include Matchers::Resource
-
-  context "should be callable as" do
-    let(:env_name) { 'testenv' }
-    let(:environments_dir) { Puppet[:environmentpath] }
-    let(:env_dir) { File.join(environments_dir, env_name) }
-    let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, 'modules')]) }
-    let(:node) { Puppet::Node.new("test", :environment => env) }
-    let(:env_dir_files) {
-      {
-        'modules' => {
-          'test' => {
-            'functions' => {
-              'call_me.pp' => 'function test::call_me() { "called" }',
-              'abc.pp'     => 'function test::abc() { "a-b-c" }',
-              'dash.pp'    => 'function test::dash() { "-" }'
-            }
-          }
-        }
-      }
-    }
-
-    let(:populated_env_dir) do
-      dir_contained_in(environments_dir, env_name => env_dir_files)
-      PuppetSpec::Files.record_tmp(env_dir)
-      env_dir
-    end
-
-    it 'call on a built-in 4x Ruby API function' do
-      expect(compile_to_catalog(<<-CODE, node)).to have_resource('Notify[a]')
-          $a = call('split', 'a-b-c', '-')
-          notify { $a[0]: }
-        CODE
-    end
-
-    it 'call on a Puppet language function with no arguments' do
-      expect(compile_to_catalog(<<-CODE, node)).to have_resource('Notify[called]')
-        notify { test::call_me(): }
-        CODE
-    end
-
-    it 'call a Ruby 4x API built-in with block' do
-      catalog = compile_to_catalog(<<-CODE, node)
-        $a = 'each'
-        $b = [1,2,3]
-        call($a, $b) |$index, $v| {
-          file { "/file_$v": ensure => present }
-        }
-      CODE
-
-      expect(catalog.resource(:file, "/file_1")['ensure']).to eq('present')
-      expect(catalog.resource(:file, "/file_2")['ensure']).to eq('present')
-      expect(catalog.resource(:file, "/file_3")['ensure']).to eq('present')
-    end
-
-    it 'call with the calling context' do
-      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['a'])
-        class a { call('notice', $title) }
-        include a
-      CODE
-    end
-
-    it 'call on a non-existent function name' do
-      expect { compile_to_catalog(<<-CODE, node) }.to raise_error(Puppet::Error, /Unknown function/)
-        $a = call('not_a_function_name')
-        notify { $a: }
-      CODE
-    end
-
-    it 'call a deferred value' do
-      expect(compile_to_catalog(<<-CODE, node)).to have_resource('Notify[a]')
-          $d = Deferred('split', ['a-b-c', '-'])
-          $a = $d.call()
-          notify { $a[0]: }
-        CODE
-    end
-
-    it 'resolves deferred value arguments in an array when calling a deferred' do
-      expect(compile_to_catalog(<<-CODE,node)).to have_resource('Notify[a]')
-          $d = Deferred('split', [Deferred('test::abc'), '-'])
-          $a = $d.call()
-          notify { $a[0]: }
-        CODE
-    end
-
-    it 'resolves deferred value arguments in a Sensitive when calling a deferred' do
-      expect(compile_to_catalog(<<-CODE, node)).to have_resource('Notify[a]')
-          function my_split(Sensitive $sensy, $on) { $sensy.unwrap |$x| { split($x, $on) } }
-          $d = Deferred('my_split', [ Sensitive(Deferred('test::abc')), '-'])
-          $a = $d.call()
-          notify { $a[0]: }
-        CODE
-    end
-
-    it 'resolves deferred value arguments in a Hash when calling a deferred' do
-      expect(compile_to_catalog(<<-CODE, node)).to have_resource('Notify[a]')
-          function my_split(Hash $hashy, $on) { split($hashy['key'], $on)  }
-          $d = Deferred('my_split', [ {'key' => Deferred('test::abc')}, '-'])
-          $a = $d.call()
-          notify { $a[0]: }
-        CODE
-    end
-
-    it 'resolves deferred value arguments in a nested structure when calling a deferred' do
-      expect(compile_to_catalog(<<-CODE,node)).to have_resource('Notify[a]')
-          function my_split(Hash $hashy, Array[Sensitive] $sensy) { split($hashy['key'][0], $sensy[0].unwrap |$x| {$x})  }
-          $d = Deferred('my_split', [ {'key' => [Deferred('test::abc')]}, [Sensitive(Deferred('test::dash'))]])
-          $a = $d.call()
-          notify { $a[0]: }
-        CODE
-    end
-
-    it 'call dig into a variable' do
-      expect(compile_to_catalog(<<-CODE, node)).to have_resource('Notify[value 3]')
-          $x = { 'a' => [1,2,3] }
-          $d = Deferred('$x', ['a', 2])
-          $a = $d.call()
-          notify { "value $a": }
-        CODE
-    end
-  end
-end

data/spec/unit/functions/camelcase_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the camelcase function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'replaces initial <char> and each _<char> with upper case version of the char' do
-    expect(compile_to_catalog("notify { 'abc_def'.camelcase: }")).to have_resource('Notify[AbcDef]')
-  end
-
-  it 'returns the value if Numeric' do
-    expect(compile_to_catalog("notify { String(42.camelcase == 42): }")).to have_resource('Notify[true]')
-  end
-
-  it 'performs camelcase of international UTF-8 characters' do
-    expect(compile_to_catalog("notify { 'åäö_äö'.camelcase: }")).to have_resource('Notify[ÅäöÄö]')
-  end
-
-  it 'returns capitalized version of each entry in an array' do
-    expect(compile_to_catalog("notify { String(['a_a', 'b_a', 'c_a'].camelcase == ['AA', 'BA', 'CA']): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns capitalized version of each entry in an Iterator' do
-    expect(compile_to_catalog("notify { String(['a_a', 'b_a', 'c_a'].reverse_each.camelcase == ['CA', 'BA', 'AA']): }")).to have_resource('Notify[true]')
-  end
-
-  it 'errors when given a a nested Array' do
-    expect { compile_to_catalog("['a', 'b', ['c']].camelcase")}.to raise_error(/'camelcase' parameter 'arg' expects a value of type Numeric, String, or Iterable/)
-  end
-
-end

data/spec/unit/functions/capitalize_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the capitalize function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'returns initial char upper case version of a string' do
-    expect(compile_to_catalog("notify { 'abc'.capitalize: }")).to have_resource('Notify[Abc]')
-  end
-
-  it 'returns the value if Numeric' do
-    expect(compile_to_catalog("notify { String(42.capitalize == 42): }")).to have_resource('Notify[true]')
-  end
-
-  it 'performs capitalize of international UTF-8 characters' do
-    expect(compile_to_catalog("notify { 'åäö'.capitalize: }")).to have_resource('Notify[Åäö]')
-  end
-
-  it 'returns capitalized version of each entry in an array' do
-    expect(compile_to_catalog("notify { String(['aa', 'ba', 'ca'].capitalize == ['Aa', 'Ba', 'Ca']): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns capitalized version of each entry in an Iterator' do
-    expect(compile_to_catalog("notify { String(['aa', 'ba', 'ca'].reverse_each.capitalize == ['Ca', 'Ba', 'Aa']): }")).to have_resource('Notify[true]')
-  end
-
-  it 'errors when given a a nested Array' do
-    expect { compile_to_catalog("['a', 'b', ['c']].capitalize")}.to raise_error(/'capitalize' parameter 'arg' expects a value of type Numeric, String, or Iterable/)
-  end
-
-end

data/spec/unit/functions/ceiling_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the ceiling function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  context 'for an integer' do
-    [ 0, 1, -1].each do |x|
-      it "called as ceiling(#{x}) results in the same value" do
-        expect(compile_to_catalog("notify { String( ceiling(#{x}) == #{x}): }")).to have_resource("Notify[true]")
-      end
-    end
-  end
-
-  context 'for a float' do
-    {
-      0.0 => 0,
-      1.1 => 2,
-      -1.1 => -1,
-    }.each_pair do |x, expected|
-      it "called as ceiling(#{x}) results in #{expected}" do
-        expect(compile_to_catalog("notify { String( ceiling(#{x}) == #{expected}): }")).to have_resource("Notify[true]")
-      end
-    end
-  end
-
-  context 'for a string' do
-    let(:logs) { [] }
-    let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
-
-    { "0" => 0,
-      "1" => 1,
-      "-1" => -1,
-      "0.0" => 0,
-      "1.1" => 2,
-      "-1.1" => -1,
-      "0777" => 777,
-      "-0777" => -777,
-      "0xFF" => 0xFF,
-    }.each_pair do |x, expected|
-      it "called as ceiling('#{x}') results in #{expected} and a deprecation warning" do
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-          expect(compile_to_catalog("notify { String( ceiling('#{x}') == #{expected}): }")).to have_resource("Notify[true]")
-        end
-        expect(warnings).to include(/auto conversion of .* is deprecated/)
-      end
-    end
-
-    ['blue', '0.2.3'].each do |x|
-      it "errors as the string '#{x}' cannot be converted to a float" do
-        expect{ compile_to_catalog("ceiling('#{x}')") }.to raise_error(/cannot convert given value to a floating point value/)
-      end
-    end
-  end
-
-  [[1,2,3], {'a' => 10}].each do |x|
-    it "errors for a value of class #{x.class}" do
-      expect{ compile_to_catalog("ceiling(#{x})") }.to raise_error(/expects a value of type Numeric or String/)
-    end
-  end
-
-end

data/spec/unit/functions/chomp_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the chomp function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'removes line endings CR LF from a string' do
-    expect(compile_to_catalog("notify { String(\"abc\r\n\".chomp == 'abc'): }")).to have_resource('Notify[true]')
-  end
-
-  it 'removes line ending CR from a string' do
-    expect(compile_to_catalog("notify { String(\"abc\r\".chomp == 'abc'): }")).to have_resource('Notify[true]')
-  end
-
-  it 'removes line ending LF from a string' do
-    expect(compile_to_catalog("notify { String(\"abc\n\".chomp == 'abc'): }")).to have_resource('Notify[true]')
-  end
-
-  it 'does not removes LF before CR line ending from a string' do
-    expect(compile_to_catalog("notify { String(\"abc\n\r\".chomp == \"abc\n\"): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns empty string for an empty string' do
-    expect(compile_to_catalog("notify { String(''.chomp == ''): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns the value if Numeric' do
-    expect(compile_to_catalog("notify { String(42.chomp == 42): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns chomped version of each entry in an array' do
-    expect(compile_to_catalog("notify { String([\"a\n\", \"b\n\", \"c\n\"].chomp == ['a', 'b', 'c']): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns chopped version of each entry in an Iterator' do
-    expect(compile_to_catalog("notify { String([\"a\n\", \"b\n\", \"c\n\"].reverse_each.chomp == ['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']].chomp")}.to raise_error(/'chomp' parameter 'arg' expects a value of type Numeric, String, or Iterable/)
-  end
-
-end