puppet 3.8.7 → 4.0.0.rc1

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

@@ -18,9 +18,6 @@ module EvaluatorRspecHelper
     node = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
 
-    # Compiler must create the top scope
-#    compiler.send(:evaluate_main)
-
     # compiler creates the top scope if one is not present
     top_scope = compiler.topscope()
     # top_scope = Puppet::Parser::Scope.new(compiler)
@@ -28,8 +25,7 @@ module EvaluatorRspecHelper
     evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
     result = evaluator.evaluate(in_top_scope.current, top_scope)
     if in_named_scope
-      other_scope = Puppet::Parser::Scope.new(compiler)
-      other_scope.add_namespace(scopename)
+      other_scope = Puppet::Parser::Scope.new(compiler, :namespace => scopename)
       result = evaluator.evaluate(in_named_scope.current, other_scope)
     end
     if in_top_scope_again

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

@@ -14,71 +14,71 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   context "When the evaluator performs boolean operations" do
     context "using operator AND" do
       it "true  && true  == true" do
-        evaluate(literal(true).and(literal(true))).should == true
+        expect(evaluate(literal(true).and(literal(true)))).to eq(true)
       end
 
       it "false && true  == false" do
-        evaluate(literal(false).and(literal(true))).should == false
+        expect(evaluate(literal(false).and(literal(true)))).to eq(false)
       end
 
       it "true  && false == false" do
-        evaluate(literal(true).and(literal(false))).should == false
+        expect(evaluate(literal(true).and(literal(false)))).to eq(false)
       end
 
       it "false && false == false" do
-        evaluate(literal(false).and(literal(false))).should == false
+        expect(evaluate(literal(false).and(literal(false)))).to eq(false)
       end
     end
 
     context "using operator OR" do
       it "true  || true  == true" do
-        evaluate(literal(true).or(literal(true))).should == true
+        expect(evaluate(literal(true).or(literal(true)))).to eq(true)
       end
 
       it "false || true  == true" do
-        evaluate(literal(false).or(literal(true))).should == true
+        expect(evaluate(literal(false).or(literal(true)))).to eq(true)
       end
 
       it "true  || false == true" do
-        evaluate(literal(true).or(literal(false))).should == true
+        expect(evaluate(literal(true).or(literal(false)))).to eq(true)
       end
 
       it "false || false == false" do
-        evaluate(literal(false).or(literal(false))).should == false
+        expect(evaluate(literal(false).or(literal(false)))).to eq(false)
       end
     end
 
     context "using operator NOT" do
       it "!false         == true" do
-        evaluate(literal(false).not()).should == true
+        expect(evaluate(literal(false).not())).to eq(true)
       end
 
       it "!true          == false" do
-        evaluate(literal(true).not()).should == false
+        expect(evaluate(literal(true).not())).to eq(false)
       end
     end
 
     context "on values requiring boxing to Boolean" do
       it "'x'            == true" do
-        evaluate(literal('x').not()).should == false
+        expect(evaluate(literal('x').not())).to eq(false)
       end
 
       it "''             == true" do
-        evaluate(literal('').not()).should == false
+        expect(evaluate(literal('').not())).to eq(false)
       end
 
       it ":undef         == false" do
-        evaluate(literal(:undef).not()).should == true
+        expect(evaluate(literal(:undef).not())).to eq(true)
       end
     end
 
     context "connectives should stop when truth is obtained" do
       it "true && false && error  == false (and no failure)" do
-        evaluate(literal(false).and(literal('0xwtf') + literal(1)).and(literal(true))).should == false
+        expect(evaluate(literal(false).and(literal('0xwtf') + literal(1)).and(literal(true)))).to eq(false)
       end
 
       it "false || true || error  == true (and no failure)" do
-        evaluate(literal(true).or(literal('0xwtf') + literal(1)).or(literal(false))).should == true
+        expect(evaluate(literal(true).or(literal('0xwtf') + literal(1)).or(literal(false)))).to eq(true)
       end
 
       it "false || false || error == error (false positive test)" do

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

