puppet 4.4.0 → 4.5.0

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

@@ -1,11 +1,13 @@
 require 'spec_helper'
 require 'puppet/pops'
 
-describe Puppet::Pops::Types::TypeParser do
+module Puppet::Pops
+module Types
+describe TypeParser do
   extend RSpec::Matchers::DSL
 
-  let(:parser) { Puppet::Pops::Types::TypeParser.new }
-  let(:types)  { Puppet::Pops::Types::TypeFactory }
+  let(:parser) { TypeParser.new }
+  let(: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
@@ -60,6 +62,14 @@ describe Puppet::Pops::Types::TypeParser do
     expect(parser.parse("Hash")).to be_the_type(types.hash_of_data)
   end
 
+  it "interprets a parameterized Array[0, 0] as an empty hash with no key and value type" do
+    expect(parser.parse("Array[0, 0]")).to be_the_type(types.array_of(types.default, types.range(0, 0)))
+  end
+
+  it "interprets a parameterized Hash[0, 0] as an empty hash with no key and value type" do
+    expect(parser.parse("Hash[0, 0]")).to be_the_type(types.hash_of(types.default, types.default, types.range(0, 0)))
+  end
+
   it "interprets a parameterized Hash[t] as a Hash of Scalar to t" do
     expect(parser.parse("Hash[Scalar, Integer]")).to be_the_type(types.hash_of(types.integer))
   end
@@ -123,7 +133,7 @@ describe Puppet::Pops::Types::TypeParser do
       'Pattern[/x9/, /([a-z]+)([1-9]+)/]'  => [:pattern, [/x9/, /([a-z]+)([1-9]+)/]],
     }.each do |source, type|
       it "such that the source '#{source}' yields the type #{type.to_s}" do
-        expect(parser.parse(source)).to be_the_type(Puppet::Pops::Types::TypeFactory.send(type[0], *type[1]))
+        expect(parser.parse(source)).to be_the_type(TypeFactory.send(type[0], *type[1]))
       end
     end
   end
@@ -135,50 +145,71 @@ describe Puppet::Pops::Types::TypeParser do
 
   context 'with scope context and loader' do
     let!(:scope) { {} }
+    let(:loader) { Object.new }
 
     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
