puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/parser/functions/versioncmp_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "the versioncmp function" do
@@ -7,7 +7,9 @@ describe "the versioncmp function" do
   end
 
   before :each do
-    @scope = Puppet::Parser::Scope.new
+    node     = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    @scope   = Puppet::Parser::Scope.new(compiler)
   end
 
   it "should exist" do

data/spec/unit/parser/functions_spec.rb

@@ -1,16 +1,20 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe Puppet::Parser::Functions do
 
   it "should have a method for returning an environment-specific module" do
-    Puppet::Parser::Functions.environment_module("myenv").should be_instance_of(Module)
+    Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.new("myenv")).should be_instance_of(Module)
   end
 
   it "should use the current default environment if no environment is provided" do
     Puppet::Parser::Functions.environment_module.should be_instance_of(Module)
   end
 
+  it "should be able to retrieve environment modules asked for by name rather than instance" do
+    Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.new("myenv")).should equal(Puppet::Parser::Functions.environment_module("myenv"))
+  end
+
   describe "when calling newfunction" do
     before do
       @module = Module.new
@@ -23,30 +27,18 @@ describe Puppet::Parser::Functions do
       Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
     end
 
-    it "should raise an error if the function type is not correct" do
-      @module.expects(:define_method).with { |name,block| name == "function_name" }.never
-
-      lambda { Puppet::Parser::Functions.newfunction("name", :type => :unknown) }.should raise_error
-    end
-  end
-
-  describe "when calling rmfunction" do
-    before do
-      @module = Module.new
-      Puppet::Parser::Functions.stubs(:environment_module).returns @module
-    end
-
-    it "should remove the function in the scope class" do
-      @module.expects(:define_method).with { |name,block| name == "function_name" }
+    it "should warn if the function already exists" do
+      @module.expects(:define_method).with { |name,block| name == "function_name" }.twice
       Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
+      Puppet.expects(:warning)
 
-      @module.expects(:remove_method).with("function_name").once
-
-      Puppet::Parser::Functions.rmfunction("name")
+      Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
     end
 
-    it "should raise an error if the function doesn't exists" do
-      lambda { Puppet::Parser::Functions.rmfunction("name") }.should raise_error
+    it "should raise an error if the function type is not correct" do
+      @module.expects(:define_method).with { |name,block| name == "function_name" }.never
+
+      lambda { Puppet::Parser::Functions.newfunction("name", :type => :unknown) }.should raise_error
     end
   end
 

data/spec/unit/parser/lexer_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/parser/lexer'
@@ -11,13 +11,6 @@ RSpec::Matchers.define :be_like do |*expected|
 end
 __ = nil
 
-def tokens_scanned_from(s)
-  lexer = Puppet::Parser::Lexer.new
-  lexer.string = s
-  lexer.fullscan[0..-2]
-end
-
-
 describe Puppet::Parser::Lexer do
   describe "when reading strings" do
     before { @lexer = Puppet::Parser::Lexer.new }
@@ -44,18 +37,6 @@ describe Puppet::Parser::Lexer do
 
       @lexer.line.should == 13
     end
-
-    {
-      'r'  => "\r",
-      'n'  => "\n",
-      't'  => "\t",
-      's'  => " "
-    }.each do |esc, expected_result|
-      it "should recognize \\#{esc} sequence" do
-        @lexer.string = "\\#{esc}'"
-        @lexer.slurpstring("'")[0].should == expected_result
-      end
-    end
   end
 end
 
@@ -231,6 +212,7 @@ describe Puppet::Parser::Lexer::TOKENS do
     "false" => :FALSE,
     "true" => :TRUE,
     "in" => :IN,
+    "unless" => :UNLESS,
   }.each do |string, name|
     it "should have a keyword named #{name.to_s}" do
       Puppet::Parser::Lexer::KEYWORDS[name].should_not be_nil
@@ -425,8 +407,7 @@ describe Puppet::Parser::Lexer::TOKENS[:RETURN] do
   end
 end
 
-
-shared_examples_for "handling `-` in standard variable names" do |prefix|
+shared_examples_for "variable names in the lexer" do |prefix|
   # Watch out - a regex might match a *prefix* on these, not just the whole
   # word, so make sure you don't have false positive or negative results based
   # on that.
@@ -443,13 +424,7 @@ shared_examples_for "handling `-` in standard variable names" do |prefix|
 
     illegal.each do |name|
       var = prefix + global_scope + name