@@ -14,29 +14,29 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   context "When evaluator performs string interpolation" do
     it "should interpolate a bare word as a variable name, \"${var}\"" do
       a_block = block(var('a').set(10), string('value is ', text(fqn('a')), ' yo'))
-      evaluate(a_block).should == "value is 10 yo"
+      expect(evaluate(a_block)).to eq("value is 10 yo")
     end
 
     it "should interpolate a variable in a text expression, \"${$var}\"" do
       a_block = block(var('a').set(10), string('value is ', text(var(fqn('a'))), ' yo'))
-      evaluate(a_block).should == "value is 10 yo"
+      expect(evaluate(a_block)).to eq("value is 10 yo")
     end
 
     it "should interpolate a variable, \"$var\"" do
       a_block = block(var('a').set(10), string('value is ', var(fqn('a')), ' yo'))
-      evaluate(a_block).should == "value is 10 yo"
+      expect(evaluate(a_block)).to eq("value is 10 yo")
     end
 
     it "should interpolate any expression in a text expression, \"${$var*2}\"" do
       a_block = block(var('a').set(5), string('value is ', text(var(fqn('a')) * 2) , ' yo'))
-      evaluate(a_block).should == "value is 10 yo"
+      expect(evaluate(a_block)).to eq("value is 10 yo")
     end
 
     it "should interpolate any expression without a text expression, \"${$var*2}\"" do
       # there is no concrete syntax for this, but the parser can generate this simpler
       # equivalent form where the expression is not wrapped in a TextExpression
       a_block = block(var('a').set(5), string('value is ', var(fqn('a')) * 2 , ' yo'))
-      evaluate(a_block).should == "value is 10 yo"
+      expect(evaluate(a_block)).to eq("value is 10 yo")
     end
 
     # TODO: Add function call tests - Pending implementation of calls in the evaluator

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

@@ -18,31 +18,31 @@ describe 'Puppet::Pops::Impl::EvaluatorImpl' do
   context "When the evaluator deals with variables" do
     context "it should handle" do
       it "simple assignment and dereference" do
-        evaluate_l(block( var('a').set(literal(2)+literal(2)), var('a'))).should == 4
+        expect(evaluate_l(block( var('a').set(literal(2)+literal(2)), var('a')))).to eq(4)
       end
 
       it "local scope shadows top scope" do
         top_scope_block   = block( var('a').set(literal(2)+literal(2)), var('a'))
         local_scope_block = block( var('a').set(var('a') + literal(2)), var('a'))
-        evaluate_l(top_scope_block, local_scope_block).should == 6
+        expect(evaluate_l(top_scope_block, local_scope_block)).to eq(6)
       end
 
       it "shadowed in local does not affect parent scope" do
         top_scope_block   = block( var('a').set(literal(2)+literal(2)), var('a'))
         local_scope_block = block( var('a').set(var('a') + literal(2)), var('a'))
         top_scope_again = var('a')
-        evaluate_l(top_scope_block, local_scope_block, top_scope_again).should == 4
+        expect(evaluate_l(top_scope_block, local_scope_block, top_scope_again)).to eq(4)
       end
 
       it "access to global names works in top scope" do
         top_scope_block   = block( var('a').set(literal(2)+literal(2)), var('::a'))
-        evaluate_l(top_scope_block).should == 4
+        expect(evaluate_l(top_scope_block)).to eq(4)
       end
 
       it "access to global names works in local scope" do
         top_scope_block     = block( var('a').set(literal(2)+literal(2)))
-        local_scope_block   = block( var('a').set(literal(100)), var('b').set(var('::a')+literal(2)), var('b'))
-        evaluate_l(top_scope_block, local_scope_block).should == 6
+        local_scope_block   = block( var('a').set(var('::a')+literal(2)), var('::a'))
+        expect(evaluate_l(top_scope_block, local_scope_block)).to eq(6)
       end
 
       it "can not change a variable value in same scope" do
@@ -51,37 +51,37 @@ describe 'Puppet::Pops::Impl::EvaluatorImpl' do
 
       context "access to numeric variables" do
         it "without a match" do
