puppet 4.4.1 → 4.4.2

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

@@ -8,19 +8,19 @@ describe 'the type asserter' do
   context 'when deferring formatting of subject'
   it 'can use an array' do
     expect{ asserter.assert_instance_of(['The %s in the %s', 'gizmo', 'gadget'], PIntegerType::DEFAULT, 'lens') }.to(
-    raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expected an Integer value, got String'))
+    raise_error(TypeAssertionError, 'The gizmo in the gadget had wrong type, expected an Integer value, got String'))
   end
 
   it 'can use an array obtained from block' do
     expect do
       asserter.assert_instance_of('gizmo', PIntegerType::DEFAULT, 'lens') { |s| ['The %s in the %s', s, 'gadget'] }
-    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expected an Integer value, got String'))
+    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget had wrong type, expected an Integer value, got String'))
   end
 
   it 'can use an subject obtained from zero argument block' do
     expect do
       asserter.assert_instance_of(nil, PIntegerType::DEFAULT, 'lens') { 'The gizmo in the gadget' }
-    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expected an Integer value, got String'))
+    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget had wrong type, expected an Integer value, got String'))
   end
 
   it 'does not produce a string unless the assertion fails' do

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

@@ -833,6 +833,12 @@ describe 'The type calculator' do
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2::DEFAULT) }
       end
 
+      it 'A tuple with parameters is assignable to the default Tuple' do
+        t = Puppet::Pops::Types::PTupleType::DEFAULT
+        t2 = Puppet::Pops::Types::PTupleType.new([Puppet::Pops::Types::PStringType::DEFAULT])
+        expect(t2).to be_assignable_to(t)
+      end
+
       it 'Tuple is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
@@ -894,6 +900,18 @@ describe 'The type calculator' do
         t2 = struct_t({not_undef_t('other_member') => string_t})
         expect(t2).not_to be_assignable_to(t1)
       end
+
+      it 'A hash of string is not assignable to struct with integer value' do
+        t1 = struct_t({'foo' => integer_t, 'bar' => string_t})
+        t2 = hash_t(string_t, string_t, range_t(2, 2))
+        expect(t1.assignable?(t2)).to eql(false)
+      end
+
+      it 'A hash of with integer key is not assignable to struct with string key' do
+        t1 = struct_t({'foo' => string_t, 'bar' => string_t})
+        t2 = hash_t(integer_t, string_t, range_t(2, 2))
+        expect(t1.assignable?(t2)).to eql(false)
+      end
     end
 
     context 'for Callable, such that' do
@@ -906,6 +924,14 @@ describe 'The type calculator' do
           Puppet::Pops::Types::PNotUndefType]
         tested_types.each {|t2| expect(t).to_not be_assignable_to(t2::DEFAULT) }
       end
+
+      it 'a callable with parameter is assignable to the default callable' do
+        expect(callable_t(string_t)).to be_assignable_to(Puppet::Pops::Types::PCallableType::DEFAULT)
+      end
+
+      it 'the default callable is not assignable to a callable with parameter' do
+        expect(Puppet::Pops::Types::PCallableType::DEFAULT).not_to be_assignable_to(callable_t(string_t))
+      end
     end
 
     it 'should recognize mapped ruby types' do
@@ -1091,11 +1117,11 @@ describe 'The type calculator' do
       end
 
       it 'accepts an empty tuple as assignable to a tuple with a min size of 0' do
-        tuple1 = constrained_tuple_t(range_t(0, :default), Object)
-        tuple2 = tuple_t
+        tuple1 = constrained_tuple_t(range_t(0, :default))
+        tuple2 = tuple_t()
 
         expect(calculator.assignable?(tuple1, tuple2)).to eq(true)
-        expect(calculator.assignable?(tuple2, tuple1)).to eq(false)
+        expect(calculator.assignable?(tuple2, tuple1)).to eq(true)
       end
 
       it 'should accept matching tuples' do
