puppet 4.0.0 → 5.0.0

data/spec/unit/parser/scope_spec.rb

@@ -33,6 +33,15 @@ describe Puppet::Parser::Scope do
     end
   end
 
+  it "should generate a simple string when inspecting a scope" do
+    expect(@scope.inspect).to eq("Scope()")
+  end
+
+  it "should generate a simple string when inspecting a scope with a resource" do
+    @scope.resource="foo::bar"
+    expect(@scope.inspect).to eq("Scope(foo::bar)")
+  end
+
   it "should return a scope for use in a test harness" do
     expect(create_test_scope_for_node("node_name_foo")).to be_a_kind_of(Puppet::Parser::Scope)
   end
@@ -82,10 +91,6 @@ describe Puppet::Parser::Scope do
     }.to raise_error(Puppet::DevError, /you must pass a compiler instance/)
   end
 
-  it "should use the resource type collection helper to find its known resource types" do
-    expect(Puppet::Parser::Scope.ancestors).to include(Puppet::Resource::TypeCollectionHelper)
-  end
-
   describe "when custom functions are called" do
     let(:env) { Puppet::Node::Environment.create(:testing, []) }
     let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new('foo', :environment => env)) }
@@ -149,7 +154,7 @@ describe Puppet::Parser::Scope do
       expect { @scope[:foo] = 12 }.to raise_error(Puppet::ParseError, /Scope variable name .* not a string/)
     end
 
-    it "should return nil for unset variables" do
+    it "should return nil for unset variables when --strict variables is not in effect" do
       expect(@scope["var"]).to be_nil
     end
 
@@ -192,16 +197,36 @@ describe Puppet::Parser::Scope do
       @scope["var"] = "childval"
       expect {
         @scope["var"] = "change"
-      }.to raise_error(Puppet::Error, "Cannot reassign variable var")
+      }.to raise_error(Puppet::Error, "Cannot reassign variable '$var'")
     end
 
     it "should be able to detect when variables are not set" do
       expect(@scope).not_to be_include("var")
     end
 
+    it "warns and return nil for non found unqualified variable" do
+      Puppet.expects(:warn_once)
+      expect(@scope["santa_clause"]).to be_nil
+    end
+
+    it "warns once for a non found variable" do
+      Puppet.expects(:warning).once
+      expect([@scope["santa_claus"],@scope["santa_claus"]]).to eq([nil, nil])
+    end
+
+    it "warns and return nil for non found qualified variable" do
+      Puppet.expects(:warn_once)
+      expect(@scope["north_pole::santa_clause"]).to be_nil
+    end
+
+    it "does not warn when a numeric variable is missing - they always exist" do
+      Puppet.expects(:warn_once).never
+      expect(@scope["1"]).to be_nil
+    end
+
     describe "and the variable is qualified" do
       before :each do
-        @known_resource_types = @scope.known_resource_types
+        @known_resource_types = @scope.environment.known_resource_types
 
         node      = Puppet::Node.new('localhost')
         @compiler = Puppet::Parser::Compiler.new(node)
@@ -222,9 +247,9 @@ describe Puppet::Parser::Scope do
         @scope.class_scope(klass)
       end
 
-      it "should be able to look up explicitly fully qualified variables from main" do
+      it "should be able to look up explicitly fully qualified variables from compiler's top scope" do
         Puppet.expects(:deprecation_warning).never
-        other_scope = create_class_scope("")
+        other_scope = @scope.compiler.topscope
 
         other_scope["othervar"] = "otherval"
 
@@ -257,17 +282,16 @@ describe Puppet::Parser::Scope do
 
       it "should warn and return nil for qualified variables whose classes have not been evaluated" do
         klass = newclass("other::deep::klass")
-        @scope.expects(:warning)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes do not exist" do
-        @scope.expects(:warning)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should return nil when asked for a non-string qualified variable from a class that does not exist" do
-        @scope.stubs(:warning)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
@@ -296,51 +320,50 @@ describe Puppet::Parser::Scope do
         expect { @scope['module_name'] }.to_not raise_error
       end
     end
-  end
 
-  describe "when variables are set with append=true" do
-    it "should raise error if the variable is already defined in this scope" do
-      @scope.setvar("var", "1", :append => false)
-      expect {
-        @scope.setvar("var", "1", :append => true)
-      }.to raise_error(
-        Puppet::ParseError,
-        "Cannot append, variable var is defined in this scope"
-      )
-    end
+    context "and strict_variables is false and --strict=off" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :off
+      end
 
-    it "should lookup current variable value" do
-      @scope.expects(:[]).with("var").returns("2")
-      @scope.setvar("var", "1", :append => true)
-    end
+      it "should not error when unknown variable is looked up and produce nil" do
+        expect(@scope['john_doe']).to be_nil
+      end
 
-    it "should store the concatenated string '42'" do
-      @topscope.setvar("var", "4", :append => false)
-      @scope.setvar("var", "2", :append => true)
-      expect(@scope["var"]).to eq("42")
+      it "should not error when unknown qualified variable is looked up and produce nil" do
+        expect(@scope['nowhere::john_doe']).to be_nil
+      end
     end
 
