puppet 5.3.7-x64-mingw32 → 5.4.0-x64-mingw32

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

@@ -0,0 +1,207 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+  module Types
+    describe 'Error type' do
+      context 'when used in Puppet expressions' do
+        include PuppetSpec::Compiler
+        it 'is equal to itself only' do
+          expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true false false))
+            $t = Error
+            notice(Error =~ Type[Error])
+            notice(Error == Error)
+            notice(Error < Error)
+            notice(Error > Error)
+            CODE
+        end
+
+        context "when parameterized" do
+          it 'is equal other types with the same parameterization' do
+            code = <<-CODE
+              notice(Error['puppet/error'] == Error['puppet/error', default])
+              notice(Error['puppet/error', 'ouch'] == Error['puppet/error', 'ouch'])
+              notice(Error['puppet/error', 'ouch'] != Error['puppet/error', 'ouch!'])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(%w(true true true))
+          end
+
+          it 'is assignable from more qualified types' do
+            expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true true))
+              notice(Error > Error['puppet/error'])
+              notice(Error['puppet/error'] > Error['puppet/error', 'ouch'])
+              notice(Error['puppet/error', default] > Error['puppet/error', 'ouch'])
+              CODE
+          end
+
+          it 'is not assignable unless kind is assignable' do
+            expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true false true false true false true))
+              notice(Error[/a/] > Error['hah'])
+              notice(Error[/a/] > Error['hbh'])
+              notice(Error[Enum[a,b,c]] > Error[a])
+              notice(Error[Enum[a,b,c]] > Error[d])
+              notice(Error[Pattern[/a/, /b/]] > Error[a])
+              notice(Error[Pattern[/a/, /b/]] > Error[c])
+              notice(Error[Pattern[/a/, /b/]] > Error[Enum[a, b]])
+              CODE
+          end
+
+          it 'presents parsable string form' do
+            code = <<-CODE
+              notice(Error['a'])
+              notice(Error[/a/])
+              notice(Error[Enum['a', 'b']])
+              notice(Error[Pattern[/a/, /b/]])
+              notice(Error['a', default])
+              notice(Error[/a/, default])
+              notice(Error[Enum['a', 'b'], default])
+              notice(Error[Pattern[/a/, /b/], default])
+              notice(Error[default,'a'])
+              notice(Error[default,/a/])
+              notice(Error[default,Enum['a', 'b']])
+              notice(Error[default,Pattern[/a/, /b/]])
+              notice(Error['a','a'])
+              notice(Error[/a/,/a/])
+              notice(Error[Enum['a', 'b'],Enum['a', 'b']])
+              notice(Error[Pattern[/a/, /b/],Pattern[/a/, /b/]])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Error['a']",
+              'Error[/a/]',
+              "Error[Enum['a', 'b']]",
+              "Error[Pattern[/a/, /b/]]",
+              "Error['a']",
+              'Error[/a/]',
+              "Error[Enum['a', 'b']]",
+              "Error[Pattern[/a/, /b/]]",
+              "Error[default, 'a']",
+              'Error[default, /a/]',
+              "Error[default, Enum['a', 'b']]",
+              "Error[default, Pattern[/a/, /b/]]",
+              "Error['a', 'a']",
+              'Error[/a/, /a/]',
+              "Error[Enum['a', 'b'], Enum['a', 'b']]",
+              "Error[Pattern[/a/, /b/], Pattern[/a/, /b/]]",
+            ])
+          end
+        end
+
+        context 'an Error instance' do
+          it 'can be created using positional arguments' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error', {'detail' => 'val'}, 'OOPS')
+              notice($o)
+              notice(type($o))
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Error({'msg' => 'bad things happened', 'kind' => 'puppet/error', 'details' => {'detail' => 'val'}, 'issue_code' => 'OOPS'})",
+              "Error['puppet/error', 'OOPS']"
+            ])
+          end
+
+          it 'can be created using named arguments' do
+            code = <<-CODE
+              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
+              notice($o)
+              notice(type($o))
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Error({'msg' => 'Sorry, not implemented', 'kind' => 'puppet/error', 'issue_code' => 'NOT_IMPLEMENTED'})",
+              "Error['puppet/error', 'NOT_IMPLEMENTED']"
+            ])
+          end
+
+          it 'exposes message' do
+            code = <<-CODE
+              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
+              notice($o.message)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["Sorry, not implemented"])
+          end
+
+          it 'exposes kind' do
+            code = <<-CODE
+              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
+              notice($o.kind)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["puppet/error"])
+          end
+
+          it 'exposes issue_code' do
+            code = <<-CODE
+              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
+              notice($o.issue_code)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["NOT_IMPLEMENTED"])
+          end
+
+          it 'exposes details' do
+            code = <<-CODE
+              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', details => { 'detailk' => 'detailv' })
+              notice($o.details)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["{detailk => detailv}"])
+          end
+
+          it 'is an instance of its inferred type' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error')
+              notice($o =~ type($o))
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+
+          it 'is an instance of Error with matching kind' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error')
+              notice($o =~ Error[/puppet\\/error/])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+
+          it 'is an instance of Error with matching issue_code' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error', {}, 'FEE')
+              notice($o =~ Error[default, 'FEE'])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+
+          it 'is an instance of Error with matching kind and issue_code' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error', {}, 'FEE')
+              notice($o =~ Error['puppet/error', 'FEE'])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+
+          it 'is not an instance of Error unless kind matches' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppetlabs/error')
+              notice($o =~ Error[/puppet\\/error/])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['false'])
+          end
+
+          it 'is not an instance of Error unless issue_code matches' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppetlabs/error', {}, 'BAR')
+              notice($o =~ Error[default, 'FOO'])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['false'])
+          end
+
+          it 'is not an instance of Error unless both kind and issue is a match' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error', {}, 'FEE')
+              notice($o =~ Error['puppetlabs/error', 'FEE'])
+              notice($o =~ Error['puppet/error', 'FUM'])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['false', 'false'])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -279,6 +279,104 @@ describe 'The Init Type' do
       CODE
       expect(eval_and_collect_notices(code)).to eql(["One({'init_one' => 'w'})"])
     end
