puppet 4.0.0-x64-mingw32 → 4.1.0-x64-mingw32

data/spec/unit/pops/parser/parse_heredoc_spec.rb

@@ -71,6 +71,32 @@ describe "egrammar parsing heredoc" do
     ].join("\n"))
   end
 
+  it "parses interpolated heredoc expression containing escapes" do
+    src = <<-CODE
+    @("END")
+    Hello \\$name
+    |- END
+    CODE
+    expect(dump(parse(src))).to eq([
+      "(@()",
+      "  (sublocated (cat 'Hello \\' (str $name) ''))",
+      ")"
+    ].join("\n"))
+  end
+
+  it "parses interpolated heredoc expression containing escapes when escaping other things than $" do
+    src = <<-CODE
+    @("END"/t)
+    Hello \\$name
+    |- END
+    CODE
+    expect(dump(parse(src))).to eq([
+      "(@()",
+      "  (sublocated (cat 'Hello \\' (str $name) ''))",
+      ")"
+    ].join("\n"))
+  end
+
   it "parses with escaped newlines without preceding whitespace" do
     src = <<-CODE
     @(END/L)

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

@@ -89,6 +89,10 @@ describe 'The type calculator' do
     Puppet::Pops::Types::TypeFactory.optional(t)
   end
 
+  def not_undef_t(t = nil)
+    Puppet::Pops::Types::TypeFactory.not_undef(t)
+  end
+
   def undef_t
     Puppet::Pops::Types::TypeFactory.undef
   end
@@ -108,6 +112,7 @@ describe 'The type calculator' do
     def all_types
       [ Puppet::Pops::Types::PAnyType,
         Puppet::Pops::Types::PUndefType,
+        Puppet::Pops::Types::PNotUndefType,
         Puppet::Pops::Types::PDataType,
         Puppet::Pops::Types::PScalarType,
         Puppet::Pops::Types::PStringType,
@@ -184,6 +189,7 @@ describe 'The type calculator' do
       result << array_t(types::PDataType.new)
       result << types::TypeFactory.hash_of_data
       result << Puppet::Pops::Types::PUndefType
+      result << not_undef_t(types::PDataType.new)
       tmp = tuple_t(types::PDataType.new)
       result << (tmp)
       tmp.size_type = range_t(0, nil)
@@ -389,7 +395,7 @@ describe 'The type calculator' do
           t = calculator.infer_set({ 'mode' => 'read', 'path' => ['foo', 'fee' ] })
           expect(t.class).to eq(Puppet::Pops::Types::PStructType)
           expect(t.elements.size).to eq(2)
-          els = t.elements.map { |e| e.type }.sort {|a,b| a.to_s <=> b.to_s }
+          els = t.elements.map { |e| e.value_type }.sort {|a,b| a.to_s <=> b.to_s }
           expect(els[0].class).to eq(Puppet::Pops::Types::PStringType)
           expect(els[1].class).to eq(Puppet::Pops::Types::PTupleType)
         end
@@ -471,6 +477,45 @@ describe 'The type calculator' do
       expect(calculator.string(calculator.common_type(r1, r2))).to eq("Class")
     end
 
+    context 'of strings' do
+      it 'computes commonality' do
+        t1 = string_t('abc')
+        t2 = string_t('xyz')
+        common_t = calculator.common_type(t1,t2)
+        expect(common_t.class).to eq(Puppet::Pops::Types::PStringType)
+        expect(common_t.values).to eq(['abc', 'xyz'])
+      end
+
+      it 'computes common size_type' do
+        t1 = string_t
+        t1.size_type = range_t(3,6)
+        t2 = string_t
+        t2.size_type = range_t(2,4)
+        common_t = calculator.common_type(t1,t2)
+        expect(common_t.class).to eq(Puppet::Pops::Types::PStringType)
+        expect(common_t.size_type).to eq(range_t(2,6))
+      end
+
+      it 'computes common size_type to be undef when one of the types has no size_type' do
+        t1 = string_t
+        t2 = string_t
+        t2.size_type = range_t(2,4)
+        common_t = calculator.common_type(t1,t2)
+        expect(common_t.class).to eq(Puppet::Pops::Types::PStringType)
+        expect(common_t.size_type).to be_nil
+      end
+
+      it 'computes values to be empty if the one has empty values' do
+        t1 = string_t('apa')
+        t1.size_type = range_t(3,6)
+        t2 = string_t
+        t2.size_type = range_t(2,4)
+        common_t = calculator.common_type(t1,t2)
+        expect(common_t.class).to eq(Puppet::Pops::Types::PStringType)
+        expect(common_t.values).to be_empty
+      end
+    end
+
     it 'computes pattern commonality' do
       t1 = pattern_t('abc')
       t2 = pattern_t('xyz')
@@ -553,6 +598,13 @@ describe 'The type calculator' do
   context 'computes assignability' do
     include_context "types_setup"
 
+    it 'such that all types are assignable to themselves' do
+      all_types.each do |tc|
+        t = tc.new
+        expect(t).to be_assignable_to(t)
+      end
+    end
+
     context 'for Unit, such that' do
       it 'all types are assignable to Unit' do
         t = Puppet::Pops::Types::PUnitType.new()
@@ -577,13 +629,55 @@ describe 'The type calculator' do
         all_types.each { |t2| expect(t2.new).to be_assignable_to(t) }
       end
 
-      it 'Any is not assignable to anything but Any' do
-        tested_types = all_types() - [Puppet::Pops::Types::PAnyType]
+      it 'Any is not assignable to anything but Any and Optional (implied Optional[Any])' do
+        tested_types = all_types() - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::POptionalType]
         t = Puppet::Pops::Types::PAnyType.new()
         tested_types.each { |t2| expect(t).not_to be_assignable_to(t2.new) }
       end
     end
 
