puppet 4.4.2-universal-darwin → 4.5.0-universal-darwin

data/spec/unit/data_providers/function_data_provider_spec.rb

@@ -43,7 +43,7 @@ describe "when using function data provider" do
     node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
     compiler = Puppet::Parser::Compiler.new(node)
     catalog = compiler.compile()
-    resources_created_in_fixture = ["Notify[env_test1]", "Notify[env_test2]", "Notify[module_test3]"]
+    resources_created_in_fixture = ["Notify[env_test1]", "Notify[env_test2]", "Notify[module_test3]", "Notify[env_test2-ipl]"]
     expect(resources_in(catalog)).to include(*resources_created_in_fixture)
   end
 
@@ -56,6 +56,24 @@ describe "when using function data provider" do
     expect(resources_in(catalog)).to include(*resources_created_in_fixture)
   end
 
+  it 'gets data from puppet function delivering environment data' do
+    Puppet[:code] = <<-CODE
+      function environment::data() {
+        { 'cls::test1' => 'env_puppet1',
+          'cls::test2' => 'env_puppet2'
+        }
+      }
+      class cls ($test1, $test2) {
+        notify { $test1: }
+        notify { $test2: }
+      }
+      include cls
+    CODE
+    node = Puppet::Node.new('testnode', :facts => Puppet::Node::Facts.new('facts', {}), :environment => 'production')
+    catalog = Puppet::Parser::Compiler.new(node).compile
+    expect(resources_in(catalog)).to include('Notify[env_puppet1]', 'Notify[env_puppet2]')
+  end
+
   it 'raises an error if the environment data function does not return a hash' do
     Puppet[:code] = 'include abc'
     # find the loaders to patch with faulty function

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -186,7 +186,7 @@ Merge strategy first
       Path "#{environmentpath}/hiera_misc/data/common.yaml"
         Original path: "common"
         Interpolation on "Value from interpolation %{scope("target_scope")}"
-          Global Scope"
+          Global Scope
             Found key: "target_scope" value: "with scope"
         Found key: "km_scope" value: "Value from interpolation with scope"
   Merged result: "Value from interpolation with scope"

data/spec/unit/defaults_spec.rb

@@ -72,6 +72,24 @@ describe "Defaults" do
 
   end
 
+  describe 'strict' do
+    it 'should accept the valid value :off' do
+      expect {Puppet.settings[:strict] = 'off'}.to_not raise_exception
+    end
+
+    it 'should accept the valid value :warning' do
+      expect {Puppet.settings[:strict] = 'warning'}.to_not raise_exception
+    end
+
+    it 'should accept the valid value :error' do
+      expect {Puppet.settings[:strict] = 'error'}.to_not raise_exception
+    end
+
+    it 'should fail if given an invalid value' do
+      expect {Puppet.settings[:strict] = 'ignore'}.to raise_exception(/Invalid value 'ignore' for parameter strict\./)
+    end
+  end
+
   describe 'supported_checksum_types' do
     it 'should default to md5,sha256' do
       expect(Puppet.settings[:supported_checksum_types]).to eq(['md5', 'sha256'])

data/spec/unit/functions/assert_type_spec.rb

@@ -92,6 +92,6 @@ describe 'the assert_type function' do
       assert_type(Struct[{a=>Integer,b=>Boolean}], {a=>hej,x=>s})
     CODE
     expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error,
-      /struct member 'a' expected an Integer value, got String.*expected a value for key 'b'.*did not have a 'x' key/m)
+      /entry 'a' expected an Integer value, got String.*expected a value for key 'b'.*unrecognized key 'x'/m)
   end
 end

