puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/spec/unit/functions/call_spec.rb

@@ -0,0 +1,77 @@
+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" }'
+            }
+          }
+        }
+      }
+    }
+
+    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)).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)
+        $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)).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) }.to raise_error(Puppet::Error, /Unknown function/)
+        $a = call('not_a_function_name')
+        notify { $a: }
+      CODE
+    end
+  end
+end

data/spec/unit/functions/contain_spec.rb

@@ -172,7 +172,7 @@ describe 'The "contain" function' do
 
       expect { apply_compiled_manifest(manifest) }.to raise_error(
         Puppet::Error,
-        /Found 1 dependency cycle/
+        /One or more resource dependency cycles detected in graph/
       )
     end
   end

data/spec/unit/functions/defined_spec.rb

@@ -268,11 +268,11 @@ describe "the 'defined' function" do
   end
 
   it 'raises error if referencing undef' do
-    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String, Type\[CatalogEntry\], or Type\[Type\], got Undef/)
+    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String or Type, got Undef/)
   end
 
   it 'raises error if referencing a number' do
-    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String, Type\[CatalogEntry\], or Type\[Type\], got Integer/)
+    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String or Type, got Integer/)
   end
 
   it 'is false if referencing empty string' do

data/spec/unit/functions/epp_spec.rb

@@ -17,16 +17,6 @@ describe "the epp function" do
       expect(eval_template("<%= $kryptonite == undef %>")).to eq("true")
     end
 
-    it "gets error accessing a variable that is malformed" do
-      expect { eval_template("<%= $kryptonite::bbbbbbbbbbbb::cccccccc::ddd::USER %>")}.to raise_error(
-        /Illegal variable name, The given name 'kryptonite::bbbbbbbbbbbb::cccccccc::ddd::USER' does not conform to the naming rule/)
-    end
-
-    it "gets error accessing a variable that is malformed as reported in PUP-7848" do
-      expect { eval_template("USER='<%= $hg_oais::archivematica::requirements::automation_tools::USER %>'")}.to raise_error(
-        /Illegal variable name, The given name 'hg_oais::archivematica::requirements::automation_tools::USER' does not conform to the naming rule/)
-    end
-
     it "get nil accessing a variable that is undef" do
       scope['undef_var'] = nil
       expect(eval_template("<%= $undef_var == undef %>")).to eq("true")

data/spec/unit/functions/hiera_spec.rb

@@ -293,11 +293,6 @@ describe 'when calling' do
         expect(func('mod::c')).to eql('mod::c (from module)')
       end
     end
-
-    it 'should not be disabled by data_binding_terminus setting' do
-      Puppet[:data_binding_terminus] = 'none'
-      expect(func('a')).to eql('first a')
-    end
   end
 
   context 'hiera_array' do

data/spec/unit/functions/lookup_fixture_spec.rb

@@ -64,7 +64,7 @@ describe 'The lookup function' do
     # Initialize loaders based on the environmentpath. It does not work to
     # just set the setting environmentpath for some reason - this achieves the same:
     # - first a loader is created, loading directory environments from the fixture (there is
-    # one environment, 'sample', which will be loaded since the node references this
+    # one environment, 'production', which will be loaded since the node references this
     # environment by name).
     # - secondly, the created env loader is set as 'environments' in the puppet context.
     #
@@ -90,11 +90,6 @@ describe 'The lookup function' do
       expect(resources).to include('module_b')
     end
 
-    it "can lookup value provided by the module that has 'sample' data_provider entry in metadata.json" do
-      resources = compile_and_get_notifications("$args = ['metawcp::b']\ninclude metawcp\nnotify { $metawcp::result: }\n")
-      expect(resources).to include('module_b')
-    end
-
     it 'can lookup value provided in global scope' do
       Puppet.settings[:hiera_config] = File.join(my_fixture_dir, 'hiera.yaml')
       resources = assemble_and_compile('${r}', "'abc::a'")

data/spec/unit/functions/lookup_spec.rb

