puppet 4.1.0 → 4.10.0

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
 require 'puppet/pops/types/type_factory'
-
+require 'base64'
 
 # relative to this spec file (./) does not work as this file is loaded by rspec
 require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')
@@ -20,6 +20,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     Puppet::Pops::Types::TypeFactory.float_range(from, to)
   end
 
+  def binary(s)
+    # Note that the factory is not aware of Binary and cannot operate on a
+    # literal binary. Instead, it must create a call to Binary.new() with the base64 encoded
+    # string as an argument
+    CALL_NAMED(QREF("Binary"), true, [Base64.strict_encode64(s)])
+  end
+
   context 'The evaluator when operating on a String' do
     it 'can get a single character using a single key index to []' do
       expect(evaluate(literal('abc')[1])).to eql('b')
@@ -45,6 +52,31 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     end
   end
 
+  context 'The evaluator when operating on a Binary' do
+    it 'can get a single character using a single key index to []' do
+      expect(evaluate(binary('abc')[1]).binary_buffer).to eql('b')
+    end
+
+    it 'can get the last character using the key -1 in []' do
+      expect(evaluate(binary('abc')[-1]).binary_buffer).to eql('c')
+    end
+
+    it 'can get a substring by giving two keys' do
+      expect(evaluate(binary('abcd')[1,2]).binary_buffer).to eql('bc')
+      # flattens keys
+      expect(evaluate(binary('abcd')[[1,2]]).binary_buffer).to eql('bc')
+    end
+
+    it 'produces empty string for a substring out of range' do
+      expect(evaluate(binary('abc')[100]).binary_buffer).to eql('')
+    end
+
+    it 'raises an error if arity is wrong for []' do
+      expect{evaluate(binary('abc')[])}.to raise_error(/String supports \[\] with one or two arguments\. Got 0/)
+      expect{evaluate(binary('abc')[1,2,3])}.to raise_error(/String supports \[\] with one or two arguments\. Got 3/)
+    end
+  end
+
   context 'The evaluator when operating on an Array' do
     it 'is tested with the correct assumptions' do
       expect(literal([1,2,3])[1].current.is_a?(Puppet::Pops::Model::AccessExpression)).to eql(true)
@@ -120,12 +152,12 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces an Integer[1]' do
       expr = fqr('Integer')[1]
-      expect(evaluate(expr)).to eql(range(1,1))
+      expect(evaluate(expr)).to eql(range(1,:default))
     end
 
-    it 'produces an Integer[from, <from]' do
+    it 'gives an error for Integer[from, <from]' do
       expr = fqr('Integer')[1,0]
-      expect(evaluate(expr)).to eql(range(1,0))
+      expect{evaluate(expr)}.to raise_error(/'from' must be less or equal to 'to'/)
     end
 
     it 'produces an error for Integer[] if there are more than 2 keys' do
@@ -146,17 +178,17 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces a Float[1.0]' do
       expr = fqr('Float')[1.0]
-      expect(evaluate(expr)).to eql(float_range(1.0,1.0))
+      expect(evaluate(expr)).to eql(float_range(1.0,:default))
     end
 
     it 'produces a Float[1]' do
       expr = fqr('Float')[1]
-      expect(evaluate(expr)).to eql(float_range(1.0,1.0))
+      expect(evaluate(expr)).to eql(float_range(1.0,:default))
     end
 
-    it 'produces a Float[from, <from]' do
+    it 'gives an error for Float[from, <from]' do
       expr = fqr('Float')[1.0,0.0]
-      expect(evaluate(expr)).to eql(float_range(1.0,0.0))
+      expect{evaluate(expr)}.to raise_error(/'from' must be less or equal to 'to'/)
     end
 
     it 'produces an error for Float[] if there are more than 2 keys' do
@@ -166,6 +198,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     # Hash Type
     #
