puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

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

@@ -14,7 +14,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   context "When the evaluator evaluates" do
     context "an if expression" do
       it 'should output the expected result when dumped' do
-        dump(IF(literal(true), literal(2), literal(5))).should == unindent(<<-TEXT
+        expect(dump(IF(literal(true), literal(2), literal(5)))).to eq unindent(<<-TEXT
           (if true
             (then 2)
             (else 5))
@@ -23,29 +23,29 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
 
       it 'if true {5} == 5' do
-        evaluate(IF(literal(true), literal(5))).should == 5
+        expect(evaluate(IF(literal(true), literal(5)))).to eq(5)
       end
 
       it 'if false {5} == nil' do
-        evaluate(IF(literal(false), literal(5))).should == nil
+        expect(evaluate(IF(literal(false), literal(5)))).to eq(nil)
       end
 
       it 'if false {2} else {5} == 5' do
-        evaluate(IF(literal(false), literal(2), literal(5))).should == 5
+        expect(evaluate(IF(literal(false), literal(2), literal(5)))).to eq(5)
       end
 
       it 'if false {2} elsif true {5} == 5' do
-        evaluate(IF(literal(false), literal(2), IF(literal(true), literal(5)))).should == 5
+        expect(evaluate(IF(literal(false), literal(2), IF(literal(true), literal(5))))).to eq(5)
       end
 
       it 'if false {2} elsif false {5} == nil' do
-        evaluate(IF(literal(false), literal(2), IF(literal(false), literal(5)))).should == nil
+        expect(evaluate(IF(literal(false), literal(2), IF(literal(false), literal(5))))).to eq(nil)
       end
     end
 
     context "an unless expression" do
       it 'should output the expected result when dumped' do
-        dump(UNLESS(literal(true), literal(2), literal(5))).should == unindent(<<-TEXT
+        expect(dump(UNLESS(literal(true), literal(2), literal(5)))).to eq unindent(<<-TEXT
           (unless true
             (then 2)
             (else 5))
@@ -54,43 +54,43 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
 
       it 'unless false {5} == 5' do
-        evaluate(UNLESS(literal(false), literal(5))).should == 5
+        expect(evaluate(UNLESS(literal(false), literal(5)))).to eq(5)
       end
 
       it 'unless true {5} == nil' do
-        evaluate(UNLESS(literal(true), literal(5))).should == nil
+        expect(evaluate(UNLESS(literal(true), literal(5)))).to eq(nil)
       end
 
       it 'unless true {2} else {5} == 5' do
-        evaluate(UNLESS(literal(true), literal(2), literal(5))).should == 5
+        expect(evaluate(UNLESS(literal(true), literal(2), literal(5)))).to eq(5)
       end
 
       it 'unless true {2} elsif true {5} == 5' do
         # not supported by concrete syntax
-        evaluate(UNLESS(literal(true), literal(2), IF(literal(true), literal(5)))).should == 5
+        expect(evaluate(UNLESS(literal(true), literal(2), IF(literal(true), literal(5))))).to eq(5)
       end
 
       it 'unless true {2} elsif false {5} == nil' do
         # not supported by concrete syntax
-        evaluate(UNLESS(literal(true), literal(2), IF(literal(false), literal(5)))).should == nil
+        expect(evaluate(UNLESS(literal(true), literal(2), IF(literal(false), literal(5))))).to eq(nil)
       end
     end
 
     context "a case expression" do
       it 'should output the expected result when dumped' do
-        dump(CASE(literal(2),
+        expect(dump(CASE(literal(2),
                   WHEN(literal(1), literal('wat')),
                   WHEN([literal(2), literal(3)], literal('w00t'))
-                  )).should == unindent(<<-TEXT
+                  ))).to eq unindent(<<-TEXT
                   (case 2
                     (when (1) (then 'wat'))
                     (when (2 3) (then 'w00t')))
                   TEXT
                   )
-        dump(CASE(literal(2),
+        expect(dump(CASE(literal(2),
                   WHEN(literal(1), literal('wat')),
                   WHEN([literal(2), literal(3)], literal('w00t'))
-                  ).default(literal(4))).should == unindent(<<-TEXT
+                  ).default(literal(4)))).to eq unindent(<<-TEXT
                   (case 2
                     (when (1) (then 'wat'))
                     (when (2 3) (then 'w00t'))
@@ -100,90 +100,90 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
 
       it "case 1 { 1 : { 'w00t'} } == 'w00t'" do
-        evaluate(CASE(literal(1), WHEN(literal(1), literal('w00t')))).should == 'w00t'
+        expect(evaluate(CASE(literal(1), WHEN(literal(1), literal('w00t'))))).to eq('w00t')
       end
 
       it "case 2 { 1,2,3 : { 'w00t'} } == 'w00t'" do
-        evaluate(CASE(literal(2), WHEN([literal(1), literal(2), literal(3)], literal('w00t')))).should == 'w00t'
+        expect(evaluate(CASE(literal(2), WHEN([literal(1), literal(2), literal(3)], literal('w00t'))))).to eq('w00t')
       end
 
       it "case 2 { 1,3 : {'wat'} 2: { 'w00t'} } == 'w00t'" do
-        evaluate(CASE(literal(2),
+        expect(evaluate(CASE(literal(2),
           WHEN([literal(1), literal(3)], literal('wat')),
-          WHEN(literal(2), literal('w00t')))).should == 'w00t'
+          WHEN(literal(2), literal('w00t'))))).to eq('w00t')
       end
 
       it "case 2 { 1,3 : {'wat'} 5: { 'wat'} default: {'w00t'}} == 'w00t'" do
-        evaluate(CASE(literal(2),
+        expect(evaluate(CASE(literal(2),
           WHEN([literal(1), literal(3)], literal('wat')),
           WHEN(literal(5), literal('wat'))).default(literal('w00t'))
-          ).should == 'w00t'
+          )).to eq('w00t')
       end
 
       it "case 2 { 1,3 : {'wat'} 5: { 'wat'} } == nil" do
-        evaluate(CASE(literal(2),
+        expect(evaluate(CASE(literal(2),
           WHEN([literal(1), literal(3)], literal('wat')),
           WHEN(literal(5), literal('wat')))
-          ).should == nil
+          )).to eq(nil)
       end
 
       it "case 'banana' { 1,3 : {'wat'} /.*ana.*/: { 'w00t'} } == w00t" do
-        evaluate(CASE(literal('banana'),
+        expect(evaluate(CASE(literal('banana'),
           WHEN([literal(1), literal(3)], literal('wat')),
           WHEN(literal(/.*ana.*/), literal('w00t')))
-          ).should == 'w00t'
+          )).to eq('w00t')
       end
 
       context "with regular expressions" do
         it "should set numeric variables from the match" do
-          evaluate(CASE(literal('banana'),
+          expect(evaluate(CASE(literal('banana'),
             WHEN([literal(1), literal(3)], literal('wat')),
             WHEN(literal(/.*(ana).*/), var(1)))
-            ).should == 'ana'
+            )).to eq('ana')
         end
       end
     end
 
     context "select expressions" do
       it 'should output the expected result when dumped' do
-        dump(literal(2).select(
+        expect(dump(literal(2).select(
                   MAP(literal(1), literal('wat')),
                   MAP(literal(2), literal('w00t'))
-                  )).should == "(? 2 (1 => 'wat') (2 => 'w00t'))"
+                  ))).to eq("(? 2 (1 => 'wat') (2 => 'w00t'))")
       end
 
       it "1 ? {1 => 'w00t'} == 'w00t'" do
-        evaluate(literal(1).select(MAP(literal(1), literal('w00t')))).should == 'w00t'
+        expect(evaluate(literal(1).select(MAP(literal(1), literal('w00t'))))).to eq('w00t')
       end
 
       it "2 ? {1 => 'wat', 2 => 'w00t'} == 'w00t'" do
-        evaluate(literal(2).select(
+        expect(evaluate(literal(2).select(
           MAP(literal(1), literal('wat')),
           MAP(literal(2), literal('w00t'))
-          )).should == 'w00t'
+          ))).to eq('w00t')
       end
 
       it "3 ? {1 => 'wat', 2 => 'wat', default => 'w00t'} == 'w00t'" do
-        evaluate(literal(3).select(
+        expect(evaluate(literal(3).select(
           MAP(literal(1), literal('wat')),
           MAP(literal(2), literal('wat')),
           MAP(literal(:default), literal('w00t'))
-          )).should == 'w00t'
+          ))).to eq('w00t')
       end
 
       it "3 ? {1 => 'wat', default => 'w00t', 3 => 'wat'} == 'w00t'" do
-        evaluate(literal(3).select(
+        expect(evaluate(literal(3).select(
           MAP(literal(1), literal('wat')),
           MAP(literal(:default), literal('w00t')),
           MAP(literal(2), literal('wat'))
-          )).should == 'w00t'
+          ))).to eq('w00t')
       end
 
       it "should set numerical variables from match" do
-        evaluate(literal('banana').select(
+        expect(evaluate(literal('banana').select(
           MAP(literal(1), literal('wat')),
           MAP(literal(/.*(ana).*/), var(1))
-          )).should == 'ana'
+          ))).to eq('ana')
       end
     end
   end

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

@@ -17,28 +17,21 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   before(:each) do
     Puppet[:strict_variables] = true
 
-    # These must be set since the 3x logic switches some behaviors on these even if the tests explicitly
-    # use the 4x parser and evaluator.
-    #
-    Puppet[:parser] = 'future'
-
-    # Puppetx cannot be loaded until the correct parser has been set (injector is turned off otherwise)
-    require 'puppetx'
-
     # 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
     # catalog for each tested expression.
     #
     @parser  = Puppet::Pops::Parser::EvaluatingParser.new
     @node = Puppet::Node.new('node.example.com')
-    @node.environment = Puppet::Node::Environment.create(:testing, [])
+    @node.environment = environment
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(@compiler)
     @scope.source = Puppet::Resource::Type.new(:node, 'node.example.com')
     @scope.parent = @compiler.topscope
   end
 
-  let(:parser) {  @parser }
+  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+  let(:parser) { @parser }
   let(:scope) { @scope }
   types = Puppet::Pops::Types::TypeFactory
 
@@ -61,7 +54,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "/.*/"          => /.*/
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
   end
@@ -78,9 +71,6 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "[1,2,3] != [1,2,3]"                              => false,
       "[1,2,3][2]"                                      => 3,
       "[1,2,3] + [4,5]"                                 => [1,2,3,4,5],
-      "[1,2,3, *[4,5]]"                                 => [1,2,3,4,5],
-      "[1,2,3, (*[4,5])]"                               => [1,2,3,4,5],
-      "[1,2,3, ((*[4,5]))]"                             => [1,2,3,4,5],
       "[1,2,3] + [[4,5]]"                               => [1,2,3,[4,5]],
       "[1,2,3] + 4"                                     => [1,2,3,4],
       "[1,2,3] << [4,5]"                                => [1,2,3,[4,5]],
@@ -94,19 +84,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "[1,2,3,3,2,4,2,3] - [2,3]"                       => [1,4],
       "[1,2,3,['a',1],['b',2]] - {'a' => 1, 'b'=>2}"    => [1,2,3],
       "[1,2,3,{'a'=>1,'b'=>2}] - [{'a' => 1, 'b'=>2}]"  => [1,2,3],
-    }.each do |source, result|
-        it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
-        end
-      end
-
-    {
       "[1,2,3] + {'a' => 1, 'b'=>2}"                    => [1,2,3,['a',1],['b',2]],
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          # This test must be done with match_array since the order of the hash
-          # is undefined and Ruby 1.8.7 and 1.9.3 produce different results.
-          expect(parser.evaluate_string(scope, source, __FILE__)).to match_array(result)
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -138,7 +119,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "{'a'=>1, 'b'=>2, 'c'=>3} - 'c'"           => {'a'=>1, 'b'=>2},
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -206,7 +187,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "true == false"  => false,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -238,12 +219,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "$x = Pattern['a.*'] a =~ $x"     => true,
       "1 =~ Integer"                    => true,
       "1 !~ Integer"                    => false,
-      "undef =~ NotUndef"               => false,
-      "undef !~ NotUndef"               => true,
       "[1,2,3] =~ Array[Integer[1,10]]" => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -303,7 +282,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "Integer in {'a'=>1}"           => false,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
-        parser.evaluate_string(scope, source, __FILE__).should == result
+        expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
       end
     end
 
@@ -316,12 +295,12 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "if /b/ in [pineapple, bananas] {$0}" => 'b',
     }.each do |source, result|
       it "sets match variables for a regexp search using in such that '#{source}' produces '#{result}'" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
       end
     end
 
     {
-      'Any'  => ['NotUndef', 'Data', 'Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
+      'Any'  => ['Data', 'Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
                     'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File', 'NotYetKnownResourceType'],
 
       # Note, Data > Collection is false (so not included)
@@ -333,13 +312,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     }.each do |general, specials|
       specials.each do |special |
         it "should compute that #{general} > #{special}" do
-          parser.evaluate_string(scope, "#{general} > #{special}", __FILE__).should == true
+          expect(parser.evaluate_string(scope, "#{general} > #{special}", __FILE__)).to eq(true)
         end
         it "should compute that  #{special} < #{general}" do
-          parser.evaluate_string(scope, "#{special} < #{general}", __FILE__).should == true
+          expect(parser.evaluate_string(scope, "#{special} < #{general}", __FILE__)).to eq(true)
         end
         it "should compute that #{general} != #{special}" do
-          parser.evaluate_string(scope, "#{special} != #{general}", __FILE__).should == true
+          expect(parser.evaluate_string(scope, "#{special} != #{general}", __FILE__)).to eq(true)
         end
       end
     end
@@ -353,7 +332,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       'Integer[1,10] == Integer[1,10]' => true,
     }.each do |source, result|
         it "should parse and evaluate the integer range comparison expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -374,7 +353,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
          "8 << 1" => 16,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
-            parser.evaluate_string(scope, source, __FILE__).should == result
+            expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
           end
         end
 
@@ -388,7 +367,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         "-6.0/3.0 "  => -2.0,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
-            parser.evaluate_string(scope, source, __FILE__).should == result
+            expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
           end
         end
 
@@ -424,7 +403,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         "'+02' + '04'"    => 6,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
-            parser.evaluate_string(scope, source, __FILE__).should == result
+            expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
           end
         end
 
@@ -432,7 +411,6 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         "'0888' + '010'"   => :error,
         "'0xWTF' + '010'"  => :error,
         "'0x12.3' + '010'" => :error,
-        "'0x12.3' + '010'" => :error,
         '"-\n 2" + "2"'    => :error,
         '"-\v 2" + "2"'    => :error,
         '"-2\n" + "2"'     => :error,
@@ -454,7 +432,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "$a = $b = 5; $a == $b"      => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -478,7 +456,6 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "unless false {5}"                => 5,
       "unless true {5}"                 => nil,
       "unless true {2} else {5}"        => 5,
-      "unless true {} else {5}"         => 5,
       "$a = if true {5} $a"                     => 5,
       "$a = if false {5} $a"                    => nil,
       "$a = if false {2} else {5} $a"           => 5,
@@ -489,7 +466,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "$a = unless true {2} else {5} $a"        => 5,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -516,34 +493,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "case ringo {
          *[paul, john, ringo, george] : { 'beatle' } }"      => 'beatle',
 
-      "case ringo {
-         (*[paul, john, ringo, george]) : { 'beatle' } }"    => 'beatle',
-
       "case undef {
          undef : { 'yes' } }"                                => 'yes',
 
       "case undef {
          *undef : { 'no' }
          default :{ 'yes' }}"                                => 'yes',
-
-      "case [green, 2, whatever] {
-         [/ee/, Integer[0,10], default] : { 'yes' }
-         default :{ 'no' }}"                                => 'yes',
-
-      "case [green, 2, whatever] {
-         default :{ 'no' }
-         [/ee/, Integer[0,10], default] : { 'yes' }}"        => 'yes',
-
-      "case {a=>1, b=>2, whatever=>3, extra => ignored} {
-         { a => Integer[0,5],
-           b => Integer[0,5],
-           whatever => default
-         }       : { 'yes' }
-         default : { 'no' }}"                               => 'yes',
-
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -557,25 +515,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'banana' ? { /.*(ana).*/  => $1 }"                 => 'ana',
       "[2] ? { Array[String] => yes, Array => yes}"       => 'yes',
       "ringo ? *[paul, john, ringo, george] => 'beatle'"  => 'beatle',
-      "ringo ? (*[paul, john, ringo, george]) => 'beatle'"=> 'beatle',
       "undef ? undef => 'yes'"                            => 'yes',
       "undef ? {*undef => 'no', default => 'yes'}"        => 'yes',
-
-      "[green, 2, whatever] ? {
-         [/ee/, Integer[0,10], default
-         ]       => 'yes',
-         default => 'no'}"                                => 'yes',
-
-      "{a=>1, b=>2, whatever=>3, extra => ignored} ?
-         {{ a => Integer[0,5],
-           b => Integer[0,5],
-           whatever => default
-         }       => 'yes',
-         default => 'no' }"                               => 'yes',
-
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -591,7 +535,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "*'a'"                 => ['a']
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
-        parser.evaluate_string(scope, source, __FILE__).should == result
+        expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
       end
     end
 
@@ -629,7 +573,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "[1,*[2,3],4][1]"  => 2,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
-        parser.evaluate_string(scope, source, __FILE__).should == result
+        expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
       end
     end
 
@@ -646,7 +590,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "$a = {} $a[free_lunch] == undef"       => true,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
-        parser.evaluate_string(scope, source, __FILE__).should == result
+        expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
       end
     end
 
@@ -681,7 +625,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'abcd'[2,-3]"  => '',
    }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
-        parser.evaluate_string(scope, source, __FILE__).should == result
+        expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
       end
     end
 
@@ -707,7 +651,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "String[Integer[1]]"              => types.constrain_size(types.string,1, :default),
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
-        parser.evaluate_string(scope, source, __FILE__).should == result
+        expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
       end
     end
 
@@ -739,8 +683,6 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'abc'[x]"                    => "The value 'x' cannot be converted to Numeric",
       "'abc'[1.0]"                  => "A String[] cannot use Float where Integer is expected",
       "'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',
       "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Integer',
       "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Integer where a resource title String is expected',
       "File[0]"                     => 'Error creating type specialization of a File-Type, Cannot use Integer where a resource title String is expected',
@@ -767,7 +709,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     context "on catalog types" do
       it "[n] gets resource parameter [n]" do
         source = "notify { 'hello': message=>'yo'} Notify[hello][message]"
-        parser.evaluate_string(scope, source, __FILE__).should == 'yo'
+        expect(parser.evaluate_string(scope, source, __FILE__)).to eq('yo')
       end
 
       it "[n] gets class parameter [n]" do
@@ -779,9 +721,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         adapted_parser = Puppet::Parser::E4ParserAdapter.new
         adapted_parser.file = __FILE__
         ast = adapted_parser.parse(source)
-        Puppet.override({:global_scope => scope}, "test") 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, '')
-          ast.code.safeevaluate(scope).should == 'chocolate'
+          expect(ast.code.safeevaluate(scope)).to eq('chocolate')
         end
       end
 
@@ -809,7 +753,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
          Notify[foo][tag]"                                                      => "by_override",
       }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -910,7 +854,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "false or true  or '0xwtf' + 1"  => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -925,8 +869,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
   context "When evaluator performs operations on literal undef" do
     it "computes non existing hash lookup as undef" do