@@ -951,8 +951,6 @@ describe "The lookup function" do
                 bab: bab (from environment)
               bc:
                 bca: bca (from environment)
-            sa:
-              sa1: ['e', 'd', '--f']
             YAML
           'second.yaml' => <<-YAML.unindent,
             a:
@@ -966,8 +964,6 @@ describe "The lookup function" do
             c:
               ca:
                 cab: c.ca.cab
-            sa:
-              sa1: ['b', 'a', 'f', 'c']
             YAML
         }
       end
@@ -1048,28 +1044,6 @@ describe "The lookup function" do
           expect(lookup('a')).to eql({'aa' => { 'aaa' => 'a.aa.aaa', 'aab' => 'a.aa.aab' }})
         end
       end
-
-      context 'and lookup options use a hash' do
-
-        let(:env_lookup_options) { <<-YAML.unindent }
-          lookup_options:
-            'sa':
-              merge:
-                strategy: deep
-                knockout_prefix: --
-                sort_merged_arrays: true
-        YAML
-
-        it 'applies knockout_prefix and sort_merged_arrays' do
-          expect(lookup('sa')).to eql({ 'sa1' => %w(a b c d e) })
-        end
-
-        it 'overrides knockout_prefix and sort_merged_arrays with explicitly given values' do
-          expect(
-            lookup('sa', 'merge' => { 'strategy' => 'deep', 'knockout_prefix' => '##', 'sort_merged_arrays' => false })).to(
-              eql({ 'sa1' => %w(b a f c e d --f) }))
-        end
-      end
     end
 
     context 'and an environment Hiera v5 configuration using globs' do
@@ -1102,81 +1076,14 @@ describe "The lookup function" do
               glob_c: value glob_a
               YAML
             'b.yaml' => <<-YAML.unindent
-              glob_d:
-                a: value glob_d.a
-                b: value glob_d.b
+              glob_b:
+                c: value glob_b.c
+                d: value glob_b.d
             YAML
 
           }
         }
       end
