puppet 0.24.9 → 0.25.0

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

@@ -14,75 +14,75 @@ describe "the regsubst function" do
 
     it "should raise a ParseError if there is less than 3 arguments" do
         lambda { @scope.function_regsubst(["foo", "bar"]) }.should(
-		raise_error(Puppet::ParseError))
+            raise_error(Puppet::ParseError))
     end
 
     it "should raise a ParseError if there is more than 5 arguments" do
         lambda { @scope.function_regsubst(["foo", "bar", "gazonk", "del", "x", "y"]) }.should(
-		raise_error(Puppet::ParseError))
+            raise_error(Puppet::ParseError))
     end
 
 
     it "should raise a ParseError when given a bad flag" do
         lambda { @scope.function_regsubst(["foo", "bar", "gazonk", "X"]) }.should(
-		raise_error(Puppet::ParseError))
+            raise_error(Puppet::ParseError))
     end
 
     it "should handle groups" do
-	result = @scope.function_regsubst(
-		[ '130.236.254.10',
-		  '^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$',
-		  '\4-\3-\2-\1'
-		])
-	result.should(eql("10-254-236-130"))
+        result = @scope.function_regsubst(
+            [ '130.236.254.10',
+              '^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$',
+              '\4-\3-\2-\1'
+            ])
+        result.should(eql("10-254-236-130"))
     end
 
     it "should handle simple regexps" do
-	result = @scope.function_regsubst(
-		[ "the monkey breaks banana trees",
-		  "b[an]*a",
-		  "coconut"
-		])
-	result.should(eql("the monkey breaks coconut trees"))
+        result = @scope.function_regsubst(
+            [ "the monkey breaks banana trees",
+              "b[an]*a",
+              "coconut"
+            ])
+        result.should(eql("the monkey breaks coconut trees"))
     end
 
     it "should handle case-sensitive regexps" do
-	result = @scope.function_regsubst(
-		[ "the monkey breaks baNAna trees",
-		  "b[an]+a",
-		  "coconut"
-		])
-	result.should(eql("the monkey breaks baNAna trees"))
+        result = @scope.function_regsubst(
+            [ "the monkey breaks baNAna trees",
+              "b[an]+a",
+              "coconut"
+            ])
+        result.should(eql("the monkey breaks baNAna trees"))
     end
 
     it "should handle case-insensitive regexps" do
-	result = @scope.function_regsubst(
-		[ "the monkey breaks baNAna trees",
-		  "b[an]+a",
-		  "coconut",
-		  "I"
-		])
-	result.should(eql("the monkey breaks coconut trees"))
+        result = @scope.function_regsubst(
+            [ "the monkey breaks baNAna trees",
+              "b[an]+a",
+              "coconut",
+              "I"
+            ])
+            result.should(eql("the monkey breaks coconut trees"))
     end
 
     it "should handle global substitutions" do
-	result = @scope.function_regsubst(
-		[ "the monkey breaks\tbanana trees",
-		  "[ \t]",
-		  "--",
-		  "G"
-		])
-	result.should(eql("the--monkey--breaks--banana--trees"))
+        result = @scope.function_regsubst(
+            [ "the monkey breaks\tbanana trees",
+              "[ \t]",
+              "--",
+              "G"
+            ])
+        result.should(eql("the--monkey--breaks--banana--trees"))
     end
 
     it "should handle global substitutions with groups" do
-	result = @scope.function_regsubst(
-		[ '130.236.254.10',
-		  '([0-9]+)',
-		  '<\1>',
-		  'G'
-		])
-	result.should(eql('<130>.<236>.<254>.<10>'))
+        result = @scope.function_regsubst(
+            [ '130.236.254.10',
+              '([0-9]+)',
+              '<\1>',
+              'G'
+            ])
+        result.should(eql('<130>.<236>.<254>.<10>'))
     end
 
 end

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

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the require function" do
+
+    before :each do
+        @catalog = stub 'catalog'
+        @compiler = stub 'compiler', :catalog => @catalog
+        @scope = Puppet::Parser::Scope.new()
+        @scope.stubs(:resource).returns("ourselves")
+        @scope.stubs(:findresource)
+        @scope.stubs(:compiler).returns(@compiler)
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("require").should == "function_require"
+    end
+
+    it "should delegate to the 'include' puppet function" do
+        @catalog.stubs(:add_edge)
+        @scope.expects(:function_include).with("myclass")
+
+        @scope.function_require("myclass")
+    end
+
+    it "should add a catalog edge from our parent resource to the included one" do
+        @scope.stubs(:function_include).with("myclass")
+        @scope.stubs(:findresource).with(:class, "myclass").returns("includedclass")
+
+        @catalog.expects(:add_edge).with("ourselves","includedclass")
+
+        @scope.function_require("myclass")
+    end
+
+end

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