-      parser.evaluate_string(scope, "{a => 1}[b] == undef", __FILE__).should == true
-      parser.evaluate_string(scope, "undef == {a => 1}[b]", __FILE__).should == true
+      expect(parser.evaluate_string(scope, "{a => 1}[b] == undef", __FILE__)).to eq(true)
+      expect(parser.evaluate_string(scope, "undef == {a => 1}[b]", __FILE__)).to eq(true)
     end
   end
 
@@ -940,15 +884,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       'sprintf( "x%iy", $a )'                 => "x10y",
       # unfolds
       'sprintf( *["x%iy", $a] )'              => "x10y",
-      '( *["x%iy", $a] ).sprintf'             => "x10y",
-      '((*["x%iy", $a])).sprintf'             => "x10y",
       '"x%iy".sprintf( $a )'                  => "x10y",
       '$b.reduce |$memo,$x| { $memo + $x }'   => 6,
       'reduce($b) |$memo,$x| { $memo + $x }'  => 6,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           populate
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -968,7 +910,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:test) do
         dispatch :test do
-          param 'Integer', 'count'
+          param 'Integer', :count
           required_block_param
         end
         def test(count)
@@ -985,7 +927,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:test) do
         dispatch :test do
-          param 'Any', 'lambda_arg'
+          param 'Any', :lambda_arg
           required_block_param
         end
         def test(lambda_arg)