+    it 'produces a Hash[0, 0] from the expression Hash[0, 0]' do
+      expr = fqr('Hash')[0, 0]
+      expect(evaluate(expr)).to be_the_type(types.hash_of(types.default, types.default, types.range(0, 0)))
+    end
+
     it 'produces a Hash[Scalar,String] from the expression Hash[Scalar, String]' do
       expr = fqr('Hash')[fqr('Scalar'), fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
@@ -192,6 +229,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     # Array Type
     #
+    it 'produces an Array[0, 0] from the expression Array[0, 0]' do
+      expr = fqr('Array')[0, 0]
+      expect(evaluate(expr)).to be_the_type(types.array_of(types.default, types.range(0, 0)))
+
+      # arguments are flattened
+      expr = fqr('Array')[[fqr('String')]]
+      expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
+    end
+
     it 'produces an Array[String] from the expression Array[String]' do
       expr = fqr('Array')[fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
@@ -208,13 +254,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces a size constrained Array when the last two arguments specify this' do
       expr = fqr('Array')[fqr('String'), 1]
-      expected_t = types.array_of(String)
-      types.constrain_size(expected_t, 1, :default)
+      expected_t = types.array_of(String, types.range(1, :default))
       expect(evaluate(expr)).to be_the_type(expected_t)
 
       expr = fqr('Array')[fqr('String'), 1, 2]
-      expected_t = types.array_of(String)
-      types.constrain_size(expected_t, 1, 2)
+      expected_t = types.array_of(String, types.range(1, 2))
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
@@ -223,15 +267,49 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect { evaluate(expr)}.to raise_error(/Array-Type\[\] arguments must be types/)
     end
 
+    # Timespan Type
+    #
+    it 'produdes a Timespan type with a lower bound' do
+      expr = fqr('Timespan')[{fqn('hours') => literal(3)}]
+      expect(evaluate(expr)).to be_the_type(types.timespan({'hours' => 3}))
+    end
+
+    it 'produdes a Timespan type with an upper bound' do
+      expr = fqr('Timespan')[literal(:default), {fqn('hours') => literal(9)}]
+      expect(evaluate(expr)).to be_the_type(types.timespan(nil, {'hours' => 9}))
+    end
+
+    it 'produdes a Timespan type with both lower and upper bounds' do
+      expr = fqr('Timespan')[{fqn('hours') => literal(3)}, {fqn('hours') => literal(9)}]
+      expect(evaluate(expr)).to be_the_type(types.timespan({'hours' => 3}, {'hours' => 9}))
+    end
+
+    # Timestamp Type
+    #
+    it 'produdes a Timestamp type with a lower bound' do
+      expr = fqr('Timestamp')[literal('2014-12-12T13:14:15 CET')]
+      expect(evaluate(expr)).to be_the_type(types.timestamp('2014-12-12T13:14:15 CET'))
+    end
+
+    it 'produdes a Timestamp type with an upper bound' do
+      expr = fqr('Timestamp')[literal(:default), literal('2016-08-23T17:50:00 CET')]
+      expect(evaluate(expr)).to be_the_type(types.timestamp(nil, '2016-08-23T17:50:00 CET'))
+    end
+
+    it 'produdes a Timestamp type with both lower and upper bounds' do
+      expr = fqr('Timestamp')[literal('2014-12-12T13:14:15 CET'), literal('2016-08-23T17:50:00 CET')]
+      expect(evaluate(expr)).to be_the_type(types.timestamp('2014-12-12T13:14:15 CET', '2016-08-23T17:50:00 CET'))
+    end
+
     # Tuple Type
     #
     it 'produces a Tuple[String] from the expression Tuple[String]' do
       expr = fqr('Tuple')[fqr('String')]
-      expect(evaluate(expr)).to be_the_type(types.tuple(String))
+      expect(evaluate(expr)).to be_the_type(types.tuple([String]))
 
       # arguments are flattened
       expr = fqr('Tuple')[[fqr('String')]]
-      expect(evaluate(expr)).to be_the_type(types.tuple(String))
+      expect(evaluate(expr)).to be_the_type(types.tuple([String]))
     end
 
     it "Tuple parameterization gives an error if parameter is not a type" do
@@ -241,13 +319,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces a varargs Tuple when the last two arguments specify size constraint' do
       expr = fqr('Tuple')[fqr('String'), 1]
-      expected_t = types.tuple(String)
-      types.constrain_size(expected_t, 1, :default)
+      expected_t = types.tuple([String], types.range(1, :default))
       expect(evaluate(expr)).to be_the_type(expected_t)
 
       expr = fqr('Tuple')[fqr('String'), 1, 2]
-      expected_t = types.tuple(String)
-      types.constrain_size(expected_t, 1, 2)
+      expected_t = types.tuple([String], types.range(1, 2))
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
@@ -416,7 +492,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     it 'produces a NotUndef instance with String type when given a literal String' do
       type_expr = fqr('NotUndef')[literal('hey')]
       tf = Puppet::Pops::Types::TypeFactory
-      expect(evaluate(type_expr)).to eql(tf.not_undef(tf.string('hey')))
+      expect(evaluate(type_expr)).to be_the_type(tf.not_undef(tf.string('hey')))
+    end
+
+    it 'Produces Optional instance with String type when using a String argument' do
+      type_expr = fqr('Optional')[literal('hey')]
+      tf = Puppet::Pops::Types::TypeFactory
+      expect(evaluate(type_expr)).to be_the_type(tf.optional(tf.string('hey')))
     end
 
     # Type Type
@@ -443,6 +525,20 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect(evaluate(type_expr)).to eql(tf.ruby_type('String'))
     end
 
+    # Callable Type
+    #
+    it 'produces Callable instance without return type' do
+      type_expr = fqr('Callable')[fqr('String')]
+      tf = Puppet::Pops::Types::TypeFactory
+      expect(evaluate(type_expr)).to eql(tf.callable(String))
+    end
+
+    it 'produces Callable instance with parameters and return type' do
+      type_expr = fqr('Callable')[[fqr('String')], fqr('Integer')]
+      tf = Puppet::Pops::Types::TypeFactory
+      expect(evaluate(type_expr)).to eql(tf.callable([String], Integer))
+    end
+
   end
 
   matcher :be_the_type do |type|

data/spec/unit/pops/evaluator/arithmetic_ops_spec.rb

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet_spec/compiler'
 
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
@@ -73,5 +74,174 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         expect(evaluate(literal('012.3') + literal('010'))).to eq(20.3)
       end
     end
+
+    context 'on timespans' do
+      include PuppetSpec::Compiler
+
+      it 'Timespan + Timespan = Timespan' do
+        code = 'notice(assert_type(Timespan, Timespan({days => 3}) + Timespan({hours => 12})))'
+        expect(eval_and_collect_notices(code)).to eql(['3-12:00:00.0'])
+      end
+
+      it 'Timespan - Timespan = Timespan' do
+        code = 'notice(assert_type(Timespan, Timespan({days => 3}) - Timespan({hours => 12})))'
+        expect(eval_and_collect_notices(code)).to eql(['2-12:00:00.0'])
+      end
+
+      it 'Timespan + -Timespan = Timespan' do
+        code = 'notice(assert_type(Timespan, Timespan({days => 3}) + -Timespan({hours => 12})))'
+        expect(eval_and_collect_notices(code)).to eql(['2-12:00:00.0'])
+      end
+
+      it 'Timespan - -Timespan = Timespan' do
+        code = 'notice(assert_type(Timespan, Timespan({days => 3}) - -Timespan({hours => 12})))'
+        expect(eval_and_collect_notices(code)).to eql(['3-12:00:00.0'])
+      end
+
+      it 'Timespan / Timespan = Float' do
+        code = "notice(assert_type(Float, Timespan({days => 3}) / Timespan('0-12:00:00')))"
+        expect(eval_and_collect_notices(code)).to eql(['6.0'])
+      end
+
+      it 'Timespan * Timespan is an error' do
+        code = 'notice(Timespan({days => 3}) * Timespan({hours => 12}))'
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /A Timestamp cannot be multiplied by a Timespan/)
+      end
+
+      it 'Timespan + Numeric = Timespan (numeric treated as seconds)' do
+        code = 'notice(assert_type(Timespan, Timespan({days => 3}) + 7300.0))'
+        expect(eval_and_collect_notices(code)).to eql(['3-02:01:40.0'])
+      end
+
+      it 'Timespan - Numeric = Timespan (numeric treated as seconds)' do
+        code = "notice(assert_type(Timespan, Timespan({days => 3}) - 7300.123))"
+        expect(eval_and_collect_notices(code)).to eql(['2-21:58:19.877'])
+      end
+
+      it 'Timespan * Numeric = Timespan (numeric treated as seconds)' do
+        code = "notice(strftime(assert_type(Timespan, Timespan({days => 3}) * 2), '%D'))"
+        expect(eval_and_collect_notices(code)).to eql(['6'])
+      end
+
+      it 'Numeric + Timespan = Timespan (numeric treated as seconds)' do
+        code = 'notice(assert_type(Timespan, 7300.0 + Timespan({days => 3})))'
+        expect(eval_and_collect_notices(code)).to eql(['3-02:01:40.0'])
+      end
+
+      it 'Numeric - Timespan = Timespan (numeric treated as seconds)' do
+        code = "notice(strftime(assert_type(Timespan, 300000 - Timespan({days => 3})), '%H:%M'))"
+        expect(eval_and_collect_notices(code)).to eql(['11:20'])
+      end
+
+      it 'Numeric * Timespan = Timespan (numeric treated as seconds)' do
+        code = "notice(strftime(assert_type(Timespan, 2 * Timespan({days => 3})), '%D'))"
+        expect(eval_and_collect_notices(code)).to eql(['6'])
+      end
+
+      it 'Timespan + Timestamp = Timestamp' do
+        code = "notice(assert_type(Timestamp, Timespan({days => 3}) + Timestamp('2016-08-27T16:44:49.999 UTC')))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-08-30T16:44:49.999 UTC'])
+      end
+
+      it 'Timespan - Timestamp is an error' do
+        code = 'notice(Timespan({days => 3}) - Timestamp())'
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /A Timestamp cannot be subtracted from a Timespan/)
+      end
+
+      it 'Timespan * Timestamp is an error' do
+        code = 'notice(Timespan({days => 3}) * Timestamp())'
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /A Timestamp cannot be multiplied by a Timestamp/)
+      end
+
+      it 'Timespan / Timestamp is an error' do
+        code = 'notice(Timespan({days => 3}) / Timestamp())'
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /A Timespan cannot be divided by a Timestamp/)
+      end
+    end
+
+
+    context 'on timestamps' do
+      include PuppetSpec::Compiler
+
+      it 'Timestamp + Timestamp is an error' do
+        code = 'notice(Timestamp() + Timestamp())'
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /A Timestamp cannot be added to a Timestamp/)
+      end
+
+      it 'Timestamp + Timespan = Timestamp' do
+        code = "notice(assert_type(Timestamp, Timestamp('2016-10-10') + Timespan('0-12:00:00')))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T12:00:00.000 UTC'])
+      end
+
+      it 'Timestamp + Numeric = Timestamp' do
+        code = "notice(assert_type(Timestamp, Timestamp('2016-10-10T12:00:00.000') + 3600.123))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T13:00:00.123 UTC'])
+      end
+
+      it 'Numeric + Timestamp = Timestamp' do
+        code = "notice(assert_type(Timestamp, 3600.123 + Timestamp('2016-10-10T12:00:00.000')))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T13:00:00.123 UTC'])
+      end
+
+      it 'Timestamp - Timestamp = Timespan' do
+        code = "notice(assert_type(Timespan, Timestamp('2016-10-10') - Timestamp('2015-10-10')))"
+        expect(eval_and_collect_notices(code)).to eql(['366-00:00:00.0'])
+      end
+
+      it 'Timestamp - Timespan = Timestamp' do
+        code = "notice(assert_type(Timestamp, Timestamp('2016-10-10') - Timespan('0-12:00:00')))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-09T12:00:00.000 UTC'])
+      end
+
+      it 'Timestamp - Numeric = Timestamp' do
+        code = "notice(assert_type(Timestamp, Timestamp('2016-10-10') - 3600.123))"
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-09T22:59:59.877 UTC'])
+      end
+
+      it 'Numeric - Timestamp = Timestamp' do
+        code = "notice(assert_type(Timestamp, 123 - Timestamp('2016-10-10')))"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '-' is not applicable.*when right side is a Timestamp/)
+      end
+
+      it 'Timestamp / Timestamp is an error' do
+        code = "notice(Timestamp('2016-10-10') / Timestamp())"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\/' is not applicable to a Timestamp/)
+      end
+
+      it 'Timestamp / Timespan is an error' do
+        code = "notice(Timestamp('2016-10-10') / Timespan('0-12:00:00'))"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\/' is not applicable to a Timestamp/)
+      end
+
+      it 'Timestamp / Numeric is an error' do
+        code = "notice(Timestamp('2016-10-10') / 3600.123)"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\/' is not applicable to a Timestamp/)
+      end
+
+      it 'Numeric / Timestamp is an error' do
+        code = "notice(3600.123 / Timestamp('2016-10-10'))"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\/' is not applicable.*when right side is a Timestamp/)
+      end
+
+      it 'Timestamp * Timestamp is an error' do
+        code = "notice(Timestamp('2016-10-10') * Timestamp())"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\*' is not applicable to a Timestamp/)
+      end
+
+      it 'Timestamp * Timespan is an error' do
+        code = "notice(Timestamp('2016-10-10') * Timespan('0-12:00:00'))"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\*' is not applicable to a Timestamp/)
+      end
+
+      it 'Timestamp * Numeric is an error' do
+        code = "notice(Timestamp('2016-10-10') * 3600.123)"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\*' is not applicable to a Timestamp/)
+      end
+
+      it 'Numeric * Timestamp is an error' do
+        code = "notice(3600.123 * Timestamp('2016-10-10'))"
+        expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /Operator '\*' is not applicable.*when right side is a Timestamp/)
+      end
+    end
   end
 end