-
-      it 'finds environment data using globs' do
-        expect(lookup('glob_a')).to eql('value glob_a')
-        expect(warnings).to be_empty
-      end
-
-      it 'finds environment data using interpolated globs' do
-        expect(lookup('glob_d.a')).to eql('value glob_d.a')
-        expect(warnings).to be_empty
-      end
-    end
-
-    context 'and an environment Hiera v5 configuration using uris' do
-      let(:env_hiera_yaml) do
-        <<-YAML.unindent
-        ---
-        version: 5
-        hierarchy:
-          - name: Uris
-            uris:
-              - "http://test.example.com"
-              - "/some/arbitrary/path"
-              - "urn:with:opaque:path"
-              - "dothis%20-f%20bar"
-            data_hash: mod::uri_test_func
-        YAML
-      end
-
-      let(:env_modules) do
-        {
-          'mod' => { 'lib' => { 'puppet' => { 'functions' => { 'mod' => { 'uri_test_func.rb' => <<-RUBY } } } } }
-            Puppet::Functions.create_function(:'mod::uri_test_func') do
-              dispatch :uri_test_func do
-                param 'Hash', :options
-                param 'Puppet::LookupContext', :context
-              end
-
-              def uri_test_func(options, context)
-                { 'uri' => [ options['uri'] ] }
-              end
-            end
-            RUBY
-        }
-      end
-
-      it 'The uris are propagated in the options hash' do
-        expect(lookup('uri', 'merge' => 'unique')).to eql(
-          %w(http://test.example.com /some/arbitrary/path urn:with:opaque:path dothis%20-f%20bar))
-        expect(warnings).to be_empty
-      end
-
-      context 'and a uri uses bad syntax' do
-        let(:env_hiera_yaml) do
-          <<-YAML.unindent
-        ---
-        version: 5
-        hierarchy:
-          - name: Uris
-            uri: "dothis -f bar"
-            data_hash: mod::uri_test_func
-          YAML
-        end
-
-        it 'an attempt to lookup raises InvalidURIError' do
-          expect{ lookup('uri', 'merge' => 'unique') }.to raise_error(/bad URI/)
-        end
-      end
     end
 
     context 'and an environment Hiera v5 configuration using mapped_paths' do
@@ -2625,7 +2532,7 @@ describe "The lookup function" do
 
           it 'fails and reports error' do
             expect{lookup('mod_a::a')}.to raise_error(
-              "Return type of 'lookup_key' function named 'mod_a::pp_lookup_key' is incorrect, expects a value of type Undef, Scalar, Sensitive, Type, Hash, or Array, got Runtime")
+              "Return type of 'lookup_key' function named 'mod_a::pp_lookup_key' is incorrect, expects a RichData value, got Runtime")
           end
         end
       end

data/spec/unit/functions/new_spec.rb

@@ -532,7 +532,7 @@ describe 'the new function' do
   context 'when invoked on Array' do
     { []            => 'Notify[Array[Unit], []]',
       [true]        => 'Notify[Array[Boolean], [true]]',
-      {'a'=>true, 'b' => false}   => 'Notify[Array[Array[Scalar]], [[a, true], [b, false]]]',
+      {'a'=>true, 'b' => false}   => 'Notify[Array[Array[ScalarData]], [[a, true], [b, false]]]',
       'abc'         => 'Notify[Array[String[1, 1]], [a, b, c]]',
       3             => 'Notify[Array[Integer], [0, 1, 2]]',
     }.each do |input, result|

data/spec/unit/functions/unique_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the unique function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context 'produces the unique set of chars from a String such that' do
+    it 'same case is considered unique' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, "abc")
+          notify{ 'test': message => 'abcbbcc'.unique }
+        SOURCE
+    end
+
+    it 'different case is not considered unique' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, "abcABC")
+          notify{ 'test': message => 'abcAbbBccC'.unique }
+        SOURCE
+    end
+
+    it 'case independent matching can be performed with a lambda' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, "abc")
+          notify{ 'test': message => 'abcAbbBccC'.unique |$x| { String($x, '%d') } }
+        SOURCE
+    end
+
+    it 'the first found value in the unique set is used' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, "AbC")
+          notify{ 'test': message => 'AbCAbbBccC'.unique |$x| { String($x, '%d') } }
+        SOURCE
+    end
+  end
+
+  context 'produces the unique set of values from an Array such that' do
+    it 'ruby equality is used to compute uniqueness by default' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, ['a', 'b', 'c', 'B', 'C'])
+          notify{ 'test': message => [a, b, c, a, 'B', 'C'].unique }
+        SOURCE
+    end
+
+    it 'accepts a lambda to perform the value to use for uniqueness' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, ['a', 'b', 'c'])
+          notify{ 'test': message => [a, b, c, a, 'B', 'C'].unique |$x| { String($x, '%d') }}
+        SOURCE
+    end
+
+    it 'the first found value in the unique set is used' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, ['A', 'b', 'C'])
+          notify{ 'test': message => ['A', b, 'C', a, 'B', 'c'].unique |$x| { String($x, '%d') }}
+        SOURCE
+    end
+  end
+
+  context 'produces the unique set of values from an Hash such that' do
+    it 'resulting keys and values in hash are arrays' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, {['a'] => [10], ['b']=>[20]})
+          notify{ 'test': message => {a => 10, b => 20}.unique }
+        SOURCE
+    end
+
+    it 'resulting keys contain all keys with same value' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, {['a', 'b'] => [10], ['c']=>[20]})
+          notify{ 'test': message => {a => 10, b => 10, c => 20}.unique }
+        SOURCE
+    end
+
+    it 'resulting values contain Ruby == unique set of values' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, {['a'] => [10], ['b', 'c']=>[11, 20]})
+          notify{ 'test': message => {a => 10, b => 11, c => 20}.unique |$x| { if $x > 10 {bigly} else { $x }}}
+        SOURCE
+    end
+  end
+
+  context 'produces the unique set of values from an Iterable' do
+    it 'such as reverse_each - in reverse order' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, ['B','b','a'])
+          notify{ 'test': message => ['a', 'b', 'B'].reverse_each.unique }
+        SOURCE
+    end
+
+    it 'such as Integer[1,5]' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, [1,2,3,4,5])
+          notify{ 'test': message => Integer[1,5].unique }
+        SOURCE
+    end
+
+    it 'such as the Integer 3' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, [0,1,2])
+          notify{ 'test': message => 3.unique }
+        SOURCE
+    end
+
+    it 'allows lambda to be used with Iterable' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, ['B','a'])
+          notify{ 'test': message => ['a', 'b', 'B'].reverse_each.unique |$x| { String($x, '%d') }}
+        SOURCE
+    end
+  end
+
+  it 'errors when given unsupported data type as input' do
+    expect do
+      compile_to_catalog(<<-SOURCE)
+        undef.unique
+      SOURCE
+    end.to raise_error(/expects an Iterable value, got Undef/)
+  end
+
+
+end