@@ -1002,7 +944,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:assert_no_undef) do
         dispatch :assert_no_undef do
-          param 'Any', 'x'
+          param 'Any', :x
         end
 
         def assert_no_undef(x)
@@ -1030,25 +972,25 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     context 'using the 3x function api' do
       it 'can call a 3x function' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
-        parser.evaluate_string(scope, "bazinga(42)", __FILE__).should == 42
+        expect(parser.evaluate_string(scope, "bazinga(42)", __FILE__)).to eq(42)
       end
 
       it 'maps :undef to empty string' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
-        parser.evaluate_string(scope, "$a = {} bazinga($a[nope])", __FILE__).should == ''
-        parser.evaluate_string(scope, "bazinga(undef)", __FILE__).should == ''
+        expect(parser.evaluate_string(scope, "$a = {} bazinga($a[nope])", __FILE__)).to eq('')
+        expect(parser.evaluate_string(scope, "bazinga(undef)", __FILE__)).to eq('')
       end
 
       it 'does not map :undef to empty string in arrays' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0][0] }
-        parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__).should == :undef
-        parser.evaluate_string(scope, "bazinga([undef])", __FILE__).should == :undef
+        expect(parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__)).to eq(:undef)
+        expect(parser.evaluate_string(scope, "bazinga([undef])", __FILE__)).to eq(:undef)
       end
 
       it 'does not map :undef to empty string in hashes' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0]['a'] }
