puppet 0.24.6 → 0.24.7

data/spec/unit/parser/functions.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Parser::Functions do
+
+    before(:each) do
+    end
+
+    after(:each) do
+        # Rationale:
+        # our various tests will almost all register to Pupet::Parser::Functions
+        # a new function called "name". All tests are required to stub Puppet::Parser::Scope
+        # so that +no+ new real ruby method are defined.
+        # After each test, we want to leave the whole Puppet::Parser::Functions environment
+        # as it was before we were called, hence we call rmfunction (which might not succeed
+        # if the function hasn't been registered in the test). It is also important in this
+        # section to stub +remove_method+ here so that we don't pollute the scope.
+        Puppet::Parser::Scope.stubs(:remove_method)
+        begin
+            Puppet::Parser::Functions.rmfunction("name")
+        rescue
+        end
+    end
+
+    describe "when calling newfunction" do
+        it "should create the function in the scope class" do
+            Puppet::Parser::Scope.expects(:define_method).with { |name,block| name == "function_name" }
+
+            Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
+        end
+
+        it "should raise an error if the function already exists" do
+            Puppet::Parser::Scope.expects(:define_method).with { |name,block| name == "function_name" }.once
+            Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
+
+            lambda { Puppet::Parser::Functions.newfunction("name", :type => :rvalue) }.should raise_error
+        end
+
+        it "should raise an error if the function type is not correct" do
+            Puppet::Parser::Scope.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
+        it "should remove the function in the scope class" do
+            Puppet::Parser::Scope.expects(:define_method).with { |name,block| name == "function_name" }
+            Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
+
+            Puppet::Parser::Scope.expects(:remove_method).with("function_name").once
+
+            Puppet::Parser::Functions.rmfunction("name")
+        end
+
+        it "should raise an error if the function doesn't exists" do
+            lambda { Puppet::Parser::Functions.rmfunction("name") }.should raise_error
+        end
+    end
+
+    describe "when calling function to test function existance" do
+
+        it "should return false if the function doesn't exist" do
+            Puppet::Parser::Functions.autoloader.stubs(:load)
+
+            Puppet::Parser::Functions.function("name").should be_false
+        end
+
+        it "should return it's name if the function exists" do
+            Puppet::Parser::Scope.expects(:define_method).with { |name,block| name == "function_name" }
+            Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
+
+            Puppet::Parser::Functions.function("name").should == "function_name"
+        end
+
+        it "should try to autoload the function if it doesn't exist yet" do
+            Puppet::Parser::Functions.autoloader.expects(:load)
+
+            Puppet::Parser::Functions.function("name")
+        end
+    end
+end

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

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the inline_template function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("inline_template").should == "function_inline_template"
+    end
+
+    it "should create a TemplateWrapper when called" do
+        tw = stub_everything 'template_wrapper'
+
+        Puppet::Parser::TemplateWrapper.expects(:new).returns(tw)
+
+        @scope.function_inline_template("test")
+    end
+
+    it "should pass the template string to TemplateWrapper.result" do
+        tw = stub_everything 'template_wrapper'
+        Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
+
+        tw.expects(:result).with("test")
+
+        @scope.function_inline_template("test")
+    end
+
+    it "should return what TemplateWrapper.result returns" do
+        tw = stub_everything 'template_wrapper'
+        Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
+
+        tw.expects(:result).returns("template contents evaluated")
+
+        @scope.function_inline_template("test").should == "template contents evaluated"
+    end
+
+    it "should concatenate template wrapper outputs for multiple templates" do
+        tw1 = stub_everything "template_wrapper1"
+        tw2 = stub_everything "template_wrapper2"
+        Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw1,tw2)
+        tw1.stubs(:result).returns("result1")
+        tw2.stubs(:result).returns("result2")
+
+        @scope.function_inline_template(["1","2"]).should == "result1result2"
+    end
+
+    it "should raise an error if the template raises an error" do
+        tw = stub_everything 'template_wrapper'
+        Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
+        tw.stubs(:result).raises
+
+        lambda { @scope.function_inline_template("1") }.should raise_error(Puppet::ParseError)
+    end
+
+end

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

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the template function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("template").should == "function_template"
+    end
+
+    it "should create a TemplateWrapper when called" do
+        tw = stub_everything 'template_wrapper'
+
+        Puppet::Parser::TemplateWrapper.expects(:new).returns(tw)
+
+        @scope.function_template("test")
+    end
+
+    it "should give the template filename to the TemplateWrapper" do
+        tw = stub_everything 'template_wrapper'
+        Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
+
+        tw.expects(:file=).with("test")
+
+        @scope.function_template("test")
+    end
+
+    it "should return what TemplateWrapper.result returns" do
+        tw = stub_everything 'template_wrapper'
+        Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
+        tw.stubs(:file=).with("test")
+
+        tw.expects(:result).returns("template contents evaluated")
+
+        @scope.function_template("test").should == "template contents evaluated"
+    end
+
+    it "should concatenate template wrapper outputs for multiple templates" do
+        tw1 = stub_everything "template_wrapper1"
+        tw2 = stub_everything "template_wrapper2"
+        Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw1,tw2)
+        tw1.stubs(:file=).with("1")
+        tw2.stubs(:file=).with("2")
+        tw1.stubs(:result).returns("result1")
+        tw2.stubs(:result).returns("result2")
+
+        @scope.function_template(["1","2"]).should == "result1result2"
+    end
+
+    it "should raise an error if the template raises an error" do
+        tw = stub_everything 'template_wrapper'
+        Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
+        tw.stubs(:result).raises
+
+        lambda { @scope.function_template("1") }.should raise_error(Puppet::ParseError)
+    end
+
+end

