puppet 4.0.0 → 4.9.1

data/spec/unit/pops/types/type_formatter_spec.rb

@@ -0,0 +1,396 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops::Types
+describe 'The type formatter' do
+  let(:s) { TypeFormatter.new }
+  let(:f) { TypeFactory }
+
+  def drop_indent(str)
+    ld = str.index("\n")
+    if ld.nil?
+      str
+    else
+      str.gsub(Regexp.compile("^ {#{ld - 1}}"), '')
+    end
+  end
+
+  context 'when representing a literal as a string' do
+    {
+      'true' => true,
+      'false' => false,
+      '?' => nil,
+      '23.4' => 23.4,
+      '145' => 145,
+      "'string'" => 'string',
+      '/expr/' => /expr/,
+      '[1, 2, 3]' => [1, 2, 3],
+      "{'a' => 32, 'b' => [1, 2, 3]}" => {'a' => 32,'b' => [1, 2, 3]}
+    }.each_pair do |str, value|
+      it "should yield '#{str}' for a value of #{str}" do
+        expect(s.string(value)).to eq(str)
+      end
+    end
+  end
+
+  context 'when using indent' do
+    it 'should put hash entries on new indented lines' do
+      expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]})).to eq(<<-FORMATTED)
+{
+  'a' => 32,
+  'b' => [1, 2, {
+    'c' => 'd'
+  }]
+}
+FORMATTED
+    end
+
+    it 'should start on given indent level' do
+      expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]}, 3)).to eq(<<-FORMATTED)
+      {
+        'a' => 32,
+        'b' => [1, 2, {
+          'c' => 'd'
+        }]
+      }
+FORMATTED
+    end
+
+    it 'should use given indent width' do
+      expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]}, 2, 4)).to eq(<<-FORMATTED)
+        {
+            'a' => 32,
+            'b' => [1, 2, {
+                'c' => 'd'
+            }]
+        }
+    FORMATTED
+  end
+end
+
+  context 'when representing the type as string' do
+    include_context 'types_setup'
+
+    it "should yield 'Type' for PType" do
+      expect(s.string(f.type_type)).to eq('Type')
+    end
+
+    it "should yield 'Any' for PAnyType" do
+      expect(s.string(f.any)).to eq('Any')
+    end
+
+    it "should yield 'Scalar' for PScalarType" do
+      expect(s.string(f.scalar)).to eq('Scalar')
+    end
+
+    it "should yield 'Boolean' for PBooleanType" do
+      expect(s.string(f.boolean)).to eq('Boolean')
+    end
+
+    it "should yield 'Data' for PDataType" do
+      expect(s.string(f.data)).to eq('Data')
+    end
+
+    it "should yield 'Numeric' for PNumericType" do
+      expect(s.string(f.numeric)).to eq('Numeric')
+    end
+
+    it "should yield 'Integer' and from/to for PIntegerType" do
+      expect(s.string(f.integer)).to eq('Integer')
+      expect(s.string(f.range(1,1))).to eq('Integer[1, 1]')
+      expect(s.string(f.range(1,2))).to eq('Integer[1, 2]')
+      expect(s.string(f.range(:default, 2))).to eq('Integer[default, 2]')
+      expect(s.string(f.range(2, :default))).to eq('Integer[2, default]')
+    end
+
+    it "should yield 'Float' for PFloatType" do
+      expect(s.string(f.float)).to eq('Float')
+    end
+
+    it "should yield 'Regexp' for PRegexpType" do
+      expect(s.string(f.regexp)).to eq('Regexp')
+    end
+
+    it "should yield 'Regexp[/pat/]' for parameterized PRegexpType" do
+      expect(s.string(f.regexp('a/b'))).to eq('Regexp[/a\/b/]')
+    end
+
+    it "should yield 'String' for PStringType" do
+      expect(s.string(f.string)).to eq('String')
+    end
+
+    it "should yield 'String' for PStringType with value" do
+      expect(s.string(f.string('a'))).to eq('String')
+    end
+
+    it "should yield 'String['a']' for PStringType with value if printed with debug_string" do
+      expect(s.debug_string(f.string('a'))).to eq("String['a']")
+    end
+
+    it "should yield 'String' and from/to for PStringType" do
+      expect(s.string(f.string(f.range(1,1)))).to eq('String[1, 1]')
+      expect(s.string(f.string(f.range(1,2)))).to eq('String[1, 2]')
+      expect(s.string(f.string(f.range(:default, 2)))).to eq('String[default, 2]')
+      expect(s.string(f.string(f.range(2, :default)))).to eq('String[2, default]')
+    end
+
+    it "should yield 'Array[Integer]' for PArrayType[PIntegerType]" do
+      expect(s.string(f.array_of(f.integer))).to eq('Array[Integer]')
+    end
+
+    it "should yield 'Array' for PArrayType::DATA" do
+      expect(s.string(f.array_of_data)).to eq('Array')
+    end
+
+    it "should yield 'Array[0, 0]' for an empty array" do
+      t = f.array_of(PUnitType::DEFAULT, f.range(0,0))
+      expect(s.string(t)).to eq('Array[0, 0]')
+    end
+
+    it "should yield 'Hash[0, 0]' for an empty hash" do
+      t = f.hash_of(PUnitType::DEFAULT, PUnitType::DEFAULT, f.range(0,0))
+      expect(s.string(t)).to eq('Hash[0, 0]')
+    end
+
+    it "should yield 'Collection' and from/to for PCollectionType" do
+      expect(s.string(f.collection(f.range(1,1)))).to eq('Collection[1, 1]')
+      expect(s.string(f.collection(f.range(1,2)))).to eq('Collection[1, 2]')
+      expect(s.string(f.collection(f.range(:default, 2)))).to eq('Collection[default, 2]')
+      expect(s.string(f.collection(f.range(2, :default)))).to eq('Collection[2, default]')
+    end
+
+    it "should yield 'Array' and from/to for PArrayType" do
+      expect(s.string(f.array_of(f.string, f.range(1,1)))).to eq('Array[String, 1, 1]')
+      expect(s.string(f.array_of(f.string, f.range(1,2)))).to eq('Array[String, 1, 2]')
+      expect(s.string(f.array_of(f.string, f.range(:default, 2)))).to eq('Array[String, default, 2]')
+      expect(s.string(f.array_of(f.string, f.range(2, :default)))).to eq('Array[String, 2, default]')
+    end
+
+    it "should yield 'Iterable' for PIterableType" do
+      expect(s.string(f.iterable)).to eq('Iterable')
+    end
+
+    it "should yield 'Iterable[Integer]' for PIterableType[PIntegerType]" do
+      expect(s.string(f.iterable(f.integer))).to eq('Iterable[Integer]')
+    end
+
+    it "should yield 'Iterator' for PIteratorType" do
+      expect(s.string(f.iterator)).to eq('Iterator')
+    end
+
+    it "should yield 'Iterator[Integer]' for PIteratorType[PIntegerType]" do
+      expect(s.string(f.iterator(f.integer))).to eq('Iterator[Integer]')
+    end
+
+    it "should yield 'Timespan' for PTimespanType" do
+      expect(s.string(f.timespan())).to eq('Timespan')
+    end
+
+    it "should yield 'Timespan[{hours => 1}] for PTimespanType[Timespan]" do
+      expect(s.string(f.timespan({'hours' => 1}))).to eq("Timespan['0-01:00:00.0']")
+    end
+
+    it "should yield 'Timespan[default, {hours => 2}] for PTimespanType[nil, Timespan]" do
+      expect(s.string(f.timespan(nil, {'hours' => 2}))).to eq("Timespan[default, '0-02:00:00.0']")
+    end
+
+    it "should yield 'Timespan[{hours => 1}, {hours => 2}] for PTimespanType[Timespan, Timespan]" do
+      expect(s.string(f.timespan({'hours' => 1}, {'hours' => 2}))).to eq("Timespan['0-01:00:00.0', '0-02:00:00.0']")
+    end
+
+    it "should yield 'Timestamp' for PTimestampType" do
+      expect(s.string(f.timestamp())).to eq('Timestamp')
+    end
+
+    it "should yield 'Timestamp['2016-09-05T13:00:00.000 UTC'] for PTimestampType[Timestamp]" do
+      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp['2016-09-05T13:00:00.000 UTC']")
+    end
+
+    it "should yield 'Timestamp[default, '2016-09-05T13:00:00.000 UTC'] for PTimestampType[nil, Timestamp]" do
+      expect(s.string(f.timestamp(nil, '2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp[default, '2016-09-05T13:00:00.000 UTC']")
+    end
+
+    it "should yield 'Timestamp['2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC'] for PTimestampType[Timestamp, Timestamp]" do
+      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC'))).to eq("Timestamp['2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC']")
+    end
+
+    it "should yield 'Tuple[Integer]' for PTupleType[PIntegerType]" do
+      expect(s.string(f.tuple([f.integer]))).to eq('Tuple[Integer]')
+    end
+
+    it "should yield 'Tuple[T, T,..]' for PTupleType[T, T, ...]" do
+      expect(s.string(f.tuple([f.integer, f.integer, f.string]))).to eq('Tuple[Integer, Integer, String]')
+    end
+
+    it "should yield 'Tuple' and from/to for PTupleType" do
+      types = [f.string]
+      expect(s.string(f.tuple(types, f.range(1,1)))).to eq('Tuple[String, 1, 1]')
+      expect(s.string(f.tuple(types, f.range(1,2)))).to eq('Tuple[String, 1, 2]')
+      expect(s.string(f.tuple(types, f.range(:default, 2)))).to eq('Tuple[String, 0, 2]')
+      expect(s.string(f.tuple(types, f.range(2, :default)))).to eq('Tuple[String, 2, default]')
+    end
+
+    it "should yield 'Struct' and details for PStructType" do
+      struct_t = f.struct({'a'=>Integer, 'b'=>String})
+      expect(s.string(struct_t)).to eq("Struct[{'a' => Integer, 'b' => String}]")
+      struct_t = f.struct({})
+      expect(s.string(struct_t)).to eq('Struct')
+    end
+
+    it "should yield 'Hash[String, Integer]' for PHashType[PStringType, PIntegerType]" do
+      expect(s.string(f.hash_of(f.integer, f.string))).to eq('Hash[String, Integer]')
+    end
+
+    it "should yield 'Hash' and from/to for PHashType" do
+      expect(s.string(f.hash_of(f.string, f.string, f.range(1,1)))).to eq('Hash[String, String, 1, 1]')
+      expect(s.string(f.hash_of(f.string, f.string, f.range(1,2)))).to eq('Hash[String, String, 1, 2]')
+      expect(s.string(f.hash_of(f.string, f.string, f.range(:default, 2)))).to eq('Hash[String, String, default, 2]')
+      expect(s.string(f.hash_of(f.string, f.string, f.range(2, :default)))).to eq('Hash[String, String, 2, default]')
+    end
+
+    it "should yield 'Hash' for PHashType::DATA" do
+      expect(s.string(f.hash_of_data)).to eq('Hash')
+    end
+
+    it "should yield 'Class' for a PHostClassType" do
+      expect(s.string(f.host_class)).to eq('Class')
+    end
+
+    it "should yield 'Class[x]' for a PHostClassType[x]" do
+      expect(s.string(f.host_class('x'))).to eq('Class[x]')
+    end
+
+    it "should yield 'Resource' for a PResourceType" do
+      expect(s.string(f.resource)).to eq('Resource')
+    end
+
+    it "should yield 'File' for a PResourceType['File']" do
+      expect(s.string(f.resource('File'))).to eq('File')
+    end
+
+    it "should yield 'File['/tmp/foo']' for a PResourceType['File', '/tmp/foo']" do
+      expect(s.string(f.resource('File', '/tmp/foo'))).to eq("File['/tmp/foo']")
+    end
+
+    it "should yield 'Enum[s,...]' for a PEnumType[s,...]" do
+      t = f.enum('a', 'b', 'c')
+      expect(s.string(t)).to eq("Enum['a', 'b', 'c']")
+    end
+
+    it "should yield 'Pattern[/pat/,...]' for a PPatternType['pat',...]" do
+      t = f.pattern('a')
+      t2 = f.pattern('a', 'b', 'c')
+      expect(s.string(t)).to eq('Pattern[/a/]')
+      expect(s.string(t2)).to eq('Pattern[/a/, /b/, /c/]')
+    end
+
+    it "should escape special characters in the string for a PPatternType['pat',...]" do
+      t = f.pattern('a/b')
+      expect(s.string(t)).to eq("Pattern[/a\\/b/]")
+    end
+
+    it "should yield 'Variant[t1,t2,...]' for a PVariantType[t1, t2,...]" do
+      t1 = f.string
+      t2 = f.integer
+      t3 = f.pattern('a')
+      t = f.variant(t1, t2, t3)
+      expect(s.string(t)).to eq('Variant[String, Integer, Pattern[/a/]]')
+    end
+
+    it "should yield 'Callable' for generic callable" do
+      expect(s.string(f.all_callables)).to eql('Callable')
+    end
+
+    it "should yield 'Callable[0,0]' for callable without params" do
+      expect(s.string(f.callable)).to eql('Callable[0, 0]')
+    end
+
+    it "should yield 'Callable[[0,0],rt]' for callable without params but with return type" do
+      expect(s.string(f.callable([], Float))).to eql('Callable[[0, 0], Float]')
+    end
+
+    it "should yield 'Callable[t,t]' for callable with typed parameters" do
+      expect(s.string(f.callable(String, Integer))).to eql('Callable[String, Integer]')
+    end
+
+    it "should yield 'Callable[[t,t],rt]' for callable with typed parameters and return type" do
+      expect(s.string(f.callable([String, Integer], Float))).to eql('Callable[[String, Integer], Float]')
+    end
+
+    it "should yield 'Callable[t,min,max]' for callable with size constraint (infinite max)" do
+      expect(s.string(f.callable(String, 0))).to eql('Callable[String, 0, default]')
+    end
+
+    it "should yield 'Callable[t,min,max]' for callable with size constraint (capped max)" do
+      expect(s.string(f.callable(String, 0, 3))).to eql('Callable[String, 0, 3]')
+    end
+
+    it "should yield 'Callable[min,max]' callable with size > 0" do
+      expect(s.string(f.callable(0, 0))).to eql('Callable[0, 0]')
+      expect(s.string(f.callable(0, 1))).to eql('Callable[0, 1]')
+      expect(s.string(f.callable(0, :default))).to eql('Callable[0, default]')
+    end
+
+    it "should yield 'Callable[Callable]' for callable with block" do
+      expect(s.string(f.callable(f.all_callables))).to eql('Callable[0, 0, Callable]')
+      expect(s.string(f.callable(f.string, f.all_callables))).to eql('Callable[String, Callable]')
+      expect(s.string(f.callable(f.string, 1,1, f.all_callables))).to eql('Callable[String, 1, 1, Callable]')
+    end
+
+    it 'should yield Unit for a Unit type' do
+      expect(s.string(PUnitType::DEFAULT)).to eql('Unit')
+    end
+
+    it "should yield 'NotUndef' for a PNotUndefType" do
+      t = f.not_undef
+      expect(s.string(t)).to eq('NotUndef')
+    end
+
+    it "should yield 'NotUndef[T]' for a PNotUndefType[T]" do
+      t = f.not_undef(f.data)
+      expect(s.string(t)).to eq('NotUndef[Data]')
+    end
+
+    it "should yield 'NotUndef['string']' for a PNotUndefType['string']" do
+      t = f.not_undef('hey')
+      expect(s.string(t)).to eq("NotUndef['hey']")
+    end
+
+    it "should yield the name of an unparameterized type reference" do
+      t = f.type_reference('What')
+      expect(s.string(t)).to eq("TypeReference['What']")
+    end
+
+    it "should yield the name and arguments of an parameterized type reference" do
+      t = f.type_reference('What[Undef, String]')
+      expect(s.string(t)).to eq("TypeReference['What[Undef, String]']")
+    end
+
+    it "should yield the name of a type alias" do
+      t = f.type_alias('Alias', 'Integer')
+      expect(s.string(t)).to eq('Alias')
+    end
+
+    it "should yield 'Type[Runtime[ruby, Puppet]]' for the Puppet module" do
+      expect(s.string(Puppet)).to eq("Runtime[ruby, 'Puppet']")
+    end
+
+    it "should yield 'Type[Runtime[ruby, Puppet::Pops]]' for the Puppet::Resource class" do
+      expect(s.string(Puppet::Resource)).to eq("Runtime[ruby, 'Puppet::Resource']")
+    end
+
+    it "should yield \"SemVer['1.x', '3.x']\" for the PSemVerType['1.x', '3.x']" do
+      expect(s.string(PSemVerType.new(['1.x', '3.x']))).to eq("SemVer['1.x', '3.x']")
+    end
+
+    it 'should present a valid simple name' do
+      (all_types - [PType, PHostClassType]).each do |t|
+        name = t::DEFAULT.simple_name
+        expect(t.name).to match("^Puppet::Pops::Types::P#{name}Type$")
+      end
+      expect(PType::DEFAULT.simple_name).to eql('Type')
+      expect(PHostClassType::DEFAULT.simple_name).to eql('Class')
+    end
+  end
+end
+end

data/spec/unit/pops/types/type_mismatch_describer_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Types
+
+describe 'the type mismatch describer' do
+  include PuppetSpec::Compiler
+
+  it 'will report a mismatch between a hash and a struct with details' do
+    code = <<-CODE
+      function f(Hash[String,String] $h) {
+         $h['a']
+      }
+      f({'a' => 'a', 'b' => 23})
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /'f' parameter 'h' entry 'b' expects a String value, got Integer/)
+  end
+
+  it 'will report a mismatch between a array and tuple with details' do
+    code = <<-CODE
+      function f(Array[String] $h) {
+         $h[0]
+      }
+      f(['a', 23])
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /'f' parameter 'h' index 1 expects a String value, got Integer/)
+  end
+
+  it 'will not report details for a mismatch between an array and a struct' do
+    code = <<-CODE
+      function f(Array[String] $h) {
+         $h[0]
+      }
+      f({'a' => 'a string', 'b' => 23})
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expects an Array value, got Struct/)
+  end
+
+  it 'will not report details for a mismatch between a hash and a tuple' do
+    code = <<-CODE
+      function f(Hash[String,String] $h) {
+         $h['a']
+      }
+      f(['a', 23])
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expects a Hash value, got Tuple/)
+  end
+
+  it 'will report an array size mismatch' do
+    code = <<-CODE
+      function f(Array[String,1,default] $h) {
+        $h[0]
+      }
+      f([])
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expects size to be at least 1, got 0/)
+  end
+
+  it 'will report a hash size mismatch' do
+    code = <<-CODE
+      function f(Hash[String,String,1,default] $h) {
+         $h['a']
+      }
+      f({})
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expects size to be at least 1, got 0/)
+  end
+
+  it 'will include the aliased type when reporting a mismatch that involves an alias' do
+    code = <<-CODE
+      type UnprivilegedPort = Integer[1024,65537]
+
+      function check_port(UnprivilegedPort $port) {}
+      check_port(34)
+    CODE
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /parameter 'port' expects an UnprivilegedPort = Integer\[1024, 65537\] value, got Integer\[34, 34\]/)
+  end
+
+  it 'will include the aliased type when reporting a mismatch that involves an alias nested in another type' do
+    code = <<-CODE
+      type UnprivilegedPort = Integer[1024,65537]
+      type PortMap = Hash[UnprivilegedPort,String]
+
+      function check_port(PortMap $ports) {}
+      check_port({ 34 => 'some service'})
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'ports' expects a PortMap = Hash\[UnprivilegedPort = Integer\[1024, 65537\], String\] value, got Hash\[Integer\[34, 34\], String\]/))
+  end
+
+  it 'will not include the aliased type more than once when reporting a mismatch that involves an alias that is self recursive' do
+    code = <<-CODE
+      type Tree = Hash[String,Tree]
+
+      function check_tree(Tree $tree) {}
+      check_tree({ 'x' => {'y' => {32 => 'n'}}})
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'tree' entry 'x' entry 'y' expects a Tree = Hash\[String, Tree\] value, got Hash\[Integer\[32, 32\], String\]/))
+  end
+
+  it 'will use type normalization' do
+    code = <<-CODE
+      type EVariants = Variant[Enum[a,b],Enum[b,c],Enum[c,d]]
+
+      function check_enums(EVariants $evars) {}
+      check_enums('n')
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+       /parameter 'evars' expects a match for EVariants = Enum\['a', 'b', 'c', 'd'\], got 'n'/))
+  end
+
+  it "will not generalize a string that doesn't match an enum in a function call" do
+    code = <<-CODE
+      function check_enums(Enum[a,b] $arg) {}
+      check_enums('c')
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got 'c'/))
+  end
+
+  it "will not disclose a Sensitive that doesn't match an enum in a function call" do
+    code = <<-CODE
+      function check_enums(Enum[a,b] $arg) {}
+      check_enums(Sensitive('c'))
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got Sensitive/))
+  end
+
+  it "reports errors on the first failing parameter when that parameter is not the first in order" do
+    code = <<-CODE
+      type Abc = Enum['a', 'b', 'c']
+      type Cde = Enum['c', 'd', 'e']
+      function two_params(Abc $a, Cde $b) {}
+      two_params('a', 'x')
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'b' expects a match for Cde = Enum\['c', 'd', 'e'\], got 'x'/))
+  end
+
+  it "will not generalize a string that doesn't match an enum in a define call" do
+    code = <<-CODE
+      define check_enums(Enum[a,b] $arg) {}
+      check_enums { x: arg => 'c' }
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got 'c'/))
+  end
+
+  it "will not disclose a Sensitive that doesn't match an enum in a define call" do
+    code = <<-CODE
+      define check_enums(Enum[a,b] $arg) {}
+      check_enums { x: arg => Sensitive('c') }
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got Sensitive/))
+  end
+
+  context 'when reporting a mismatch between' do
+    let(:parser) { TypeParser.singleton }
+    let(:subject) { TypeMismatchDescriber.singleton }
+
+    context 'hash and struct' do
+      it 'reports a size mismatch when hash has unlimited size' do
+        expected = parser.parse('Struct[{a=>Integer,b=>Integer}]')
+        actual = parser.parse('Hash[String,Integer]')
+        expect(subject.describe_mismatch('', expected, actual)).to eq('expects size to be 2, got unlimited')
+      end
+
+      it 'reports a size mismatch when hash has specified but incorrect size' do
+        expected = parser.parse('Struct[{a=>Integer,b=>Integer}]')
+        actual = parser.parse('Hash[String,Integer,1,1]')
+        expect(subject.describe_mismatch('', expected, actual)).to eq('expects size to be 2, got 1')
+      end
+
+      it 'reports a full type mismatch when size is correct but hash value type is incorrect' do
+        expected = parser.parse('Struct[{a=>Integer,b=>String}]')
+        actual = parser.parse('Hash[String,Integer,2,2]')
+        expect(subject.describe_mismatch('', expected, actual)).to eq("expects a Struct[{'a' => Integer, 'b' => String}] value, got Hash[String, Integer]")
+      end
+    end
+
+    it 'reports a missing parameter as "has no parameter"' do
+      t = parser.parse('Struct[{a=>String}]')
+      expect { subject.validate_parameters('v', t, {'a'=>'a','b'=>'b'}, false) }.to raise_error(Puppet::Error, "v: has no parameter named 'b'")
+    end
+
+    it 'reports a missing value as "expects a value"' do
+      t = parser.parse('Struct[{a=>String,b=>String}]')
+      expect { subject.validate_parameters('v', t, {'a'=>'a'}, false) }.to raise_error(Puppet::Error, "v: expects a value for parameter 'b'")
+    end
+
+    it 'reports a missing block as "expects a block"' do
+      callable = parser.parse('Callable[String,String,Callable]')
+      args_tuple = parser.parse('Tuple[String,String]')
+      dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], 'block', nil, nil, false)
+      expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' expects a block")
+    end
+
+    it 'reports an unexpected block as "does not expect a block"' do
+      callable = parser.parse('Callable[String,String]')
+      args_tuple = parser.parse('Tuple[String,String,Callable]')
+      dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], nil, nil, nil, false)
+      expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' does not expect a block")
+    end
+
+    it 'reports a block return type mismatch' do
+      callable = parser.parse('Callable[[0,0,Callable[ [0,0],String]],Undef]')
+      args_tuple = parser.parse('Tuple[Callable[[0,0],Integer]]')
+      dispatch = Functions::Dispatch.new(callable, 'foo', [], 'block', nil, nil, false)
+      expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' block return expects a String value, got Integer")
+    end
+  end
+end
+end
+end