puppet 5.0.1-x64-mingw32 → 5.1.0-x64-mingw32

data/spec/unit/pops/serialization/serialization_spec.rb

@@ -295,7 +295,7 @@ module Serialization
 
           def self.register_ptype(loader, ir)
             @type = Pcore.create_object_type(loader, ir, DerivedArray, 'DerivedArray', nil, 'values' => Types::PArrayType::DEFAULT)
-              .resolve(Types::TypeParser.singleton, loader)
+              .resolve(loader)
           end
 
           def initialize(values)
@@ -316,7 +316,7 @@ module Serialization
 
           def self.register_ptype(loader, ir)
             @type = Pcore.create_object_type(loader, ir, DerivedHash, 'DerivedHash', nil, '_pcore_init_hash' => Types::PHashType::DEFAULT)
-              .resolve(Types::TypeParser.singleton, loader)
+              .resolve(loader)
           end
 
           def initialize(_pcore_init_hash)

data/spec/unit/pops/serialization/to_from_hr_spec.rb

@@ -321,7 +321,7 @@ module Serialization
 
           def self.register_ptype(loader, ir)
             @type = Pcore.create_object_type(loader, ir, DerivedArray, 'DerivedArray', nil, 'values' => Types::PArrayType::DEFAULT)
-              .resolve(Types::TypeParser.singleton, loader)
+              .resolve(loader)
           end
 
           def initialize(values)
@@ -342,7 +342,7 @@ module Serialization
 
           def self.register_ptype(loader, ir)
             @type = Pcore.create_object_type(loader, ir, DerivedHash, 'DerivedHash', nil, '_pcore_init_hash' => Types::PHashType::DEFAULT)
-              .resolve(Types::TypeParser.singleton, loader)
+              .resolve(loader)
           end
 
           def initialize(_pcore_init_hash)

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

@@ -50,8 +50,8 @@ describe 'The iterable support' do
       PStructType::DEFAULT,
       PUnitType::DEFAULT
     ]
-    iterable_types << PType.new(PIntegerType.new(0, 10))
-    iterable_types << PType.new(PEnumType.new(%w(yes no)))
+    iterable_types << PTypeType.new(PIntegerType.new(0, 10))
+    iterable_types << PTypeType.new(PEnumType.new(%w(yes no)))
     iterable_types << PRuntimeType.new(:ruby, 'Puppet::Pops::Types::Iterator')
     iterable_types << PVariantType.new(iterable_types.clone)
 
@@ -62,7 +62,7 @@ describe 'The iterable support' do
       PCatalogEntryType::DEFAULT,
       PDefaultType::DEFAULT,
       PFloatType::DEFAULT,
-      PHostClassType::DEFAULT,
+      PClassType::DEFAULT,
       PNotUndefType::DEFAULT,
       PNumericType::DEFAULT,
       POptionalType::DEFAULT,
@@ -72,10 +72,10 @@ describe 'The iterable support' do
       PRuntimeType::DEFAULT,
       PScalarType::DEFAULT,
       PScalarDataType::DEFAULT,
-      PType::DEFAULT,
+      PTypeType::DEFAULT,
       PUndefType::DEFAULT
     ]
-    not_iterable_types << PType.new(PIntegerType::DEFAULT)
+    not_iterable_types << PTypeType.new(PIntegerType::DEFAULT)
     not_iterable_types << PVariantType.new([iterable_types[0], not_iterable_types[0]])
 
     iterable_types.each do |type|
@@ -91,19 +91,19 @@ describe 'The iterable support' do
     end
 
     it "should consider Type[Integer[0,5]] to be assignable to Iterable[Integer[0,5]]" do
-      expect(PIterableType.new(PIntegerType.new(0,5)).assignable?(PType.new(PIntegerType.new(0,5)))).to eq(true)
+      expect(PIterableType.new(PIntegerType.new(0,5)).assignable?(PTypeType.new(PIntegerType.new(0,5)))).to eq(true)
     end
 
     it "should consider Type[Enum[yes,no]] to be assignable to Iterable[Enum[yes,no]]" do