@@ -1157,7 +1183,7 @@ describe 'The type calculator' do
 
       it 'should accept empty array when tuple allows min of 0' do
         tuple1 = constrained_tuple_t(range_t(0, 1), Integer)
-        array = array_t(Integer, range_t(0, 0))
+        array = array_t(unit_t, range_t(0, 0))
         expect(calculator.assignable?(tuple1, array)).to eq(true)
         expect(calculator.assignable?(array, tuple1)).to eq(false)
       end
@@ -1210,9 +1236,9 @@ describe 'The type calculator' do
         expect(calculator.assignable?(hsh, struct1)).to eq(true)
       end
 
-      it 'should accept empty hash with key_type undef' do
+      it 'should accept empty hash with key_type unit' do
         struct1 = struct_t({'a'=>optional_t(Integer)})
-        hsh = hash_t(undef_t, undef_t, range_t(0, 0))
+        hsh = hash_t(unit_t, unit_t, range_t(0, 0))
         expect(calculator.assignable?(struct1, hsh)).to eq(true)
       end
     end

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

@@ -175,6 +175,32 @@ describe 'The type factory' do
       expect(t.size_type.to).to eq(2)
     end
 
+    it 'it is illegal to create a typed empty array' do
+      expect {
+        Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::TypeFactory.data, Puppet::Pops::Types::TypeFactory.range(0,0))
+      }.to raise_error(/An empty collection may not specify an element type/)
+    end
+
+    it 'it is legal to create an empty array of unit element type' do
+      t = Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::PUnitType::DEFAULT, Puppet::Pops::Types::TypeFactory.range(0,0))
+      expect(t.size_type.class).to eq(Puppet::Pops::Types::PIntegerType)
+      expect(t.size_type.from).to eq(0)
+      expect(t.size_type.to).to eq(0)
+    end
+
+    it 'it is illegal to create a typed empty hash' do
+      expect {
+        Puppet::Pops::Types::TypeFactory.hash_of(Puppet::Pops::Types::TypeFactory.scalar, Puppet::Pops::Types::TypeFactory.data, Puppet::Pops::Types::TypeFactory.range(0,0))
+      }.to raise_error(/An empty collection may not specify an element type/)
+    end
+
+    it 'it is legal to create an empty hash where key and value types are of Unit type' do
+      t = Puppet::Pops::Types::TypeFactory.hash_of(Puppet::Pops::Types::PUnitType::DEFAULT, Puppet::Pops::Types::PUnitType::DEFAULT, Puppet::Pops::Types::TypeFactory.range(0,0))
+      expect(t.size_type.class).to eq(Puppet::Pops::Types::PIntegerType)
+      expect(t.size_type.from).to eq(0)
+      expect(t.size_type.to).to eq(0)
+    end
+
     context 'callable types' do
       it 'the callable methods produces a Callable' do
         t = Puppet::Pops::Types::TypeFactory.callable()

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

@@ -76,9 +76,14 @@ describe 'The type formatter' do
       expect(s.string(f.array_of_data)).to eq('Array')
     end
 
-    it "should yield 'Array[Unit, 0, 0]' for an empty array" do
+    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[Unit, 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

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

@@ -92,6 +92,31 @@ describe 'the type mismatch describer' do
        /parameter 'evars' expects a match for EVariants = Enum\['a', 'b', 'c', 'd'\], got 'n'/))
   end
 
