puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/parser/parser_spec.rb

@@ -19,18 +19,14 @@ describe Puppet::Parser do
   end
 
   it "should set the environment" do
-    env = Puppet::Node::Environment.new
+    env = Puppet::Node::Environment.create(:testing, [], '')
     Puppet::Parser::Parser.new(env).environment.should == env
   end
 
-  it "should convert the environment into an environment instance if a string is provided" do
-    env = Puppet::Node::Environment.new("testing")
-    Puppet::Parser::Parser.new("testing").environment.should == env
-  end
-
   it "should be able to look up the environment-specific resource type collection" do
-    rtc = Puppet::Node::Environment.new("development").known_resource_types
-    parser = Puppet::Parser::Parser.new "development"
+    env = Puppet::Node::Environment.create(:development, [], '')
+    rtc = env.known_resource_types
+    parser = Puppet::Parser::Parser.new env
     parser.known_resource_types.should equal(rtc)
   end
 
@@ -53,8 +49,8 @@ describe Puppet::Parser do
 
   describe "when parsing files" do
     before do
-      Puppet::FileSystem::File.stubs(:exist?).returns true
-      File.stubs(:read).returns ""
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Puppet::FileSystem.stubs(:read).returns ""
       @parser.stubs(:watch_file)
     end
 
@@ -528,4 +524,12 @@ describe Puppet::Parser do
     @parser.known_resource_types.hostclass('funtest').
       should == @parser.find_hostclass("", "fUntEst")
   end
+
+  context "deprecations" do
+    it "should flag use of import as deprecated" do
+      Puppet.expects(:deprecation_warning).once
+      @parser.known_resource_types.loader.expects(:import).with('foo', Dir.pwd)
+      @parser.parse("import 'foo'")
+    end
+  end
 end

data/spec/unit/parser/resource_spec.rb

@@ -1,15 +1,11 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-# LAK: FIXME This is just new tests for resources; I have
-# not moved all tests over yet.
-
 describe Puppet::Parser::Resource do
   before do
-    @node = Puppet::Node.new("yaynode")
-    @known_resource_types = Puppet::Resource::TypeCollection.new("env")
+    environment = Puppet::Node::Environment.create(:testing, [], '')
+    @node = Puppet::Node.new("yaynode", :environment => environment)
+    @known_resource_types = environment.known_resource_types
     @compiler = Puppet::Parser::Compiler.new(@node)
-    @compiler.environment.stubs(:known_resource_types).returns @known_resource_types
     @source = newclass ""
     @scope = @compiler.topscope
   end
@@ -131,8 +127,6 @@ describe Puppet::Parser::Resource do
 
   describe "when evaluating" do
     before do
-      @node = Puppet::Node.new "test-node"
-      @compiler = Puppet::Parser::Compiler.new @node
       @catalog = Puppet::Resource::Catalog.new
       source = stub('source')
       source.stubs(:module_name)

data/spec/unit/parser/scope_spec.rb

@@ -1,8 +1,11 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
+require 'puppet_spec/scope'
 
 describe Puppet::Parser::Scope do
+  include PuppetSpec::Scope
+
   before :each do
     @scope = Puppet::Parser::Scope.new(
       Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
@@ -12,26 +15,26 @@ describe Puppet::Parser::Scope do
     @scope.parent = @topscope
   end
 
-  describe ".new_for_test_harness" do
+  describe "create_test_scope_for_node" do
     let(:node_name) { "node_name_foo" }
-    let(:scope) { described_class.new_for_test_harness(node_name) }
+    let(:scope) { create_test_scope_for_node(node_name) }
 
     it "should be a kind of Scope" do
-      scope.should be_a_kind_of Puppet::Parser::Scope
+      scope.should be_a_kind_of(Puppet::Parser::Scope)
     end
     it "should set the source to a node resource" do
-      scope.source.should be_a_kind_of Puppet::Resource::Type
+      scope.source.should be_a_kind_of(Puppet::Resource::Type)
     end
     it "should have a compiler" do
-      scope.compiler.should be_a_kind_of Puppet::Parser::Compiler
+      scope.compiler.should be_a_kind_of(Puppet::Parser::Compiler)
     end
     it "should set the parent to the compiler topscope" do
-      scope.parent.should be scope.compiler.topscope
+      scope.parent.should be(scope.compiler.topscope)
     end
   end
 
   it "should return a scope for use in a test harness" do
-    described_class.new_for_test_harness("node_name_foo").should be_a_kind_of Puppet::Parser::Scope
+    create_test_scope_for_node("node_name_foo").should be_a_kind_of(Puppet::Parser::Scope)
   end
 
   it "should be able to retrieve class scopes by name" do
@@ -61,7 +64,7 @@ describe Puppet::Parser::Scope do
   end
 
   it "should get its environment from its compiler" do
-    env = Puppet::Node::Environment.new
+    env = Puppet::Node::Environment.create(:testing, [], '')
     compiler = stub 'compiler', :environment => env, :is_a? => true
     scope = Puppet::Parser::Scope.new(compiler)
     scope.environment.should equal(env)
@@ -84,7 +87,7 @@ describe Puppet::Parser::Scope do
   end
 
   describe "when custom functions are called" do
-    let(:env) { Puppet::Node::Environment.new('testing') }
+    let(:env) { Puppet::Node::Environment.create(:testing, [], '') }
     let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new('foo', :environment => env)) }
     let(:scope) { Puppet::Parser::Scope.new(compiler) }
 