@@ -0,0 +1,92 @@
+#! /usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the shellquote function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("shellquote").should == "function_shellquote"
+    end
+
+
+    it "should handle no arguments" do
+        result = @scope.function_shellquote([])
+        result.should(eql(""))
+    end
+
+    it "should handle several simple arguments" do
+        result = @scope.function_shellquote(
+            ['foo', 'bar@example.com', 'localhost:/dev/null', 'xyzzy+-4711,23'])
+        result.should(eql(
+            'foo bar@example.com localhost:/dev/null xyzzy+-4711,23'))
+    end
+
+    it "should handle array arguments" do
+        result = @scope.function_shellquote(
+            ['foo', ['bar@example.com', 'localhost:/dev/null'],
+             'xyzzy+-4711,23'])
+        result.should(eql(
+            'foo bar@example.com localhost:/dev/null xyzzy+-4711,23'))
+    end
+
+    it "should quote unsafe characters" do
+        result = @scope.function_shellquote(
+            ['/etc/passwd ', '(ls)', '*', '[?]', "'&'"])
+        result.should(eql(
+            '"/etc/passwd " "(ls)" "*" "[?]" "\'&\'"'))
+    end
+
+    it "should deal with double quotes" do
+        result = @scope.function_shellquote(
+           ['"foo"bar"'])
+        result.should(eql(
+            '\'"foo"bar"\''))
+    end
+
+    it "should cope with dollar signs" do
+        result = @scope.function_shellquote(
+           ['$PATH', 'foo$bar', '"x$"'])
+        result.should(eql(
+            "'$PATH' 'foo$bar' '\"x$\"'"))
+    end
+
+    it "should deal with apostrophes (single quotes)" do
+        result = @scope.function_shellquote(
+           ["'foo'bar'", "`$'EDITOR'`"])
+        result.should(eql(
+            '"\'foo\'bar\'" "\\`\\$\'EDITOR\'\\`"'))
+    end
+
+    it "should cope with grave accents (backquotes)" do
+        result = @scope.function_shellquote(
+           ['`echo *`', '`ls "$MAILPATH"`'])
+        result.should(eql(
+            "'`echo *`' '`ls \"$MAILPATH\"`'"))
+    end
+
+    it "should deal with both single and double quotes" do
+        result = @scope.function_shellquote(
+           ['\'foo"bar"xyzzy\'', '"foo\'bar\'xyzzy"'])
+        result.should(eql(
+            '"\'foo\\"bar\\"xyzzy\'" "\\"foo\'bar\'xyzzy\\""'))
+    end
+
+    it "should handle multiple quotes *and* dollars and backquotes" do
+        result = @scope.function_shellquote(
+           ['\'foo"$x`bar`"xyzzy\''])
+        result.should(eql(
+            '"\'foo\\"\\$x\\`bar\\`\\"xyzzy\'"'))
+    end
+
+    it "should handle linefeeds" do
+        result = @scope.function_shellquote(
+           ["foo \n bar"])
+        result.should(eql(
+            "\"foo \n bar\""))
+    end
+
+end

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