+  context 'when reporting a mismatch between' do
+    let(:parser) { TypeParser.new }
+    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('expected 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('expected 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("expected a Struct[{'a' => Integer, 'b' => String}] value, got Hash[String, Integer]")
+      end
+    end
+  end
+
   context 'when using present tense' do
     let(:parser) { TypeParser.new }
     let(:subject) { TypeMismatchDescriber.singleton }

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

@@ -243,7 +243,7 @@ describe Puppet::Pops::Types::TypeParser do
 
   it 'parses a parameterized callable type with 0 min/max' do
     t = parser.parse("Callable[0,0]")
-    expect(t).to be_the_type(types.callable())
+    expect(t).to be_the_type(types.callable(0,0))
     expect(t.param_types.types).to be_empty
   end
 

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

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'puppet/pops'
+require 'puppet_spec/compiler'
 
 module Puppet::Pops
 module Types
@@ -150,6 +151,92 @@ describe 'Puppet Type System' do
     end
   end
 
+  context 'Iterable type' do
+    include PuppetSpec::Compiler
+
+    it 'can be parameterized with element type' do
+      code = <<-CODE
+      function foo(Iterable[String] $x) {
+        $x.each |$e| {
+          notice $e
+        }
+      }
+      foo([bar, baz, cake])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['bar', 'baz', 'cake'])
+    end
+  end
+
+  context 'Iterator type' do
+    include PuppetSpec::Compiler
+
+    let!(:iterint) { tf.iterator(tf.integer) }
+
+    context 'when testing instance?' do
+      it 'will consider an iterable on an integer is an instance of Iterator[Integer]' do
+        expect(iterint.instance?(Iterable.on(3))).to be_truthy
+      end
+
+      it 'will consider an iterable on string to be an instance of Iterator[Integer]' do
+        expect(iterint.instance?(Iterable.on('string'))).to be_falsey
+      end
+    end
+
+    context 'when testing assignable?' do
+      it 'will consider an iterator with an assignable type as assignable' do
+        expect(tf.iterator(tf.numeric).assignable?(iterint)).to be_truthy
+      end
+
+      it 'will not consider an iterator with a non assignable type as assignable' do
+        expect(tf.iterator(tf.string).assignable?(iterint)).to be_falsey
+      end
+    end
+
+    context 'when asked for an iterable type' do
+      it 'the default iterator type returns the default iterable type' do
+        expect(PIteratorType::DEFAULT.iterable_type).to be(PIterableType::DEFAULT)
+      end
+
+      it 'a typed iterator type returns the an equally typed iterable type' do
+        expect(iterint.iterable_type).to eq(tf.iterable(tf.integer))
+      end
+    end
+
+    it 'can be parameterized with an element type' do
+      code = <<-CODE
+      function foo(Iterator[String] $x) {
+        $x.each |$e| {
+          notice $e
+        }
+      }
+      foo([bar, baz, cake].reverse_each)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['cake', 'baz', 'bar'])
+    end
+  end
+
+  context 'Collection type' do
+    include PuppetSpec::Compiler
+
+    it 'can be parameterized with a range' do
+      code = <<-CODE
+      notice(Collection[5, default] == Collection[5])
+      notice(Collection[5, 5] > Tuple[Integer, 0, 10])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'false'])
+    end
+  end
+
+  context 'Struct type' do
+    context 'can be used as key in hash' do
+      it 'compacts optional in optional in optional to just optional' do
+        key1 = tf.struct({'foo' => tf.string})
+        key2 = tf.struct({'foo' => tf.string})
+        expect({key1 => 'hi'}[key2]).to eq('hi')
+      end
+    end
+  end
+
   context 'Optional type' do
     let!(:overlapping_ints) { tf.variant(tf.range(10, 20), tf.range(18, 28)) }
     let!(:optoptopt) { tf.optional(tf.optional(tf.optional(overlapping_ints))) }
@@ -169,6 +256,7 @@ describe 'Puppet Type System' do
   context 'NotUndef type' do
     let!(:nununu) { tf.not_undef(tf.not_undef(tf.not_undef(tf.any))) }
     let!(:nuopt) { tf.not_undef(tf.optional(tf.any)) }
+    let!(:nuoptint) { tf.not_undef(tf.optional(tf.integer)) }
 
     context 'when normalizing' do
       it 'compacts NotUndef in NotUndef in NotUndef to just NotUndef' do
@@ -178,6 +266,10 @@ describe 'Puppet Type System' do
       it 'compacts Optional in NotUndef to just NotUndef' do
         expect(nuopt.normalize).to eq(tf.not_undef(tf.any))
       end