+
+    context 'computes if x is an instance such that' do
+      %w(true false True False TRUE FALSE tRuE FaLsE Yes No yes no YES NO YeS nO y n Y N).each do |str|
+        it "string '#{str}' is an instance of Init[Boolean]" do
+          expect(eval_and_collect_notices("notice('#{str}' =~ Init[Boolean])")).to eql(['true'])
+        end
+      end
+
+      it 'arbitrary string is not an instance of Init[Boolean]' do
+        expect(eval_and_collect_notices("notice('blue' =~ Init[Boolean])")).to eql(['false'])
+      end
+
+      it 'empty string is not an instance of Init[Boolean]' do
+        expect(eval_and_collect_notices("notice('' =~ Init[Boolean])")).to eql(['false'])
+      end
+
+      it 'undef string is not an instance of Init[Boolean]' do
+        expect(eval_and_collect_notices("notice(undef =~ Init[Boolean])")).to eql(['false'])
+      end
+
+      %w(0 1 0634 0x3b -0xba 0b1001 +0b1111 23.14 -2.3 2e-21 1.23e18  -0.23e18).each do |str|
+        it "string '#{str}' is an instance of Init[Numeric]" do
+          expect(eval_and_collect_notices("notice('#{str}' =~ Init[Numeric])")).to eql(['true'])
+        end
+      end
+
+      it 'non numeric string is not an instance of Init[Numeric]' do
+        expect(eval_and_collect_notices("notice('blue' =~ Init[Numeric])")).to eql(['false'])
+      end
+
+      it 'empty string is not an instance of Init[Numeric]' do
+        expect(eval_and_collect_notices("notice('' =~ Init[Numeric])")).to eql(['false'])
+      end
+
+      it 'undef is not an instance of Init[Numeric]' do
+        expect(eval_and_collect_notices("notice(undef =~ Init[Numeric])")).to eql(['false'])
+      end
+
+      %w(0 1 0634 0x3b -0xba 0b1001 +0b1111 23.14 -2.3 2e-21 1.23e18  -0.23e18).each do |str|
+        it "string '#{str}' is an instance of Init[Float]" do
+          expect(eval_and_collect_notices("notice('#{str}' =~ Init[Float])")).to eql(['true'])
+        end
+      end
+
+      it 'non numeric string is not an instance of Init[Float]' do
+        expect(eval_and_collect_notices("notice('blue' =~ Init[Float])")).to eql(['false'])
+      end
+
+      it 'empty string is not an instance of Init[Float]' do
+        expect(eval_and_collect_notices("notice('' =~ Init[Float])")).to eql(['false'])
+      end
+
+      it 'undef is not an instance of Init[Float]' do
+        expect(eval_and_collect_notices("notice(undef =~ Init[Float])")).to eql(['false'])
+      end
+
+      %w(0 1 0634 0x3b -0xba 0b1001 0b1111).each do |str|
+        it "string '#{str}' is an instance of Init[Integer]" do
+          expect(eval_and_collect_notices("notice('#{str}' =~ Init[Integer])")).to eql(['true'])
+        end
+      end
+
+      %w(23.14 -2.3 2e-21 1.23e18  -0.23e18).each do |str|
+        it "valid float string '#{str}' is not an instance of Init[Integer]" do
+          expect(eval_and_collect_notices("notice('#{str}' =~ Init[Integer])")).to eql(['false'])
+        end
+      end
+
+      it 'non numeric string is not an instance of Init[Integer]' do
+        expect(eval_and_collect_notices("notice('blue' =~ Init[Integer])")).to eql(['false'])
+      end
+
+      it 'empty string is not an instance of Init[Integer]' do
+        expect(eval_and_collect_notices("notice('' =~ Init[Integer])")).to eql(['false'])
+      end
+
+      it 'undef is not an instance of Init[Integer]' do
+        expect(eval_and_collect_notices("notice(undef =~ Init[Integer])")).to eql(['false'])
+      end
+
+      %w(1.2.3 1.1.1-a3 1.2.3+b3 1.2.3-a3+b3).each do |str|
+        it "string '#{str}' is an instance of Init[SemVer]" do
+          expect(eval_and_collect_notices("notice('#{str}' =~ Init[SemVer])")).to eql(['true'])
+        end
+      end
+
+      it 'non SemVer compliant string is not an instance of Init[SemVer]' do
+        expect(eval_and_collect_notices("notice('blue' =~ Init[SemVer])")).to eql(['false'])
+      end
+
+      it 'empty string is not an instance of Init[SemVer]' do
+        expect(eval_and_collect_notices("notice('' =~ Init[SemVer])")).to eql(['false'])
+      end
+
+      it 'undef is not an instance of Init[SemVer]' do
+        expect(eval_and_collect_notices("notice(undef =~ Init[SemVer])")).to eql(['false'])
+      end
+    end
   end
 end
 end

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

