puppet 3.4.3 → 3.5.0.rc1

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

@@ -0,0 +1,75 @@
+require 'puppet/pops'
+require 'puppet/pops/evaluator/evaluator_impl'
+
+require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
+
+module EvaluatorRspecHelper
+  include FactoryRspecHelper
+
+  # Evaluate a Factory wrapper round a model object in top scope + named scope
+  # Optionally pass two or three model objects (typically blocks) to be executed
+  # in top scope, named scope, and then top scope again. If a named_scope is used, it must
+  # be preceded by the name of the scope.
+  # The optional block is executed before the result of the last specified model object
+  # is evaluated. This block gets the top scope as an argument. The intent is to pass
+  # a block that asserts the state of the top scope after the operations.
+  #
+  def evaluate in_top_scope, scopename="x", in_named_scope = nil, in_top_scope_again = nil, &block
+    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)
+
+    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)
+      result = evaluator.evaluate(in_named_scope.current, other_scope)
+    end
+    if in_top_scope_again
+      result = evaluator.evaluate(in_top_scope_again.current, top_scope)
+    end
+    if block_given?
+      block.call(top_scope)
+    end
+    result
+  end
+
+  # Evaluate a Factory wrapper round a model object in top scope + local scope
+  # Optionally pass two or three model objects (typically blocks) to be executed
+  # in top scope, local scope, and then top scope again
+  # The optional block is executed before the result of the last specified model object
+  # is evaluated. This block gets the top scope as an argument. The intent is to pass
+  # a block that asserts the state of the top scope after the operations.
+  #
+  def evaluate_l in_top_scope, in_local_scope = nil, in_top_scope_again = nil, &block
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+
+    # compiler creates the top scope if one is not present
+    top_scope = compiler.topscope()
+
+    evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
+    result = evaluator.evaluate(in_top_scope.current, top_scope)
+    if in_local_scope
+      # This is really bad in 3.x scope
+      elevel = top_scope.ephemeral_level
+      top_scope.new_ephemeral(true)
+      result = evaluator.evaluate(in_local_scope.current, top_scope)
+      top_scope.unset_ephemeral_var(elevel)
+    end
+    if in_top_scope_again
+      result = evaluator.evaluate(in_top_scope_again.current, top_scope)
+    end
+    if block_given?
+      block.call(top_scope)
+    end
+    result
+  end
+end

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