data/spec/unit/pops/evaluator/basic_expressions_spec.rb

@@ -31,8 +31,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'should evaluator types to types' do
-      array_type = Puppet::Pops::Types::PArrayType.new()
-      array_type.element_type = Puppet::Pops::Types::PDataType.new()
+      array_type = Puppet::Pops::Types::PArrayType::DATA
       expect(evaluate(fqr('Array'))).to eq(array_type)
     end
   end

data/spec/unit/pops/evaluator/comparison_ops_spec.rb

@@ -86,6 +86,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       it "'1.0' < 1.1 == true" do
         expect{evaluate(literal('1.0') <  literal(1.1))}.to raise_error(/String < Float/)
       end
+      it "undef < 1.1 == true" do
+        expect{evaluate(literal(nil) <  literal(1.1))}.to raise_error(/Undef Value < Float/)
+      end
     end
 
     context "of regular expressions" do

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -16,6 +16,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   include PuppetSpec::Scope
   before(:each) do
     Puppet[:strict_variables] = true
+    Puppet[:data_binding_terminus] = 'none'
 
     # Tests needs a known configuration of node/scope/compiler since it parses and evaluates
     # snippets as the compiler will evaluate them, butwithout the overhead of compiling a complete
@@ -28,6 +29,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     @scope = Puppet::Parser::Scope.new(@compiler)
     @scope.source = Puppet::Resource::Type.new(:node, 'node.example.com')
     @scope.parent = @compiler.topscope