-    it "should store the concatenated array [4,2]" do
-      @topscope.setvar("var", [4], :append => false)
-      @scope.setvar("var", [2], :append => true)
-      expect(@scope["var"]).to eq([4,2])
-    end
+    context "and strict_variables is false and --strict=warning" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
+      end
 
-    it "should store the merged hash {a => b, c => d}" do
-      @topscope.setvar("var", {"a" => "b"}, :append => false)
-      @scope.setvar("var", {"c" => "d"}, :append => true)
-      expect(@scope["var"]).to eq({"a" => "b", "c" => "d"})
+      it "should not error when unknown variable is looked up" do
+        expect(@scope['john_doe']).to be_nil
+      end
+
+      it "should not error when unknown qualified variable is looked up" do
+        expect(@scope['nowhere::john_doe']).to be_nil
+      end
     end
 
-    it "should raise an error when appending a hash with something other than another hash" do
-      @topscope.setvar("var", {"a" => "b"}, :append => false)
+    context "and strict_variables is false and --strict=error" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :error
+      end
 
-      expect {
-        @scope.setvar("var", "not a hash", :append => true)
-      }.to raise_error(
-        ArgumentError,
-        "Trying to append to a hash with something which is not a hash is unsupported"
-      )
+      it "should raise error when unknown variable is looked up" do
+        expect { @scope['john_doe'] }.to raise_error(/Undefined variable/)
+      end
+
+      it "should not throw a symbol when unknown qualified variable is looked up" do
+        expect { @scope['nowhere::john_doe'] }.to raise_error(/Undefined variable/)
+      end
     end
   end
 
@@ -349,8 +372,8 @@ describe Puppet::Parser::Scope do
       expect(Puppet::Parser::Scope.number?([2])).to be_nil
     end
 
-    it "should return a Fixnum for a Fixnum" do
-      expect(Puppet::Parser::Scope.number?(2)).to be_an_instance_of(Fixnum)
+    it "should return a Integer for an Integer" do
+      expect(Puppet::Parser::Scope.number?(2)).to be_a(Integer)
     end
 
     it "should return a Float for a Float" do
@@ -408,31 +431,10 @@ describe Puppet::Parser::Scope do
 
   describe "when using ephemeral variables" do
     it "should store the variable value" do
-#      @scope.setvar("1", :value, :ephemeral => true)
       @scope.set_match_data({1 => :value})
       expect(@scope["1"]).to eq(:value)
     end
 