data/spec/unit/functions4_spec.rb

@@ -200,7 +200,7 @@ describe 'the 4x function api' do
     it 'a function can use inexact argument mapping' do
       f = create_function_with_inexact_dispatch
       func = f.new(:closure_scope, :loader)
-      expect(func.call({}, 3,4,5)).to eql([Fixnum, Fixnum, Fixnum])
+      expect(func.call({}, 3.0,4.0,5.0)).to eql([Float, Float, Float])
       expect(func.call({}, 'Apple', 'Banana')).to eql([String, String])
     end
 
@@ -253,35 +253,6 @@ describe 'the 4x function api' do
       end
     end
 
-    context 'can use injection' do
-      before :all do
-        injector = Puppet::Pops::Binder::Injector.create('test') do
-          bind.name('a_string').to('evoe')
-          bind.name('an_int').to(42)
-        end
-        Puppet.push_context({:injector => injector}, "injector for testing function API")
-      end
-
-      after :all do
-        Puppet.pop_context()
-      end
-
-      it 'attributes can be injected' do
-        f1 = create_function_with_class_injection()
-        f = f1.new(:closure_scope, :loader)
-        expect(f.test_attr2()).to eql("evoe")
-        expect(f.serial().produce(nil)).to eql(42)
-        expect(f.test_attr().class.name).to eql("FunctionAPISpecModule::TestDuck")
-      end
-
-      it 'parameters can be injected and woven with regular dispatch' do
-        f1 = create_function_with_param_injection_regular()
-        f = f1.new(:closure_scope, :loader)
-        expect(f.call(nil, 10, 20)).to eql("evoe! 10, and 20 < 42 = true")
-        expect(f.call(nil, 50, 20)).to eql("evoe! 50, and 20 < 42 = false")
-      end
-    end
-
     context 'when requesting a type' do
       it 'responds with a Callable for a single signature' do
         tf = Puppet::Pops::Types::TypeFactory
@@ -839,18 +810,6 @@ describe 'the 4x function api' do
     end
   end
 
-  def create_function_with_class_injection
-    f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
-      attr_injected Puppet::Pops::Types::TypeFactory.type_of(FunctionAPISpecModule::TestDuck), :test_attr
-      attr_injected Puppet::Pops::Types::TypeFactory.string(), :test_attr2, "a_string"
-      attr_injected_producer Puppet::Pops::Types::TypeFactory.integer(), :serial, "an_int"
-
-      def test(x,y,a=1, b=1, *c)
-        x <= y ? x : y
-      end
-    end
-  end
-
   def create_function_with_param_injection_regular
     f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
       attr_injected Puppet::Pops::Types::TypeFactory.type_of(FunctionAPISpecModule::TestDuck), :test_attr
@@ -999,7 +958,7 @@ describe 'the 4x function api' do
   end
 
   def type_alias_t(name, type_string)
-    type_expr = Puppet::Pops::Parser::EvaluatingParser.new.parse_string(type_string).current
+    type_expr = Puppet::Pops::Parser::EvaluatingParser.new.parse_string(type_string)
     Puppet::Pops::Types::TypeFactory.type_alias(name, type_expr)
   end