-          evaluate_l(block(literal(2) + literal(2),
-            [var(0), var(1), var(2), var(3)])).should == [nil, nil, nil, nil]
+          expect(evaluate_l(block(literal(2) + literal(2),
+            [var(0), var(1), var(2), var(3)]))).to eq([nil, nil, nil, nil])
         end
 
         it "after a match" do
-          evaluate_l(block(literal('abc') =~ literal(/(a)(b)(c)/),
-            [var(0), var(1), var(2), var(3)])).should == ['abc', 'a', 'b', 'c']
+          expect(evaluate_l(block(literal('abc') =~ literal(/(a)(b)(c)/),
+            [var(0), var(1), var(2), var(3)]))).to eq(['abc', 'a', 'b', 'c'])
         end
 
         it "after a failed match" do
-          evaluate_l(block(literal('abc') =~ literal(/(x)(y)(z)/),
-            [var(0), var(1), var(2), var(3)])).should == [nil, nil, nil, nil]
+          expect(evaluate_l(block(literal('abc') =~ literal(/(x)(y)(z)/),
+            [var(0), var(1), var(2), var(3)]))).to eq([nil, nil, nil, nil])
         end
 
         it "a failed match does not alter previous match" do
-          evaluate_l(block(
+          expect(evaluate_l(block(
             literal('abc') =~ literal(/(a)(b)(c)/),
             literal('abc') =~ literal(/(x)(y)(z)/),
-            [var(0), var(1), var(2), var(3)])).should == ['abc', 'a', 'b', 'c']
+            [var(0), var(1), var(2), var(3)]))).to eq(['abc', 'a', 'b', 'c'])
         end
 
         it "a new match completely shadows previous match" do
-          evaluate_l(block(
+          expect(evaluate_l(block(
             literal('abc') =~ literal(/(a)(b)(c)/),
             literal('abc') =~ literal(/(a)bc/),
-            [var(0), var(1), var(2), var(3)])).should == ['abc', 'a', nil, nil]
+            [var(0), var(1), var(2), var(3)]))).to eq(['abc', 'a', nil, nil])
         end
 
         it "after a match with variable referencing a non existing group" do
-          evaluate_l(block(literal('abc') =~ literal(/(a)(b)(c)/),
-            [var(0), var(1), var(2), var(3), var(4)])).should == ['abc', 'a', 'b', 'c', nil]
+          expect(evaluate_l(block(literal('abc') =~ literal(/(a)(b)(c)/),
+            [var(0), var(1), var(2), var(3), var(4)]))).to eq(['abc', 'a', 'b', 'c', nil])
         end
       end
     end

data/spec/unit/pops/factory_rspec_helper.rb

@@ -45,14 +45,6 @@ module FactoryRspecHelper
     Puppet::Pops::Model::Factory.WHEN(values, block)
   end
 
-  def respond_to? method
-    if Puppet::Pops::Model::Factory.respond_to? method
-      true
-    else
-      super
-    end
-  end
-
   def method_missing(method, *args, &block)
     if Puppet::Pops::Model::Factory.respond_to? method
       Puppet::Pops::Model::Factory.send(method, *args, &block)

data/spec/unit/pops/factory_spec.rb

@@ -11,81 +11,81 @@ describe Puppet::Pops::Model::Factory do
 
   context "When factory methods are invoked they should produce expected results" do
     it "tests #var should create a VariableExpression" do
-      var('a').current.class.should == Puppet::Pops::Model::VariableExpression
+      expect(var('a').current.class).to eq(Puppet::Pops::Model::VariableExpression)
     end
 
     it "tests #fqn should create a QualifiedName" do
-      fqn('a').current.class.should == Puppet::Pops::Model::QualifiedName
+      expect(fqn('a').current.class).to eq(Puppet::Pops::Model::QualifiedName)
     end
 
     it "tests #QNAME should create a QualifiedName" do
-      QNAME('a').current.class.should == Puppet::Pops::Model::QualifiedName
+      expect(QNAME('a').current.class).to eq(Puppet::Pops::Model::QualifiedName)
     end
 
     it "tests #QREF should create a QualifiedReference" do