-    it "should remove the variable value when unset_ephemeral_var(:all) is called" do
-#      @scope.setvar("1", :value, :ephemeral => true)
-      @scope.set_match_data({1 => :value})
-      @scope.stubs(:parent).returns(nil)
-
-      @scope.unset_ephemeral_var(:all)
-
-      expect(@scope["1"]).to be_nil
-    end
-
-    it "should not remove classic variables when unset_ephemeral_var(:all) is called" do
-      @scope['myvar'] = :value1
-      @scope.set_match_data({1 => :value2})
-      @scope.stubs(:parent).returns(nil)
-
-      @scope.unset_ephemeral_var(:all)
-
-      expect(@scope["myvar"]).to eq(:value1)
-    end
-
     it "should raise an error when setting numerical variable" do
       expect {
         @scope.setvar("1", :value3, :ephemeral => true)
@@ -454,8 +456,6 @@ describe Puppet::Parser::Scope do
       end
 
       it "should not check presence of an ephemeral variable across multiple levels" do
-        # This test was testing that scope actuallys screwed up - making values from earlier matches show as if they
-        # where true for latest match - insanity !
         @scope.new_ephemeral
         @scope.set_match_data({1 => :value1})
         @scope.new_ephemeral
@@ -480,17 +480,15 @@ describe Puppet::Parser::Scope do
         expect(@scope.include?("1")).to be_falsey
       end
 
-      describe "when calling unset_ephemeral_var with a level" do
+      describe "when using a guarded scope" do
         it "should remove ephemeral scopes up to this level" do
           @scope.set_match_data({1 => :value1})
           @scope.new_ephemeral
           @scope.set_match_data({1 => :value2})
-          level = @scope.ephemeral_level()
-          @scope.new_ephemeral
-          @scope.set_match_data({1 => :value3})
-
-          @scope.unset_ephemeral_var(level)
-
+          @scope.with_guarded_scope do
+            @scope.new_ephemeral
+            @scope.set_match_data({1 => :value3})
+          end
           expect(@scope["1"]).to eq(:value2)
         end
       end
@@ -504,13 +502,13 @@ describe Puppet::Parser::Scope do
       expect(@scope["apple"]).to eq(:fruit)
     end
 
-    it "should remove all local scope variables on unset" do
-      @scope.new_ephemeral true
-      @scope.setvar("apple", :fruit)
-      expect(@scope["apple"]).to eq(:fruit)
-      @scope.unset_ephemeral_var
-      expect(@scope["apple"]).to eq(nil)
+    it 'should store an undef in local scope and let it override parent scope' do
+      @scope['cloaked'] = 'Cloak me please'
+      @scope.new_ephemeral(true)
+      @scope['cloaked'] = nil
+      expect(@scope['cloaked']).to eq(nil)
     end
+
     it "should be created from a hash" do
       @scope.ephemeral_from({ "apple" => :fruit, "strawberry" => :berry})
       expect(@scope["apple"]).to eq(:fruit)

data/spec/unit/parser/templatewrapper_spec.rb

@@ -94,7 +94,7 @@ describe Puppet::Parser::TemplateWrapper do
     Puppet::Parser::Files.stubs(:find_template).
       with(name, anything()).
       returns(full_name)
-    File.stubs(:read).with(full_name).returns(contents)
+    Puppet::FileSystem.stubs(:read_preserve_line_endings).with(full_name).returns(contents)
 
     full_name
   end

data/spec/unit/pops/benchmark_spec.rb

@@ -4,11 +4,6 @@ require 'puppet/pops'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 
-require 'rgen/environment'
-require 'rgen/metamodel_builder'
-require 'rgen/serializer/json_serializer'
-require 'rgen/instantiator/json_instantiator'
-
 describe "Benchmark", :benchmark => true do
   include PuppetSpec::Pops
   include PuppetSpec::Scope
@@ -28,30 +23,17 @@ $a = "interpolate ${foo} and stuff"
     alias write concat
   end
 
-  class MyJSonSerializer < RGen::Serializer::JsonSerializer
-    def attributeValue(value, a)
-      x = super
-      puts "#{a.eType} value: <<#{value}>> serialize: <<#{x}>>"
-      x
-    end
-  end
-
   def json_dump(model)
     output = StringWriter.new
-    ser = MyJSonSerializer.new(output)
-    ser.serialize(model)
+    ser = Puppet::Pops::Serialization::Serializer.new(Puppet::Pops::Serialization::JSON.writer.new(output))
+    ser.write(model)
+    ser.finish
     output
   end
 
-  def json_load(string)
-    env = RGen::Environment.new
-    inst = RGen::Instantiator::JsonInstantiator.new(env, Puppet::Pops::Model)
-    inst.instantiate(string)
-  end
-
   it "transformer", :profile => true do
     parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string(code).current
+    model = parser.parse_string(code).model
     transformer = Puppet::Pops::Model::AstTransformer.new()
     m = Benchmark.measure { 10000.times { transformer.transform(model) }}
     puts "Transformer: #{m}"
@@ -67,7 +49,7 @@ $a = "interpolate ${foo} and stuff"
   it "parse transform", :profile => true do
     parser = Puppet::Pops::Parser::Parser.new()
     transformer = Puppet::Pops::Model::AstTransformer.new()
-    m = Benchmark.measure { 10000.times { transformer.transform(parser.parse_string(code).current) }}
+    m = Benchmark.measure { 10000.times { transformer.transform(parser.parse_string(code).model) }}
     puts "Parse and transform: #{m}"
   end
 
@@ -85,7 +67,7 @@ $a = "interpolate ${foo} and stuff"
 
   it "marshal1", :profile => true do
     parser = Puppet::Pops::Parser::EvaluatingParser.new()
-    model = parser.parse_string(code).current
+    model = parser.parse_string(code).model
     dumped = Marshal.dump(model)
     m = Benchmark.measure { 10000.times { Marshal.load(dumped) }}
     puts "Marshal1: #{m}"
@@ -93,10 +75,10 @@ $a = "interpolate ${foo} and stuff"
 
   it "rgenjson", :profile => true do
     parser = Puppet::Pops::Parser::EvaluatingParser.new()
-    model = parser.parse_string(code).current
+    model = parser.parse_string(code).model
     dumped = json_dump(model)
     m = Benchmark.measure { 10000.times { json_load(dumped) }}
-    puts "RGen Json: #{m}"
+    puts "Pcore Json: #{m}"
   end
 
   it "lexer2", :profile => true do

data/spec/unit/pops/containment_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require File.join(File.dirname(__FILE__), 'factory_rspec_helper')
-
-describe Puppet::Pops::Containment do
-  include FactoryRspecHelper
-
-  it "Should return an Enumerable if eAllContents is called without arguments" do
-    expect((literal(1) + literal(2)).current.eAllContents.is_a?(Enumerable)).to eq(true)
-  end
-
-  it "Should return all content" do
-    # Note the top object is not included (an ArithmeticOperation with + operator)
-    expect((literal(1) + literal(2) + literal(3)).current.eAllContents.collect {|x| x}.size).to eq(4)
-  end
-
-  it "Should return containing feature" do
-    left = literal(1)
-    right = literal(2)
-    op = left + right
-
-    #pending "eContainingFeature does not work on _uni containments in RGen < 0.6.1"
-    expect(left.current.eContainingFeature).to eq(:left_expr)
-    expect(right.current.eContainingFeature).to eq(:right_expr)
-  end
-end