+    context "for NotUndef, such that" do
+      it 'all types except types assignable from Undef are assignable to NotUndef' do
+        t = not_undef_t
+        tc = Puppet::Pops::Types::TypeCalculator.singleton
+        undef_t = Puppet::Pops::Types::PUndefType.new()
+        all_types().each do |c|
+          t2 = c.new
+          if tc.assignable?(t2, undef_t)
+            expect(t2).not_to be_assignable_to(t)
+          else
+            expect(t2).to be_assignable_to(t)
+          end
+        end
+      end
+
+      it 'type NotUndef[T] is assignable from T unless T is assignable from Undef ' do
+        tc = Puppet::Pops::Types::TypeCalculator.singleton
+        undef_t = Puppet::Pops::Types::PUndefType.new()
+        all_types().select do |c|
+          t2 = c.new
+          not_undef_t = not_undef_t(t2)
+          if tc.assignable?(t2, undef_t)
+            expect(t2).not_to be_assignable_to(not_undef_t)
+          else
+            expect(t2).to be_assignable_to(not_undef_t)
+          end
+        end
+      end
+
+      it 'type T is assignable from NotUndef[T] unless T is assignable from Undef' do
+        tc = Puppet::Pops::Types::TypeCalculator.singleton
+        undef_t = Puppet::Pops::Types::PUndefType.new()
+        all_types().select do |c|
+          t2 = c.new
+          not_undef_t = not_undef_t(t2)
+          unless tc.assignable?(t2, undef_t)
+            expect(not_undef_t).to be_assignable_to(t2)
+          end
+        end
+      end
+    end
+
     context "for Data, such that" do
       it 'all scalars + array and hash are assignable to Data' do
         t = Puppet::Pops::Types::PDataType.new()
@@ -610,7 +704,7 @@ describe 'The type calculator' do
       end
 
       it 'Data is not assignable to any disjunct type' do
-        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::PDataType] - scalar_types
+        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::POptionalType, Puppet::Pops::Types::PDataType] - scalar_types
         t = Puppet::Pops::Types::PDataType.new()
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2.new) }
       end
@@ -647,7 +741,7 @@ describe 'The type calculator' do
       end
 
       it 'Scalar is not assignable to any disjunct type' do