@@ -9,13 +9,17 @@ describe 'The Object Type' do
 
   let(:parser) { TypeParser.singleton }
   let(:pp_parser) { Parser::EvaluatingParser.new }
+  let(:env) { Puppet::Node::Environment.create(:testing, []) }
+  let(:node) { Puppet::Node.new('testnode', :environment => env) }
   let(:loader) { Loaders.find_loader(nil) }
   let(:factory) { TypeFactory }
 
-  around(:each) do |example|
-    Puppet.override(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
-      example.run
-    end
+  before(:each) do
+    Puppet.push_context(:loaders => Loaders.new(env))
+  end
+
+  after(:each) do
+    Puppet.pop_context()
   end
 
   def type_object_t(name, body_string)
@@ -765,14 +769,30 @@ describe 'The Object Type' do
       expect(obj.to_s).to eql("Object[{name => 'MyObject', attributes => {'a' => Integer}}]")
     end
 
-    it 'produced hash that does not include defaults' do
+    it 'produced hash that does not include default for equality_include_type' do
+      obj = t = parse_object('MyObject', <<-OBJECT)
+        attributes => { a => Integer },
+        equality_include_type => true
+      OBJECT
+      expect(obj.to_s).to eql("Object[{name => 'MyObject', attributes => {'a' => Integer}}]")
+    end
+
+    it 'constants are presented in a separate hash if they use a generic type' do
       obj = t = parse_object('MyObject', <<-OBJECT)
         attributes => {
-          a => { type => Integer, value => 23, kind => constant, final => true },
+          a => { type => Integer, value => 23, kind => constant },
+        },
+      OBJECT
+      expect(obj.to_s).to eql("Object[{name => 'MyObject', constants => {'a' => 23}}]")
+    end
+
+    it 'constants are not presented in a separate hash unless they use a generic type' do
+      obj = t = parse_object('MyObject', <<-OBJECT)
+        attributes => {
+          a => { type => Integer[0, 30], value => 23, kind => constant },
         },
-        equality_include_type => true
       OBJECT
-      expect(obj.to_s).to eql("Object[{name => 'MyObject', attributes => {'a' => {type => Integer, kind => constant, value => 23}}}]")
+      expect(obj.to_s).to eql("Object[{name => 'MyObject', attributes => {'a' => {type => Integer[0, 30], kind => constant, value => 23}}}]")
     end
 
     it 'can create an equal copy from produced hash' do
@@ -1109,11 +1129,13 @@ describe 'The Object Type' do
           "name => 'MyFirstObject', "+
           "attributes => {"+
           "'first_a' => Integer, "+
-          "'first_b' => {type => String, kind => constant, value => 'the first constant'}, "+
           "'first_c' => {type => String, final => true, kind => derived}, "+
           "'first_d' => {type => String, kind => given_or_derived}, "+
           "'first_e' => String"+
           "}, "+
+          "constants => {"+
+          "'first_b' => 'the first constant'"+
+          "}, "+
           "functions => {"+
           "'first_x' => Callable[Integer], "+
           "'first_y' => Callable[String]"+
@@ -1125,9 +1147,11 @@ describe 'The Object Type' do
           "parent => MyFirstObject, "+
           "attributes => {"+
           "'second_a' => Integer, "+
-          "'second_b' => {type => String, kind => constant, value => 'the second constant'}, "+
           "'first_e' => {type => Enum['fee', 'foo', 'fum'], final => true, override => true, value => 'fee'}"+
           "}, "+
+          "constants => {"+
+          "'second_b' => 'the second constant'"+
+          "}, "+
           "functions => {"+
           "'second_x' => Callable[Integer], "+
           "'second_y' => Callable[String]"+
@@ -1136,6 +1160,247 @@ describe 'The Object Type' do
           "}]"
         ])
     end