data/spec/unit/functions/dig_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the dig function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'returns a value from an array index via integer index' do
+    expect(compile_to_catalog("notify { [testing].dig(0): }")).to have_resource('Notify[testing]')
+  end
+
+  it 'returns undef if given an undef key' do
+  expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test-Undef-ing]')
+    notify { "test-${type([testing].dig(undef))}-ing": }
+    SOURCE
+  end
+
+  it 'returns undef if starting with undef' do
+  expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test-Undef-ing]')
+    notify { "test-${type(undef.dig(undef))}-ing": }
+    SOURCE
+  end
+
+  it 'returns a value from an hash key via given key' do
+    expect(compile_to_catalog("notify { {key => testing}.dig(key): }")).to have_resource('Notify[testing]')
+  end
+
+  it 'continues digging if result is an array' do
+    expect(compile_to_catalog("notify { [nope, [testing]].dig(1, 0): }")).to have_resource('Notify[testing]')
+  end
+
+  it 'continues digging if result is a hash' do
+    expect(compile_to_catalog("notify { [nope, {yes => testing}].dig(1, yes): }")).to have_resource('Notify[testing]')
+  end
+
+  it 'stops digging when step is undef' do
+    expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[testing]')
+    $result = [nope, {yes => testing}].dig(1, no, 2)
+    notify { "test${result}ing": }
+    SOURCE
+  end
+
+  it 'errors if step is neither Array nor Hash' do
+    expect { compile_to_catalog(<<-SOURCE)}.to raise_error(/The given data does not contain a Collection at \[1, "yes"\], got 'String'/)
+    $result = [nope, {yes => testing}].dig(1, yes, 2)
+    notify { "test${result}ing": }
+    SOURCE
+  end
+
+  it 'errors if not given a non Collection as the starting point' do
+    expect { compile_to_catalog(<<-SOURCE)}.to raise_error(/'dig' parameter 'data' expects a Collection value, got String/)
+    "hello".dig(1, yes, 2)
+    SOURCE
+  end
+
+end

data/spec/unit/functions/lest_spec.rb

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

data/spec/unit/functions/lookup_spec.rb

@@ -249,7 +249,7 @@ describe "when performing lookup" do
         expect do
           assemble_and_compile('${r[a]}_${r[b]}', "'abc::x'", 'Hash[String,String]', 'undef', "{'a' => 'dflt_x', 'b' => 32}")
         end.to raise_error(Puppet::ParseError,
-          /Default value had wrong type, expected a Hash\[String, String\] value, got Struct\[\{'a' => String, 'b' => Integer\}\]/)
+          /Default value had wrong type, entry 'b' expected a String value, got Integer/)
       end
     end
 
@@ -283,7 +283,7 @@ describe "when performing lookup" do
         expect do
           assemble_and_compile_with_block('${r[a]}_${r[b]}', "{'a' => 'dflt_x', 'b' => 32}", "'abc::x'", 'Hash[String,String]')
         end.to raise_error(Puppet::ParseError,
-          /Value returned from default block had wrong type, expected a Hash\[String, String\] value, got Struct\[\{'a' => String, 'b' => Integer\}\]/)
+          /Value returned from default block had wrong type, entry 'b' expected a String value, got Integer/)
       end
 
       it 'receives a single name parameter' do
@@ -298,6 +298,38 @@ describe "when performing lookup" do
     end
   end
 
+  context 'when using dotted keys' do
+    it 'can access values in data using dot notation' do
+      source = <<-CODE
+      function environment::data() {
+        { a => { b => { c => 'the data' }}}
+      }
+      notice(lookup('a.b.c'))
+      CODE
+      expect(eval_and_collect_notices(source)).to include('the data')
+    end
+
+    it 'can find data using quoted dot notation' do
+      source = <<-CODE
+      function environment::data() {
+        { 'a.b.c' => 'the data' }
+      }
+      notice(lookup('"a.b.c"'))
+      CODE
+      expect(eval_and_collect_notices(source)).to include('the data')
+    end
+
+    it 'can access values in data using a mix of dot notation and quoted dot notation' do
+      source = <<-CODE
+      function environment::data() {
+        { 'a' => { 'b.c' => 'the data' }}
+      }
+      notice(lookup('a."b.c"'))
+      CODE
+      expect(eval_and_collect_notices(source)).to include('the data')
+    end
+  end
+
   context 'when passing a hash as the only parameter' do
     it 'can pass a single name correctly' do
       resources = assemble_and_compile('${r}', "{name => 'abc::a'}")
@@ -432,6 +464,58 @@ describe "when performing lookup" do
     end
   end
 