-        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::PDataType] - scalar_types
+        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::POptionalType, Puppet::Pops::Types::PNotUndefType, Puppet::Pops::Types::PDataType] - scalar_types
         t = Puppet::Pops::Types::PScalarType.new()
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2.new) }
       end
@@ -668,6 +762,8 @@ describe 'The type calculator' do
       it 'Numeric is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PDataType,
           Puppet::Pops::Types::PScalarType,
           ] - numeric_types
@@ -689,7 +785,7 @@ describe 'The type calculator' do
       end
 
       it 'Collection is not assignable to any disjunct type' do
-        tested_types = all_types - [Puppet::Pops::Types::PAnyType] - collection_types
+        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::POptionalType, Puppet::Pops::Types::PNotUndefType] - collection_types
         t = Puppet::Pops::Types::PCollectionType.new()
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2.new) }
       end
@@ -700,6 +796,7 @@ describe 'The type calculator' do
         t = Puppet::Pops::Types::PArrayType.new()
         tested_types = collection_types - [
           Puppet::Pops::Types::PCollectionType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PArrayType,
           Puppet::Pops::Types::PTupleType]
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2.new) }
@@ -708,6 +805,8 @@ describe 'The type calculator' do
       it 'Array is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PArrayType.new()
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2.new) }
@@ -727,6 +826,8 @@ describe 'The type calculator' do
       it 'Hash is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PHashType.new()
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2.new) }
@@ -762,6 +863,8 @@ describe 'The type calculator' do
       it 'Tuple is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PTupleType.new()
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2.new) }
@@ -781,10 +884,41 @@ describe 'The type calculator' do
       it 'Struct is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PStructType.new()
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2.new) }
       end
+
+      it 'Default key optionality is controlled by value assignability to undef' do
+        t1 = struct_t({'member' => string_t})
+        expect(t1.elements[0].key_type).to eq(string_t('member'))
+        t1 = struct_t({'member' => object_t})
+        expect(t1.elements[0].key_type).to eq(optional_t(string_t('member')))
+      end
+
+      it "NotUndef['key'] becomes String['key'] (since its implied that String is required)" do
+        t1 = struct_t({not_undef_t('member') => string_t})
+        expect(t1.elements[0].key_type).to eq(string_t('member'))
+      end
+
+      it "Optional['key'] becomes Optional[String['key']]" do
+        t1 = struct_t({optional_t('member') => string_t})
+        expect(t1.elements[0].key_type).to eq(optional_t(string_t('member')))
+      end
+
+      it 'Optional members are not required' do
+        t1 = struct_t({optional_t('optional_member') => string_t, not_undef_t('other_member') => string_t})
+        t2 = struct_t({not_undef_t('other_member') => string_t})
+        expect(t2).to be_assignable_to(t1)
+      end
+
+      it 'Required members not optional even when value is' do
+        t1 = struct_t({not_undef_t('required_member') => object_t, not_undef_t('other_member') => string_t})
+        t2 = struct_t({not_undef_t('other_member') => string_t})
+        expect(t2).not_to be_assignable_to(t1)
+      end
     end
 
     context "for Callable, such that" do
@@ -792,8 +926,10 @@ describe 'The type calculator' do
         t = Puppet::Pops::Types::PCallableType.new()
         tested_types = all_types - [
           Puppet::Pops::Types::PCallableType,
-          Puppet::Pops::Types::PAnyType]
-        tested_types.each {|t2| expect(t).not_to be_assignable_to(t2.new) }
+          Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType]
+        tested_types.each {|t2| expect(t).to_not be_assignable_to(t2.new) }
       end
     end
 
@@ -1231,7 +1367,7 @@ describe 'The type calculator' do
       expect(calculator.instance?(Puppet::Pops::Types::POptionalType.new(), :undef)).to eq(true)
     end
 