data/spec/unit/parser/interpreter.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Parser::Interpreter do
+    before do
+        @interp = Puppet::Parser::Interpreter.new
+        @parser = mock 'parser'
+    end
+
+    describe "when creating parser instances" do
+        it "should create a parser with code if there is code defined in the :code setting" do
+            Puppet.settings.stubs(:value).with(:code, :myenv).returns("mycode")
+            @parser.expects(:string=).with("mycode")
+            @parser.expects(:parse)
+            Puppet::Parser::Parser.expects(:new).with(:environment => :myenv).returns(@parser)
+            @interp.send(:create_parser, :myenv).object_id.should equal(@parser.object_id)
+        end
+
+        it "should create a parser with the main manifest when the code setting is an empty string" do
+            Puppet.settings.stubs(:value).with(:code, :myenv).returns("")
+            Puppet.settings.stubs(:value).with(:manifest, :myenv).returns("/my/file")
+            @parser.expects(:parse)
+            @parser.expects(:file=).with("/my/file")
+            Puppet::Parser::Parser.expects(:new).with(:environment => :myenv).returns(@parser)
+            @interp.send(:create_parser, :myenv).should equal(@parser)
+        end
+
+        it "should return nothing when new parsers fail" do
+            Puppet::Parser::Parser.expects(:new).with(:environment => :myenv).raises(ArgumentError)
+            proc { @interp.send(:create_parser, :myenv) }.should raise_error(Puppet::Error)
+        end
+
+        it "should create parsers with environment-appropriate manifests" 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)
+
+            parser1 = mock 'parser1'
+            Puppet::Parser::Parser.expects(:new).with(:environment => :env1).returns(parser1)
+            parser1.expects(:file=).with("/t/env1.pp")
+            parser1.expects(:parse)
+            @interp.send(:create_parser, :env1)
+
+            parser2 = mock 'parser2'
+            Puppet::Parser::Parser.expects(:new).with(:environment => :env2).returns(parser2)
+            parser2.expects(:file=).with("/t/env2.pp")
+            parser2.expects(:parse)
+            @interp.send(:create_parser, :env2)
+        end
+    end
+
+    describe "when managing parser instances" do
+        it "should use the same parser when the parser does not need reparsing" do
+            @interp.expects(:create_parser).with(:myenv).returns(@parser)
+            @interp.send(:parser, :myenv).should equal(@parser)
+
+            @parser.expects(:reparse?).returns(false)
+            @interp.send(:parser, :myenv).should equal(@parser)
+        end
+
+        it "should fail intelligently if a parser cannot be created and one does not already exist" do
+            @interp.expects(:create_parser).with(:myenv).raises(ArgumentError)
+            proc { @interp.send(:parser, :myenv) }.should raise_error(ArgumentError)
+        end
+
+        it "should use different parsers for different environments" do
+            # get one for the first env
+            @interp.expects(:create_parser).with(:first_env).returns(@parser)
+            @interp.send(:parser, :first_env).should equal(@parser)
+
+            other_parser = mock('otherparser')
+            @interp.expects(:create_parser).with(:second_env).returns(other_parser)
+            @interp.send(:parser, :second_env).should equal(other_parser)
+        end
+
+        describe "when files need reparsing" do
+            it "should create a new parser" do
+                oldparser = mock('oldparser')
+                newparser = mock('newparser')
+                oldparser.expects(:reparse?).returns(true)
+
+                @interp.expects(:create_parser).with(:myenv).returns(oldparser)
+                @interp.send(:parser, :myenv).should equal(oldparser)
+                @interp.expects(:create_parser).with(:myenv).returns(newparser)
+                @interp.send(:parser, :myenv).should equal(newparser)
+            end
+
+            it "should raise an exception if a new parser cannot be created" do
+                # Get the first parser in the hash.
+                @interp.expects(:create_parser).with(:myenv).returns(@parser)
+                @interp.send(:parser, :myenv).should equal(@parser)
+
+                @parser.expects(:reparse?).returns(true)
+
+                @interp.expects(:create_parser).with(:myenv).raises(Puppet::Error, "Could not parse")
+
+                lambda { @interp.parser(:myenv) }.should raise_error(Puppet::Error) 
+            end
+        end
+    end
+
+    describe "when compiling a catalog" do
+        before do
+            @node = stub 'node', :environment => :myenv
+            @compiler = mock 'compile'
+        end
+
+        it "should create a compile with the node and parser" do
+            @compiler.expects(:compile).returns(:config)
+            @interp.expects(:parser).with(:myenv).returns(@parser)
+            Puppet::Parser::Compiler.expects(:new).with(@node, @parser).returns(@compiler)
+            @interp.compile(@node)
+        end
+
+        it "should fail intelligently when no parser can be found" do
+            @node.stubs(:name).returns("whatever")
+            @interp.expects(:parser).with(:myenv).returns(nil)
+            proc { @interp.compile(@node) }.should raise_error(Puppet::ParseError)
+        end
+    end
+
+    describe "when returning catalog version" do
+        it "should ask the appropriate parser for the catalog version" do
+            node = mock 'node'
+            node.expects(:environment).returns(:myenv)
+            parser = mock 'parser'
+            parser.expects(:version).returns(:myvers)
+            @interp.expects(:parser).with(:myenv).returns(parser)
+            @interp.configuration_version(node).should equal(:myvers)
+        end
+    end
+end