@@ -117,8 +120,8 @@ describe Puppet::Parser::Scope do
 
   describe "when initializing" do
     it "should extend itself with its environment's Functions module as well as the default" do
-      env = Puppet::Node::Environment.new("myenv")
-      root = Puppet::Node::Environment.root
+      env = Puppet::Node::Environment.create(:myenv, [], '')
+      root = Puppet.lookup(:root_environment)
       compiler = stub 'compiler', :environment => env, :is_a? => true
 
       scope = Puppet::Parser::Scope.new(compiler)
@@ -127,7 +130,7 @@ describe Puppet::Parser::Scope do
     end
 
     it "should extend itself with the default Functions module if its environment is the default" do
-      root     = Puppet::Node::Environment.root
+      root     = Puppet.lookup(:root_environment)
       node     = Puppet::Node.new('localhost')
       compiler = Puppet::Parser::Compiler.new(node)
       scope    = Puppet::Parser::Scope.new(compiler)
@@ -187,18 +190,6 @@ describe Puppet::Parser::Scope do
       @scope.should_not be_include("var")
     end
 
-    it "should support iteration over its variables" do
-      @scope["one"] = "two"
-      @scope["three"] = "four"
-      hash = {}
-      @scope.each { |name, value| hash[name] = value }
-      hash.should == {"one" => "two", "three" => "four" }
-    end
-
-    it "should include Enumerable" do
-      @scope.singleton_class.ancestors.should be_include(Enumerable)
-    end
-
     describe "and the variable is qualified" do
       before :each do
         @known_resource_types = @scope.known_resource_types
@@ -277,6 +268,20 @@ describe Puppet::Parser::Scope do
         @scope["other::deep::klass::var"].should be_nil
       end
     end
+
+    context "and strict_variables is true" do
+      before(:each) do
+        Puppet[:strict_variables] = true
+      end
+
+      it "should raise an error when unknown variable is looked up" do
+        expect { @scope['john_doe'] }.to raise_error(/Undefined variable/)
+      end
+
+      it "should raise an error when unknown qualified variable is looked up" do
+        expect { @scope['nowhere::john_doe'] }.to raise_error(/Undefined variable/)
+      end
+    end
   end
 
   describe "when variables are set with append=true" do
@@ -389,50 +394,42 @@ 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.setvar("1", :value, :ephemeral => true)
+      @scope.set_match_data({1 => :value})
       @scope["1"].should == :value
     end
 
-    it "should remove the variable value when unset_ephemeral_var is called" do
-      @scope.setvar("1", :value, :ephemeral => true)
+    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
+      @scope.unset_ephemeral_var(:all)
 
       @scope["1"].should be_nil
     end
 
-    it "should not remove classic variables when unset_ephemeral_var is called" do
+    it "should not remove classic variables when unset_ephemeral_var(:all) is called" do
       @scope['myvar'] = :value1
-      @scope.setvar("1", :value2, :ephemeral => true)
+      @scope.set_match_data({1 => :value2})
       @scope.stubs(:parent).returns(nil)
 
-      @scope.unset_ephemeral_var
+      @scope.unset_ephemeral_var(:all)
 
       @scope["myvar"].should == :value1
     end
 
-    it "should raise an error when setting it again" do
-      @scope.setvar("1", :value2, :ephemeral => true)
+    it "should raise an error when setting numerical variable" do
       expect {
         @scope.setvar("1", :value3, :ephemeral => true)
-      }.to raise_error(Puppet::ParseError, /Cannot reassign variable 1/)
-    end
-
-    it "should declare ephemeral number only variable names" do
-      @scope.ephemeral?("0").should be_true
-    end
-
-    it "should not declare ephemeral other variable names" do
-      @scope.ephemeral?("abc0").should be_nil
+      }.to raise_error(Puppet::ParseError, /Cannot assign to a numeric match result variable/)
     end
 
     describe "with more than one level" do
       it "should prefer latest ephemeral scopes" do