-      QREF('a').current.class.should == Puppet::Pops::Model::QualifiedReference
+      expect(QREF('a').current.class).to eq(Puppet::Pops::Model::QualifiedReference)
     end
 
     it "tests #block should create a BlockExpression" do
-      block().current.is_a?(Puppet::Pops::Model::BlockExpression).should == true
+      expect(block().current.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
     end
 
     it "should create a literal undef on :undef" do
-      literal(:undef).current.class.should == Puppet::Pops::Model::LiteralUndef
+      expect(literal(:undef).current.class).to eq(Puppet::Pops::Model::LiteralUndef)
     end
 
     it "should create a literal default on :default" do
-      literal(:default).current.class.should == Puppet::Pops::Model::LiteralDefault
+      expect(literal(:default).current.class).to eq(Puppet::Pops::Model::LiteralDefault)
     end
   end
 
   context "When calling block_or_expression" do
     it "A single expression should produce identical output" do
-      block_or_expression(literal(1) + literal(2)).current.is_a?(Puppet::Pops::Model::ArithmeticExpression).should == true
+      expect(block_or_expression(literal(1) + literal(2)).current.is_a?(Puppet::Pops::Model::ArithmeticExpression)).to eq(true)
     end
 
     it "Multiple expressions should produce a block expression" do
       built = block_or_expression(literal(1) + literal(2), literal(2) + literal(3)).current
-      built.is_a?(Puppet::Pops::Model::BlockExpression).should == true
-      built.statements.size.should == 2
+      expect(built.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
+      expect(built.statements.size).to eq(2)
     end
   end
 
   context "When processing calls with CALL_NAMED" do
     it "Should be possible to state that r-value is required" do
       built = CALL_NAMED("foo", true, []).current
-      built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression).should == true
-      built.rval_required.should == true
+      expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
+      expect(built.rval_required).to eq(true)
     end
 
     it "Should produce a call expression without arguments" do
       built = CALL_NAMED("foo", false, []).current
-      built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression).should == true
-      built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName).should == true
-      built.functor_expr.value.should == "foo"
-      built.rval_required.should == false
-      built.arguments.size.should == 0
+      expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
+      expect(built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName)).to eq(true)
+      expect(built.functor_expr.value).to eq("foo")
+      expect(built.rval_required).to eq(false)
+      expect(built.arguments.size).to eq(0)
     end
 
     it "Should produce a call expression with one argument" do
       built = CALL_NAMED("foo", false, [literal(1) + literal(2)]).current
-      built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression).should == true
-      built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName).should == true
-      built.functor_expr.value.should == "foo"
-      built.rval_required.should == false
-      built.arguments.size.should == 1
-      built.arguments[0].is_a?(Puppet::Pops::Model::ArithmeticExpression).should == true
+      expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
+      expect(built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName)).to eq(true)
+      expect(built.functor_expr.value).to eq("foo")
+      expect(built.rval_required).to eq(false)
+      expect(built.arguments.size).to eq(1)
+      expect(built.arguments[0].is_a?(Puppet::Pops::Model::ArithmeticExpression)).to eq(true)
     end
 
     it "Should produce a call expression with two arguments" do
       built = CALL_NAMED("foo", false, [literal(1) + literal(2), literal(1) + literal(2)]).current
-      built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression).should == true
-      built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName).should == true
-      built.functor_expr.value.should == "foo"
-      built.rval_required.should == false
-      built.arguments.size.should == 2
-      built.arguments[0].is_a?(Puppet::Pops::Model::ArithmeticExpression).should == true
-      built.arguments[1].is_a?(Puppet::Pops::Model::ArithmeticExpression).should == true
+      expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
+      expect(built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName)).to eq(true)
+      expect(built.functor_expr.value).to eq("foo")
+      expect(built.rval_required).to eq(false)
+      expect(built.arguments.size).to eq(2)
+      expect(built.arguments[0].is_a?(Puppet::Pops::Model::ArithmeticExpression)).to eq(true)
+      expect(built.arguments[1].is_a?(Puppet::Pops::Model::ArithmeticExpression)).to eq(true)
     end
   end
 