data/spec/unit/parser/lexer.rb

@@ -0,0 +1,646 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/parser/lexer'
+
+describe Puppet::Parser::Lexer do
+    describe "when reading strings" do
+        before { @lexer = Puppet::Parser::Lexer.new }
+        it "should increment the line count for every carriage return in the string" do
+            @lexer.line = 10
+            @lexer.string = "this\nis\natest'"
+            @lexer.slurpstring("'")
+
+            @lexer.line.should == 12
+        end
+
+        it "should not increment the line count for escapes in the string" do
+            @lexer.line = 10
+            @lexer.string = "this\\nis\\natest'"
+            @lexer.slurpstring("'")
+
+            @lexer.line.should == 10
+        end
+    end
+end
+
+describe Puppet::Parser::Lexer::Token do
+    before do
+        @token = Puppet::Parser::Lexer::Token.new(%r{something}, :NAME)
+    end
+
+    [:regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate].each do |param|
+        it "should have a #{param.to_s} reader" do
+            @token.should be_respond_to(param)
+        end
+
+        it "should have a #{param.to_s} writer" do
+            @token.should be_respond_to(param.to_s + "=")
+        end
+    end
+end
+
+describe Puppet::Parser::Lexer::Token, "when initializing" do
+    it "should create a regex if the first argument is a string" do
+        Puppet::Parser::Lexer::Token.new("something", :NAME).regex.should == %r{something}
+    end
+
+    it "should set the string if the first argument is one" do
+        Puppet::Parser::Lexer::Token.new("something", :NAME).string.should == "something"
+    end
+
+    it "should set the regex if the first argument is one" do
+        Puppet::Parser::Lexer::Token.new(%r{something}, :NAME).regex.should == %r{something}
+    end
+end
+
+describe Puppet::Parser::Lexer::TokenList do
+    before do
+        @list = Puppet::Parser::Lexer::TokenList.new
+    end
+
+    it "should have a method for retrieving tokens by the name" do
+        token = @list.add_token :name, "whatever"
+        @list[:name].should equal(token)
+    end
+
+    it "should have a method for retrieving string tokens by the string" do
+        token = @list.add_token :name, "whatever"
+        @list.lookup("whatever").should equal(token)
+    end
+
+    it "should add tokens to the list when directed" do
+        token = @list.add_token :name, "whatever"
+        @list[:name].should equal(token)
+    end
+
+    it "should have a method for adding multiple tokens at once" do
+        @list.add_tokens "whatever" => :name, "foo" => :bar
+        @list[:name].should_not be_nil
+        @list[:bar].should_not be_nil
+    end
+
+    it "should fail to add tokens sharing a name with an existing token" do
+        @list.add_token :name, "whatever"
+        lambda { @list.add_token :name, "whatever" }.should raise_error(ArgumentError)
+    end
+
+    it "should set provided options on tokens being added" do
+        token = @list.add_token :name, "whatever", :skip_text => true
+        token.skip_text.should == true
+    end
+
+    it "should define any provided blocks as a :convert method" do
+        token = @list.add_token(:name, "whatever")  do "foo" end
+        token.convert.should == "foo"
+    end
+
+    it "should store all string tokens in the :string_tokens list" do
+        one = @list.add_token(:name, "1")
+        @list.string_tokens.should be_include(one)
+    end
+
+    it "should store all regex tokens in the :regex_tokens list" do
+        one = @list.add_token(:name, %r{one})
+        @list.regex_tokens.should be_include(one)
+    end
+
+    it "should not store string tokens in the :regex_tokens list" do
+        one = @list.add_token(:name, "1")
+        @list.regex_tokens.should_not be_include(one)
+    end
+
+    it "should not store regex tokens in the :string_tokens list" do
+        one = @list.add_token(:name, %r{one})
+        @list.string_tokens.should_not be_include(one)
+    end
+
+    it "should sort the string tokens inversely by length when asked" do
+        one = @list.add_token(:name, "1")
+        two = @list.add_token(:other, "12")
+        @list.sort_tokens
+        @list.string_tokens.should == [two, one]
+    end
+end
+
+describe Puppet::Parser::Lexer::TOKENS do
+    before do
+        @lexer = Puppet::Parser::Lexer.new()
+    end
+
+    {
+        :LBRACK => '[',
+        :RBRACK => ']',
+        :LBRACE => '{',
+        :RBRACE => '}',
+        :LPAREN => '(',
+        :RPAREN => ')', 
+        :EQUALS => '=',
+        :ISEQUAL => '==',
+        :GREATEREQUAL => '>=', 
+        :GREATERTHAN => '>',
+        :LESSTHAN => '<',
+        :LESSEQUAL => '<=',
+        :NOTEQUAL => '!=',
+        :NOT => '!',
+        :COMMA => ',',
+        :DOT => '.',
+        :COLON => ':',
+        :AT => '@',
+        :LLCOLLECT => '<<|',
+        :RRCOLLECT => '|>>',
+        :LCOLLECT => '<|',
+        :RCOLLECT => '|>',
+        :SEMIC => ';',
+        :QMARK => '?',
+        :BACKSLASH => '\\',
+        :FARROW => '=>',
+        :PARROW => '+>',
+        :APPENDS => '+=',
+        :PLUS => '+',
+        :MINUS => '-',
+        :DIV => '/',
+        :TIMES => '*',
+        :LSHIFT => '<<',
+        :RSHIFT => '>>',
+    }.each do |name, string|
+        it "should have a token named #{name.to_s}" do
+            Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
+        end
+
+        it "should match '#{string}' for the token #{name.to_s}" do
+            Puppet::Parser::Lexer::TOKENS[name].string.should == string
+        end
+    end
+
+    {
+        "case" => :CASE,
+        "class" => :CLASS,
+        "default" => :DEFAULT,
+        "define" => :DEFINE,
+        "import" => :IMPORT,
+        "if" => :IF,
+        "elsif" => :ELSIF,
+        "else" => :ELSE,
+        "inherits" => :INHERITS,
+        "node" => :NODE,
+        "and"  => :AND,
+        "or"   => :OR,
+        "undef"   => :UNDEF,
+        "false" => :FALSE,
+        "true" => :TRUE
+    }.each do |string, name|
+        it "should have a keyword named #{name.to_s}" do
+            Puppet::Parser::Lexer::KEYWORDS[name].should_not be_nil
+        end
+
+        it "should have the keyword for #{name.to_s} set to #{string}" do
+            Puppet::Parser::Lexer::KEYWORDS[name].string.should == string
+        end
+    end
+
+    # These tokens' strings don't matter, just that the tokens exist.
+    [:DQTEXT, :SQTEXT, :BOOLEAN, :NAME, :NUMBER, :COMMENT, :MLCOMMENT, :RETURN, :SQUOTE, :DQUOTE, :VARIABLE].each do |name|
+        it "should have a token named #{name.to_s}" do
+            Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
+        end
+    end
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:CLASSNAME] do
+    before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSNAME] }
+
+    it "should match against lower-case alpha-numeric terms separated by double colons" do
+        @token.regex.should =~ "one::two"
+    end
+
+    it "should match against many lower-case alpha-numeric terms separated by double colons" do
+        @token.regex.should =~ "one::two::three::four::five"
+    end
+
+    it "should match against lower-case alpha-numeric terms prefixed by double colons" do
+        @token.regex.should =~ "::one"
+    end
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:CLASSREF] do
+    before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSREF] }
+
+    it "should match against single upper-case alpha-numeric terms" do
+        @token.regex.should =~ "One"
+    end
+
+    it "should match against upper-case alpha-numeric terms separated by double colons" do
+        @token.regex.should =~ "One::Two"
+    end
+
+    it "should match against many upper-case alpha-numeric terms separated by double colons" do
+        @token.regex.should =~ "One::Two::Three::Four::Five"
+    end
+
+    it "should match against upper-case alpha-numeric terms prefixed by double colons" do
+        @token.regex.should =~ "::One"
+    end
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:NAME] do
+    before { @token = Puppet::Parser::Lexer::TOKENS[:NAME] }
+
+    it "should match against lower-case alpha-numeric terms" do
+        @token.regex.should =~ "one-two"
+    end
+
+    it "should return itself and the value if the matched term is not a keyword" do
+        Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(nil)
+        @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
+    end
+
+    it "should return the keyword token and the value if the matched term is a keyword" do
+        keyword = stub 'keyword', :name => :testing
+        Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
+        @token.convert(stub("lexer"), "myval").should == [keyword, "myval"]
+    end
+
+    it "should return the BOOLEAN token and 'true' if the matched term is the string 'true'" do
+        keyword = stub 'keyword', :name => :TRUE
+        Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
+        @token.convert(stub('lexer'), "true").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], true]
+    end
+
+    it "should return the BOOLEAN token and 'false' if the matched term is the string 'false'" do
+        keyword = stub 'keyword', :name => :FALSE
+        Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
+        @token.convert(stub('lexer'), "false").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], false]
+    end
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:NUMBER] do
+    before do
+        @token = Puppet::Parser::Lexer::TOKENS[:NUMBER]
+#        @regex = Regexp.new('^'+@token.regex.source+'$')
+        @regex = @token.regex
+    end
+
+    it "should match against numeric terms" do
+        @regex.should =~ "2982383139"
+    end
+
+    it "should match against float terms" do
+        @regex.should =~ "29823.235"
+    end
+
+    it "should match against hexadecimal terms" do
+        @regex.should =~ "0xBEEF0023"
+    end
+
+    it "should match against float with exponent terms" do
+        @regex.should =~ "10e23"
+    end
+
+    it "should match against float terms with negative exponents" do
+        @regex.should =~ "10e-23"
+    end
+
+    it "should match against float terms with fractional parts and exponent" do
+        @regex.should =~ "1.234e23"
+    end
+
+    it "should return the NAME token and the value" do
+        @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
+    end
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:COMMENT] do
+    before { @token = Puppet::Parser::Lexer::TOKENS[:COMMENT] }
+
+    it "should match against lines starting with '#'" do
+        @token.regex.should =~ "# this is a comment"
+    end
+
+    it "should be marked to get skipped" do
+        @token.skip?.should be_true
+    end
+
+    it "should be marked to accumulate" do
+        @token.accumulate?.should be_true
+    end
+
+    it "'s block should return the comment without the #" do
+        @token.convert(@lexer,"# this is a comment")[1].should == "this is a comment"
+    end
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:MLCOMMENT] do
+    before do
+        @token = Puppet::Parser::Lexer::TOKENS[:MLCOMMENT]
+        @lexer = stub 'lexer', :line => 0
+    end
+
+    it "should match against lines enclosed with '/*' and '*/'" do
+        @token.regex.should =~ "/* this is a comment */"
+    end
+
+    it "should match multiple lines enclosed with '/*' and '*/'" do
+        @token.regex.should =~ """/*
+                                   this is a comment
+                                   */"""
+    end
+
+    it "should increase the lexer current line number by the amount of lines spanned by the comment" do
+        @lexer.expects(:line=).with(2)
+        @token.convert(@lexer, "1\n2\n3")
+    end
+
+    it "should not greedily match comments" do
+        match = @token.regex.match("/* first */ word /* second */")
+        match[1].should == " first "
+    end
+
+    it "should be marked to accumulate" do
+        @token.accumulate?.should be_true
+    end
+
+    it "'s block should return the comment without the comment marks" do
+        @lexer.stubs(:line=).with(0)
+
+        @token.convert(@lexer,"/* this is a comment */")[1].should == "this is a comment"
+    end
+
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:RETURN] do
+    before { @token = Puppet::Parser::Lexer::TOKENS[:RETURN] }
+
+    it "should match against carriage returns" do
+        @token.regex.should =~ "\n"
+    end
+
+    it "should be marked to initiate text skipping" do
+        @token.skip_text.should be_true
+    end
+
+    it "should be marked to increment the line" do
+        @token.incr_line.should be_true
+    end
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:SQUOTE] do
+    before { @token = Puppet::Parser::Lexer::TOKENS[:SQUOTE] }
+
+    it "should match against single quotes" do
+        @token.regex.should =~ "'"
+    end
+
+    it "should slurp the rest of the quoted string" do
+        lexer = stub("lexer")
+        lexer.expects(:slurpstring).with("myval").returns("otherval")
+        @token.convert(lexer, "myval")
+    end
+
+    it "should return the SQTEXT token with the slurped string" do
+        lexer = stub("lexer")
+        lexer.stubs(:slurpstring).with("myval").returns("otherval")
+        @token.convert(lexer, "myval").should == [Puppet::Parser::Lexer::TOKENS[:SQTEXT], "otherval"]
+    end
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:DQUOTE] do
+    before { @token = Puppet::Parser::Lexer::TOKENS[:DQUOTE] }
+
+    it "should match against single quotes" do
+        @token.regex.should =~ '"'
+    end
+
+    it "should slurp the rest of the quoted string" do
+        lexer = stub("lexer")
+        lexer.expects(:slurpstring).with("myval").returns("otherval")
+        @token.convert(lexer, "myval")
+    end
+
+    it "should return the DQTEXT token with the slurped string" do
+        lexer = stub("lexer")
+        lexer.stubs(:slurpstring).with("myval").returns("otherval")
+        @token.convert(lexer, "myval").should == [Puppet::Parser::Lexer::TOKENS[:DQTEXT], "otherval"]
+    end
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:VARIABLE] do
+    before { @token = Puppet::Parser::Lexer::TOKENS[:VARIABLE] }
+
+    it "should match against alpha words prefixed with '$'" do
+        @token.regex.should =~ '$this_var'
+    end
+
+    it "should return the VARIABLE token and the variable name stripped of the '$'" do
+        @token.convert(stub("lexer"), "$myval").should == [Puppet::Parser::Lexer::TOKENS[:VARIABLE], "myval"]
+    end
+end
+
+describe Puppet::Parser::Lexer, "when lexing comments" do
+    before { @lexer = Puppet::Parser::Lexer.new }
+
+    it "should accumulate token in munge_token" do
+        token = stub 'token', :skip => true, :accumulate? => true, :incr_line => nil, :skip_text => false
+
+        token.stubs(:convert).with(@lexer, "# this is a comment").returns([token, " this is a comment"])
+        @lexer.munge_token(token, "# this is a comment")
+        @lexer.munge_token(token, "# this is a comment")
+
+        @lexer.getcomment.should == " this is a comment\n this is a comment\n"
+    end
+
+    it "should add a new comment stack level on LBRACE" do
+        @lexer.string = "{"
+
+        @lexer.expects(:commentpush)
+
+        @lexer.fullscan
+    end
+
+    it "should return the current comments on getcomment" do
+        @lexer.string = "# comment"
+        @lexer.fullscan
+
+        @lexer.getcomment.should == "comment\n"
+    end
+
+    it "should discard the previous comments on blank line" do
+        @lexer.string = "# 1\n\n# 2"
+        @lexer.fullscan
+
+        @lexer.getcomment.should == "2\n"
+    end
+
+end
+
+# FIXME: We need to rewrite all of these tests, but I just don't want to take the time right now.
+describe "Puppet::Parser::Lexer in the old tests" do
+    before { @lexer = Puppet::Parser::Lexer.new }
+
+    it "should do simple lexing" do
+        strings = {
+%q{\\} => [[:BACKSLASH,"\\"],[false,false]],
+%q{simplest scanner test} => [[:NAME,"simplest"],[:NAME,"scanner"],[:NAME,"test"],[false,false]],
+%q{returned scanner test
+} => [[:NAME,"returned"],[:NAME,"scanner"],[:NAME,"test"],[false,false]]
+        }
+        strings.each { |str,ary|
+            @lexer.string = str
+            @lexer.fullscan().should == ary
+        }
+    end
+
+    it "should correctly lex quoted strings" do
+        strings = {
+%q{a simple "scanner" test
+} => [[:NAME,"a"],[:NAME,"simple"],[:DQTEXT,"scanner"],[:NAME,"test"],[false,false]],
+%q{a simple 'single quote scanner' test
+} => [[:NAME,"a"],[:NAME,"simple"],[:SQTEXT,"single quote scanner"],[:NAME,"test"],[false,false]],
+%q{a harder 'a $b \c"'
+} => [[:NAME,"a"],[:NAME,"harder"],[:SQTEXT,'a $b \c"'],[false,false]],
+%q{a harder "scanner test"
+} => [[:NAME,"a"],[:NAME,"harder"],[:DQTEXT,"scanner test"],[false,false]],
+%q{a hardest "scanner \"test\""
+} => [[:NAME,"a"],[:NAME,"hardest"],[:DQTEXT,'scanner "test"'],[false,false]],
+%q{a hardestest "scanner \"test\"
+"
+} => [[:NAME,"a"],[:NAME,"hardestest"],[:DQTEXT,'scanner "test"
+'],[false,false]],
+%q{function("call")} => [[:NAME,"function"],[:LPAREN,"("],[:DQTEXT,'call'],[:RPAREN,")"],[false,false]]
+}
+        strings.each { |str,array|
+            @lexer.string = str
+            @lexer.fullscan().should == array
+        }
+    end
+
+    it "should fail usefully" do
+        strings = %w{
+            ^
+        }
+        strings.each { |str|
+            @lexer.string = str
+            lambda { @lexer.fullscan() }.should raise_error(RuntimeError)
+        }
+    end
+
+    it "should fail if the string is not set" do
+        lambda { @lexer.fullscan() }.should raise_error(Puppet::LexError)
+    end
+
+    it "should correctly identify keywords" do
+        @lexer.string = "case"
+        @lexer.fullscan.should == [[:CASE, "case"], [false, false]]
+    end
+
+    it "should correctly match strings" do
+        names = %w{this is a bunch of names}
+        types = %w{Many Different Words A Word}
+        words = %w{differently Cased words A a}
+
+        names.each { |t|
+            @lexer.string = t
+            @lexer.fullscan.should == [[:NAME,t],[false,false]]
+        }
+        types.each { |t|
+            @lexer.string = t
+            @lexer.fullscan.should == [[: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]]
+       }
+    end
+
+    it "should correctly parse empty strings" do
+        bit = '$var = ""'
+
+        @lexer.string = bit
+
+        lambda { @lexer.fullscan }.should_not raise_error
+    end
+
+    it "should correctly parse virtual resources" do
+        string = "@type {"
+
+        @lexer.string = string
+
+        @lexer.fullscan.should == [[:AT, "@"], [:NAME, "type"], [:LBRACE, "{"], [false,false]]
+    end
+
+    it "should correctly deal with namespaces" do
+        @lexer.string = %{class myclass}
+
+        @lexer.fullscan
+
+        @lexer.namespace.should == "myclass"
+
+        @lexer.namepop
+
+        @lexer.namespace.should == ""
+
+        @lexer.string = "class base { class sub { class more"
+
+        @lexer.fullscan
+
+        @lexer.namespace.should == "base::sub::more"
+
+        @lexer.namepop
+
+        @lexer.namespace.should == "base::sub"
+    end
+
+    it "should correctly handle fully qualified names" do
+        @lexer.string = "class base { class sub::more {"
+
+        @lexer.fullscan
+
+        @lexer.namespace.should == "base::sub::more"
+
+        @lexer.namepop
+
+        @lexer.namespace.should == "base"
+    end
+
+    it "should correctly lex variables" do
+        ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable"].each do |string|
+            @lexer.string = string
+
+            @lexer.scan do |t, s|
+                t.should == :VARIABLE
+                string.sub(/^\$/, '').should == s
+                break
+            end
+        end
+    end
+
+    # #774
+    it "should correctly parse the CLASSREF token" do
+        string = ["Foo", "::Foo","Foo::Bar","::Foo::Bar"]
+
+        string.each do |foo|
+            @lexer.string = foo
+            @lexer.fullscan[0].should == [:CLASSREF, foo]
+        end
+    end
+
+end
+
+require 'puppettest/support/utils'
+describe "Puppet::Parser::Lexer in the old tests when lexing example files" do
+    extend PuppetTest
+    extend PuppetTest::Support::Utils
+    textfiles() do |file|
+        it "should correctly lex #{file}" do
+            lexer = Puppet::Parser::Lexer.new()
+            lexer.file = file
+            lambda { lexer.fullscan() }.should_not raise_error
+        end
+    end
+end