-      it "when `variable_with_dash` is disabled it should NOT accept #{var.inspect} as a valid variable name" do
-        Puppet[:allow_variables_with_dashes] = false
-        (subject.regex.match(var) || [])[0].should_not == var
-      end
-
-      it "when `variable_with_dash` is enabled it should NOT accept #{var.inspect} as a valid variable name" do
-        Puppet[:allow_variables_with_dashes] = true
+      it "should NOT accept #{var.inspect} as a valid variable name" do
         (subject.regex.match(var) || [])[0].should_not == var
       end
     end
@@ -460,118 +435,20 @@ describe Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] do
   its(:skip_text) { should be_false }
   its(:incr_line) { should be_false }
 
-  it_should_behave_like "handling `-` in standard variable names", '$'
+  it_should_behave_like "variable names in the lexer", '$'
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:VARIABLE] do
   its(:skip_text) { should be_false }
   its(:incr_line) { should be_false }
 
-  it_should_behave_like "handling `-` in standard variable names", ''
+  it_should_behave_like "variable names in the lexer", ''
 end
 
-describe "the horrible deprecation / compatibility variables with dashes" do
-  NamesWithDashes = %w{f- f-o -f f::-o f::o- f::o-o}
-
-  { Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR_WITH_DASH] => '$',
-    Puppet::Parser::Lexer::TOKENS[:VARIABLE_WITH_DASH]   => ''
-  }.each do |token, prefix|
-    describe token do
-      its(:skip_text) { should be_false }
-      its(:incr_line) { should be_false }
-
-      context "when compatibly is disabled" do
-        before :each do Puppet[:allow_variables_with_dashes] = false end
-        Puppet::Parser::Lexer::TOKENS.each do |name, value|
-          it "should be unacceptable after #{name}" do
-            token.acceptable?(:after => name).should be_false
-          end
-        end
-
-        # Yes, this should still *match*, just not be acceptable.
-        NamesWithDashes.each do |name|
-          ["", "::"].each do |global_scope|
-            var = prefix + global_scope + name
-            it "should match #{var.inspect}" do
-              subject.regex.match(var).to_a.should == [var]
-            end
-          end
-        end
-      end
-
-      context "when compatibility is enabled" do
-        before :each do Puppet[:allow_variables_with_dashes] = true end
-        it "should be acceptable after DQPRE" do
-          token.acceptable?(:after => :DQPRE).should be_true
-        end
-
-        NamesWithDashes.each do |name|
-          ["", "::"].each do |global_scope|
-            var = prefix + global_scope + name
-            it "should match #{var.inspect}" do
-              subject.regex.match(var).to_a.should == [var]
-            end
-          end
-        end
-      end
-    end
-  end
-
-  context "deprecation warnings" do
-    before :each do Puppet[:allow_variables_with_dashes] = true end
-
-    it "should match a top level variable" do
-      Puppet.expects(:deprecation_warning).once
-
-      tokens_scanned_from('$foo-bar').should == [
-        [:VARIABLE, { :value => 'foo-bar', :line => 1 }]
-      ]
-    end
-
-    it "does not warn about a variable without a dash" do
-      Puppet.expects(:deprecation_warning).never
-
-      tokens_scanned_from('$c').should == [
-        [:VARIABLE, { :value => "c", :line => 1 }]
-      ]
-    end
-
-    it "does not warn about referencing a class name that contains a dash" do
-      Puppet.expects(:deprecation_warning).never
-
-      tokens_scanned_from('foo-bar').should == [
-        [:NAME, { :value => "foo-bar", :line => 1 }]
-      ]
-    end
-
-    it "warns about reference to variable" do
-      Puppet.expects(:deprecation_warning).once
-
-      tokens_scanned_from('$::foo-bar::baz-quux').should == [
-        [:VARIABLE, { :value => "::foo-bar::baz-quux", :line => 1 }]
-      ]
-    end
-
-    it "warns about reference to variable interpolated in a string" do
-      Puppet.expects(:deprecation_warning).once
-
-      tokens_scanned_from('"$::foo-bar::baz-quux"').should == [
-        [:DQPRE,    { :value => "",                    :line => 1 }],
-        [:VARIABLE, { :value => "::foo-bar::baz-quux", :line => 1 }],
-        [:DQPOST,   { :value => "",                    :line => 1 }],
-      ]
-    end
-
-    it "warns about reference to variable interpolated in a string as an expression" do
-      Puppet.expects(:deprecation_warning).once
-
-      tokens_scanned_from('"${::foo-bar::baz-quux}"').should == [
-        [:DQPRE,    { :value => "",                    :line => 1 }],
-        [:VARIABLE, { :value => "::foo-bar::baz-quux", :line => 1 }],
-        [:DQPOST,   { :value => "",                    :line => 1 }],
-      ]
-    end
-  end
+def tokens_scanned_from(s)
+  lexer = Puppet::Parser::Lexer.new
+  lexer.string = s
+  lexer.fullscan[0..-2]
 end
 
 describe Puppet::Parser::Lexer,"when lexing strings" do