@@ -0,0 +1,51 @@
+#! /usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the split function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("split").should == "function_split"
+    end
+
+    it "should raise a ParseError if there is less than 2 arguments" do
+        lambda { @scope.function_split(["foo"]) }.should(
+		raise_error(Puppet::ParseError))
+    end
+
+    it "should raise a ParseError if there is more than 2 arguments" do
+        lambda { @scope.function_split(["foo", "bar", "gazonk"]) }.should(
+		raise_error(Puppet::ParseError))
+    end
+
+    it "should raise a RegexpError if the regexp is malformed" do
+        lambda { @scope.function_split(["foo", "("]) }.should(
+		raise_error(RegexpError))
+    end
+
+
+    it "should handle simple string without metacharacters" do
+	result = @scope.function_split([ "130;236;254;10", ";"])
+	result.should(eql(["130", "236", "254", "10"]))
+    end
+
+    it "should handle simple regexps" do
+	result = @scope.function_split([ "130.236;254.;10", "[.;]+"])
+	result.should(eql(["130", "236", "254", "10"]))
+    end
+
+    it "should handle groups" do
+	result = @scope.function_split([ "130.236;254.;10", "([.;]+)"])
+	result.should(eql(["130", ".", "236", ";", "254", ".;", "10"]))
+    end
+
+    it "should handle simple string without metacharacters" do
+	result = @scope.function_split([ "130.236.254.10", ";"])
+	result.should(eql(["130.236.254.10"]))
+    end
+
+end

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

@@ -14,29 +14,29 @@ describe "the sprintf function" do
 
     it "should raise a ParseError if there is less than 1 argument" do
         lambda { @scope.function_sprintf([]) }.should(
-		raise_error(Puppet::ParseError))
+            raise_error(Puppet::ParseError))
     end
 
     it "should format integers" do
-	result = @scope.function_sprintf(["%+05d", "23"])
-	result.should(eql("+0023"))
+        result = @scope.function_sprintf(["%+05d", "23"])
+        result.should(eql("+0023"))
     end
 
     it "should format floats" do
-	result = @scope.function_sprintf(["%+.2f", "2.7182818284590451"])
-	result.should(eql("+2.72"))
+        result = @scope.function_sprintf(["%+.2f", "2.7182818284590451"])
+        result.should(eql("+2.72"))
     end
 
     it "should format large floats" do
-	result = @scope.function_sprintf(["%+.2e", "27182818284590451"])
-	result.should(eql("+2.72e+16"))
+        result = @scope.function_sprintf(["%+.2e", "27182818284590451"])
+        result.should(eql("+2.72e+16"))
     end
 
     it "should perform more complex formatting" do
-	result = @scope.function_sprintf(
-		[ "<%.8s:%#5o %#8X (%-8s)>",
-		  "overlongstring", "23", "48879", "foo" ])
-	result.should(eql("<overlong:  027   0XBEEF (foo     )>"))
+        result = @scope.function_sprintf(
+            [ "<%.8s:%#5o %#8X (%-8s)>",
+              "overlongstring", "23", "48879", "foo" ])
+        result.should(eql("<overlong:  027   0XBEEF (foo     )>"))
     end
 
 end

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

@@ -15,11 +15,11 @@ describe "the versioncmp function" do
     it "should raise a ParseError if there is less than 2 arguments" do
         lambda { @scope.function_versioncmp(["1.2"]) }.should raise_error(Puppet::ParseError)
     end
-    
+
     it "should raise a ParseError if there is more than 2 arguments" do
         lambda { @scope.function_versioncmp(["1.2", "2.4.5", "3.5.6"]) }.should raise_error(Puppet::ParseError)
     end
-    
+
     it "should call Puppet::Util::Package.versioncmp (included in scope)" do
         Puppet::Util::Package.expects(:versioncmp).with("1.2", "1.3").returns(-1)
 

data/spec/unit/parser/interpreter.rb

@@ -35,11 +35,9 @@ describe Puppet::Parser::Interpreter do
             # Set our per-environment values.  We can't just stub :value, because
             # it's called by too much of the rest of the code.
             text = "[env1]\nmanifest = /t/env1.pp\n[env2]\nmanifest = /t/env2.pp"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            Puppet.settings.stubs(:read_file).with(file).returns(text)
-            Puppet.settings.parse(file)
+            FileTest.stubs(:exist?).returns true
+            Puppet.settings.stubs(:read_file).returns(text)
+            Puppet.settings.parse
 
             parser1 = mock 'parser1'
             Puppet::Parser::Parser.expects(:new).with(:environment => :env1).returns(parser1)