+
+    context 'object with type parameters' do
+      it 'can be declared' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['ok'])
+        type MyType = Object[
+          type_parameters => {
+            p1 => String
+          }]
+        notice('ok')
+        PUPPET
+      end
+
+      it 'can be referenced' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(["MyType['hello']"])
+        type MyType = Object[
+          type_parameters => {
+            p1 => String
+          }]
+
+        notice(MyType['hello'])
+        PUPPET
+      end
+
+      it 'leading unset parameters are represented as default in string representation' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(["MyType[default, 'world']"])
+        type MyType = Object[
+          type_parameters => {
+            p1 => String,
+            p2 => String,
+          }]
+
+        notice(MyType[default, 'world'])
+        PUPPET
+      end
+
+      it 'trailing unset parameters are skipped in string representation' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(["MyType['my']"])
+        type MyType = Object[
+          type_parameters => {
+            p1 => String,
+            p2 => String,
+          }]
+
+        notice(MyType['my'])
+        PUPPET
+      end
+
+      it 'a type with more than 2 type parameters uses named arguments in string representation' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(["MyType[{'p1' => 'my'}]"])
+        type MyType = Object[
+          type_parameters => {
+            p1 => String,
+            p2 => String,
+            p3 => String,
+          }]
+
+        notice(MyType['my'])
+        PUPPET
+      end
+
+      it 'can be used without parameters' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(["Object[{name => 'MyType', type_parameters => {'p1' => String}}]"])
+        type MyType = Object[
+          type_parameters => {
+            p1 => String
+          }]
+
+        notice(MyType)
+        PUPPET
+      end
+
+      it 'involves type parameter values when testing instance of' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['true', 'false', 'true'])
+        type MyType = Object[
+          type_parameters => {
+            p1 => String
+          },
+          attributes => {
+            p1 => String
+          }]
+
+        $x = MyType('world')
+        notice($x =~ MyType)
+        notice($x =~ MyType['hello'])
+        notice($x =~ MyType['world'])
+        PUPPET
+      end
+
+      it 'involves type parameter values when testing assignability' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['true', 'false', 'true', 'true', 'false', 'true'])
+        type MyType = Object[
+          type_parameters => {
+            p1 => String
+          },
+          attributes => {
+            p1 => String
+          }]
+
+        $x = MyType['world']
+        notice($x <= MyType)
+        notice($x <= MyType['hello'])
+        notice($x <= MyType['world'])
+
+        notice(MyType >= $x)
+        notice(MyType['hello'] >= $x)
+        notice(MyType['world'] >= $x)
+        PUPPET
+      end
+
+      it 'parameters can be types' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['true', 'true', 'true', 'true', 'false'])
+        type MyType = Object[
+          type_parameters => {
+            p1 => Variant[String,Regexp,Type[Enum],Type[Pattern],Type[NotUndef]],
+            p2 => Variant[String,Regexp,Type[Enum],Type[Pattern],Type[NotUndef]],
+          },
+          attributes => {
+            p1 => String,
+            p2 => String
+          }]
+        $x = MyType('good bye', 'cruel world')
+        notice($x =~ MyType)
+        notice($x =~ MyType[Enum['hello', 'good bye']])
+        notice($x =~ MyType[Enum['hello', 'good bye'], Pattern[/world/, /universe/]])
+        notice($x =~ MyType[NotUndef, NotUndef])
+        notice($x =~ MyType[Enum['hello', 'yo']])
+        PUPPET
+      end
+
+      it 'parameters can be provided using named arguments' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['true', 'false', 'true'])
+        type MyType = Object[
+          type_parameters => {
+            p1 => String,
+            p2 => String
+          },
+          attributes => {
+            p1 => String,
+            p2 => String
+          }]
+        $x = MyType('good bye', 'cruel world')
+        notice($x =~ MyType)
+        notice($x =~ MyType[p1 => 'hello', p2 => 'cruel world'])
+        notice($x =~ MyType[p1 => 'good bye', p2 => 'cruel world'])
+        PUPPET
+      end
+
+      it 'at least one parameter must be given' do
+        expect{eval_and_collect_notices(<<-PUPPET, node)}.to raise_error(/The MyType-Type cannot be parameterized using an empty parameter list/)
+        type MyType = Object[
+          type_parameters => {
+            p1 => Variant[String,Regexp,Type[Enum],Type[Pattern]],
+          },
+          attributes => {
+            p1 => String,
+          }]
+        notice(MyType[default])
+        PUPPET
+      end
+
+      it 'undef is a valid value for a type parameter' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['true', 'false'])
+        type MyType = Object[
+          type_parameters => {
+            p1 => Optional[String],
+          },
+          attributes => {
+            p1 => Optional[String],
+          }]
+        notice(MyType() =~ MyType[undef])
+        notice(MyType('hello') =~ MyType[undef])
+        PUPPET
+      end
+
+      it 'Type parameters does not mean that type must be parameterized' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['true'])
+        type MyType = Object[
+          type_parameters => {
+            p1 => Variant[Undef,String,Regexp,Type[Enum],Type[Pattern]],
+            p2 => Variant[Undef,String,Regexp,Type[Enum],Type[Pattern]],
+          },
+          attributes => {
+            p1 => String,
+            p2 => String
+          }]
+        notice(MyType('hello', 'world') =~ MyType)
+        PUPPET
+      end
+
+      it 'A parameterized type is assignable to another parameterized type if base type and parameters are assignable' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['true'])
+        type MyType = Object[
+          type_parameters => {
+            p1 => Variant[Undef,String,Regexp,Type[Enum],Type[Pattern]],
+            p2 => Variant[Undef,String,Regexp,Type[Enum],Type[Pattern]],
+          },
+          attributes => {
+            p1 => String,
+            p2 => String
+          }]
+        notice(MyType[Pattern[/a/,/b/]] > MyType[Enum['a','b']])
+        PUPPET
+      end
+
+      it 'Instance is inferred to parameterized type' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['true', 'true', 'true', 'true', 'true'])
+        type MyType = Object[
+          type_parameters => {
+            p1 => Variant[Undef,String,Regexp,Type[Enum],Type[Pattern]],
+            p2 => Variant[Undef,String,Regexp,Type[Enum],Type[Pattern]],
+          },
+          attributes => {
+            p1 => String,
+            p2 => String
+          }]
+        $x = MyType('hello', 'world')
+        notice(type($x, generalized) == MyType)
+        notice(type($x) < MyType)
+        notice(type($x) < MyType['hello'])
+        notice(type($x) < MyType[/hello/, /world/])
+        notice(type($x) == MyType['hello', 'world'])
+        PUPPET
+      end
+
+      it 'Attributes of instance of parameterized type can be accessed using function calls' do
+        expect(eval_and_collect_notices(<<-PUPPET, node)).to eql(['hello', 'world'])
+        type MyType = Object[
+          type_parameters => {
+            p1 => Variant[Undef,String,Regexp,Type[Enum],Type[Pattern]],
+            p2 => Variant[Undef,String,Regexp,Type[Enum],Type[Pattern]],
+          },
+          attributes => {
+            p1 => String,
+            p2 => String
+          }]
+        $x = MyType('hello', 'world')
+        notice($x.p1)
+        notice($x.p2)
+        PUPPET
+      end
+    end
   end
 
   context "when used with function 'new'" do