@@ -0,0 +1,90 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/evaluator/evaluator_impl'
+
+
+# relative to this spec file (./) does not work as this file is loaded by rspec
+require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')
+
+describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
+  include EvaluatorRspecHelper
+
+  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
+      end
+
+      it "false && true  == false" do
+        evaluate(literal(false).and(literal(true))).should == false
+      end
+
+      it "true  && false == false" do
+        evaluate(literal(true).and(literal(false))).should == false
+      end
+
+      it "false && false == false" do
+        evaluate(literal(false).and(literal(false))).should == false
+      end
+    end
+
+    context "using operator OR" do
+      it "true  || true  == true" do
+        evaluate(literal(true).or(literal(true))).should == true
+      end
+
+      it "false || true  == true" do
+        evaluate(literal(false).or(literal(true))).should == true
+      end
+
+      it "true  || false == true" do
+        evaluate(literal(true).or(literal(false))).should == true
+      end
+
+      it "false || false == false" do
+        evaluate(literal(false).or(literal(false))).should == false
+      end
+    end
+
+    context "using operator NOT" do
+      it "!false         == true" do
+        evaluate(literal(false).not()).should == true
+      end
+
+      it "!true          == false" do
+        evaluate(literal(true).not()).should == false
+      end
+    end
+
+    context "on values requiring boxing to Boolean" do
+      it "'x'            == true" do
+        evaluate(literal('x').not()).should == false
+      end
+
+      it "''             == false" do
+        evaluate(literal('').not()).should == true
+      end
+
+      it ":undef         == false" do
+        evaluate(literal(:undef).not()).should == 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
+      end
+
+      it "false || true || error  == true (and no failure)" do
+        evaluate(literal(true).or(literal('0xwtf') + literal(1)).or(literal(false))).should == true
+      end
+
+      it "false || false || error == error (false positive test)" do
+        # TODO: Change the exception type
+        expect {evaluate(literal(true).and(literal('0xwtf') + literal(1)).or(literal(false)))}.to raise_error(Puppet::ParseError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/evaluator/evaluator_impl'
+
+
+# relative to this spec file (./) does not work as this file is loaded by rspec
+require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')
+
+describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
+  include EvaluatorRspecHelper
+
+  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"
+    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"
+    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"
+    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"
+    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"
+    end
+
+    # TODO: Add function call tests - Pending implementation of calls in the evaluator
+  end
+end

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

@@ -0,0 +1,194 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet/pops/evaluator/evaluator_impl'
+
+
+# This file contains basic testing of variable references and assignments
+# using a top scope and a local scope.
+# It does not test variables and named scopes.
+#
+
+# relative to this spec file (./) does not work as this file is loaded by rspec
+require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')
+
+describe 'Puppet::Pops::Impl::EvaluatorImpl' do
+  include EvaluatorRspecHelper
+
+  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
+      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
+      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
+      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
+      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(var('::a')+literal(2)), var('::a'))
+        evaluate_l(top_scope_block, local_scope_block).should == 6
+      end
+
+      it "can not change a variable value in same scope" do
+        expect { evaluate_l(block(var('a').set(10), var('a').set(20))) }.to raise_error(/Cannot reassign variable a/)
+      end
+
+      context "-= operations" do
+        # Also see collections_ops_spec.rb where delete via - is fully tested, here only the
+        # the -= operation itself is tested (there are many combinations)
+        #
+        it 'deleting from non existing value produces :undef, nil -= ?' do
+          top_scope_block = var('b').set([1,2,3])
+          local_scope_block = block(var('a').minus_set([4]), fqn('a').var)
+          evaluate_l(top_scope_block, local_scope_block).should == :undef
+        end
+
+        it 'deletes from a list' do
+          top_scope_block = var('a').set([1,2,3])
+          local_scope_block = block(var('a').minus_set([2]), fqn('a').var())
+          evaluate_l(top_scope_block, local_scope_block).should == [1,3]
+        end
+
+        it 'deletes from a hash' do
+          top_scope_block = var('a').set({'a'=>1,'b'=>2,'c'=>3})
+          local_scope_block = block(var('a').minus_set('b'), fqn('a').var())
+          evaluate_l(top_scope_block, local_scope_block).should == {'a'=>1,'c'=>3}
+        end
+      end
+
+      context "+= operations" do
+        # Also see collections_ops_spec.rb where concatenation via + is fully tested
+        it "appending to non existing value, nil += []" do
+          top_scope_block = var('b').set([1,2,3])
+          local_scope_block = var('a').plus_set([4])
+          evaluate_l(top_scope_block, local_scope_block).should == [4]
+        end
+
+        context "appending to list" do
+          it "from list, [] += []" do
+            top_scope_block = var('a').set([1,2,3])
+            local_scope_block = block(var('a').plus_set([4]), fqn('a').var())
+            evaluate_l(top_scope_block, local_scope_block).should == [1,2,3,4]
+          end
+
+          it "from hash, [] += {a=>b}" do
+            top_scope_block = var('a').set([1,2,3])
+            local_scope_block = block(var('a').plus_set({'a' => 1, 'b'=>2}), fqn('a').var())
+            evaluate_l(top_scope_block, local_scope_block).should satisfy {|result|
+              # hash in 1.8.7 is not insertion order preserving, hence this hoop
+             result == [1,2,3,['a',1],['b',2]] || result == [1,2,3,['b',2],['a',1]]
+            }
+          end
+
+          it "from single value, [] += x" do
+            top_scope_block = var('a').set([1,2,3])
+            local_scope_block = block(var('a').plus_set(4), fqn('a').var())
+            evaluate_l(top_scope_block, local_scope_block).should == [1,2,3,4]
+          end
+
+          it "from embedded list, [] += [[x]]" do
+            top_scope_block = var('a').set([1,2,3])
+            local_scope_block = block(var('a').plus_set([[4,5]]), fqn('a').var())
+            evaluate_l(top_scope_block, local_scope_block).should == [1,2,3,[4,5]]
+          end
+        end
+
+        context "appending to hash" do
+          it "from hash, {a=>b} += {x=>y}" do
+            top_scope_block = var('a').set({'a' => 1, 'b' => 2})
+            local_scope_block = block(var('a').plus_set({'c' => 3}), fqn('a').var())
+            evaluate_l(top_scope_block, local_scope_block) do |scope|
+              # Assert no change to top scope hash
+              scope['a'].should == {'a' =>1, 'b'=> 2}
+            end.should == {'a' => 1, 'b' => 2, 'c' => 3}
+          end
+
+          it "from list, {a=>b} += ['x', y]" do
+            top_scope_block = var('a').set({'a' => 1, 'b' => 2})
+            local_scope_block = block(var('a').plus_set(['c', 3]), fqn('a').var())
+            evaluate_l(top_scope_block, local_scope_block) do |scope|
+              # Assert no change to top scope hash
+              scope['a'].should == {'a' =>1, 'b'=> 2}
+            end.should == {'a' => 1, 'b' => 2, 'c' => 3}
+          end
+
+          it "with overwrite from hash, {a=>b} += {a=>c}" do
+            top_scope_block = var('a').set({'a' => 1, 'b' => 2})
+            local_scope_block = block(var('a').plus_set({'b' => 4, 'c' => 3}),fqn('a').var())
+            evaluate_l(top_scope_block, local_scope_block) do |scope|
+              # Assert no change to top scope hash
+              scope['a'].should == {'a' =>1, 'b'=> 2}
+            end.should == {'a' => 1, 'b' => 4, 'c' => 3}
+          end
+
+          it "with overwrite from list, {a=>b} += ['a', c]" do
+            top_scope_block = var('a').set({'a' => 1, 'b' => 2})
+            local_scope_block = block(var('a').plus_set(['b', 4, 'c', 3]), fqn('a').var())
+            evaluate_l(top_scope_block, local_scope_block) do |scope|
+              # Assert no change to topscope hash
+              scope['a'].should == {'a' =>1, 'b'=> 2}
+            end.should == {'a' => 1, 'b' => 4, 'c' => 3}
+          end
+
+          it "from odd length array - error" do
+            top_scope_block = var('a').set({'a' => 1, 'b' => 2})
+            local_scope_block = var('a').plus_set(['b', 4, 'c'])
+            expect { evaluate_l(top_scope_block, local_scope_block) }.to raise_error(/Append assignment \+= failed with error: odd number of arguments for Hash/)
+          end
+        end
+      end
+
+      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]
+        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']
+        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]
+        end
+
+        it "a failed match does not alter previous match" do
+          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']
+        end
+
+        it "a new match completely shadows previous match" do
+          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]
+        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]
+        end
+      end
+    end
+  end
+end