@@ -100,7 +98,7 @@ describe Puppet::Parser::Interpreter do
 
                 @interp.expects(:create_parser).with(:myenv).raises(Puppet::Error, "Could not parse")
 
-                lambda { @interp.parser(:myenv) }.should raise_error(Puppet::Error) 
+                lambda { @interp.parser(:myenv) }.should raise_error(Puppet::Error)
             end
         end
     end
@@ -112,7 +110,8 @@ describe Puppet::Parser::Interpreter do
         end
 
         it "should create a compile with the node and parser" do
-            @compiler.expects(:compile).returns(:config)
+            catalog = stub 'catalog', :to_resource => nil
+            @compiler.expects(:compile).returns(catalog)
             @interp.expects(:parser).with(:myenv).returns(@parser)
             Puppet::Parser::Compiler.expects(:new).with(@node, @parser).returns(@compiler)
             @interp.compile(@node)
@@ -123,6 +122,16 @@ describe Puppet::Parser::Interpreter do
             @interp.expects(:parser).with(:myenv).returns(nil)
             proc { @interp.compile(@node) }.should raise_error(Puppet::ParseError)
         end
+
+        it "should return the results of the compile, converted to a plain resource catalog" do
+            catalog = mock 'catalog'
+            @compiler.expects(:compile).returns(catalog)
+            @interp.stubs(:parser).returns(@parser)
+            Puppet::Parser::Compiler.stubs(:new).returns(@compiler)
+
+            catalog.expects(:to_resource).returns "my_resource_catalog"
+            @interp.compile(@node).should == "my_resource_catalog"
+        end
     end
 
     describe "when returning catalog version" do

data/spec/unit/parser/lexer.rb

@@ -4,6 +4,20 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/parser/lexer'
 
+# This is a special matcher to match easily lexer output
+Spec::Matchers.create :be_like do |ary|
+    match do |result|
+        r = true
+        result.zip(ary) do |a,b|
+            unless a[0] == b[0] and ((a[1].is_a?(Hash) and a[1][:value] == b[1]) or a[1] == b[1])
+                r = false
+                break
+            end
+        end
+        r
+    end
+end
+
 describe Puppet::Parser::Lexer do
     describe "when reading strings" do
         before { @lexer = Puppet::Parser::Lexer.new }
@@ -135,10 +149,10 @@ describe Puppet::Parser::Lexer::TOKENS do
         :LBRACE => '{',
         :RBRACE => '}',
         :LPAREN => '(',
-        :RPAREN => ')', 
+        :RPAREN => ')',
         :EQUALS => '=',
         :ISEQUAL => '==',
-        :GREATEREQUAL => '>=', 
+        :GREATEREQUAL => '>=',
         :GREATERTHAN => '>',
         :LESSTHAN => '<',
         :LESSEQUAL => '<=',
@@ -164,6 +178,8 @@ describe Puppet::Parser::Lexer::TOKENS do
         :TIMES => '*',
         :LSHIFT => '<<',
         :RSHIFT => '>>',
+        :MATCH => '=~',
+        :NOMATCH => '!~',
     }.each do |name, string|
         it "should have a token named #{name.to_s}" do
             Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
@@ -437,6 +453,32 @@ describe Puppet::Parser::Lexer::TOKENS[:VARIABLE] do
     end
 end
 
+describe Puppet::Parser::Lexer::TOKENS[:REGEX] do
+    before { @token = Puppet::Parser::Lexer::TOKENS[:REGEX] }
+
+    it "should match against any expression enclosed in //" do
+        @token.regex.should =~ '/this is a regex/'
+    end
+
+    describe "when including escaped slashes" do
+        before { @lexer = Puppet::Parser::Lexer.new }
+
+        it "should not consider escaped slashes to be the end of a regex" do
+            @lexer.string = "/this \\/ foo/"
+            tokens = []
+            @lexer.scan do |name, value|
+                tokens << value
+            end
+            tokens[0][:value].should == Regexp.new("this / foo")
+        end
+    end
+
+
+    it "should return the REGEX token and a Regexp" do
+        @token.convert(stub("lexer"), "/myregex/").should == [Puppet::Parser::Lexer::TOKENS[:REGEX], Regexp.new(/myregex/)]
+    end
+end
+
 describe Puppet::Parser::Lexer, "when lexing comments" do
     before { @lexer = Puppet::Parser::Lexer.new }
 