+    Puppet.push_context(:loaders => @compiler.loaders)
+  end
+
+  after(:each) do
+    Puppet.pop_context
   end
 
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
@@ -56,7 +62,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
-      end
+    end
+
+    it 'should error when it encounters an unknown resource' do
+      expect {parser.evaluate_string(scope, '$a = SantaClause', __FILE__)}.to raise_error(/Resource type not found: SantaClause/)
+    end
+
+    it 'should error when it encounters an unknown resource with a parameter' do
+      expect {parser.evaluate_string(scope, '$b = ToothFairy[emea]', __FILE__)}.to raise_error(/Resource type not found: ToothFairy/)
+    end
   end
 
   context "When the evaluator evaluates Lists and Hashes" do
@@ -252,9 +266,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "xxx in bananas"                => false,
       "/ana/ in bananas"              => true,
       "/xxx/ in bananas"              => false,
-      "ANA in bananas"                => false, # ANA is a type, not a String
+      "FILE in profiler"              => false, # FILE is a type, not a String
+      "'FILE' in profiler"            => true,
       "String[1] in bananas"          => false, # Philosophically true though :-)
-      "'ANA' in bananas"              => true,
       "ana in 'BANANAS'"              => true,
       "/ana/ in 'BANANAS'"            => false,
       "/ANA/ in 'BANANAS'"            => true,