+  context 'when accessing nil values' do
+    it 'will find a key with undef value in a yaml file' do
+      Puppet[:code] = 'include empty_key_yaml'
+      compiler.compile do |catalog|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('empty_key_yaml::has_undef_value',nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::Error
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "empty_key_yaml::has_undef_value"
+  Data Provider "FunctionEnvDataProvider"
+    No such key: "empty_key_yaml::has_undef_value"
+  Module "empty_key_yaml" using Data Provider "Hiera Data Provider, version 4"
+    ConfigurationPath "#{environmentpath}/production/modules/empty_key_yaml/hiera.yaml"
+    Data Provider "empty_key"
+      Path "#{environmentpath}/production/modules/empty_key_yaml/data/empty_key.yaml"
+        Original path: "empty_key"
+        Found key: "empty_key_yaml::has_undef_value" value: nil
+  Merged result: nil
+EOS
+      end
+    end
+
+    it 'will find a key with undef value in a json file' do
+      Puppet[:code] = 'include empty_key_json'
+      compiler.compile do |catalog|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('empty_key_json::has_undef_value',nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::Error
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "empty_key_json::has_undef_value"
+  Data Provider "FunctionEnvDataProvider"
+    No such key: "empty_key_json::has_undef_value"
+  Module "empty_key_json" using Data Provider "Hiera Data Provider, version 4"
+    ConfigurationPath "#{environmentpath}/production/modules/empty_key_json/hiera.yaml"
+    Data Provider "empty_key"
+      Path "#{environmentpath}/production/modules/empty_key_json/data/empty_key.json"
+        Original path: "empty_key"
+        Found key: "empty_key_json::has_undef_value" value: nil
+  Merged result: nil
+EOS
+      end
+    end
+  end
+
   context 'when using explain' do
     it 'will explain that module is not found' do
       assemble_and_compile('${r}', "'abc::a'") do |scope|
@@ -558,6 +642,28 @@ EOS
       end
     end
 
+    it 'will explain value access caused by dot notation in key' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        Puppet::Pops::Lookup.lookup('abc::f.k1.s1', Puppet::Pops::Types::TypeParser.new.parse('String'), nil, false, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "abc::f.k1.s1"
+  Data Provider "FunctionEnvDataProvider"
+    Sub key: "k1.s1"
+      Found key: "k1" value: {
+        "s1" => "env_f11",
+        "s2" => "env_f12"
+      }
+      Found key: "s1" value: "env_f11"
+    Found key: "abc::f.k1.s1" value: "env_f11"
+  Merged result: "env_f11"
+EOS
+      end
+    end
+
+
     it 'will provide a hash containing all explanation elements' do
       assemble_and_compile('${r}', "'abc::a'") do |scope|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)

data/spec/unit/functions/new_spec.rb

@@ -0,0 +1,543 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the new function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'yields converted value if given a block' do
+    expect(compile_to_catalog(<<-MANIFEST
+      $x = Integer.new('42') |$x| { $x+2 }
+      notify { "${type($x, generalized)}, $x": }
+    MANIFEST
+    )).to have_resource('Notify[Integer, 44]')
+  end
+
+  it 'produces undef if given an undef value and type accepts it' do
+    expect(compile_to_catalog(<<-MANIFEST
+      $x = Optional[Integer].new(undef)
+      notify { "one${x}word": }
+    MANIFEST
+    )).to have_resource('Notify[oneword]')
+  end
+
+  it 'errors if given undef and type does not accept the value' do
+    expect{compile_to_catalog(<<-MANIFEST
+      $x = Integer.new(undef)
+      notify { "one${x}word": }
+    MANIFEST
+    )}.to raise_error(Puppet::Error, /expected an Integer value, got Undef/)
+  end
+
+  it 'errors if converted value is not assignable to the type' do
+    expect{compile_to_catalog(<<-MANIFEST
+      $x = Integer[1,5].new('42')
+      notify { "one${x}word": }
+    MANIFEST
+    )}.to raise_error(Puppet::Error, /expected an Integer\[1, 5\] value, got Integer\[42, 42\]/)
+  end
+
+  context 'when invoked on NotUndef' do
+    it 'produces an instance of the NotUndef nested type' do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = NotUndef[Integer].new(42)
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Integer, 42]')
+    end
+
+    it 'produces the given value when there is no type specified' do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = NotUndef.new(42)
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Integer, 42]')
+    end
+  end
+
+  context 'when invoked on an Integer' do
+    it 'produces 42 when given the integer 42' do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = Integer.new(42)
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Integer, 42]')
+    end
+
+    it 'produces 3 when given the float 3.1415' do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = Integer.new(3.1415)
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Integer, 3]')
+    end
+
+    it 'produces 0 from false' do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = Integer.new(false)
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Integer, 0]')
+    end
+
+    it 'produces 1 from true' do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = Integer.new(true)
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Integer, 1]')
+    end
+
+    context "when radix is not set it uses default and" do
+      { "10"     => 10,
+        "010"    => 8,
+        "0x10"   => 16,
+        "0X10"   => 16,
+        '0B111'  => 7,
+        '0b111'  => 7
+      }.each do |str, result|
+        it "produces #{result} from the string '#{str}'" do
+          expect(compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}")
+            notify { "${type($x, generalized)}, $x": }
+          MANIFEST
+          )).to have_resource("Notify[Integer, #{result}]")
+        end
+      end
+    end
+
+    context "when radix is explicitly set to 'default' it" do
+      { "10"     => 10,
+        "010"    => 8,
+        "0x10"   => 16,
+        "0X10"   => 16,
+        '0B111'  => 7,
+        '0b111'  => 7
+      }.each do |str, result|
+        it "produces #{result} from the string '#{str}'" do
+          expect(compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}", default)
+            notify { "${type($x, generalized)}, $x": }
+          MANIFEST
+          )).to have_resource("Notify[Integer, #{result}]")
+        end
+      end
+    end
+
+    context "when radix is explicitly set to '2' it" do
+      { "10"     => 2,
+        "010"    => 2,
+        "00010"  => 2,
+        '0B111'  => 7,
+        '0b111'  => 7
+      }.each do |str, result|
+        it "produces #{result} from the string '#{str}'" do
+          expect(compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}", 2)
+            notify { "${type($x, generalized)}, $x": }
+          MANIFEST
+          )).to have_resource("Notify[Integer, #{result}]")
+        end
+      end
+
+      { "0x10"  => :error,
+        '0X10'  => :error
+      }.each do |str, result|
+        it "errors when given the non binary value compliant string '#{str}'" do
+          expect{compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}", 2)
+          MANIFEST
+        )}.to raise_error(Puppet::Error, /invalid value/)
+        end
+      end
+    end
+
+    context "when radix is explicitly set to '8' it" do
+      { "10"     => 8,
+        "010"    => 8,
+        "00010"  => 8,
+      }.each do |str, result|
+        it "produces #{result} from the string '#{str}'" do
+          expect(compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}", 8)
+            notify { "${type($x, generalized)}, $x": }
+          MANIFEST
+          )).to have_resource("Notify[Integer, #{result}]")
+        end
+      end
+
+      { "0x10"  => :error,
+        '0X10'  => :error,
+        '0B10'  => :error,
+        '0b10'  => :error,
+      }.each do |str, result|
+        it "errors when given the non octal value compliant string '#{str}'" do
+          expect{compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}", 8)
+          MANIFEST
+        )}.to raise_error(Puppet::Error, /invalid value/)
+        end
+      end
+    end
+
+    context "when radix is explicitly set to '16' it" do
+      { "10"     => 16,
+        "010"    => 16,
+        "00010"  => 16,
+        "0x10"   => 16,
+        "0X10"   => 16,
+        "0b1"    => 16*11+1,
+        "0B1"    => 16*11+1,
+      }.each do |str, result|
+        it "produces #{result} from the string '#{str}'" do
+          expect(compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}", 16)
+            notify { "${type($x, generalized)}, $x": }
+          MANIFEST
+          )).to have_resource("Notify[Integer, #{result}]")
+        end
+      end
+
+      { '0XGG'  => :error,
+      }.each do |str, result|
+        it "errors when given the non octal value compliant string '#{str}'" do
+          expect{compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}", 8)
+          MANIFEST
+        )}.to raise_error(Puppet::Error, /invalid value/)
+        end
+      end
+    end
+
+    context "when radix is explicitly set to '10' it" do
+      { "10"     => 10,
+        "010"    => 10,
+        "00010"  => 10,
+      }.each do |str, result|
+        it "produces #{result} from the string '#{str}'" do
+          expect(compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}", 10)
+            notify { "${type($x, generalized)}, $x": }
+          MANIFEST
+          )).to have_resource("Notify[Integer, #{result}]")
+        end
+      end
+
+      { '0X10'  => :error,
+        '0X10'  => :error,
+        '0b10'  => :error,
+        '0B10'  => :error,
+      }.each do |str, result|
+        it "errors when given the non octal value compliant string '#{str}'" do
+          expect{compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}", 10)
+          MANIFEST
+        )}.to raise_error(Puppet::Error, /invalid value/)
+        end
+      end
+    end
+
+    context "input can be given in long form " do
+      { {'from' => "10", 'radix' => 2}     => 2,
+        {'from' => "10", 'radix' => 8}     => 8,
+        {'from' => "10", 'radix' => 10}    => 10,
+        {'from' => "10", 'radix' => 16}    => 16,
+        {'from' => "10", 'radix' => :default}    => 10,
+      }.each do |options, result|
+        it "produces #{result} from the long form '#{options}'" do
+          src = <<-"MANIFEST"
+            $x = Integer.new(#{options.to_s.gsub(/:/, '')})
+            notify { "${type($x, generalized)}, $x": }
+          MANIFEST
+          expect(compile_to_catalog(src)).to have_resource("Notify[Integer, #{result}]")
+        end
+      end
+    end
+
+    context 'errors when' do
+      it 'radix is wrong and when given directly' do
+        expect{compile_to_catalog(<<-"MANIFEST"
+          $x = Integer.new('10', 3)
+        MANIFEST
+      )}.to raise_error(Puppet::Error, /rejected: parameter 'radix'/m)
+      end
+
+      it 'radix is wrong and when given in long form' do
+        expect{compile_to_catalog(<<-"MANIFEST"
+          $x = Integer.new({from =>'10', radix=>3})
+        MANIFEST
+      )}.to raise_error(Puppet::Error, /rejected: parameter 'hash_args' entry 'radix'/m)
+      end
+
+      it 'value is not numeric and given directly' do
+        expect{compile_to_catalog(<<-"MANIFEST"
+          $x = Integer.new('eleven', 10)
+        MANIFEST
+      )}.to raise_error(Puppet::Error, /invalid value/)
+      end
+
+      it 'value is not numeric and given in long form' do
+        expect{compile_to_catalog(<<-"MANIFEST"
+      $x = Integer.new({from => 'eleven', radix => 10})
+        MANIFEST
+      )}.to raise_error(Puppet::Error, /invalid value/)
+      end
+    end
+  end
+
+  context 'when invoked on Numeric' do
+    { 42 => "Notify[Integer, 42]",
+      42.3 => "Notify[Float, 42.3]",
+      "42.0" => "Notify[Float, 42.0]",
+      "42.3" => "Notify[Float, 42.3]",
+      "0x10" => "Notify[Integer, 16]",
+      "010" => "Notify[Integer, 8]",
+      "0.10" => "Notify[Float, 0.1]",
+      "0b10" => "Notify[Integer, 2]",
+      false => "Notify[Integer, 0]",
+      true => "Notify[Integer, 1]",
+    }.each do |input, result|
+      it "produces #{result} when given the value #{input.inspect}" do
+        expect(compile_to_catalog(<<-MANIFEST
+          $x = Numeric.new(#{input.inspect})
+          notify { "${type($x, generalized)}, $x": }
+        MANIFEST
+        )).to have_resource(result)
+      end
+    end
+
+    it "produces a result when long from hash {from => val} is used" do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = Numeric.new({from=>'42'})
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Integer, 42]')
+    end
+  end
+
+  context 'when invoked on Float' do
+    { 42     => "Notify[Float, 42.0]",
+      42.3   => "Notify[Float, 42.3]",
+      "42.0" => "Notify[Float, 42.0]",
+      "42.3" => "Notify[Float, 42.3]",
+      "0x10" => "Notify[Float, 16.0]",
+      "010"  => "Notify[Float, 10.0]",
+      "0.10" => "Notify[Float, 0.1]",
+      false  => "Notify[Float, 0.0]",
+      true   => "Notify[Float, 1.0]",
+      '0b10'  => "Notify[Float, 2.0]",
+      '0B10'  => "Notify[Float, 2.0]",
+    }.each do |input, result|
+      it "produces #{result} when given the value #{input.inspect}" do
+        expect(compile_to_catalog(<<-MANIFEST
+          $x = Float.new(#{input.inspect})
+          notify { "${type($x, generalized)}, $x": }
+        MANIFEST
+        )).to have_resource(result)
+      end
+    end
+
+    it "produces a result when long from hash {from => val} is used" do
+      expect(compile_to_catalog(<<-MANIFEST
+        $x = Float.new({from=>42})
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Float, 42.0]')
+    end
+  end
+
+  context 'when invoked on Boolean' do
+    { true     => 'Notify[Boolean, true]',
+      false    => 'Notify[Boolean, false]',
+      0        => 'Notify[Boolean, false]',
+      1        => 'Notify[Boolean, true]',
+      0.0      => 'Notify[Boolean, false]',
+      1.0      => 'Notify[Boolean, true]',
+
+      'true'   => 'Notify[Boolean, true]',
+      'TrUe'   => 'Notify[Boolean, true]',
+      'yes'    => 'Notify[Boolean, true]',
+      'YeS'    => 'Notify[Boolean, true]',
+      'y'      => 'Notify[Boolean, true]',
+      'Y'      => 'Notify[Boolean, true]',
+
+      'false'  => 'Notify[Boolean, false]',
+      'no'     => 'Notify[Boolean, false]',
+      'n'      => 'Notify[Boolean, false]',
+      'FalSE'  => 'Notify[Boolean, false]',
+      'nO'     => 'Notify[Boolean, false]',
+      'N'      => 'Notify[Boolean, false]',
+    }.each do |input, result|
+      it "produces #{result} when given the value #{input.inspect}" do
+        expect(compile_to_catalog(<<-MANIFEST
+          $x = Boolean.new(#{input.inspect})
+          notify { "${type($x, generalized)}, $x": }
+        MANIFEST
+        )).to have_resource(result)
+      end
+    end
+
+    it "errors when given an non boolean representation like the string 'hello'" do
+      expect{compile_to_catalog(<<-"MANIFEST"
+        $x = Boolean.new('hello')
+      MANIFEST
+      )}.to raise_error(Puppet::Error, /cannot be converted to Boolean/)
+    end
+
+    it "does not convert an undef (as may be expected, but is handled as every other undef)" do
+      expect{compile_to_catalog(<<-"MANIFEST"
+        $x = Boolean.new(undef)
+      MANIFEST
+      )}.to raise_error(Puppet::Error, /expected a Boolean value, got Undef/)
+    end
+  end
+
+  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]]]',
+      'abc'         => 'Notify[Array[String], [a, b, c]]',
+      3             => 'Notify[Array[Integer], [0, 1, 2]]',
+    }.each do |input, result|
+      it "produces #{result} when given the value #{input.inspect} and wrap is not given" do
+        expect(compile_to_catalog(<<-MANIFEST
+          $x = Array.new(#{input.inspect})
+          notify { "${type($x, generalized)}, $x": }
+        MANIFEST
+        )).to have_resource(result)
+      end
+    end
+
+    {
+      true          => /cannot be converted to Array/,
+      42.3          => /cannot be converted to Array/,
+    }.each do |input, error_match|
+      it "errors when given an non convertible #{input.inspect} when wrap is not given" do
+        expect{compile_to_catalog(<<-"MANIFEST"
+          $x = Array.new(#{input.inspect})
+        MANIFEST
+        )}.to raise_error(Puppet::Error, error_match)
+      end
+    end
+
+    { []            => 'Notify[Array[Unit], []]',
+      [true]        => 'Notify[Array[Boolean], [true]]',
+      {'a'=>true}   => 'Notify[Array[Hash[String, Boolean]], [{a => true}]]',
+      'hello'       => 'Notify[Array[String], [hello]]',
+      true          => 'Notify[Array[Boolean], [true]]',
+      42            => 'Notify[Array[Integer], [42]]',
+    }.each do |input, result|
+      it "produces #{result} when given the value #{input.inspect} and wrap is given" do
+        expect(compile_to_catalog(<<-MANIFEST
+          $x = Array.new(#{input.inspect}, true)
+          notify { "${type($x, generalized)}, $x": }
+        MANIFEST
+        )).to have_resource(result)
+      end
+    end
+  end
+
+  context 'when invoked on Tuple' do
+    { 'abc'         => 'Notify[Array[String], [a, b, c]]',
+      3             => 'Notify[Array[Integer], [0, 1, 2]]',
+    }.each do |input, result|
+      it "produces #{result} when given the value #{input.inspect} and wrap is not given" do
+        expect(compile_to_catalog(<<-MANIFEST
+          $x = Tuple[Any,3].new(#{input.inspect})
+          notify { "${type($x, generalized)}, $x": }
+        MANIFEST
+        )).to have_resource(result)
+      end
+    end
+
+    it "errors when tuple requirements are not met" do
+      expect{compile_to_catalog(<<-"MANIFEST"
+        $x = Tuple[Integer,6].new(3)
+      MANIFEST
+      )}.to raise_error(Puppet::Error, /expected size to be at least 6, got 3/)
+    end
+  end
+
+  context 'when invoked on Hash' do
+    { {}            => 'Notify[Hash[0, 0], {}]',
+      []            => 'Notify[Hash[0, 0], {}]',
+      {'a'=>true}   => 'Notify[Hash[String, Boolean], {a => true}]',
+      [1,2,3,4]     => 'Notify[Hash[Integer, Integer], {1 => 2, 3 => 4}]',
+      [[1,2],[3,4]] => 'Notify[Hash[Integer, Integer], {1 => 2, 3 => 4}]',
+      'abcd'        => 'Notify[Hash[String, String], {a => b, c => d}]',
+      4             => 'Notify[Hash[Integer, Integer], {0 => 1, 2 => 3}]',
+
+    }.each do |input, result|
+      it "produces #{result} when given the value #{input.inspect}" do
+        expect(compile_to_catalog(<<-MANIFEST
+          $x = Hash.new(#{input.inspect})
+          notify { "${type($x, generalized)}, $x": }
+        MANIFEST
+        )).to have_resource(result)
+      end
+    end
+
+    { true             => /cannot be converted to Hash/,
+      [1,2,3]          => /odd number of arguments for Hash/,
+    }.each do |input, error_match|
+      it "errors when given an non convertible #{input.inspect}" do
+        expect{compile_to_catalog(<<-"MANIFEST"
+          $x = Hash.new(#{input.inspect})
+        MANIFEST
+        )}.to raise_error(Puppet::Error, error_match)
+      end
+    end
+  end
+
+  context 'when invoked on Struct' do
+    { {'a' => 2}      => 'Notify[Struct[{\'a\' => Integer[2, 2]}], {a => 2}]',
+    }.each do |input, result|
+      it "produces #{result} when given the value #{input.inspect}" do
+        expect(compile_to_catalog(<<-MANIFEST
+          $x = Struct[{a => Integer[2]}].new(#{input.inspect})
+          notify { "${type($x)}, $x": }
+        MANIFEST
+        )).to have_resource(result)
+      end
+    end
+
+    it "errors when tuple requirements are not met" do
+      expect{compile_to_catalog(<<-"MANIFEST"
+        $x = Struct[{a => Integer[2]}].new({a => 0})
+      MANIFEST
+      )}.to raise_error(Puppet::Error, /entry 'a' expected an Integer\[2, default\]/)
+    end
+  end
+
+  context 'when invoked on String' do
+    { {}            => 'Notify[String, {}]',
+      []            => 'Notify[String, []]',
+      {'a'=>true}   => 'Notify[String, {"a" => true}]',
+      [1,2,3,4]     => 'Notify[String, [1, 2, 3, 4]]',
+      [[1,2],[3,4]] => 'Notify[String, [[1, 2], [3, 4]]]',
+      'abcd'        => 'Notify[String, abcd]',
+      4             => 'Notify[String, 4]',
+    }.each do |input, result|
+      it "produces #{result} when given the value #{input.inspect}" do
+        expect(compile_to_catalog(<<-MANIFEST
+          $x = String.new(#{input.inspect})
+          notify { "${type($x, generalized)}, $x": }
+        MANIFEST
+        )).to have_resource(result)
+      end
+    end
+  end
+
+  context 'when invoked on a type alias' do
+    it 'delegates the new to the aliased type' do
+      expect(compile_to_catalog(<<-MANIFEST
+        type X = Boolean
+        $x = X.new('yes')
+        notify { "${type($x, generalized)}, $x": }
+      MANIFEST
+      )).to have_resource('Notify[Boolean, true]')
+    end
+  end
+end