-        parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__).should == :undef
-        parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__).should == :undef
+        expect(parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__)).to eq(:undef)
+        expect(parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__)).to eq(:undef)
       end
     end
   end
@@ -1076,7 +1018,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           populate
-          parser.evaluate_string(scope, source, __FILE__).should == result
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
@@ -1088,7 +1030,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       alt_results = ["value is {a => 1, b => 2} yo", "value is {b => 2, a => 1} yo" ]
       populate
       parse_result = parser.evaluate_string(scope, source, __FILE__)
-      alt_results.include?(parse_result).should == true
+      expect(alt_results.include?(parse_result)).to eq(true)
     end
 
     it 'should accept a variable with leading underscore when used directly' do
@@ -1142,14 +1084,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it "a lex error should be raised for '$foo::::bar'" do
-      expect { parser.evaluate_string(scope, "$foo::::bar") }.to raise_error(Puppet::ParseErrorWithIssue, /Illegal fully qualified name at line 1:7/)
+      expect { parser.evaluate_string(scope, "$foo::::bar") }.to raise_error(Puppet::LexError, /Illegal fully qualified name at line 1:7/)
     end
 
     { '$a = $0'   => nil,
       '$a = $1'   => nil,
     }.each do |source, value|
       it "it is ok to reference numeric unassigned variables '#{source}'" do