@@ -93,148 +93,148 @@ describe Puppet::Pops::Model::Factory do
     it "Should produce an attribute operation for =>" do
       built = ATTRIBUTE_OP("aname", :'=>', 'x').current
       built.is_a?(Puppet::Pops::Model::AttributeOperation)
-      built.operator.should == :'=>'
-      built.attribute_name.should == "aname"
-      built.value_expr.is_a?(Puppet::Pops::Model::LiteralString).should == true
+      expect(built.operator).to eq(:'=>')
+      expect(built.attribute_name).to eq("aname")
+      expect(built.value_expr.is_a?(Puppet::Pops::Model::LiteralString)).to eq(true)
     end
 
     it "Should produce an attribute operation for +>" do
       built = ATTRIBUTE_OP("aname", :'+>', 'x').current
       built.is_a?(Puppet::Pops::Model::AttributeOperation)
-      built.operator.should == :'+>'
-      built.attribute_name.should == "aname"
-      built.value_expr.is_a?(Puppet::Pops::Model::LiteralString).should == true
+      expect(built.operator).to eq(:'+>')
+      expect(built.attribute_name).to eq("aname")
+      expect(built.value_expr.is_a?(Puppet::Pops::Model::LiteralString)).to eq(true)
     end
   end
 
   context "When processing RESOURCE" do
     it "Should create a Resource body" do
       built = RESOURCE_BODY("title", [ATTRIBUTE_OP('aname', :'=>', 'x')]).current
-      built.is_a?(Puppet::Pops::Model::ResourceBody).should == true
-      built.title.is_a?(Puppet::Pops::Model::LiteralString).should == true
-      built.operations.size.should == 1
-      built.operations[0].class.should == Puppet::Pops::Model::AttributeOperation
-      built.operations[0].attribute_name.should == 'aname'
+      expect(built.is_a?(Puppet::Pops::Model::ResourceBody)).to eq(true)
+      expect(built.title.is_a?(Puppet::Pops::Model::LiteralString)).to eq(true)
+      expect(built.operations.size).to eq(1)
+      expect(built.operations[0].class).to eq(Puppet::Pops::Model::AttributeOperation)
+      expect(built.operations[0].attribute_name).to eq('aname')
     end
 
     it "Should create a RESOURCE without a resource body" do
       bodies = []
       built = RESOURCE("rtype", bodies).current
-      built.class.should == Puppet::Pops::Model::ResourceExpression
-      built.bodies.size.should == 0
+      expect(built.class).to eq(Puppet::Pops::Model::ResourceExpression)
+      expect(built.bodies.size).to eq(0)
     end
 
     it "Should create a RESOURCE with 1 resource body" do
       bodies = [] << RESOURCE_BODY('title', [])
       built = RESOURCE("rtype", bodies).current
-      built.class.should == Puppet::Pops::Model::ResourceExpression
-      built.bodies.size.should == 1
-      built.bodies[0].title.value.should == 'title'
+      expect(built.class).to eq(Puppet::Pops::Model::ResourceExpression)
+      expect(built.bodies.size).to eq(1)
+      expect(built.bodies[0].title.value).to eq('title')
     end
 
     it "Should create a RESOURCE with 2 resource bodies" do
       bodies = [] << RESOURCE_BODY('title', []) << RESOURCE_BODY('title2', [])
       built = RESOURCE("rtype", bodies).current
-      built.class.should == Puppet::Pops::Model::ResourceExpression
-      built.bodies.size.should == 2
-      built.bodies[0].title.value.should == 'title'
-      built.bodies[1].title.value.should == 'title2'
+      expect(built.class).to eq(Puppet::Pops::Model::ResourceExpression)
+      expect(built.bodies.size).to eq(2)
+      expect(built.bodies[0].title.value).to eq('title')
+      expect(built.bodies[1].title.value).to eq('title2')
     end
   end
 
   context "When processing simple literals" do
     it "Should produce a literal boolean from a boolean" do
       built = literal(true).current
-      built.class.should == Puppet::Pops::Model::LiteralBoolean
-      built.value.should == true
+      expect(built.class).to eq(Puppet::Pops::Model::LiteralBoolean)
+      expect(built.value).to eq(true)
       built = literal(false).current