-        @scope.setvar("0", :earliest, :ephemeral => true)
+        @scope.set_match_data({0 => :earliest})
         @scope.new_ephemeral
-        @scope.setvar("0", :latest, :ephemeral => true)
+        @scope.set_match_data({0 => :latest})
         @scope["0"].should == :latest
       end
 
@@ -442,52 +439,43 @@ describe Puppet::Parser::Scope do
         @scope.ephemeral_level.should == 2
       end
 
-      it "should check presence of an ephemeral variable accross multiple levels" do
+      it "should not check presence of an ephemeral variable accross 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.setvar("1", :value1, :ephemeral => true)
+        @scope.set_match_data({1 => :value1})
         @scope.new_ephemeral
-        @scope.setvar("0", :value2, :ephemeral => true)
+        @scope.set_match_data({0 => :value2})
         @scope.new_ephemeral
-        @scope.ephemeral_include?("1").should be_true
+        @scope.include?("1").should be_false
       end
 
       it "should return false when an ephemeral variable doesn't exist in any ephemeral scope" do
         @scope.new_ephemeral
-        @scope.setvar("1", :value1, :ephemeral => true)
+        @scope.set_match_data({1 => :value1})
         @scope.new_ephemeral
-        @scope.setvar("0", :value2, :ephemeral => true)
+        @scope.set_match_data({0 => :value2})
         @scope.new_ephemeral
-        @scope.ephemeral_include?("2").should be_false
+        @scope.include?("2").should be_false
       end
 
-      it "should get ephemeral values from earlier scope when not in later" do
-        @scope.setvar("1", :value1, :ephemeral => true)
+      it "should not get ephemeral values from earlier scope when not in later" do
+        @scope.set_match_data({1 => :value1})
         @scope.new_ephemeral
-        @scope.setvar("0", :value2, :ephemeral => true)
-        @scope["1"].should == :value1
-      end
-
-      describe "when calling unset_ephemeral_var without a level" do
-        it "should remove all the variables values"  do
-          @scope.setvar("1", :value1, :ephemeral => true)
-          @scope.new_ephemeral
-          @scope.setvar("1", :value2, :ephemeral => true)
-
-          @scope.unset_ephemeral_var
-
-          @scope["1"].should be_nil
-        end
+        @scope.set_match_data({0 => :value2})
+        @scope.include?("1").should be_false
       end
 
       describe "when calling unset_ephemeral_var with a level" do
         it "should remove ephemeral scopes up to this level" do
-          @scope.setvar("1", :value1, :ephemeral => true)
+          @scope.set_match_data({1 => :value1})
           @scope.new_ephemeral
-          @scope.setvar("1", :value2, :ephemeral => true)
+          @scope.set_match_data({1 => :value2})
+          level = @scope.ephemeral_level()
           @scope.new_ephemeral
-          @scope.setvar("1", :value3, :ephemeral => true)
+          @scope.set_match_data({1 => :value3})
 
-          @scope.unset_ephemeral_var(2)
+          @scope.unset_ephemeral_var(level)
 
           @scope["1"].should == :value2
         end
@@ -531,22 +519,37 @@ describe Puppet::Parser::Scope do
     end
 
     it "should set $0 with the full match" do
-      @scope.expects(:setvar).with { |*arg| arg[0] == "0" and arg[1] == "this is a string" and arg[2][:ephemeral] }
-
+      # This is an internal impl detail test
+      @scope.expects(:new_match_scope).with { |*arg| arg[0][0] == "this is a string" }
       @scope.ephemeral_from(@match)
     end
 
     it "should set every capture as ephemeral var" do
-      @match.stubs(:captures).returns([:capture1,:capture2])
-      @scope.expects(:setvar).with { |*arg| arg[0] == "1" and arg[1] == :capture1 and arg[2][:ephemeral] }
-      @scope.expects(:setvar).with { |*arg| arg[0] == "2" and arg[1] == :capture2 and arg[2][:ephemeral] }
+      # This is an internal impl detail test
+      @match.stubs(:[]).with(1).returns(:capture1)
+      @match.stubs(:[]).with(2).returns(:capture2)
+      @scope.expects(:new_match_scope).with { |*arg| arg[0][1] == :capture1 && arg[0][2] == :capture2 }
+
+      @scope.ephemeral_from(@match)
+    end
+
+    it "should shadow previous match variables" do
+      # This is an internal impl detail test
+      @match.stubs(:[]).with(1).returns(:capture1)
+      @match.stubs(:[]).with(2).returns(:capture2)
 