-        parser.evaluate_string(scope, source, __FILE__).should == value
+        expect(parser.evaluate_string(scope, source, __FILE__)).to eq(value)
       end
     end
 
@@ -1168,7 +1110,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         '$__a = 1'   => 1,
       }.each do |source, value|
         it "as in this example '#{source}'" do
-          parser.evaluate_string(scope, source, __FILE__).should == value
+          expect(parser.evaluate_string(scope, source, __FILE__)).to eq(value)
         end
       end
     end
@@ -1178,48 +1120,48 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     it 'should form a relation with File[a] -> File[b]' do
       source = "File[a] -> File[b]"
       parser.evaluate_string(scope, source, __FILE__)
-      scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'b'])
+      expect(scope.compiler).to have_relationship(['File', 'a', '->', 'File', 'b'])
     end
 
     it 'should form a relation with resource -> resource' do
       source = "notify{a:} -> notify{b:}"
       parser.evaluate_string(scope, source, __FILE__)
-      scope.compiler.should have_relationship(['Notify', 'a', '->', 'Notify', 'b'])
+      expect(scope.compiler).to have_relationship(['Notify', 'a', '->', 'Notify', 'b'])
     end
 
     it 'should form a relation with [File[a], File[b]] -> [File[x], File[y]]' do
       source = "[File[a], File[b]] -> [File[x], File[y]]"
       parser.evaluate_string(scope, source, __FILE__)
