puppet 0.24.9 → 0.25.0

data/spec/unit/parser/loaded_code.rb

@@ -0,0 +1,198 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/parser/loaded_code'
+
+describe Puppet::Parser::LoadedCode do
+    %w{hostclass node definition}.each do |data|
+        it "should have a method for adding a #{data}" do
+            Puppet::Parser::LoadedCode.new.should respond_to("add_" + data)
+        end
+
+        it "should be able to retrieve #{data} by name" do
+            loader = Puppet::Parser::LoadedCode.new
+            loader.send("add_" + data, "foo", "bar")
+            loader.send(data, "foo").should == "bar"
+        end
+
+        it "should retrieve #{data} insensitive to case" do
+            loader = Puppet::Parser::LoadedCode.new
+            loader.send("add_" + data, "Foo", "bar")
+            loader.send(data, "fOo").should == "bar"
+        end
+
+        it "should return nil when asked for a #{data} that has not been added" do
+            Puppet::Parser::LoadedCode.new.send(data, "foo").should be_nil
+        end
+
+        it "should be able to retrieve all #{data}s" do
+            plurals = { "hostclass" => "hostclasses", "node" => "nodes", "definition" => "definitions" }
+            loader = Puppet::Parser::LoadedCode.new
+            loader.send("add_" + data , "foo", "bar")
+            loader.send(plurals[data]).should == { "foo" => "bar" }
+        end
+    end
+
+    describe "when finding a qualified instance" do
+        it "should return any found instance if the instance name is fully qualified" do
+            loader = Puppet::Parser::LoadedCode.new
+            loader.add_hostclass "foo::bar", "yay"
+            loader.find("namespace", "::foo::bar", :hostclass).should == "yay"
+        end
+
+        it "should return nil if the instance name is fully qualified and no such instance exists" do
+            loader = Puppet::Parser::LoadedCode.new
+            loader.find("namespace", "::foo::bar", :hostclass).should be_nil
+        end
+
+        it "should return the partially qualified object if it exists in the provided namespace" do
+            loader = Puppet::Parser::LoadedCode.new
+            loader.add_hostclass "foo::bar::baz", "yay"
+            loader.find("foo", "bar::baz", :hostclass).should == "yay"
+        end
+
+        it "should return the unqualified object if it exists in the provided namespace" do
+            loader = Puppet::Parser::LoadedCode.new
+            loader.add_hostclass "foo::bar", "yay"
+            loader.find("foo", "bar", :hostclass).should == "yay"
+        end
+
+        it "should return the unqualified object if it exists in the parent namespace" do
+            loader = Puppet::Parser::LoadedCode.new
+            loader.add_hostclass "foo::bar", "yay"
+            loader.find("foo::bar::baz", "bar", :hostclass).should == "yay"
+        end
+
+        it "should should return the partially qualified object if it exists in the parent namespace" do
+            loader = Puppet::Parser::LoadedCode.new
+            loader.add_hostclass "foo::bar::baz", "yay"
+            loader.find("foo::bar", "bar::baz", :hostclass).should == "yay"
+        end
+
+        it "should return the qualified object if it exists in the root namespace" do
+            loader = Puppet::Parser::LoadedCode.new
+            loader.add_hostclass "foo::bar::baz", "yay"
+            loader.find("foo::bar", "foo::bar::baz", :hostclass).should == "yay"
+        end
+
+        it "should return nil if the object cannot be found" do
+            loader = Puppet::Parser::LoadedCode.new
+            loader.add_hostclass "foo::bar::baz", "yay"
+            loader.find("foo::bar", "eh", :hostclass).should be_nil
+        end
+    end
+
+    it "should use the generic 'find' method with an empty namespace to find nodes" do
+        loader = Puppet::Parser::LoadedCode.new
+        loader.expects(:find).with("", "bar", :node)
+        loader.find_node("bar")
+    end
+
+    it "should use the generic 'find' method to find hostclasses" do
+        loader = Puppet::Parser::LoadedCode.new
+        loader.expects(:find).with("foo", "bar", :hostclass)
+        loader.find_hostclass("foo", "bar")
+    end
+
+    it "should use the generic 'find' method to find definitions" do
+        loader = Puppet::Parser::LoadedCode.new
+        loader.expects(:find).with("foo", "bar", :definition)
+        loader.find_definition("foo", "bar")
+    end
+
+    it "should indicate whether any nodes are defined" do
+        loader = Puppet::Parser::LoadedCode.new
+        loader.add_node("foo", "bar")
+        loader.should be_nodes
+    end
+
+    it "should indicate whether no nodes are defined" do
+        Puppet::Parser::LoadedCode.new.should_not be_nodes
+    end
+
+    describe "when adding nodes" do
+        it "should create an HostName if nodename is a string" do
+            Puppet::Parser::AST::HostName.expects(:new).with(:value => "foo")
+            loader = Puppet::Parser::LoadedCode.new
+            loader.add_node("foo", "bar")
+        end
+
+        it "should not create an HostName if nodename is an HostName" do
+            name = Puppet::Parser::AST::HostName.new(:value => "foo")
+
+            Puppet::Parser::AST::HostName.expects(:new).with(:value => "foo").never
+
+            loader = Puppet::Parser::LoadedCode.new
+            loader.add_node(name, "bar")
+        end
+    end
+
+    describe "when finding nodes" do
+        before :each do
+            @loader = Puppet::Parser::LoadedCode.new
+
+            @nodename1 = stub 'nodename1', :is_a? => true
+            @node1 = stub 'node1'
+            @nodename2 = stub 'nodename2', :is_a? => true
+            @node2 = stub 'node2'
+        end
+        it "should create an HostName if nodename is a string" do
+            Puppet::Parser::AST::HostName.expects(:new).with(:value => "foo")
+
+            @loader.node("foo")
+        end
+
+        it "should not create an HostName if nodename is an HostName" do
+            name = Puppet::Parser::AST::HostName.new(:value => "foo")
+
+            Puppet::Parser::AST::HostName.expects(:new).with(:value => "foo").never
+
+            @loader.node(name)
+        end
+
+        it "should be able to find node by HostName" do
+            namein = Puppet::Parser::AST::HostName.new(:value => "foo")
+            nameout = Puppet::Parser::AST::HostName.new(:value => "foo")
+
+            @loader.add_node(namein, "bar")
+            @loader.node(nameout) == "bar"
+        end
+
+        it "should return the first matching regex nodename" do
+            @nodename1.stubs(:regex?).returns(true)
+            @nodename1.stubs(:match).returns(true)
+            @nodename2.stubs(:regex?).returns(true)
+            @nodename2.stubs(:match).returns(true)
+
+            @loader.add_node(@nodename1, @node1)
+            @loader.add_node(@nodename2, @node2)
+
+            @loader.node("test").should == @node1
+        end
+
+        it "should not scan non-regex node" do
+            @nodename1.stubs(:regex?).returns(true)
+            @nodename1.stubs(:match).returns(false)
+            @nodename2.stubs(:regex?).returns(false)
+            @nodename2.expects(:match).never
+
+            @loader.add_node(@nodename1,@node1)
+            @loader.add_node(@nodename2,@node2)
+
+            @loader.node("test")
+        end
+
+        it "should prefer non-regex nodes to regex nodes" do
+            @nodename1.stubs(:regex?).returns(false)
+            @nodename1.expects(:match).never
+            @nodename2.stubs(:regex?).returns(true)
+            @nodename2.expects(:match).never
+
+            @loader.add_node(@nodename1,@node1)
+            @loader.add_node(@nodename2,@node2)
+
+            @loader.node(@nodename1)
+        end
+    end
+end