@@ -581,7 +458,6 @@ describe Puppet::Parser::Lexer,"when lexing strings" do
     %q{'single quoted string with an escaped "\\'"'}                => [[:STRING,'single quoted string with an escaped "\'"']],
     %q{'single quoted string with an escaped "\$"'}                 => [[:STRING,'single quoted string with an escaped "\$"']],
     %q{'single quoted string with an escaped "\."'}                 => [[:STRING,'single quoted string with an escaped "\."']],
-    %q{'single quoted string with an escaped "\r\n"'}               => [[:STRING,'single quoted string with an escaped "\r\n"']],
     %q{'single quoted string with an escaped "\n"'}                 => [[:STRING,'single quoted string with an escaped "\n"']],
     %q{'single quoted string with an escaped "\\\\"'}               => [[:STRING,'single quoted string with an escaped "\\\\"']],
     %q{"string with an escaped '\\"'"}                              => [[:STRING,"string with an escaped '\"'"]],

data/spec/unit/parser/parser_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe Puppet::Parser do
@@ -13,7 +13,9 @@ describe Puppet::Parser do
   end
 
   it "should require an environment at initialization" do
-    lambda { Puppet::Parser::Parser.new }.should raise_error(ArgumentError)
+    expect {
+      Puppet::Parser::Parser.new
+    }.to raise_error(ArgumentError, /wrong number of arguments/)
   end
 
   it "should set the environment" do
@@ -33,18 +35,16 @@ describe Puppet::Parser do
   end
 
   context "when importing" do
-    it "uses the directory of the currently parsed file" do
-      @parser.lexer.stubs(:file).returns "/tmp/current_file"
-
-      @parser.known_resource_types.loader.expects(:import).with("newfile", "/tmp")
-
-      @parser.import("newfile")
+    it "should delegate importing to the known resource type loader" do
+      parser = Puppet::Parser::Parser.new "development"
+      parser.known_resource_types.loader.expects(:import).with("newfile", "current_file")
+      parser.lexer.expects(:file).returns "current_file"
+      parser.import("newfile")
     end
 
-    it "uses the current working directory, when there is no file being parsed" do
-      @parser.known_resource_types.loader.expects(:import).with('one', Dir.pwd)
-      @parser.known_resource_types.loader.expects(:import).with('two', Dir.pwd)
-
+    it "should import multiple files on one line" do
+      @parser.known_resource_types.loader.expects(:import).with('one', nil)
+      @parser.known_resource_types.loader.expects(:import).with('two', nil)
       @parser.parse("import 'one', 'two'")
     end
   end
@@ -66,11 +66,13 @@ describe Puppet::Parser do
   describe "when parsing append operator" do
 
     it "should not raise syntax errors" do
-      lambda { @parser.parse("$var += something") }.should_not raise_error
+      expect { @parser.parse("$var += something") }.to_not raise_error
     end
 
-    it "shouldraise syntax error on incomplete syntax " do
-      lambda { @parser.parse("$var += ") }.should raise_error
+    it "should raise syntax error on incomplete syntax " do
+      expect {
+        @parser.parse("$var += ")
+      }.to raise_error(Puppet::ParseError, /Syntax error at end of file/)
     end
 
     it "should create ast::VarDef with append=true" do
@@ -89,7 +91,31 @@ describe Puppet::Parser do
 
   describe "when parsing selector" do
     it "should support hash access on the left hand side" do