@@ -306,13 +320,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
     {
       'Any'  => ['NotUndef', 'Data', 'Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
-                    'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File', 'NotYetKnownResourceType'],
+                    'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File' ],
 
       # Note, Data > Collection is false (so not included)
       'Data'    => ['Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Array', 'Hash',],
       'Scalar' => ['Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern'],
       'Numeric' => ['Integer', 'Float'],
-      'CatalogEntry' => ['Class', 'Resource', 'File', 'NotYetKnownResourceType'],
+      'CatalogEntry' => ['Class', 'Resource', 'File'],
       'Integer[1,10]' => ['Integer[2,3]'],
     }.each do |general, specials|
       specials.each do |special |
@@ -597,6 +611,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(result).to include(['b', 20])
     end
 
+    it "should create an array from an Iterator" do
+      expect(parser.evaluate_string(scope, '[1,2,3].reverse_each', __FILE__).is_a?(Array)).to be(false)
+      result = parser.evaluate_string(scope, '*[1,2,3].reverse_each', __FILE__)
+      expect(result).to eql([3,2,1])
+    end
   end
 
   context "When evaluator performs [] operations" do
@@ -684,23 +703,23 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     # Type operations (full set tested by tests covering type calculator)
     {
       "Array[Integer]"                  => types.array_of(types.integer),
-      "Array[Integer,1]"                => types.constrain_size(types.array_of(types.integer),1, :default),
-      "Array[Integer,1,2]"              => types.constrain_size(types.array_of(types.integer),1, 2),
-      "Array[Integer,Integer[1,2]]"     => types.constrain_size(types.array_of(types.integer),1, 2),
-      "Array[Integer,Integer[1]]"       => types.constrain_size(types.array_of(types.integer),1, :default),
+      "Array[Integer,1]"                => types.array_of(types.integer, types.range(1, :default)),
+      "Array[Integer,1,2]"              => types.array_of(types.integer, types.range(1, 2)),
+      "Array[Integer,Integer[1,2]]"     => types.array_of(types.integer, types.range(1, 2)),
+      "Array[Integer,Integer[1]]"       => types.array_of(types.integer, types.range(1, :default)),
       "Hash[Integer,Integer]"           => types.hash_of(types.integer, types.integer),
-      "Hash[Integer,Integer,1]"         => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
-      "Hash[Integer,Integer,1,2]"       => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
-      "Hash[Integer,Integer,Integer[1,2]]" => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
-      "Hash[Integer,Integer,Integer[1]]"   => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
+      "Hash[Integer,Integer,1]"         => types.hash_of(types.integer, types.integer, types.range(1, :default)),
+      "Hash[Integer,Integer,1,2]"       => types.hash_of(types.integer, types.integer, types.range(1, 2)),
+      "Hash[Integer,Integer,Integer[1,2]]" => types.hash_of(types.integer, types.integer, types.range(1, 2)),
+      "Hash[Integer,Integer,Integer[1]]"   => types.hash_of(types.integer, types.integer, types.range(1, :default)),
       "Resource[File]"                  => types.resource('File'),
       "Resource['File']"                => types.resource(types.resource('File')),
       "File[foo]"                       => types.resource('file', 'foo'),
       "File[foo, bar]"                  => [types.resource('file', 'foo'), types.resource('file', 'bar')],
       "Pattern[a, /b/, Pattern[c], Regexp[d]]"  => types.pattern('a', 'b', 'c', 'd'),
-      "String[1,2]"                     => types.constrain_size(types.string,1, 2),
-      "String[Integer[1,2]]"            => types.constrain_size(types.string,1, 2),
-      "String[Integer[1]]"              => types.constrain_size(types.string,1, :default),
+      "String[1,2]"                     => types.string(types.range(1, 2)),
+      "String[Integer[1,2]]"            => types.string(types.range(1, 2)),
+      "String[Integer[1]]"              => types.string(types.range(1, :default)),
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
@@ -732,8 +751,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "Array[Integer,1,2,3]"        => 'Array-Type[] accepts 1 to 3 arguments. Got 4',
       "Array[Integer,String]"       => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String-Type",
       "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 2 to 4 arguments. Got 5',
-      "'abc'[x]"                    => "The value 'x' cannot be converted to Numeric",
-      "'abc'[1.0]"                  => "A String[] cannot use Float where Integer is expected",
+      "'abc'[x]"                    => "A substring operation does not accept a String as a character index. Expected an Integer",
+      "'abc'[1.0]"                  => "A substring operation does not accept a Float as a character index. Expected an Integer",
+      "'abc'[1, x]"                 => "A substring operation does not accept a String as a character index. Expected an Integer",
       "'abc'[1,2,3]"                => "String supports [] with one or two arguments. Got 3",
       "NotUndef[0]"                 => 'NotUndef-Type[] argument must be a Type or a String. Got Fixnum',
       "NotUndef[a,b]"               => 'NotUndef-Type[] accepts 0 to 1 arguments. Got 2',
@@ -778,7 +798,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         Puppet.override({:global_scope => scope,
                          :environments => Puppet::Environments::Static.new(@node.environment)
         }, "gets class parameter test") do
-          scope.known_resource_types.import_ast(ast, '')
+          scope.environment.known_resource_types.import_ast(ast, '')
           expect(ast.code.safeevaluate(scope)).to eq('chocolate')
         end
       end
@@ -860,7 +880,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         # NOTE: these meta-esque parameters are not recognized as such
         "notify { id: message=>explicit} Notify[id][title]"   => /does not have a parameter called 'title'/,
         "notify { id: message=>explicit} Notify[id]['type']"   => /does not have a parameter called 'type'/,
-        "notify { id: message=>explicit } Notify[id]{message=>override}" => /'message' is already set on Notify\[id\]/
+        "notify { id: message=>explicit } Notify[id]{message=>override}" => /'message' is already set on Notify\[id\]/,
+        "notify { id: message => 'once', message => 'twice' }" => /'message' has already been set/
       }.each do |source, result|
         it "should parse '#{source}' and raise error matching #{result}" do
           expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(result)