data/spec/unit/parser/parser.rb

@@ -7,7 +7,8 @@ describe Puppet::Parser do
     ast = Puppet::Parser::AST
 
     before :each do
-        @parser = Puppet::Parser::Parser.new :environment => "development"
+        @loaded_code = Puppet::Parser::LoadedCode.new
+        @parser = Puppet::Parser::Parser.new :environment => "development", :loaded_code => @loaded_code
         @true_ast = Puppet::Parser::AST::Boolean.new :value => true
     end
 
@@ -33,14 +34,14 @@ describe Puppet::Parser do
 
     end
 
-    describe Puppet::Parser, "when parsing 'if'" do
+    describe "when parsing 'if'" do
         it "not, it should create the correct ast objects" do
             ast::Not.expects(:new).with { |h| h[:value].is_a?(ast::Boolean) }
             @parser.parse("if ! true { $var = 1 }")
         end
 
         it "boolean operation, it should create the correct ast objects" do
-            ast::BooleanOperator.expects(:new).with { 
+            ast::BooleanOperator.expects(:new).with {
                 |h| h[:rval].is_a?(ast::Boolean) and h[:lval].is_a?(ast::Boolean) and h[:operator]=="or"
             }
             @parser.parse("if true or true { $var = 1 }")
@@ -48,7 +49,7 @@ describe Puppet::Parser do
         end
 
         it "comparison operation, it should create the correct ast objects" do
-             ast::ComparisonOperator.expects(:new).with { 
+             ast::ComparisonOperator.expects(:new).with {
                  |h| h[:lval].is_a?(ast::Name) and h[:rval].is_a?(ast::Name) and h[:operator]=="<"
              }
              @parser.parse("if 1 < 2 { $var = 1 }")
@@ -57,13 +58,13 @@ describe Puppet::Parser do
 
     end
 
-    describe Puppet::Parser, "when parsing if complex expressions" do
+    describe "when parsing if complex expressions" do
          it "should create a correct ast tree" do
              aststub = stub_everything 'ast'
-             ast::ComparisonOperator.expects(:new).with { 
+             ast::ComparisonOperator.expects(:new).with {
                  |h| h[:rval].is_a?(ast::Name) and h[:lval].is_a?(ast::Name) and h[:operator]==">"
              }.returns(aststub)
-             ast::ComparisonOperator.expects(:new).with { 
+             ast::ComparisonOperator.expects(:new).with {
                  |h| h[:rval].is_a?(ast::Name) and h[:lval].is_a?(ast::Name) and h[:operator]=="=="
              }.returns(aststub)
              ast::BooleanOperator.expects(:new).with {
@@ -78,8 +79,8 @@ describe Puppet::Parser do
 
     end
 
-    describe Puppet::Parser, "when parsing resource references" 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
         end
@@ -87,18 +88,18 @@ describe Puppet::Parser do
         it "should not raise syntax errors with multiple references" do
             lambda { @parser.parse('exec { test: param => File["a","b"] }') }.should_not raise_error
         end
-        
+
         it "should create an ast::ResourceReference" do
             ast::Resource.stubs(:new)
-            ast::ResourceReference.expects(:new).with { |arg| 
+            ast::ResourceReference.expects(:new).with { |arg|
                 arg[:line]==1 and arg[:type]=="File" and arg[:title].is_a?(ast::ASTArray)
             }
             @parser.parse('exec { test: command => File["a","b"] }')
         end
     end
-     
-    describe Puppet::Parser, "when parsing resource overrides" 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
         end
@@ -108,15 +109,15 @@ describe Puppet::Parser do
         end
 
         it "should create an ast::ResourceOverride" do
-            ast::ResourceOverride.expects(:new).with { |arg| 
+            ast::ResourceOverride.expects(:new).with { |arg|
                 arg[:line]==1 and arg[:object].is_a?(ast::ResourceReference) and arg[:params].is_a?(ast::ResourceParam)
             }
             @parser.parse('Resource["title1","title2"] { param => value }')
         end
-        
+
     end
-     
-    describe Puppet::Parser, "when parsing if statements" 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
@@ -142,7 +143,7 @@ describe Puppet::Parser do
 
     end
 
-    describe Puppet::Parser, "when parsing function calls" do
+    describe "when parsing function calls" do
 
         it "should not raise errors with no arguments" do
             lambda { @parser.parse("tag()") }.should_not raise_error
@@ -162,18 +163,18 @@ describe Puppet::Parser do
 
         it "should not raise errors with multiple arguments and a trailing comma" do
             lambda { @parser.parse("notice(1,2,)") }.should_not raise_error
-		end
+        end
 
-	end
+    end
 
-	describe Puppet::Parser, "when parsing arrays with trailing comma" do
+    describe "when parsing arrays with trailing comma" do
 
         it "should not raise errors with a trailing comma" do
             lambda { @parser.parse("$a = [1,2,]") }.should_not raise_error
         end
     end
-            
-    describe Puppet::Parser, "when instantiating class of same name" do
+
+    describe "when instantiating class of same name" do
 
         before :each do
             @one = stub 'one', :is_a? => true
@@ -201,18 +202,18 @@ describe Puppet::Parser do
         end
     end
 
-    describe Puppet::Parser, "when parsing comments before statement" do
+    describe "when parsing comments before statement" do
         it "should associate the documentation to the statement AST node" do
             ast = @parser.parse("""
             # comment
             class test {}
             """)
 
-            ast[:classes]["test"].doc.should == "comment\n"
+            ast.hostclass("test").doc.should == "comment\n"
         end
     end
 
-    describe Puppet::Parser, "when building ast nodes" do
+    describe "when building ast nodes" do
         it "should get lexer comments if ast node declares use_docs" do
             lexer = stub 'lexer'
             ast = mock 'ast', :nil? => false, :use_docs => true, :doc => ""
@@ -225,4 +226,190 @@ describe Puppet::Parser do
             @parser.ast(Puppet::Parser::AST::Definition)
         end
     end
- end
+
+    describe "when creating a node" do
+        before :each do
+            @lexer = stub 'lexer'
+            @lexer.stubs(:getcomment)
+            @parser.stubs(:lexer).returns(@lexer)
+            @node = stub_everything 'node'
+            @parser.stubs(:ast).returns(@node)
+            @parser.stubs(:node).returns(nil)
+
+            @nodename = stub 'nodename', :is_a? => false, :to_classname => "node"
+            @nodename.stubs(:is_a?).with(Puppet::Parser::AST::HostName).returns(true)
+        end
+
+        it "should get the lexer stacked comments" do
+            @lexer.expects(:getcomment)
+
+            @parser.newnode(@nodename)
+        end
+
+        it "should create an HostName if needed" do
+            Puppet::Parser::AST::HostName.expects(:new).with(:value => "node").returns(@nodename)
+
+            @parser.newnode("node")
+        end
+
+        it "should raise an error if the node already exists" do
+            @loaded_code.stubs(:node).with(@nodename).returns(@node)
+
+            lambda { @parser.newnode(@nodename) }.should raise_error
+        end
+
+        it "should store the created node in the loaded code" do
+            @loaded_code.expects(:add_node).with(@nodename, @node)
+
+            @parser.newnode(@nodename)
+        end
+
+        it "should create the node with code if provided" do
+            @parser.stubs(:ast).with { |*args| args[1][:code] == :code }.returns(@node)
+
+            @parser.newnode(@nodename, :code => :code)
+        end
+
+        it "should create the node with a parentclass if provided" do
+            @parser.stubs(:ast).with { |*args| args[1][:parent] == :parent }.returns(@node)
+
+            @parser.newnode(@nodename, :parent => :parent)
+        end
+
+        it "should set the node classname from the HostName" do
+            @nodename.stubs(:to_classname).returns(:classname)
+
+            @node.expects(:classname=).with(:classname)
+
+            @parser.newnode(@nodename)
+        end
+
+        it "should return an array of nodes" do
+            @parser.newnode(@nodename).should == [@node]
+        end
+    end
+
+    describe "when retrieving a specific node" do
+        it "should delegate to the loaded_code node" do
+            @loaded_code.expects(:node).with("node")
+
+            @parser.node("node")
+        end
+    end
+
+    describe "when retrieving a specific class" do
+        it "should delegate to the loaded code" do
+            @loaded_code.expects(:hostclass).with("class")
+
+            @parser.hostclass("class")
+        end
+    end
+
+    describe "when retrieving a specific definitions" do
+        it "should delegate to the loaded code" do
+            @loaded_code.expects(:definition).with("define")
+
+            @parser.definition("define")
+        end
+    end
+
+    describe "when determining the configuration version" do
+        it "should default to the current time" do
+            time = Time.now
+
+            Time.stubs(:now).returns time
+            @parser.version.should == time.to_i
+        end
+
+        it "should use the output of the config_version setting if one is provided" do
+            Puppet.settings.stubs(:[]).with(:config_version).returns("/my/foo")
+
+            @parser.expects(:`).with("/my/foo").returns "output\n"
+            @parser.version.should == "output"
+        end
+    end
+
+    describe Puppet::Parser,"when looking up definitions" do
+        it "should check for them by name" do
+            @parser.stubs(:find_or_load).with("namespace","name",:definition).returns(:this_value)
+            @parser.find_definition("namespace","name").should == :this_value
+        end
+    end
+
+    describe Puppet::Parser,"when looking up hostclasses" do
+        it "should check for them by name" do
+            @parser.stubs(:find_or_load).with("namespace","name",:hostclass).returns(:this_value)
+            @parser.find_hostclass("namespace","name").should == :this_value
+        end
+    end
+
+    describe Puppet::Parser,"when looking up names" do
+        before :each do
+            @loaded_code = mock 'loaded code'
+            @loaded_code.stubs(:find_my_type).with('loaded_namespace',  'loaded_name').returns(true)
+            @loaded_code.stubs(:find_my_type).with('bogus_namespace',   'bogus_name' ).returns(false)
+            @parser = Puppet::Parser::Parser.new :environment => "development",:loaded_code => @loaded_code
+        end
+
+        describe "that are already loaded" do
+            it "should not try to load anything" do
+                @parser.expects(:load).never
+                @parser.find_or_load("loaded_namespace","loaded_name",:my_type)
+            end
+            it "should return true" do
+                @parser.find_or_load("loaded_namespace","loaded_name",:my_type).should == true
+            end
+        end
+
+        describe "that aren't already loaded" do
+            it "should first attempt to load them with the all lowercase fully qualified name" do
+                @loaded_code.stubs(:find_my_type).with("foo_namespace","foo_name").returns(false,true,true)
+                @parser.expects(:load).with("foo_namespace::foo_name").returns(true).then.raises(Exception)
+                @parser.find_or_load("Foo_namespace","Foo_name",:my_type).should == true
+            end
+
+            it "should next attempt to load them with the all lowercase namespace" do
+                @loaded_code.stubs(:find_my_type).with("foo_namespace","foo_name").returns(false,false,true,true)
+                @parser.expects(:load).with("foo_namespace::foo_name").returns(false).then.raises(Exception)
+                @parser.expects(:load).with("foo_namespace"          ).returns(true ).then.raises(Exception)
+                @parser.find_or_load("Foo_namespace","Foo_name",:my_type).should == true
+            end
+
+            it "should finally attempt to load them with the all lowercase unqualified name" do
+                @loaded_code.stubs(:find_my_type).with("foo_namespace","foo_name").returns(false,false,false,true,true)
+                @parser.expects(:load).with("foo_namespace::foo_name").returns(false).then.raises(Exception)
+                @parser.expects(:load).with("foo_namespace"          ).returns(false).then.raises(Exception)
+                @parser.expects(:load).with(               "foo_name").returns(true ).then.raises(Exception)
+                @parser.find_or_load("Foo_namespace","Foo_name",:my_type).should == true
+            end
+
+            it "should return false if the name isn't found" do
+                @parser.stubs(:load).returns(false)
+                @parser.find_or_load("Bogus_namespace","Bogus_name",:my_type).should == false
+            end
+
+            it "should directly look for fully qualified classes" do
+                @loaded_code.stubs(:find_hostclass).with("foo_namespace","::foo_name").returns(false, true)
+                @parser.expects(:load).with("foo_name").returns true
+                @parser.find_or_load("foo_namespace","::foo_name",:hostclass)
+            end
+        end
+    end
+
+    describe Puppet::Parser,"when loading classnames" do
+        before :each do
+            @loaded_code = mock 'loaded code'
+            @parser = Puppet::Parser::Parser.new :environment => "development",:loaded_code => @loaded_code
+        end
+
+        it "should just return false if the classname is empty" do
+            @parser.expects(:import).never
+            @parser.load("").should == false
+        end
+
+        it "should just return true if the item is loaded" do
+            pending "Need to access internal state (@parser's @loaded) to force this"
+            @parser.load("").should == false
+        end
+    end
+end