-      built.class.should == Puppet::Pops::Model::LiteralBoolean
-      built.value.should == false
+      expect(built.class).to eq(Puppet::Pops::Model::LiteralBoolean)
+      expect(built.value).to eq(false)
     end
   end
 
   context "When processing COLLECT" do
     it "should produce a virtual query" do
       built = VIRTUAL_QUERY(fqn('a') == literal(1)).current
-      built.class.should == Puppet::Pops::Model::VirtualQuery
-      built.expr.class.should == Puppet::Pops::Model::ComparisonExpression
-      built.expr.operator.should ==  :'=='
+      expect(built.class).to eq(Puppet::Pops::Model::VirtualQuery)
+      expect(built.expr.class).to eq(Puppet::Pops::Model::ComparisonExpression)
+      expect(built.expr.operator).to eq(:'==')
     end
 
     it "should produce an export query" do
       built = EXPORTED_QUERY(fqn('a') == literal(1)).current
-      built.class.should == Puppet::Pops::Model::ExportedQuery
-      built.expr.class.should == Puppet::Pops::Model::ComparisonExpression
-      built.expr.operator.should ==  :'=='
+      expect(built.class).to eq(Puppet::Pops::Model::ExportedQuery)
+      expect(built.expr.class).to eq(Puppet::Pops::Model::ComparisonExpression)
+      expect(built.expr.operator).to eq(:'==')
     end
 
     it "should produce a collect expression" do
       q = VIRTUAL_QUERY(fqn('a') == literal(1))
       built = COLLECT(literal('t'), q, [ATTRIBUTE_OP('name', :'=>', 3)]).current
-      built.class.should == Puppet::Pops::Model::CollectExpression
-      built.operations.size.should == 1
+      expect(built.class).to eq(Puppet::Pops::Model::CollectExpression)
+      expect(built.operations.size).to eq(1)
     end
 
     it "should produce a collect expression without attribute operations" do
       q = VIRTUAL_QUERY(fqn('a') == literal(1))
       built = COLLECT(literal('t'), q, []).current
-      built.class.should == Puppet::Pops::Model::CollectExpression
-      built.operations.size.should == 0
+      expect(built.class).to eq(Puppet::Pops::Model::CollectExpression)
+      expect(built.operations.size).to eq(0)
     end
   end
 
   context "When processing concatenated string(iterpolation)" do
     it "should handle 'just a string'" do
       built = string('blah blah').current
-      built.class.should == Puppet::Pops::Model::ConcatenatedString
+      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
       built.segments.size == 1