+      @match2 = stub 'match', :is_a? => true
+      @match2.stubs(:[]).with(1).returns(:capture2_1)
+      @match2.stubs(:[]).with(2).returns(nil)
       @scope.ephemeral_from(@match)
+      @scope.ephemeral_from(@match2)
+      @scope.lookupvar('2').should == nil
     end
 
     it "should create a new ephemeral level" do
-      @scope.expects(:new_ephemeral)
+      level_before = @scope.ephemeral_level
       @scope.ephemeral_from(@match)
+      expect(level_before < @scope.ephemeral_level)
     end
   end
 

data/spec/unit/parser/type_loader_spec.rb

@@ -19,10 +19,6 @@ describe Puppet::Parser::TypeLoader do
     loader.environment.name.should == :myenv
   end
 
-  it "should include the Environment Helper" do
-    loader.class.ancestors.should be_include(Puppet::Node::Environment::Helper)
-  end
-
   it "should delegate its known resource types to its environment" do
     loader.known_resource_types.should be_instance_of(Puppet::Resource::TypeCollection)
   end

data/spec/unit/pops/benchmark_spec.rb

@@ -0,0 +1,142 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+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
+
+    def code
+      'if true
+{
+$a = 10 + 10
+}
+else
+{
+$a = "interpolate ${foo} and stuff"
+}
+'    end
+
+  class StringWriter < String
+    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)
+    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
+    transformer = Puppet::Pops::Model::AstTransformer.new()
+    m = Benchmark.measure { 10000.times { transformer.transform(model) }}
+    puts "Transformer: #{m}"
+  end
+
+  it "validator", :profile => true do
+    parser = Puppet::Pops::Parser::EvaluatingParser.new()
+    model = parser.parse_string(code)
+    m = Benchmark.measure { 100000.times { parser.assert_and_report(model) }}
+    puts "Validator: #{m}"
+  end
+
+  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) }}
+    puts "Parse and transform: #{m}"
+  end
+
+  it "parser0", :profile => true do
+    parser = Puppet::Parser::Parser.new('test')
+    m = Benchmark.measure { 10000.times { parser.parse(code) }}
+    puts "Parser 0: #{m}"
+  end
+
+  it "parser1", :profile => true do
+    parser = Puppet::Pops::Parser::EvaluatingParser.new()
+    m = Benchmark.measure { 10000.times { parser.parse_string(code) }}
+    puts "Parser1: #{m}"
+  end
+
+  it "marshal1", :profile => true do
+    parser = Puppet::Pops::Parser::EvaluatingParser.new()
+    model = parser.parse_string(code).current
+    dumped = Marshal.dump(model)
+    m = Benchmark.measure { 10000.times { Marshal.load(dumped) }}
+    puts "Marshal1: #{m}"
+  end
+
+  it "rgenjson", :profile => true do
+    parser = Puppet::Pops::Parser::EvaluatingParser.new()
+    model = parser.parse_string(code).current
+    dumped = json_dump(model)
+    m = Benchmark.measure { 10000.times { json_load(dumped) }}
+    puts "RGen Json: #{m}"
+  end
+
+  it "lexer2", :profile => true do
+    lexer = Puppet::Pops::Parser::Lexer2.new
+     m = Benchmark.measure {10000.times {lexer.string = code; lexer.fullscan }}
+     puts "Lexer2: #{m}"
+  end
+
+  it "lexer1", :profile => true do
+    lexer = Puppet::Pops::Parser::Lexer.new
+    m = Benchmark.measure {10000.times {lexer.string = code; lexer.fullscan }}
+    puts "Pops Lexer: #{m}"
+  end
+
+  it "lexer0", :profile => true do
+    lexer = Puppet::Parser::Lexer.new
+    m = Benchmark.measure {10000.times {lexer.string = code; lexer.fullscan }}
+    puts "Original Lexer: #{m}"
+  end
+
+  context "Measure Evaluator" do
+    let(:parser) { Puppet::Pops::Parser::EvaluatingParser::Transitional.new }
+    let(:node) { 'node.example.com' }
+    let(:scope) { s = create_test_scope_for_node(node); s }
+    it "evaluator", :profile => true do
+      # Do the loop in puppet code since it otherwise drowns in setup
+      puppet_loop =
+        'Integer[0, 1000].each |$i| { if true
+{
+$a = 10 + 10
+}
+else
+{
+$a = "interpolate ${foo} and stuff"
+}}
+'
+      # parse once, only measure the evaluation
+      model = parser.parse_string(puppet_loop, __FILE__)
+      m = Benchmark.measure { parser.evaluate(create_test_scope_for_node(node), model) }
+      puts("Evaluator: #{m}")
+    end
+  end
+end