+      Adapters::LoaderAdapter.expects(:loader_for_model_object).with(instance_of(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'))
+    it 'interprets anything that is not found by the loader to be a type reference' do
+      loader.expects(:load).with(:type, 'nonesuch').returns nil
+      expect(parser.parse('Nonesuch', scope)).to be_the_type(types.type_reference('Nonesuch'))
+    end
+
+    it 'interprets anything that is found by the loader to be what the loader found' do
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(parser.parse('File', scope)).to be_the_type(types.resource('File'))
     end
 
     it "parses a resource type with title" do
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       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
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       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
+      loader.expects(:load).with(:type, 'file').returns nil
       expect(parser.parse("Resource[File, '/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
+
+    it "parses a resource type with title using 'Resource[Type[title]]'" do
+      loader.expects(:load).with(:type, 'nonesuch').returns nil
+      expect(parser.parse("Resource[Nonesuch['fife']]", scope)).to be_the_type(types.resource('nonesuch', 'fife'))
+    end
   end
 
   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
+    it 'interprets anything that is not found by the loader to be a type reference' do
+      loader.expects(:load).with(:type, 'nonesuch').returns nil
+      expect(parser.parse('Nonesuch', loader)).to be_the_type(types.type_reference('Nonesuch'))
+    end
+
+    it 'interprets anything that is found by the loader to be what the loader found' do
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse('File', loader)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title" do
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       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
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       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
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("Resource[File, '/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
   end
@@ -189,7 +220,7 @@ describe Puppet::Pops::Types::TypeParser do
     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']))
+      expect(parser.parse("File['/tmp/foo']")).to eq(types.type_reference("File['/tmp/foo']"))
     end
   end
 
@@ -243,7 +274,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
 
@@ -251,11 +282,17 @@ describe Puppet::Pops::Types::TypeParser do
     t = parser.parse("Callable[0,1]")
     expect(t).to be_the_type(types.callable(0,1))
     # Contains a Unit type to indicate "called with what you accept"
-    expect(t.param_types.types[0]).to be_the_type(Puppet::Pops::Types::PUnitType.new())
+    expect(t.param_types.types[0]).to be_the_type(PUnitType.new())
+  end
+
+  it 'parses all known literals' do
+    t = parser.parse('Nonesuch[{a=>undef,b=>true,c=>false,d=>default,e=>"string",f=>0,g=>1.0,h=>[1,2,3]}]')
+    expect(t).to be_a(PTypeReferenceType)
+    expect(t.type_string).to eql('Nonesuch[{a=>undef,b=>true,c=>false,d=>default,e=>"string",f=>0,g=>1.0,h=>[1,2,3]}]')
   end
 
   matcher :be_the_type do |type|
-    calc = Puppet::Pops::Types::TypeCalculator.new
+    calc = TypeCalculator.new
 
     match do |actual|
       calc.assignable?(actual, type) && calc.assignable?(type, actual)
@@ -283,6 +320,8 @@ describe Puppet::Pops::Types::TypeParser do
   end
 
   def the_type_spec_for(type)
-    Puppet::Pops::Types::TypeFormatter.string(type)
+    TypeFormatter.string(type)
   end
 end
+end
+end

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

@@ -1,9 +1,12 @@
 require 'spec_helper'
 require 'puppet/pops'
+require 'puppet_spec/compiler'
 
 module Puppet::Pops
 module Types
 describe 'Puppet Type System' do
+  include PuppetSpec::Compiler
+
   let(:tf) { TypeFactory }
   context 'Integer type' do
     let!(:a) { tf.range(10, 20) }
@@ -150,6 +153,86 @@ describe 'Puppet Type System' do
     end
   end
 
+  context 'Iterable type' do
+    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
+    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
+    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 +252,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 +262,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,7 +323,239 @@ 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 'Runtime type' do
+    it 'can be created with a runtime and a runtime type name' do
+      expect(tf.runtime('ruby', 'Hash').to_s).to eq("Runtime[ruby, 'Hash']")
+    end
+
+    it 'can be created with a runtime and, puppet name pattern, and runtime replacement' do
+      expect(tf.runtime('ruby', [/^MyPackage::(.*)$/, 'MyModule::\1']).to_s).to eq("Runtime[ruby, [/^MyPackage::(.*)$/, 'MyModule::\\1']]")
+    end
+
+    it 'will map a Puppet name to a runtime type' do
+      t = tf.runtime('ruby', [/^MyPackage::(.*)$/, 'MyModule::\1'])
+      expect(t.from_puppet_name('MyPackage::MyType').to_s).to eq("Runtime[ruby, 'MyModule::MyType']")
+    end
+  end
+
+  context 'Type aliases' do
+    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
+
+    it 'will not allow dynamic constructs in type definition' do
+      code = <<-CODE
+      type Foo = Enum[$facts[os][family]]
+      notice(Foo)
+      CODE
+      expect{ eval_and_collect_notices(code) }.to raise_error(Puppet::Error,
+        /The expression <\$facts\[os\]\[family\]> is not a valid type specification/)
+    end
+  end
+
+  context 'Type mappings' do
+    it 'can register a singe type mapping' do
+      source = <<-CODE
+        type MyModule::ImplementationRegistry = Object[{}]
+        type Runtime[ruby, 'Puppet::Pops::Types::ImplementationRegistry'] = MyModule::ImplementationRegistry
+        notice(true)
+      CODE
+      collect_notices(source) do |compiler|
+        compiler.compile do |catalog|
+          type = Loaders.implementation_registry.type_for_module(ImplementationRegistry)
+          expect(type).to be_a(PObjectType)
+          expect(type.name).to eql('MyModule::ImplementationRegistry')
+          catalog
+        end
+      end
+    end
+
+    it 'can register a regexp based mapping' do
+      source = <<-CODE
+        type MyModule::TypeMismatchDescriber = Object[{}]
+        type Runtime[ruby, [/^Puppet::Pops::Types::(\\w+)$/, 'MyModule::\\1']] = [/^MyModule::(\\w+)$/, 'Puppet::Pops::Types::\\1']
+        notice(true)
+      CODE
+      collect_notices(source) do |compiler|
+        compiler.compile do |catalog|
+          type = Loaders.implementation_registry.type_for_module(TypeMismatchDescriber)
+          expect(type).to be_a(PObjectType)
+          expect(type.name).to eql('MyModule::TypeMismatchDescriber')
+          catalog
+        end
+      end
+    end
+
+    it 'a type mapping affects type inference' do
+      source = <<-CODE
+        type MyModule::ImplementationRegistry = Object[{}]
+        type Runtime[ruby, 'Puppet::Pops::Types::ImplementationRegistry'] = MyModule::ImplementationRegistry
+        notice(true)
+      CODE
+      collect_notices(source) do |compiler|
+        compiler.compile do |catalog|
+          type = TypeCalculator.singleton.infer(Loaders.implementation_registry)
+          expect(type).to be_a(PObjectType)
+          expect(type.name).to eql('MyModule::ImplementationRegistry')
+          catalog
+        end
+      end
+    end
+  end
+
+  context 'When attempting to redefine a built in type' do
+    it 'such as Integer, an error is raised' do
+      code = <<-CODE
+        type Integer = String
+        notice 'hello' =~ Integer
+      CODE
+      expect{ eval_and_collect_notices(code) }.to raise_error(/Attempt to redefine entity 'type\/integer'. Originally set by Puppet-Type-System\/Static-Loader/)
+    end
+  end
+
+  context 'instantiation via new_function is supported by' do
+    let(:loader) { Loader::BaseLoader.new(nil, "types_unit_test_loader") }
+    it 'Integer' do
+      func_class = tf.integer.new_function(loader)
+      expect(func_class).to be_a(Class)
+      expect(func_class.superclass).to be(Puppet::Functions::Function)
+    end
+
+    it 'Optional[Integer]' do
+      func_class = tf.optional(tf.integer).new_function(loader)
+      expect(func_class).to be_a(Class)
+      expect(func_class.superclass).to be(Puppet::Functions::Function)
+    end
+  end
+
+  context 'instantiation via new_function is not supported by' do
+    let(:loader) { Loader::BaseLoader.new(nil, "types_unit_test_loader") }
+
+      it 'Any, Scalar, Collection' do
+        [tf.any, tf.scalar, tf.collection ].each do |t|
+        expect { t.new_function(loader)
+        }.to raise_error(ArgumentError, /Creation of new instance of type '#{t.to_s}' is not supported/)
+      end
+    end
+  end
+
 end
 end
 end

data/spec/unit/pops/validator/validator_spec.rb

@@ -2,9 +2,7 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet_spec/pops'
-
-# relative to this spec file (./) does not work as this file is loaded by rspec
-require File.join(File.dirname(__FILE__), '../parser/parser_rspec_helper')
+require_relative '../parser/parser_rspec_helper'
 
 describe "validating 4x" do
   include ParserRspecHelper
@@ -34,6 +32,45 @@ describe "validating 4x" do
     expect(validate(fqn('::_aa').var())).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
   end
 
+  context 'with the default settings for --strict' do
+    it 'produces a warning for duplicate keyes in a literal hash' do
+      acceptor = validate(parse('{ a => 1, a => 2 }'))
+      expect(acceptor.warning_count).to eql(1)
+      expect(acceptor.error_count).to eql(0)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
+    end
+  end
+
+  context 'with --strict set to warning' do
+    before(:each) { Puppet[:strict] = :warning }
+    it 'produces a warning for duplicate keyes in a literal hash' do
+      acceptor = validate(parse('{ a => 1, a => 2 }'))
+      expect(acceptor.warning_count).to eql(1)
+      expect(acceptor.error_count).to eql(0)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
+    end
+  end
+
+  context 'with --strict set to error' do
+    before(:each) { Puppet[:strict] = :error }
+    it 'produces an error for duplicate keyes in a literal hash' do
+      acceptor = validate(parse('{ a => 1, a => 2 }'))
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
+      expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
+    end
+  end
+
+  context 'with --strict set to off' do
+    before(:each) { Puppet[:strict] = :off }
+    it 'does not produce an error or warning for duplicate keyes in a literal hash' do
+      acceptor = validate(parse('{ a => 1, a => 2 }'))
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(0)
+      expect(acceptor).to_not have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
+    end
+  end
+
   context 'for non productive expressions' do
     [ '1',
       '3.14',
@@ -385,16 +422,53 @@ describe "validating 4x" do
         expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_EXPRESSION)
       end
     end
-  end
 
-  context "capability annotations" do
-    before(:each) do
-      with_app_management(true)
-    end
+    context 'that are type mappings' do
+      it 'accepts a valid type mapping expression' do
+        source = <<-CODE
+          type Runtime[ruby, 'MyModule::MyObject'] = MyPackage::MyObject
+          notice(true)
+        CODE
+        expect(validate(parse(source))).not_to have_any_issues
+      end
+
+      it 'accepts a valid regexp based type mapping expression' do
+        source = <<-CODE
+          type Runtime[ruby, [/^MyPackage::(\w+)$/, 'MyModule::\1']] = [/^MyModule::(\w+)$/, 'MyPackage::\1']
+          notice(true)
+        CODE
+        expect(validate(parse(source))).not_to have_any_issues
+      end
+
+      it 'raises an error when a regexp based Runtime type is paired with a Puppet Type' do
+        source = <<-CODE
+          type Runtime[ruby, [/^MyPackage::(\w+)$/, 'MyModule::\1']] = MyPackage::MyObject
+          notice(true)
+        CODE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_REGEXP_TYPE_MAPPING)
+      end
 
-    after(:each) do
-      with_app_management(false)
+      it 'raises an error when a singleton Runtime type is paired with replacement pattern' do
+        source = <<-CODE
+          type Runtime[ruby, 'MyModule::MyObject'] = [/^MyModule::(\w+)$/, 'MyPackage::\1']
+          notice(true)
+        CODE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_SINGLE_TYPE_MAPPING)
+      end
+
+      it 'raises errors unless LHS is Runtime type' do
+        source = <<-CODE
+          type Pattern[/^MyPackage::(\w+)$/, 'MyModule::\1'] = [/^MyModule::(\w+)$/, 'MyPackage::\1']
+          notice(true)
+        CODE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::UNSUPPORTED_EXPRESSION)
+      end
     end
+  end
+
+  context "capability annotations" do
+    before(:each) { Puppet[:app_management] = true }
+    after(:each) { Puppet[:app_management] = false }
 
     ['produces', 'consumes'].each do |word|
       it "rejects illegal resource types in #{word} clauses" do