puppet 7.30.0-x64-mingw32 → 8.0.1-x64-mingw32

data/spec/unit/functions/tree_each_spec.rb

@@ -0,0 +1,493 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+require 'shared_behaviours/iterative_functions'
+
+describe 'the tree_each function' do
+  include PuppetSpec::Compiler
+
+  context "can be called on" do
+    it 'an Array, yielding path and value when lambda has arity 2' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each() |$path, $v| { -%>
+          path: <%= $path %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 'path: [] value: [1, 2, 3]',
+          'path: [0] value: 1',
+          'path: [1] value: 2',
+          'path: [2] value: 3',
+          ''
+          ].join("\n"))
+    end
+
+    it 'an Array, yielding only value  when lambda has arity 1' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each() | $v| { -%>
+          path: - value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 'path: - value: [1, 2, 3]',
+          'path: - value: 1',
+          'path: - value: 2',
+          'path: - value: 3',
+          ''
+          ].join("\n"))
+    end
+
+    it 'a Hash, yielding path and value when lambda has arity 2' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>'apple','b'=>'banana'}
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each() |$path, $v| { -%>
+          path: <%= $path %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 'path: [] value: {a => apple, b => banana}',
+          'path: [a] value: apple',
+          'path: [b] value: banana',
+          ''
+          ].join("\n"))
+    end
+
+    it 'a Hash, yielding only value when lambda has arity 1' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {'a'=>'apple','b'=>'banana'}
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each() | $v| { -%>
+          path: - value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 'path: - value: {a => apple, b => banana}',
+          'path: - value: apple',
+          'path: - value: banana',
+          ''
+          ].join("\n"))
+    end
+
+    it 'an Object, yielding path and value when lambda has arity 2' do
+      # this also tests that include_refs => true includes references
+      catalog = compile_to_catalog(<<-MANIFEST)
+        type Person = Object[{attributes => {
+          name => String,
+          father => Optional[Person],
+          mother => { kind => reference, type => Optional[Person] }
+        }}]
+        $adam  = Person({name => 'Adam'})
+        $eve   = Person({name => 'Eve'})
+        $cain  = Person({name => 'Cain',  mother => $eve,  father => $adam})
+        $awan  = Person({name => 'Awan',  mother => $eve,  father => $adam})
+        $enoch = Person({name => 'Enoch', mother => $awan, father => $cain})
+
+        $msg = inline_epp(@(TEMPLATE))
+          <% $enoch.tree_each({include_containers=>false, include_refs => true}) |$path, $v| { unless $v =~ Undef {-%>
+          path: <%= $path %> value: <%= $v %>
+          <% }} -%>
+          | TEMPLATE
+        notify {'with_refs': message => $msg}
+
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'with_refs')['message']).to eq(
+        [
+          'path: [name] value: Enoch',
+          'path: [father, name] value: Cain',
+          'path: [father, father, name] value: Adam',
+          'path: [father, mother, name] value: Eve',
+          'path: [mother, name] value: Awan',
+          'path: [mother, father, name] value: Adam',
+          'path: [mother, mother, name] value: Eve',
+          ''
+          ].join("\n"))
+    end
+  end
+
+  context 'a yielded path' do
+    it 'holds integer values for Array index at each level' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,[2,[3]]]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each() |$path, $v| { -%>
+          path: <%= $path %> t: <%= $path.map |$x| { type($x, generalized) } %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 'path: [] t: [] value: [1, [2, [3]]]',
+          'path: [0] t: [Integer] value: 1',
+          'path: [1] t: [Integer] value: [2, [3]]',
+          'path: [1, 0] t: [Integer, Integer] value: 2',
+          'path: [1, 1] t: [Integer, Integer] value: [3]',
+          'path: [1, 1, 0] t: [Integer, Integer, Integer] value: 3',
+          ''
+          ].join("\n"))
+    end
+
+    it 'holds Any values for Hash keys at each level' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = {a => 1, /fancy/=> {c => 2, d=>{[e] => 3}}}
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each() |$path, $v| { -%>
+          path: <%= $path %> t: <%= $path.map |$x| { type($x, generalized) } %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 'path: [] t: [] value: {a => 1, /fancy/ => {c => 2, d => {[e] => 3}}}',
+          'path: [a] t: [String] value: 1',
+          'path: [/fancy/] t: [Regexp[/fancy/]] value: {c => 2, d => {[e] => 3}}',
+          'path: [/fancy/, c] t: [Regexp[/fancy/], String] value: 2',
+          'path: [/fancy/, d] t: [Regexp[/fancy/], String] value: {[e] => 3}',
+          'path: [/fancy/, d, [e]] t: [Regexp[/fancy/], String, Array[String]] value: 3',
+          ''
+          ].join("\n"))
+    end
+  end
+
+  it 'errors when asked to operate on a String' do
+    expect {
+      compile_to_catalog(<<-MANIFEST)
+      "hello".tree_each() |$path, $v| {
+        notice "$v"
+      }
+    MANIFEST
+    }.to raise_error(/expects a value of type Iterator, Array, Hash, or Object/)
+  end
+
+  context 'produces' do
+    it 'the receiver when given a lambda' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1, 3, 2]
+        $b = $a.tree_each |$path, $x| { "unwanted" }
+        file { "/file_${b[1]}":
+          ensure => present
+        }
+      MANIFEST
+
+      expect(catalog.resource(:file, "/file_3")['ensure']).to eq('present')
+    end
+
+    it 'an Iterator when not given a lambda' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1, 3, 2]
+        $b = $a.tree_each
+        file { "/file_${$b =~ Iterator}":
+          ensure => present
+        }
+      MANIFEST
+
+      expect(catalog.resource(:file, "/file_true")['ensure']).to eq('present')
+    end
+  end
+
+  context 'a produced iterator' do
+    ['depth_first', 'breadth_first'].each do |order|
+      context "for #{order} can be unrolled by creating an Array using" do
+        it "the () operator" do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            $a = [1, 3, 2]
+            $b = Array($a.tree_each({order => #{order}}))
+            $msg = inline_epp(@(TEMPLATE))
+              <% $b.each() |$v| { -%>
+              path: <%= $v[0] %> value: <%= $v[1] %>
+              <% } -%>
+              | TEMPLATE
+            notify {'test': message => $msg}
+          MANIFEST
+
+          expect(catalog.resource(:notify, "test")['message']).to eq([
+            'path: [] value: [1, 3, 2]',
+            'path: [0] value: 1',
+            'path: [1] value: 3',
+            'path: [2] value: 2',
+            ''
+            ].join("\n"))
+        end
+
+        it "the splat operator" do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            $a = [1, 3, 2]
+            $b = *$a.tree_each({order => #{order}})
+            assert_type(Array[Array], $b)
+            $msg = inline_epp(@(TEMPLATE))
+              <% $b.each() |$v| { -%>
+              path: <%= $v[0] %> value: <%= $v[1] %>
+              <% } -%>
+              | TEMPLATE
+            notify {'test': message => $msg}
+          MANIFEST
+
+          expect(catalog.resource(:notify, "test")['message']).to eq([
+            'path: [] value: [1, 3, 2]',
+            'path: [0] value: 1',
+            'path: [1] value: 3',
+            'path: [2] value: 2',
+            ''
+            ].join("\n"))
+        end
+      end
+    end
+  end
+
+  context 'recursively yields under the control of options such that' do
+    it 'both containers and leafs are included by default' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,[2,[3]]]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each() |$path, $v| { -%>
+          path: <%= $path %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 'path: [] value: [1, [2, [3]]]',
+          'path: [0] value: 1',
+          'path: [1] value: [2, [3]]',
+          'path: [1, 0] value: 2',
+          'path: [1, 1] value: [3]',
+          'path: [1, 1, 0] value: 3',
+          ''
+          ].join("\n"))
+    end
+
+    it 'containers are skipped when option include_containers=false is used' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,[2,[3]]]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each({include_containers => false}) |$path, $v| { -%>
+          path: <%= $path %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 
+          'path: [0] value: 1',
+          'path: [1, 0] value: 2',
+          'path: [1, 1, 0] value: 3',
+          ''
+          ].join("\n"))
+    end
+
+    it 'values are skipped when option include_values=false is used' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,[2,[3]]]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each({include_values => false}) |$path, $v| { -%>
+          path: <%= $path %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 'path: [] value: [1, [2, [3]]]',
+          'path: [1] value: [2, [3]]',
+          'path: [1, 1] value: [3]',
+          ''
+          ].join("\n"))
+    end
+
+    it 'the root container is skipped when option include_root=false is used' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,[2,[3]]]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each({include_root => false, include_values => false}) |$path, $v| { -%>
+          path: <%= $path %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 'path: [1] value: [2, [3]]',
+          'path: [1, 1] value: [3]',
+          ''
+          ].join("\n"))
+    end
+
+    it 'containers must be included for root to be included' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,[2,[3]]]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each({include_containers => false, include_root => true}) |$path, $v| { -%>
+          path: <%= $path %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [ 
+          'path: [0] value: 1',
+          'path: [1, 0] value: 2',
+          'path: [1, 1, 0] value: 3',
+          ''
+          ].join("\n"))
+    end
+
+    it 'errors when asked to exclude both containers and values' do
+      expect {
+        compile_to_catalog(<<-MANIFEST)
+          [1,2,3].tree_each({include_containers => false, include_values => false}) |$path, $v| {
+          notice "$v"
+        }
+      MANIFEST
+      }.to raise_error(/Options 'include_containers' and 'include_values' cannot both be false/)
+    end
+
+    it 'tree nodes are yielded in depth first order if option order=depth_first' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,[2,[3], 4], 5]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each({order => depth_first, include_containers => false}) |$path, $v| { -%>
+          path: <%= $path %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [
+          'path: [0] value: 1',
+          'path: [1, 0] value: 2',
+          'path: [1, 1, 0] value: 3',
+          'path: [1, 2] value: 4',
+          'path: [2] value: 5',
+          ''
+          ].join("\n"))
+    end
+
+    it 'tree nodes are yielded in breadth first order if option order=breadth_first' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,[2,[3], 4], 5]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each({order => breadth_first, include_containers => false}) |$path, $v| { -%>
+          path: <%= $path %> value: <%= $v %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [
+          'path: [0] value: 1',
+          'path: [2] value: 5',
+          'path: [1, 0] value: 2',
+          'path: [1, 2] value: 4',
+          'path: [1, 1, 0] value: 3',
+          ''
+          ].join("\n"))
+    end
+
+    it 'attributes of an Object of "reference" kind are not yielded by default' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        type Person = Object[{attributes => {
+          name => String,
+          father => Optional[Person],
+          mother => { kind => reference, type => Optional[Person] }
+        }}]
+        $adam  = Person({name => 'Adam'})
+        $eve   = Person({name => 'Eve'})
+        $cain  = Person({name => 'Cain',  mother => $eve,  father => $adam})
+        $awan  = Person({name => 'Awan',  mother => $eve,  father => $adam})
+        $enoch = Person({name => 'Enoch', mother => $awan, father => $cain})
+
+        $msg = inline_epp(@(TEMPLATE))
+          <% $enoch.tree_each({include_containers=>false }) |$path, $v| { unless $v =~ Undef {-%>
+          path: <%= $path %> value: <%= $v %>
+          <% }} -%>
+          | TEMPLATE
+        notify {'by_default': message => $msg}
+
+        $msg2 = inline_epp(@(TEMPLATE))
+          <% $enoch.tree_each({include_containers=>false, include_refs => false}) |$path, $v| { unless $v =~ Undef {-%>
+          path: <%= $path %> value: <%= $v %>
+          <% }} -%>
+          | TEMPLATE
+        notify {'when_false': message => $msg2}
+
+      MANIFEST
+
+      expected_refs_excluded_result = [
+        'path: [name] value: Enoch',
+        'path: [father, name] value: Cain',
+        'path: [father, father, name] value: Adam',
+        ''
+        ].join("\n")
+
+      expect(catalog.resource(:notify, 'by_default')['message']).to eq(expected_refs_excluded_result)
+      expect(catalog.resource(:notify, 'when_false')['message']).to eq(expected_refs_excluded_result)
+    end
+  end
+
+  context 'can be chained' do
+    it 'with reverse_each()' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,[2,[3]]]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each({include_containers => false}).reverse_each |$v| { -%>
+          path: <%= $v[0] %> value: <%= $v[1] %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [
+          'path: [1, 1, 0] value: 3',
+          'path: [1, 0] value: 2',
+          'path: [0] value: 1',
+          ''
+          ].join("\n"))
+    end
+
+    it 'with step()' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,[2,[3,[4,[5]]]]]
+        $msg = inline_epp(@(TEMPLATE))
+          <% $a.tree_each({include_containers => false}).step(2) |$v| { -%>
+          path: <%= $v[0] %> value: <%= $v[1] %>
+          <% } -%>
+          | TEMPLATE
+        notify {'test': message => $msg}
+      MANIFEST
+
+      expect(catalog.resource(:notify, 'test')['message']).to eq(
+        [
+          'path: [0] value: 1',
+          'path: [1, 1, 0] value: 3',
+          'path: [1, 1, 1, 1, 0] value: 5',
+          ''
+          ].join("\n"))
+    end
+  end
+end