-    it 'should not consider undef to be an instance of any other type than Any, NilType and Data' do
+    it 'should not consider undef to be an instance of any other type than Any, UndefType and Data' do
       types_to_test = all_types - [
         Puppet::Pops::Types::PAnyType,
         Puppet::Pops::Types::PUndefType,
@@ -1248,9 +1384,10 @@ describe 'The type calculator' do
       expect(calculator.instance?(Puppet::Pops::Types::PAnyType.new(), :default)).to eq(true)
     end
 
-    it 'should not consider "default" to be an instance of anything but Default, and Any' do
+    it 'should not consider "default" to be an instance of anything but Default, NotUndef, and Any' do
       types_to_test = all_types - [
         Puppet::Pops::Types::PAnyType,
+        Puppet::Pops::Types::PNotUndefType,
         Puppet::Pops::Types::PDefaultType,
         ]
 
@@ -1281,6 +1418,13 @@ describe 'The type calculator' do
       expect(calculator.instance?(range, 'abcd')).to eq(false)
     end
 
+    it 'should consider string values' do
+      string = string_t('a', 'b')
+      expect(calculator.instance?(string, 'a')).to eq(true)
+      expect(calculator.instance?(string, 'b')).to eq(true)
+      expect(calculator.instance?(string, 'c')).to eq(false)
+    end
+
     it 'should consider array in length range' do
       range = factory.constrain_size(array_t(integer_t), 1,3)
       expect(calculator.instance?(range, [1])).to    eq(true)
@@ -1380,6 +1524,26 @@ describe 'The type calculator' do
         struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>optional_t(Float)})
         expect(calculator.instance?(struct, {'a'=>1, 'b'=>'a', 'c'=>'x'})).to eq(false)
       end
+
+      it 'should consider nil to be a valid element value' do
+        struct = struct_t({not_undef_t('a') => object_t, 'b'=>String})
+        expect(calculator.instance?(struct, {'a'=>nil , 'b'=>'a'})).to eq(true)
+      end
+
+      it 'should consider nil to be a valid element value but subject to value type' do
+        struct = struct_t({not_undef_t('a') => String, 'b'=>String})
+        expect(calculator.instance?(struct, {'a'=>nil , 'b'=>'a'})).to eq(false)
+      end
+
+      it 'should consider nil to be a valid element value but subject to value type even when key is optional' do
+        struct = struct_t({optional_t('a') => String, 'b'=>String})
+        expect(calculator.instance?(struct, {'a'=>nil , 'b'=>'a'})).to eq(false)
+      end
+
+      it 'should consider a hash where optional key is missing as assignable even if value of optional key is required' do
+        struct = struct_t({optional_t('a') => String, 'b'=>String})
+        expect(calculator.instance?(struct, {'b'=>'a'})).to eq(true)
+      end
     end
 
     context 'and t is Data' do
@@ -1722,6 +1886,21 @@ describe 'The type calculator' do
     it "should yield Unit for a Unit type" do
       expect(calculator.string(unit_t)).to eql('Unit')
     end
+
+    it "should yield 'NotUndef' for a PNotUndefType" do
+      t = not_undef_t
+      expect(calculator.string(t)).to eq('NotUndef')
+    end
+
+    it "should yield 'NotUndef[T]' for a PNotUndefType[T]" do
+      t = not_undef_t(data_t)
+      expect(calculator.string(t)).to eq('NotUndef[Data]')
+    end
+
+    it "should yield 'NotUndef['string']' for a PNotUndefType['string']" do
+      t = not_undef_t('hey')
+      expect(calculator.string(t)).to eq("NotUndef['hey']")
+    end
   end
 
   context 'when processing meta type' do
@@ -1865,7 +2044,7 @@ describe 'The type calculator' do
       expect(generic.element_type.values).to eq([])
     end
 
-    it "a generic result is created by generalize! given an instance specific result for a Hash" do
+    it 'a generic result is created by generalize! given an instance specific result for a Hash' do
       generic = calculator.infer({'a' =>1,'b' => 2})
       expect(generic.key_type.values.sort).to eq(['a', 'b'])
       expect(generic.element_type.from).to eq(1)
@@ -1876,6 +2055,20 @@ describe 'The type calculator' do
       expect(generic.element_type.to).to eq(nil)
     end
 