-      built.segments[0].class.should == Puppet::Pops::Model::LiteralString
-      built.segments[0].value.should == "blah blah"
+      expect(built.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
+      expect(built.segments[0].value).to eq("blah blah")
     end
 
     it "should handle one expression in the middle" do
       built = string('blah blah', TEXT(literal(1)+literal(2)), 'blah blah').current
-      built.class.should == Puppet::Pops::Model::ConcatenatedString
+      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
       built.segments.size == 3
-      built.segments[0].class.should == Puppet::Pops::Model::LiteralString
-      built.segments[0].value.should == "blah blah"
-      built.segments[1].class.should == Puppet::Pops::Model::TextExpression
-      built.segments[1].expr.class.should == Puppet::Pops::Model::ArithmeticExpression
-      built.segments[2].class.should == Puppet::Pops::Model::LiteralString
-      built.segments[2].value.should == "blah blah"
+      expect(built.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
+      expect(built.segments[0].value).to eq("blah blah")
+      expect(built.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
+      expect(built.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
+      expect(built.segments[2].class).to eq(Puppet::Pops::Model::LiteralString)
+      expect(built.segments[2].value).to eq("blah blah")
     end
 
     it "should handle one expression at the end" do
       built = string('blah blah', TEXT(literal(1)+literal(2))).current
-      built.class.should == Puppet::Pops::Model::ConcatenatedString
+      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
       built.segments.size == 2
-      built.segments[0].class.should == Puppet::Pops::Model::LiteralString
-      built.segments[0].value.should == "blah blah"
-      built.segments[1].class.should == Puppet::Pops::Model::TextExpression
-      built.segments[1].expr.class.should == Puppet::Pops::Model::ArithmeticExpression
+      expect(built.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
+      expect(built.segments[0].value).to eq("blah blah")
+      expect(built.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
+      expect(built.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
     end
 
     it "should handle only one expression" do
       built = string(TEXT(literal(1)+literal(2))).current
-      built.class.should == Puppet::Pops::Model::ConcatenatedString
+      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
       built.segments.size == 1
-      built.segments[0].class.should == Puppet::Pops::Model::TextExpression
-      built.segments[0].expr.class.should == Puppet::Pops::Model::ArithmeticExpression
+      expect(built.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
+      expect(built.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
     end
 
     it "should handle several expressions" do
       built = string(TEXT(literal(1)+literal(2)), TEXT(literal(1)+literal(2))).current
-      built.class.should == Puppet::Pops::Model::ConcatenatedString
+      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
       built.segments.size == 2
-      built.segments[0].class.should == Puppet::Pops::Model::TextExpression
-      built.segments[0].expr.class.should == Puppet::Pops::Model::ArithmeticExpression
-      built.segments[1].class.should == Puppet::Pops::Model::TextExpression
-      built.segments[1].expr.class.should == Puppet::Pops::Model::ArithmeticExpression
+      expect(built.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
+      expect(built.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
+      expect(built.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
+      expect(built.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
     end
 
     it "should handle no expression" do
       built = string().current
-      built.class.should == Puppet::Pops::Model::ConcatenatedString
+      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
       built.segments.size == 0
     end
   end
@@ -242,36 +242,36 @@ describe Puppet::Pops::Model::Factory do
   context "When processing UNLESS" do
     it "should create an UNLESS expression with then part" do
       built = UNLESS(true, literal(1), nil).current
-      built.class.should == Puppet::Pops::Model::UnlessExpression
-      built.test.class.should == Puppet::Pops::Model::LiteralBoolean
-      built.then_expr.class.should == Puppet::Pops::Model::LiteralInteger
-      built.else_expr.class.should == Puppet::Pops::Model::Nop
+      expect(built.class).to eq(Puppet::Pops::Model::UnlessExpression)
+      expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
+      expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
+      expect(built.else_expr.class).to eq(Puppet::Pops::Model::Nop)
     end
 
     it "should create an UNLESS expression with then and else parts" do
       built = UNLESS(true, literal(1), literal(2)).current
-      built.class.should == Puppet::Pops::Model::UnlessExpression
-      built.test.class.should == Puppet::Pops::Model::LiteralBoolean
-      built.then_expr.class.should == Puppet::Pops::Model::LiteralInteger
-      built.else_expr.class.should == Puppet::Pops::Model::LiteralInteger
+      expect(built.class).to eq(Puppet::Pops::Model::UnlessExpression)
+      expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
+      expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
+      expect(built.else_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
     end
   end
 
   context "When processing IF" do
     it "should create an IF expression with then part" do
       built = IF(true, literal(1), nil).current
-      built.class.should == Puppet::Pops::Model::IfExpression
-      built.test.class.should == Puppet::Pops::Model::LiteralBoolean
-      built.then_expr.class.should == Puppet::Pops::Model::LiteralInteger
-      built.else_expr.class.should == Puppet::Pops::Model::Nop
+      expect(built.class).to eq(Puppet::Pops::Model::IfExpression)
+      expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
+      expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
+      expect(built.else_expr.class).to eq(Puppet::Pops::Model::Nop)
     end
 
     it "should create an IF expression with then and else parts" do
       built = IF(true, literal(1), literal(2)).current
-      built.class.should == Puppet::Pops::Model::IfExpression
-      built.test.class.should == Puppet::Pops::Model::LiteralBoolean
-      built.then_expr.class.should == Puppet::Pops::Model::LiteralInteger
-      built.else_expr.class.should == Puppet::Pops::Model::LiteralInteger
+      expect(built.class).to eq(Puppet::Pops::Model::IfExpression)
+      expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
+      expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
+      expect(built.else_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
     end
   end