-      scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'x'])
-      scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'x'])
-      scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'y'])
-      scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'y'])
+      expect(scope.compiler).to have_relationship(['File', 'a', '->', 'File', 'x'])
+      expect(scope.compiler).to have_relationship(['File', 'b', '->', 'File', 'x'])
+      expect(scope.compiler).to have_relationship(['File', 'a', '->', 'File', 'y'])
+      expect(scope.compiler).to have_relationship(['File', 'b', '->', 'File', 'y'])
     end
 
     it 'should tolerate (eliminate) duplicates in operands' do
       source = "[File[a], File[a]] -> File[x]"
       parser.evaluate_string(scope, source, __FILE__)
-      scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'x'])
-      scope.compiler.relationships.size.should == 1
+      expect(scope.compiler).to have_relationship(['File', 'a', '->', 'File', 'x'])
+      expect(scope.compiler.relationships.size).to eq(1)
     end
 
     it 'should form a relation with <-' do
       source = "File[a] <- File[b]"
       parser.evaluate_string(scope, source, __FILE__)
-      scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'a'])
+      expect(scope.compiler).to have_relationship(['File', 'b', '->', 'File', 'a'])
     end
 
     it 'should form a relation with <-' do
       source = "File[a] <~ File[b]"
       parser.evaluate_string(scope, source, __FILE__)