data/spec/unit/pops/factory_spec.rb

@@ -239,35 +239,12 @@ describe Puppet::Pops::Model::Factory do
     end
   end
 
-  context "When processing instance / resource references" do
-    it "should produce an InstanceReference without a reference" do
-      built = INSTANCE(QREF('a'), []).current
-      built.class.should == Puppet::Pops::Model::InstanceReferences
-      built.names.size.should == 0
-    end
-
-    it "should produce an InstanceReference with one reference" do
-      built = INSTANCE(QREF('a'), [QNAME('b')]).current
-      built.class.should == Puppet::Pops::Model::InstanceReferences
-      built.names.size.should == 1
-      built.names[0].value.should == 'b'
-    end
-
-    it "should produce an InstanceReference with two references" do
-      built = INSTANCE(QREF('a'), [QNAME('b'), QNAME('c')]).current
-      built.class.should == Puppet::Pops::Model::InstanceReferences
-      built.names.size.should == 2
-      built.names[0].value.should == 'b'
-      built.names[1].value.should == 'c'
-    end
-  end
-
   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::LiteralNumber
+      built.then_expr.class.should == Puppet::Pops::Model::LiteralInteger
       built.else_expr.class.should == Puppet::Pops::Model::Nop
     end
 
@@ -275,8 +252,8 @@ describe Puppet::Pops::Model::Factory 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::LiteralNumber
-      built.else_expr.class.should == Puppet::Pops::Model::LiteralNumber
+      built.then_expr.class.should == Puppet::Pops::Model::LiteralInteger
+      built.else_expr.class.should == Puppet::Pops::Model::LiteralInteger
     end
   end
 
@@ -285,7 +262,7 @@ describe Puppet::Pops::Model::Factory 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::LiteralNumber
+      built.then_expr.class.should == Puppet::Pops::Model::LiteralInteger
       built.else_expr.class.should == Puppet::Pops::Model::Nop
     end
 
@@ -293,8 +270,8 @@ describe Puppet::Pops::Model::Factory 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::LiteralNumber
-      built.else_expr.class.should == Puppet::Pops::Model::LiteralNumber
+      built.then_expr.class.should == Puppet::Pops::Model::LiteralInteger
+      built.else_expr.class.should == Puppet::Pops::Model::LiteralInteger
     end
   end