puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

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

@@ -0,0 +1,280 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops::Types
+describe 'The type formatter' do
+  let(:s) { TypeFormatter.new }
+  let(:f) { TypeFactory }
+
+  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 'Object' 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 multiple values" do
+      expect(s.string(f.string(nil, 'a', 'b', 'c'))).to eq('String')
+    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[Unit, 0, 0]' for an empty array" do
+      t = f.array_of(PUnitType::DEFAULT, f.range(0,0))
+      expect(s.string(t)).to eq('Array[Unit, 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 '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[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,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('What')
+    end
+
+    it "should yield the name and arguments of an parameterized type reference" do
+      t = f.type_reference('What', [f.undef, f.string])
+      expect(s.string(t)).to eq('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 present a valid simple name' do
+      (all_types - [PType]).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')
+    end
+  end
+end
+end

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

@@ -0,0 +1,152 @@
+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, /expects a Hash\[String, String\] value, got Struct\[\{'a' => String, 'b' => 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, /expects an Array\[String\] value, got Tuple\[String, 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 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\[12, 12\]\]/))
+  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' expects a Tree = Hash\[String, Tree\] value, got Struct\[\{'x' => Struct\[\{'y' => Hash\[Integer, 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
+
+  context 'when using present tense' do
+    let(:parser) { TypeParser.new }
+    let(:subject) { TypeMismatchDescriber.singleton }
+    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, :present) }.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, :present) }.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, :present)).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, :present)).to eq("'function' does not expect a block")
+    end
+  end
+
+  context 'when using past tense' do
+    let(:parser) { TypeParser.new }
+    let(:subject) { TypeMismatchDescriber.singleton }
+    it 'reports a missing parameter as "did not have a parameter"' do
+      t = parser.parse('Struct[{a=>String}]')
+      expect { subject.validate_parameters('v', t, {'a'=>'a','b'=>'b'}, false, :past) }.to raise_error(Puppet::Error, "v: did not have a parameter named 'b'")
+    end
+
+    it 'reports a missing value as "expected a value"' do
+      t = parser.parse('Struct[{a=>String,b=>String}]')
+      expect { subject.validate_parameters('v', t, {'a'=>'a'}, false, :past) }.to raise_error(Puppet::Error, "v: expected a value for parameter 'b'")
+    end
+
+    it 'reports a missing block as "expected 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, :past)).to eq("'function' expected a block")
+    end
+
+    it 'reports an unexpected block as "did 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, :past)).to eq("'function' did not expect a block")
+    end
+  end
+end
+end
+end

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

@@ -6,8 +6,6 @@ describe Puppet::Pops::Types::TypeParser do
 
   let(:parser) { Puppet::Pops::Types::TypeParser.new }
   let(:types)  { Puppet::Pops::Types::TypeFactory }
-
-
   it "rejects a puppet expression" do
     expect { parser.parse("1 + 1") }.to raise_error(Puppet::ParseError, /The expression <1 \+ 1> is not a valid type specification/)
   end
@@ -135,20 +133,64 @@ describe Puppet::Pops::Types::TypeParser do
     expect { parser.parse("Hash[Integer, Integer, 1,2,3]") }.to raise_the_parameter_error("Hash", "2 to 4", 5)
   end
 
-  it "interprets anything that is not a built in type to be a resource type" do
-    expect(parser.parse("File")).to be_the_type(types.resource('file'))
-  end
+  context 'with scope context and loader' do
+    let!(:scope) { {} }
+
+    before :each do
+      loader = mock
+      loader.stubs(:load).returns nil
+      Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).with(instance_of(Puppet::Pops::Model::QualifiedReference), scope).at_most_once.returns loader
+    end
+
+    it "interprets anything that is not a built in type to be a resource type" do
+      expect(parser.parse('File', scope)).to be_the_type(types.resource('file'))
+    end
 
-  it "parses a resource type with title" do
-    expect(parser.parse("File['/tmp/foo']")).to be_the_type(types.resource('file', '/tmp/foo'))
+    it "parses a resource type with title" do
+      expect(parser.parse("File['/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
+    end
+
+    it "parses a resource type using 'Resource[type]' form" do
+      expect(parser.parse("Resource[File]", scope)).to be_the_type(types.resource('file'))
+    end
+
+    it "parses a resource type with title using 'Resource[type, title]'" do
+      expect(parser.parse("Resource[File, '/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
+    end
   end
 
-  it "parses a resource type using 'Resource[type]' form" do
-    expect(parser.parse("Resource[File]")).to be_the_type(types.resource('file'))
+  context 'with loader context' do
+    let(:loader) { Puppet::Pops::Loader::BaseLoader.new(nil, "type_parser_unit_test_loader") }
+    before :each do
+      loader.stubs(:load).returns nil
+      Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).never
+    end
+
+    it "interprets anything that is not a built in type to be a resource type" do
+      expect(parser.parse('File', loader)).to be_the_type(types.resource('file'))
+    end
+
+    it "parses a resource type with title" do
+      expect(parser.parse("File['/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
+    end
+
+    it "parses a resource type using 'Resource[type]' form" do
+      expect(parser.parse("Resource[File]", loader)).to be_the_type(types.resource('file'))
+    end
+
+    it "parses a resource type with title using 'Resource[type, title]'" do
+      expect(parser.parse("Resource[File, '/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
+    end
   end
 
-  it "parses a resource type with title using 'Resource[type, title]'" do
-    expect(parser.parse("Resource[File, '/tmp/foo']")).to be_the_type(types.resource('file', '/tmp/foo'))
+  context 'without a scope' do
+    it "interprets anything that is not a built in type to be a type reference" do
+      expect(parser.parse('File')).to eq(types.type_reference('File'))
+    end
+
+    it "interprets anything that is not a built in type with parameterers to be type reference with parameters" do
+      expect(parser.parse("File['/tmp/foo']")).to eq(types.type_reference('File', ['/tmp/foo']))
+    end
   end
 
   it "parses a host class type" do
@@ -163,6 +205,10 @@ describe Puppet::Pops::Types::TypeParser do
    expect(parser.parse("Integer[1,2]")).to be_the_type(types.range(1,2))
   end
 
+  it 'parses a negative integer range' do
+    expect(parser.parse("Integer[-3,-1]")).to be_the_type(types.range(-3,-1))
+  end
+
   it 'parses a float range' do
    expect(parser.parse("Float[1.0,2.0]")).to be_the_type(types.float_range(1.0,2.0))
   end
@@ -237,7 +283,6 @@ describe Puppet::Pops::Types::TypeParser do
   end
 
   def the_type_spec_for(type)
-    calc = Puppet::Pops::Types::TypeCalculator.new
-    calc.string(type)
+    Puppet::Pops::Types::TypeFormatter.string(type)
   end
 end