@@ -959,7 +980,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
 
     it "provides location information on error in unparenthesized call logic" do
-    expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /line 1\:1/)
+    expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /:1:1/)
     end
 
     it 'defaults can be given in a lambda and used only when arg is missing' do
@@ -1025,6 +1046,12 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect{parser.evaluate_string(scope, "assert_no_undef({1 => undef})")}.to_not raise_error()
     end
 
+    it 'a lambda return value is checked using the return type' do
+      expect(parser.evaluate_string(scope, "[1,2].map |Integer $x| >> Integer { $x }")).to eql([1,2])
+      expect { parser.evaluate_string(scope, "[1,2].map |Integer $x| >> String { $x }") }.to raise_error(
+        /value returned from lambda has wrong type, expects a String value, got Integer/)
+    end
+
     context 'using the 3x function api' do
       it 'can call a 3x function' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
@@ -1194,6 +1221,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(scope.compiler).to have_relationship(['File', 'b', '->', 'File', 'y'])
     end
 
+    it 'should form a relation with 3.x resource -> resource' do
+      # Create a 3.x resource since this is the value given as arguments to defined type
+      scope['a_3x_resource']= Puppet::Parser::Resource.new('notify', 'a', {:scope => scope, :file => __FILE__, :line => 1})
+      source = "$a_3x_resource -> notify{b:}"
+      parser.evaluate_string(scope, source, __FILE__)
+      expect(scope.compiler).to have_relationship(['Notify', 'a', '->', 'Notify', 'b'])
+    end
+
     it 'should tolerate (eliminate) duplicates in operands' do
       source = "[File[a], File[a]] -> File[x]"
       parser.evaluate_string(scope, source, __FILE__)