data/spec/unit/functions/type_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the type function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'produces the type of a given value with default detailed quality' do
+  expect(compile_to_catalog('notify { "${ type([2, 3.14]) }": }')).to have_resource(
+      'Notify[Tuple[Integer[2, 2], Float[3.14, 3.14]]]')
+  end
+
+  it 'produces the type of a give value with detailed quality when quality is given' do
+    expect(compile_to_catalog('notify { "${ type([2, 3.14], detailed) }": }')).to have_resource(
+      'Notify[Tuple[Integer[2, 2], Float[3.14, 3.14]]]')
+  end
+
+  it 'produces the type of a given value with reduced quality when quality is given' do
+    expect(compile_to_catalog('notify { "${ type([2, 3.14], reduced) }": }')).to have_resource(
+      'Notify[Array[Numeric, 2, 2]]')
+  end
+
+  it 'produces the type of a given value with generalized quality when quality is given' do
+    expect(compile_to_catalog('notify { "${ type([2, 3.14], generalized) }": }')).to have_resource(
+      'Notify[Array[Numeric]]')
+  end
+
+  it 'errors when given a fault inference quality' do
+    expect do
+      compile_to_catalog("notify { type([2, 4.14], gobbledygooked): }")
+    end.to raise_error(/expects a match for Enum\['detailed', 'generalized', 'reduced'\], got 'gobbledygooked'/)
+  end
+end

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/functions/unwrap_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the unwrap function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'unwraps a sensitive value' do
+    code = <<-CODE
+      $sensitive = Sensitive.new("12345")
+      notice("unwrapped value is ${sensitive.unwrap}")
+    CODE
+    expect(eval_and_collect_notices(code)).to eq(['unwrapped value is 12345'])
+  end
+
+  it 'just returns a non-sensitive value' do
+    code = <<-CODE
+      $non_sensitive = "12345"
+      notice("value is still ${non_sensitive.unwrap}")
+    CODE
+    expect(eval_and_collect_notices(code)).to eq(['value is still 12345'])
+  end
+
+  it 'unwraps a sensitive value when given a code block' do
+    code = <<-CODE
+      $sensitive = Sensitive.new("12345")
+      $split = $sensitive.unwrap |$unwrapped| {
+        notice("unwrapped value is $unwrapped")
+        $unwrapped.split(/3/)
+      }
+      notice("split is $split")
+    CODE
+    expect(eval_and_collect_notices(code)).to eq(['unwrapped value is 12345', 'split is [12, 45]'])
+  end
+end