-      lambda { @parser.parse("$h = { 'a' => 'b' } $a = $h['a'] ? { 'b' => 'd', default => undef }") }.should_not raise_error
+      expect { @parser.parse("$h = { 'a' => 'b' } $a = $h['a'] ? { 'b' => 'd', default => undef }") }.to_not raise_error
+    end
+  end
+
+  describe "parsing 'unless'" do
+    it "should create the correct ast objects" do
+      Puppet::Parser::AST::Not.expects(:new).with { |h| h[:value].is_a?(Puppet::Parser::AST::Boolean) }
+      @parser.parse("unless false { $var = 1 }")
+    end
+    
+    it "should not raise an error with empty statements" do
+      expect { @parser.parse("unless false { }") }.to_not raise_error
+    end
+    
+    #test for bug #13296
+    it "should not override 'unless' as a parameter inside resources" do
+      lambda { @parser.parse("exec {'/bin/echo foo': unless => '/usr/bin/false',}") }.should_not raise_error
+    end
+  end
+
+  describe "when parsing parameter names" do
+    Puppet::Parser::Lexer::KEYWORDS.sort_tokens.each do |keyword|
+      it "should allow #{keyword} as a keyword" do
+        lambda { @parser.parse("exec {'/bin/echo foo': #{keyword} => '/usr/bin/false',}") }.should_not raise_error
+      end
     end
   end
 
@@ -133,7 +159,9 @@ describe Puppet::Parser do
     end
 
     it "should raise an error on incorrect expression" do
-      lambda { @parser.parse("if (1 > 2 > ) or (1 == 2) { $var = 1 }") }.should raise_error
+      expect {
+        @parser.parse("if (1 > 2 > ) or (1 == 2) { $var = 1 }")
+      }.to raise_error(Puppet::ParseError, /Syntax error at '\)'/)
     end
 
   end
@@ -141,11 +169,11 @@ describe Puppet::Parser do
   describe "when parsing resource references" do
 
     it "should not raise syntax errors" do
-      lambda { @parser.parse('exec { test: param => File["a"] }') }.should_not raise_error
+      expect { @parser.parse('exec { test: param => File["a"] }') }.to_not raise_error
     end
 
     it "should not raise syntax errors with multiple references" do
-      lambda { @parser.parse('exec { test: param => File["a","b"] }') }.should_not raise_error
+      expect { @parser.parse('exec { test: param => File["a","b"] }') }.to_not raise_error
     end
 
     it "should create an ast::ResourceReference" do
@@ -159,11 +187,11 @@ describe Puppet::Parser do
   describe "when parsing resource overrides" do
 
     it "should not raise syntax errors" do
-      lambda { @parser.parse('Resource["title"] { param => value }') }.should_not raise_error
+      expect { @parser.parse('Resource["title"] { param => value }') }.to_not raise_error
     end
 
     it "should not raise syntax errors with multiple overrides" do
-      lambda { @parser.parse('Resource["title1","title2"] { param => value }') }.should_not raise_error
+      expect { @parser.parse('Resource["title1","title2"] { param => value }') }.to_not raise_error
     end
 
     it "should create an ast::ResourceOverride" do
@@ -182,15 +210,15 @@ describe Puppet::Parser do
   describe "when parsing if statements" do
 
     it "should not raise errors with empty if" do
-      lambda { @parser.parse("if true { }") }.should_not raise_error
+      expect { @parser.parse("if true { }") }.to_not raise_error
     end
 
     it "should not raise errors with empty else" do
-      lambda { @parser.parse("if false { notice('if') } else { }") }.should_not raise_error
+      expect { @parser.parse("if false { notice('if') } else { }") }.to_not raise_error
     end
 
     it "should not raise errors with empty if and else" do
-      lambda { @parser.parse("if false { } else { }") }.should_not raise_error
+      expect { @parser.parse("if false { } else { }") }.to_not raise_error
     end
 
     it "should create a nop node for empty branch" do
@@ -204,7 +232,7 @@ describe Puppet::Parser do
     end
 
     it "should build a chain of 'ifs' if there's an 'elsif'" do
-      lambda { @parser.parse(<<-PP) }.should_not raise_error
+      expect { @parser.parse(<<-PP) }.to_not raise_error
         if true { notice('test') } elsif true {} else { }
       PP
     end
@@ -212,33 +240,39 @@ describe Puppet::Parser do
   end
 
   describe "when parsing function calls" do
-
     it "should not raise errors with no arguments" do
-      lambda { @parser.parse("tag()") }.should_not raise_error
+      expect { @parser.parse("tag()") }.to_not raise_error
     end
 
     it "should not raise errors with rvalue function with no args" do
-      lambda { @parser.parse("$a = template()") }.should_not raise_error
+      expect { @parser.parse("$a = template()") }.to_not raise_error
     end
 
     it "should not raise errors with arguments" do
-      lambda { @parser.parse("notice(1)") }.should_not raise_error
+      expect { @parser.parse("notice(1)") }.to_not raise_error
     end
 
     it "should not raise errors with multiple arguments" do