-      scope.compiler.should have_relationship(['File', 'b', '~>', 'File', 'a'])
+      expect(scope.compiler).to have_relationship(['File', 'b', '~>', 'File', 'a'])
     end
   end
 
   context "When evaluating heredoc" do
     it "evaluates plain heredoc" do
       src = "@(END)\nThis is\nheredoc text\nEND\n"
-      parser.evaluate_string(scope, src).should == "This is\nheredoc text\n"
+      expect(parser.evaluate_string(scope, src)).to eq("This is\nheredoc text\n")
     end
 
     it "parses heredoc with margin" do
@@ -1230,7 +1172,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "   | END",
       ""
       ].join("\n")
-      parser.evaluate_string(scope, src).should == "This is\nheredoc text\n"
+      expect(parser.evaluate_string(scope, src)).to eq("This is\nheredoc text\n")
     end
 
     it "parses heredoc with margin and right newline trim" do
@@ -1241,7 +1183,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "   |- END",
       ""
       ].join("\n")
-      parser.evaluate_string(scope, src).should == "This is\nheredoc text"
+      expect(parser.evaluate_string(scope, src)).to eq("This is\nheredoc text")
     end
 
     it "parses escape specification" do
@@ -1250,7 +1192,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       Tex\\tt\\n
       |- END
       CODE
-      parser.evaluate_string(scope, src).should == "Tex\tt\\n"
+      expect(parser.evaluate_string(scope, src)).to eq("Tex\tt\\n")
     end
 
     it "parses syntax checked specification" do
@@ -1259,7 +1201,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       ["foo", "bar"]
       |- END
       CODE
-      parser.evaluate_string(scope, src).should == '["foo", "bar"]'
+      expect(parser.evaluate_string(scope, src)).to eq('["foo", "bar"]')
     end
 
     it "parses syntax checked specification with error and reports it" do
@@ -1278,17 +1220,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       Hello $name
       |- END
       CODE
-      parser.evaluate_string(scope, src).should == "Hello Fjodor"
-    end
-
-    it "parses interpolated heredoc expression with escapes" do
-      src = <<-CODE
-      $name = 'Fjodor'
-      @("END")
-      Hello\\ \\$name
-      |- END
-      CODE
-      parser.evaluate_string(scope, src).should == "Hello\\ \\Fjodor"
+      expect(parser.evaluate_string(scope, src)).to eq("Hello Fjodor")
     end
 
   end
@@ -1319,14 +1251,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'for non r-value producing define' do
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => "Invalid use of expression. A 'define' expression does not produce a value", :line => 1, :pos => 6))
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
+      Puppet.expects(:err).with("Invalid use of expression. A 'define' expression does not produce a value at line 1:6")
+      Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = define foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for non r-value producing class' do
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Invalid use of expression. A Host Class Definition does not produce a value', :line => 1, :pos => 6))
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
+      Puppet.expects(:err).with("Invalid use of expression. A Host Class Definition does not produce a value at line 1:6")
+      Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = class foo { }", nil) }.to raise_error(/2 errors/)
     end
 
@@ -1340,8 +1272,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'for multiple errors with a summary exception' do
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Invalid use of expression. A Node Definition does not produce a value', :line => 1, :pos => 6))
-      Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
+      Puppet.expects(:err).with("Invalid use of expression. A Node Definition does not produce a value at line 1:6")
+      Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = node x { }",nil) }.to raise_error(/2 errors/)
     end
 
@@ -1410,7 +1342,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
     end
 
-    failure_message_for_should do |actual|
+    failure_message do |actual|
       "Relationship #{expected[0]}[#{expected[1]}] #{expected[2]} #{expected[3]}[#{expected[4]}] but was unknown to compiler"
     end
   end