+
+      it 'compacts NotUndef[Optional[Integer]] in NotUndef to just Integer' do
+        expect(nuoptint.normalize).to eq(tf.integer)
+      end
     end
   end
 
@@ -235,6 +327,129 @@ describe 'Puppet Type System' do
         )
       end
     end
+
+    context 'when generalizing' do
+      it 'will generalize and compact contained types' do
+        expect(tf.variant(tf.string(tf.range(3,3)), tf.string(tf.range(5,5))).generalize).to eq(tf.variant(tf.string))
+      end
+    end
+  end
+
+  context 'Type aliases' do
+    include PuppetSpec::Compiler
+
+    it 'will resolve nested objects using self recursion' do
+      code = <<-CODE
+      type Tree = Hash[String,Variant[String,Tree]]
+      notice({a => {b => {c => d}}} =~ Tree)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true'])
+    end
+
+    it 'will find mismatches using self recursion' do
+      code = <<-CODE
+      type Tree = Hash[String,Variant[String,Tree]]
+      notice({a => {b => {c => 1}}} =~ Tree)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['false'])
+    end
+
+    it 'will not allow an alias chain to only contain aliases' do
+      code = <<-CODE
+      type Foo = Bar
+      type Fee = Foo
+      type Bar = Fee
+      notice(0 =~ Bar)
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Type alias 'Foo' cannot be resolved to a real type/)
+    end
+
+    it 'will not allow an alias chain that contains nothing but aliases and variants' do
+      code = <<-CODE
+      type Foo = Bar
+      type Fee = Foo
+      type Bar = Variant[Fee,Foo]
+      notice(0 =~ Bar)
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Type alias 'Foo' cannot be resolved to a real type/)
+    end
+
+    it 'will not allow an alias to directly reference itself' do
+      code = <<-CODE
+      type Foo = Foo
+      notice(0 =~ Foo)
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Type alias 'Foo' cannot be resolved to a real type/)
+    end
+
+    it 'will allow an alias to directly reference itself in a variant with other types' do
+      code = <<-CODE
+      type Foo = Variant[Foo,String]
+      notice(a =~ Foo)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true'])
+    end
+
+    it 'will allow an alias where a variant references an alias with a variant that references itself' do
+      code = <<-CODE
+      type X = Variant[Y, Integer]
+      type Y = Variant[X, String]
+
+      notice(X >= X)
+      notice(X >= Y)
+      notice(Y >= X)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true','true','true'])
+    end
+
+    it 'will detect a mismatch in an alias that directly references itself in a variant with other types' do
+      code = <<-CODE
+      type Foo = Variant[Foo,String]
+      notice(3 =~ Foo)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['false'])
+    end
+
+    it 'will normalize a Variant containing a self reference so that the self reference is removed' do
+      code = <<-CODE
+      type Foo = Variant[Foo,String,Integer]
+      assert_type(Foo, /x/)
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(/expected a value of type String or Integer, got Regexp/)
+    end
+
+    it 'will handle a scalar correctly in combinations of nested aliased variants' do
+      code = <<-CODE
+      type Bar = Variant[Foo,Integer]
+      type Foo = Variant[Bar,String]
+      notice(a =~ Foo)
+      notice(1 =~ Foo)
+      notice(/x/ =~ Foo)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true', 'false'])
+    end
+
+    it 'will handle a non scalar correctly in combinations of nested aliased array with nested variants' do
+      code = <<-CODE
+      type Bar = Variant[Foo,Integer]
+      type Foo = Array[Variant[Bar,String]]
+      notice([a] =~ Foo)
+      notice([1] =~ Foo)
+      notice([/x/] =~ Foo)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true', 'false'])
+    end
+
+    it 'will handle a non scalar correctly in combinations of nested aliased variants with array' do
+      code = <<-CODE
+      type Bar = Variant[Foo,Array[Integer]]
+      type Foo = Variant[Bar,Array[String]]
+      notice([a] =~ Foo)
+      notice([1] =~ Foo)
+      notice([/x/] =~ Foo)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true', 'false'])
+    end
   end
 end
 end