-      lambda { @parser.parse("notice(1,2)") }.should_not raise_error
+      expect { @parser.parse("notice(1,2)") }.to_not raise_error
     end
 
     it "should not raise errors with multiple arguments and a trailing comma" do
-      lambda { @parser.parse("notice(1,2,)") }.should_not raise_error
+      expect { @parser.parse("notice(1,2,)") }.to_not raise_error
     end
 
   end
 
-  describe "when parsing arrays with trailing comma" do
+  describe "when parsing arrays" do
+    it "should parse an array" do
+      expect { @parser.parse("$a = [1,2]") }.to_not raise_error
+    end
 
     it "should not raise errors with a trailing comma" do
-      lambda { @parser.parse("$a = [1,2,]") }.should_not raise_error
+      expect { @parser.parse("$a = [1,2,]") }.to_not raise_error
+    end
+
+    it "should accept an empty array" do
+      expect { @parser.parse("$var = []\n") }.to_not raise_error
     end
   end
 
@@ -348,7 +382,7 @@ describe Puppet::Parser do
 
   describe "when looking up hostclasses" do
     it "should use the known resource types to check for them by name" do
-      @parser.known_resource_types.stubs(:find_or_load).with("namespace","name",:hostclass).returns(:this_value)
+      @parser.known_resource_types.stubs(:find_or_load).with("namespace","name",:hostclass,{}).returns(:this_value)
       @parser.find_hostclass("namespace","name").should == :this_value
     end
   end
@@ -379,6 +413,10 @@ describe Puppet::Parser do
       @parser.parse("class foobar { $var = val }").code[0].code.should_not be_nil
     end
 
+    it "should accept parameters with trailing comma" do
+      @parser.parse("file { '/example': ensure => file, }").should be
+    end
+
     it "should accept parametrized classes with trailing comma" do
       @parser.parse("class foobar ($var1 = 0,) { $var = val }").code[0].code.should_not be_nil
     end
@@ -398,7 +436,7 @@ describe Puppet::Parser do
 
     it "should be able to parse class resources" do
       @krt.add(Puppet::Resource::Type.new(:hostclass, "foobar", :arguments => {"biz" => nil}))
-      lambda { @parser.parse("class { foobar: biz => stuff }") }.should_not raise_error
+      expect { @parser.parse("class { foobar: biz => stuff }") }.to_not raise_error
     end
 
     it "should correctly mark exported resources as exported" do
@@ -435,4 +473,57 @@ describe Puppet::Parser do
       node.names[2].value.should == "baz"
     end
   end
+
+  it "should fail if trying to collect defaults" do
+    expect {
+      @parser.parse("@Port { protocols => tcp }")
+    }.to raise_error(Puppet::ParseError, /Defaults are not virtualizable/)
+  end
+
+  context "when parsing collections" do
+    it "should parse basic collections" do
+      @parser.parse("Port <| |>").code.
+        should be_all {|x| x.is_a? Puppet::Parser::AST::Collection }
+    end
+
+    it "should parse fully qualified collections" do
+      @parser.parse("Port::Range <| |>").code.
+        should be_all {|x| x.is_a? Puppet::Parser::AST::Collection }
+    end
+  end
+
+  it "should not assign to a fully qualified variable" do
+    expect {
+      @parser.parse("$one::two = yay")
+    }.to raise_error(Puppet::ParseError, /Cannot assign to variables in other namespaces/)
+  end
+
+  it "should parse assignment of undef" do
+    tree = @parser.parse("$var = undef")
+    tree.code.children[0].should be_an_instance_of Puppet::Parser::AST::VarDef
+    tree.code.children[0].value.should be_an_instance_of Puppet::Parser::AST::Undef
+  end
+
+  context "#namesplit" do
+    { "base::sub" => %w{base sub},
+      "main" => ["", "main"],
+      "one::two::three::four" => ["one::two::three", "four"],
+    }.each do |input, output|
+      it "should split #{input.inspect} to #{output.inspect}" do
+        @parser.namesplit(input).should == output
+      end
+    end
+  end
+
+  it "should treat classes as case insensitive" do
+    @parser.known_resource_types.import_ast(@parser.parse("class yayness {}"), '')
+    @parser.known_resource_types.hostclass('yayness').
+      should == @parser.find_hostclass("", "YayNess")
+  end
+
+  it "should treat defines as case insensitive" do
+    @parser.known_resource_types.import_ast(@parser.parse("define funtest {}"), '')
+    @parser.known_resource_types.hostclass('funtest').
+      should == @parser.find_hostclass("", "fUntEst")
+  end
 end