puppet 4.4.2-x64-mingw32 → 4.5.0-x64-mingw32

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

@@ -15,7 +15,7 @@ describe 'the type mismatch describer' do
       }
       f({'a' => 'a', 'b' => 23})
     CODE
-    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expects a Hash\[String, String\] value, got Struct\[\{'a' => String, 'b' => Integer\}\]/)
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /'f' parameter 'h' entry 'b' expects a String value, got Integer/)
   end
 
   it 'will report a mismatch between a array and tuple with details' do
@@ -78,7 +78,7 @@ describe 'the type mismatch describer' do
       check_tree({ 'x' => {'y' => {32 => 'n'}}})
     CODE
     expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
-      /parameter 'tree' expects a Tree = Hash\[String, Tree\] value, got Struct\[\{'x' => Struct\[\{'y' => Hash\[Integer, String\]\}\]\}\]/))
+      /parameter 'tree' entry 'x' entry 'y' expects a Tree = Hash\[String, Tree\] value, got Hash\[Integer\[32, 32\], String\[1, 1\]\]/))
   end
 
   it 'will use type normalization' do

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
 
@@ -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

@@ -5,6 +5,8 @@ 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) }
@@ -152,8 +154,6 @@ describe 'Puppet Type System' do
   end
 
   context 'Iterable type' do
-    include PuppetSpec::Compiler
-
     it 'can be parameterized with element type' do
       code = <<-CODE
       function foo(Iterable[String] $x) {
@@ -168,8 +168,6 @@ describe 'Puppet Type System' do
   end
 
   context 'Iterator type' do
-    include PuppetSpec::Compiler
-
     let!(:iterint) { tf.iterator(tf.integer) }
 
     context 'when testing instance?' do
@@ -216,8 +214,6 @@ describe 'Puppet Type System' do
   end
 
   context 'Collection type' do
-    include PuppetSpec::Compiler
-
     it 'can be parameterized with a range' do
       code = <<-CODE
       notice(Collection[5, default] == Collection[5])
@@ -335,9 +331,22 @@ describe 'Puppet Type System' do
     end
   end
 
-  context 'Type aliases' do
-    include PuppetSpec::Compiler
+  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]]
@@ -450,7 +459,103 @@ describe 'Puppet Type System' do
       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