-      expect(PIterableType.new(PEnumType.new(%w(yes no))).assignable?(PType.new(PEnumType.new(%w(yes no))))).to eq(true)
+      expect(PIterableType.new(PEnumType.new(%w(yes no))).assignable?(PTypeType.new(PEnumType.new(%w(yes no))))).to eq(true)
     end
 
     it "should not consider Type[Enum[ok,fail]] to be assignable to Iterable[Enum[yes,no]]" do
-      expect(PIterableType.new(PEnumType.new(%w(ok fail))).assignable?(PType.new(PEnumType.new(%w(yes no))))).to eq(false)
+      expect(PIterableType.new(PEnumType.new(%w(ok fail))).assignable?(PTypeType.new(PEnumType.new(%w(yes no))))).to eq(false)
     end
 
     it "should not consider Type[String] to be assignable to Iterable[String]" do
-      expect(PIterableType.new(PStringType::DEFAULT).assignable?(PType.new(PStringType::DEFAULT))).to eq(false)
+      expect(PIterableType.new(PStringType::DEFAULT).assignable?(PTypeType.new(PStringType::DEFAULT))).to eq(false)
     end
   end
 

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

@@ -0,0 +1,285 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Types
+describe 'The Init Type' do
+  include PuppetSpec::Compiler
+  include_context 'types_setup'
+
+  context 'when used in Puppet expressions' do
+    it 'an unparameterized type can be used' do
+      code = <<-CODE
+      notice(type(Init))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['Type[Init]'])
+    end
+
+    it 'a parameterized type can be used' do
+      code = <<-CODE
+      notice(type(Init[Integer]))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['Type[Init[Integer]]'])
+    end
+
+    it 'a parameterized type can have additional arguments' do
+      code = <<-CODE
+      notice(type(Init[Integer, 16]))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['Type[Init[Integer, 16]]'])
+    end
+
+    (all_types - abstract_types - internal_types).map { |tc| tc::DEFAULT.name }.each do |type_name|
+      it "can be created on a #{type_name}" do
+        code = <<-CODE
+        notice(type(Init[#{type_name}]))
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(["Type[Init[#{type_name}]]"])
+      end
+    end
+
+    (abstract_types - internal_types).map { |tc| tc::DEFAULT.name }.each do |type_name|
+      it "cannot be created on a #{type_name}" do
+        code = <<-CODE
+        type(Init[#{type_name}]('x'))
+        CODE
+        expect { eval_and_collect_notices(code) }.to raise_error(/Creation of new instance of type '#{type_name}' is not supported/)
+      end
+    end
+
+    it 'an Init[Integer, 16] can create an instance from a String' do
+      code = <<-CODE
+      notice(Init[Integer, 16]('100'))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['256'])
+    end
+
+    it "an Init[String,'%x'] can create an instance from an Integer" do
+      code = <<-CODE
+      notice(Init[String,'%x'](128))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['80'])
+    end
+
+    it "an Init[String,23] raises an error because no available dispatcher exists" do
+      code = <<-CODE
+      notice(Init[String,23](128))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(
+        /The type 'Init\[String, 23\]' does not represent a valid set of parameters for String\.new\(\)/)
+    end
+
+    it 'an Init[String] can create an instance from an Integer' do
+      code = <<-CODE
+      notice(Init[String](128))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['128'])
+    end
+
+    it 'an Init[String] can create an instance from an array with an Integer' do
+      code = <<-CODE
+      notice(Init[String]([128]))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['128'])
+    end
+
+    it 'an Init[String] can create an instance from an array with an Integer and a format' do
+      code = <<-CODE
+      notice(Init[String]([128, '%x']))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['80'])
+    end
+
+    it 'an Init[String] can create an instance from an array with an array' do
+      code = <<-CODE
+      notice(Init[String]([[128, '%x']]))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(["[128, '%x']"])
+    end
+
+    it 'an Init[Binary] can create an instance from a string' do
+      code = <<-CODE
+      notice(Init[Binary]('b25lIHR3byB0aHJlZQ=='))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['b25lIHR3byB0aHJlZQ=='])
+    end
+
+    it 'an Init[String] can not create an instance from an Integer and a format unless given as an array argument' do
+      code = <<-CODE
+      notice(Init[String](128, '%x'))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(/'new_Init' expects 1 argument, got 2/)
+    end
+
+    it 'the array [128] is an instance of Init[String]' do
+      code = <<-CODE
+      notice(assert_type(Init[String], [128]))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['[128]'])
+    end
+
+    it 'the value 128 is an instance of Init[String]' do
+      code = <<-CODE
+      notice(assert_type(Init[String], 128))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['128'])
+    end
+
+    it "the array [128] is an instance of Init[String]" do
+      code = <<-CODE
+      notice(assert_type(Init[String], [128]))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['[128]'])
+    end
+
+    it "the array [128, '%x'] is an instance of Init[String]" do
+      code = <<-CODE
+      notice(assert_type(Init[String], [128, '%x']))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['[128, %x]'])
+    end
+
+    it "the array [[128, '%x']] is an instance of Init[String]" do
+      code = <<-CODE
+      notice(assert_type(Init[String], [[128, '%x']]))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['[[128, %x]]'])
+    end
+
+    it 'RichData is assignable to Init' do
+      code = <<-CODE
+      notice(Init > RichData)
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true'])
+    end
+
+    it 'Runtime is not assignable to Init' do
+      code = <<-CODE
+      notice(Init > Runtime['ruby', 'Time'])
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['false'])
+    end
+
+    it 'Init is not assignable to RichData' do
+      code = <<-CODE
+      notice(Init < RichData)
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['false'])
+    end
+
+    it 'Init[T1] is assignable to Init[T2] when T1 is assignable to T2' do
+      code = <<-CODE
+      notice(Init[Integer] < Init[Numeric])
+      notice(Init[Tuple[Integer]] < Init[Array[Integer]])
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true', 'true'])
+    end
+
+    it 'Init[T1] is not assignable to Init[T2] unless T1 is assignable to T2' do
+      code = <<-CODE
+      notice(Init[Integer] > Init[Numeric])
+      notice(Init[Tuple[Integer]] > Init[Array[Integer]])
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['false', 'false'])
+    end
+
+    it 'T is assignable to Init[T]' do
+      code = <<-CODE
+      notice(Integer < Init[Integer])
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true'])
+    end
+
+    it 'T1 is assignable to Init[T2] if T2 can be created from instance of T1 is valid' do
+      code = <<-CODE
+      notice(Integer < Init[String])
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true'])
+    end
+
+    it 'a RichData value is an instance of Init' do
+      code = <<-CODE
+      notice(
+        String(assert_type(Init, { 'a' => [ 1, 2, Sensitive(3) ], 2 => Timestamp('2014-12-01T13:15:00') }),
+          { Any => { format => '%s', string_formats => { Any => '%s' }}}))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['{a => [1, 2, Sensitive [value redacted]], 2 => 2014-12-01T13:15:00.000000000 UTC}'])
+    end
+
+    it 'an Init[Sensitive[String]] can create an instance from a String' do
+      code = <<-CODE
+      notice(Init[Sensitive[String]]('256'))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['Sensitive [value redacted]'])
+    end
+
+    it 'an Init[Type] can create an instance from a String' do
+      code = <<-CODE
+      notice(Init[Type]('Integer[2,3]'))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['Integer[2, 3]'])
+    end
+
+    it 'an Init[Type[Numeric]] can not create an unassignable type from a String' do
+      code = <<-CODE
+      notice(Init[Type[Numeric]]('String'))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(
+        /Converted value from Type\[Numeric\]\.new\(\) has wrong type, expects a Type\[Numeric\] value, got Type\[String\]/)
+    end
+
+    it 'an Init with a custom object type can create an instance from a Hash' do
+      code = <<-CODE
+      type MyType = Object[{
+        attributes => {
+          granularity => String,
+          price => String,
+          category => Integer
+        }
+      }]
+      notice(Init[MyType]({ granularity => 'fine', price => '$10', category => 23 }))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(["MyType({'granularity' => 'fine', 'price' => '$10', 'category' => 23})"])
+    end
+
+    it 'an Init with a custom object type and additional parameters can create an instance from a value' do
+      code = <<-CODE
+      type MyType = Object[{
+        attributes => {
+          granularity => String,
+          price => String,
+          category => Integer
+        }
+      }]
+      notice(Init[MyType,'$5',20]('coarse'))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(["MyType({'granularity' => 'coarse', 'price' => '$5', 'category' => 20})"])
+    end
+
+    it 'an Init with a custom object with one Array parameter, can be created from an Array' do
+      code = <<-CODE
+      type MyType = Object[{
+        attributes => { array => Array[String] }
+      }]
+      notice(Init[MyType](['a']))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(["MyType({'array' => ['a']})"])
+    end
+
+    it 'an Init type can be used recursively' do
+      # Even if it doesn't make sense, it should not crash
+      code = <<-CODE
+        type One = Object[{
+          attributes => {
+            init_one => Variant[Init[One],String]
+          }
+        }]
+        notice(Init[One]('w'))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(["One({'init_one' => 'w'})"])
+    end
+  end
+end
+end
+end

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