@@ -472,6 +514,24 @@ describe Puppet::Parser::Lexer, "when lexing comments" do
         @lexer.getcomment.should == "2\n"
     end
 
+    it "should skip whitespace before lexing the next token after a non-token" do
+        @lexer.string = "/* 1\n\n */ \ntest"
+        @lexer.fullscan.should be_like([[:NAME, "test"],[false,false]])
+    end
+
+    it "should not return comments seen after the current line" do
+        @lexer.string = "# 1\n\n# 2"
+        @lexer.fullscan
+
+        @lexer.getcomment(1).should == ""
+    end
+
+    it "should return a comment seen before the current line" do
+        @lexer.string = "# 1\n# 2"
+        @lexer.fullscan
+
+        @lexer.getcomment(2).should == "1\n2\n"
+    end
 end
 
 # FIXME: We need to rewrite all of these tests, but I just don't want to take the time right now.
@@ -487,7 +547,7 @@ describe "Puppet::Parser::Lexer in the old tests" do
         }
         strings.each { |str,ary|
             @lexer.string = str
-            @lexer.fullscan().should == ary
+            @lexer.fullscan().should be_like(ary)
         }
     end
 
@@ -511,7 +571,7 @@ describe "Puppet::Parser::Lexer in the old tests" do
 }
         strings.each { |str,array|
             @lexer.string = str
-            @lexer.fullscan().should == array
+            @lexer.fullscan().should be_like(array)
         }
     end
 
@@ -531,7 +591,7 @@ describe "Puppet::Parser::Lexer in the old tests" do
 
     it "should correctly identify keywords" do
         @lexer.string = "case"
-        @lexer.fullscan.should == [[:CASE, "case"], [false, false]]
+        @lexer.fullscan.should be_like([[:CASE, "case"], [false, false]])
     end
 
     it "should correctly match strings" do
@@ -541,20 +601,20 @@ describe "Puppet::Parser::Lexer in the old tests" do
 
         names.each { |t|
             @lexer.string = t
-            @lexer.fullscan.should == [[:NAME,t],[false,false]]
+            @lexer.fullscan.should be_like([[:NAME,t],[false,false]])
         }
         types.each { |t|
             @lexer.string = t
-            @lexer.fullscan.should == [[:CLASSREF,t],[false,false]]
+            @lexer.fullscan.should be_like([[:CLASSREF,t],[false,false]])
         }
     end
 
     it "should correctly parse names with numerals" do
        string = %w{1name name1 11names names11}
-    
+
        string.each { |t|
             @lexer.string = t
-            @lexer.fullscan.should == [[:NAME,t],[false,false]]
+            @lexer.fullscan.should be_like([[:NAME,t],[false,false]])
        }
     end
 
@@ -571,7 +631,7 @@ describe "Puppet::Parser::Lexer in the old tests" do
 
         @lexer.string = string
 
-        @lexer.fullscan.should == [[:AT, "@"], [:NAME, "type"], [:LBRACE, "{"], [false,false]]
+        @lexer.fullscan.should be_like([[:AT, "@"], [:NAME, "type"], [:LBRACE, "{"], [false,false]])
     end
 
     it "should correctly deal with namespaces" do
@@ -614,7 +674,7 @@ describe "Puppet::Parser::Lexer in the old tests" do
 
             @lexer.scan do |t, s|
                 t.should == :VARIABLE
-                string.sub(/^\$/, '').should == s
+                string.sub(/^\$/, '').should == s[:value]
                 break
             end
         end
@@ -626,7 +686,7 @@ describe "Puppet::Parser::Lexer in the old tests" do
 
         string.each do |foo|
             @lexer.string = foo
-            @lexer.fullscan[0].should == [:CLASSREF, foo]
+            @lexer.fullscan.should be_like([[:CLASSREF, foo],[false,false]])
         end
     end