@@ -1251,7 +1286,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(parser.evaluate_string(scope, src)).to eq("Tex\tt\\n")
     end
 
-    it "parses syntax checked specification" do
+    it "parses json syntax checked specification" do
       src = <<-CODE
       @(END:json)
       ["foo", "bar"]
@@ -1260,7 +1295,16 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(parser.evaluate_string(scope, src)).to eq('["foo", "bar"]')
     end
 
-    it "parses syntax checked specification with error and reports it" do
+    it "parses base64 syntax checked specification" do
+      src = <<-CODE
+      @(END:base64)
+        dGhlIHF1aWNrIHJlZCBmb3g=
+        |- END
+      CODE
+      expect(parser.evaluate_string(scope, src)).to eq('dGhlIHF1aWNrIHJlZCBmb3g=')
+    end
+
+    it "parses json syntax checked specification with error and reports it" do
       src = <<-CODE
       @(END:json)
       ['foo', "bar"]
@@ -1269,6 +1313,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect { parser.evaluate_string(scope, src)}.to raise_error(/Cannot parse invalid JSON string/)
     end
 
+    it "parses base syntax checked specification with error and reports it" do
+      src = <<-CODE
+      @(END:base64)
+        dGhlIHF1aWNrIHJlZCBmb3g
+        |- END
+      CODE
+      expect { parser.evaluate_string(scope, src)}.to raise_error(/Cannot parse invalid Base64 string/)
+    end
+
     it "parses interpolated heredoc expression" do
       src = <<-CODE
       $pname = 'Fjodor'