+    it 'ensures that Struct key types are not generalized' do
+      generic = calculator.generalize!(struct_t({'a' => object_t}))
+      expect(calculator.string(generic)).to eq("Struct[{'a'=>Any}]")
+      generic = calculator.generalize!(struct_t({not_undef_t('a') => object_t}))
+      expect(calculator.string(generic)).to eq("Struct[{NotUndef['a']=>Any}]")
+      generic = calculator.generalize!(struct_t({optional_t('a') => string_t}))
+      expect(calculator.string(generic)).to eq("Struct[{Optional['a']=>String}]")
+    end
+
+    it 'ensures that Struct value types are generalized' do
+      generic = calculator.generalize!(struct_t({'a' => range_t(1, 3)}))
+      expect(calculator.string(generic)).to eq("Struct[{'a'=>Integer}]")
+    end
+
     it "does not reduce by combining types when using infer_set" do
       element_type = calculator.infer(['a','b',1,2]).element_type
       expect(element_type.class).to eq(Puppet::Pops::Types::PScalarType)
@@ -1981,7 +2174,7 @@ describe 'The type calculator' do
   end
 
   matcher :be_assignable_to do |type|
-    calc = Puppet::Pops::Types::TypeCalculator.new
+    calc = Puppet::Pops::Types::TypeCalculator.singleton
 
     match do |actual|
       calc.assignable?(type, actual)

data/spec/unit/pops/validation_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe 'Puppet::Pops::Validation::Diagnostic' do
+
+  # Mocks a SourcePosAdapter as it is used in these use cases
+  # of a Diagnostic
+  #
+  class MockSourcePos
+    attr_reader :offset
+    def initialize(offset)
+      @offset = offset
+    end
+  end
+
+  it "computes equal hash value ignoring arguments" do
+    issue = Puppet::Pops::Issues::DIV_BY_ZERO
+    source_pos = MockSourcePos.new(10)
+    d1 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos, {:foo => 10})
+    d2 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos.clone, {:bar => 20})
+    expect(d1.hash).to eql(d2.hash)
+  end
+
+  it "computes non equal hash value for different severities" do
+    issue = Puppet::Pops::Issues::DIV_BY_ZERO
+    source_pos = MockSourcePos.new(10)
+    d1 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos, {})
+    d2 = Puppet::Pops::Validation::Diagnostic.new(:error, issue, "foo", source_pos.clone, {})
+    expect(d1.hash).to_not eql(d2.hash)
+  end
+
+  it "computes non equal hash value for different offsets" do
+    issue = Puppet::Pops::Issues::DIV_BY_ZERO
+    source_pos1 = MockSourcePos.new(10)
+    source_pos2 = MockSourcePos.new(11)
+    d1 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos1, {})
+    d2 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos2, {})
+    expect(d1.hash).to_not eql(d2.hash)
+  end
+
+  it "can be used in a set" do
+    the_set = Set.new()
+    issue = Puppet::Pops::Issues::DIV_BY_ZERO
+    source_pos = MockSourcePos.new(10)
+    d1 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos, {})
+    d2 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos.clone, {})
+    d3 = Puppet::Pops::Validation::Diagnostic.new(:error, issue, "foo", source_pos.clone, {})
+    expect(the_set.add?(d1)).to_not be_nil
+    expect(the_set.add?(d2)).to be_nil
+    expect(the_set.add?(d3)).to_not be_nil
+  end
+
+end
+
+describe "Puppet::Pops::Validation::SeverityProducer" do
+  it 'sets default severity given in initializer' do
+    producer = Puppet::Pops::Validation::SeverityProducer.new(:warning)
+    expect(producer.severity(Puppet::Pops::Issues::DIV_BY_ZERO)).to be(:warning)
+  end
+
+  it 'sets default severity to :error if not given' do
+    producer = Puppet::Pops::Validation::SeverityProducer.new()
+    expect(producer.severity(Puppet::Pops::Issues::DIV_BY_ZERO)).to be(:error)
+  end
+
+end