@@ -26,7 +26,7 @@ describe 'The Object Type' do
 
   def parse_object(name, body_string)
     type_object_t(name, body_string)
-    parser.parse(name, loader)
+    parser.parse(name, loader).resolve(loader)
   end
 
   context 'when dealing with attributes' do
@@ -597,7 +597,7 @@ describe 'The Object Type' do
     end
   end
 
-  context 'when producing an i12n_type' do
+  context 'when producing an init_hash_type' do
     it 'produces a struct of all attributes that are not derived or constant' do
       t = parse_object('MyObject', <<-OBJECT)
         attributes => {
@@ -607,7 +607,7 @@ describe 'The Object Type' do
           d => { type => Integer, kind => constant, value => 4 }
         }
       OBJECT
-      expect(t.i12n_type).to eql(factory.struct({
+      expect(t.init_hash_type).to eql(factory.struct({
         'a' => factory.integer,
         'b' => factory.integer
       }))
@@ -620,7 +620,7 @@ describe 'The Object Type' do
           b => { type => Integer, value => 4 }
         }
       OBJECT
-      expect(t.i12n_type).to eql(factory.struct({
+      expect(t.init_hash_type).to eql(factory.struct({
         'a' => factory.integer,
         factory.optional('b') => factory.integer
       }))
@@ -638,8 +638,8 @@ describe 'The Object Type' do
           b => { type => Integer }
         }
       OBJECT
-      expect(t1.i12n_type).to eql(factory.struct({ 'a' => factory.integer }))
-      expect(t2.i12n_type).to eql(factory.struct({ 'a' => factory.integer, 'b' => factory.integer }))
+      expect(t1.init_hash_type).to eql(factory.struct({ 'a' => factory.integer }))
+      expect(t2.init_hash_type).to eql(factory.struct({ 'a' => factory.integer, 'b' => factory.integer }))
     end
 
     it 'produces a struct that reflects overrides made in derived type' do
@@ -655,8 +655,8 @@ describe 'The Object Type' do
           b => { type => Integer, override => true, value => 5 }
         }
       OBJECT
-      expect(t1.i12n_type).to eql(factory.struct({ 'a' => factory.integer, 'b' => factory.integer }))
-      expect(t2.i12n_type).to eql(factory.struct({ 'a' => factory.integer, factory.optional('b') => factory.integer }))
+      expect(t1.init_hash_type).to eql(factory.struct({ 'a' => factory.integer, 'b' => factory.integer }))
+      expect(t2.init_hash_type).to eql(factory.struct({ 'a' => factory.integer, factory.optional('b') => factory.integer }))
     end
   end
 

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

@@ -20,6 +20,10 @@ describe 'Sensitive Type' do
       expect(t.type).to eql(PIntegerType::DEFAULT)
     end
 
+    it 'string representation of unparameterized instance is "Sensitive"' do
+      expect(PSensitiveType::DEFAULT.to_s).to eql('Sensitive')
+    end
+
     context 'when used in Puppet expressions' do
       it 'is equal to itself only' do
         code = <<-CODE

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

@@ -24,6 +24,20 @@ describe 'Timespan type' do
       expect(eval_and_collect_notices(code)).to eq(%w(true true false false))
     end
 
+    it 'does not consider an Integer to be an instance' do
+      code = <<-CODE
+        notice(assert_type(Timespan, 1234))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(/expects a Timespan value, got Integer/)
+    end
+
+    it 'does not consider a Float to be an instance' do
+      code = <<-CODE
+        notice(assert_type(Timespan, 1.234))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(/expects a Timespan value, got Float/)
+    end
+
     context "when parameterized" do
       it 'is equal other types with the same parameterization' do
         code = <<-CODE