puppet 0.24.9 → 0.25.0

data/spec/unit/parser/compiler.rb

@@ -35,39 +35,36 @@ describe Puppet::Parser::Compiler do
         @node = Puppet::Node.new "testnode"
         @parser = Puppet::Parser::Parser.new :environment => "development"
 
-        @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
+        @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]', :type => "class"
         @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
         @compiler = Puppet::Parser::Compiler.new(@node, @parser)
     end
 
-    describe Puppet::Parser::Compiler do
-
-        it "should be able to store references to class scopes" do
-            lambda { @compiler.class_set "myname", "myscope" }.should_not raise_error
-        end
+    it "should be able to store references to class scopes" do
+        lambda { @compiler.class_set "myname", "myscope" }.should_not raise_error
+    end
 
-        it "should be able to retrieve class scopes by name" do
-            @compiler.class_set "myname", "myscope"
-            @compiler.class_scope("myname").should == "myscope"
-        end
+    it "should be able to retrieve class scopes by name" do
+        @compiler.class_set "myname", "myscope"
+        @compiler.class_scope("myname").should == "myscope"
+    end
 
-        it "should be able to retrieve class scopes by object" do
-            klass = mock 'ast_class'
-            klass.expects(:classname).returns("myname")
-            @compiler.class_set "myname", "myscope"
-            @compiler.class_scope(klass).should == "myscope"
-        end
+    it "should be able to retrieve class scopes by object" do
+        klass = mock 'ast_class'
+        klass.expects(:classname).returns("myname")
+        @compiler.class_set "myname", "myscope"
+        @compiler.class_scope(klass).should == "myscope"
+    end
 
-        it "should be able to return a class list containing all set classes" do
-            @compiler.class_set "", "empty"
-            @compiler.class_set "one", "yep"
-            @compiler.class_set "two", "nope"
+    it "should be able to return a class list containing all set classes" do
+        @compiler.class_set "", "empty"
+        @compiler.class_set "one", "yep"
+        @compiler.class_set "two", "nope"
 
-            @compiler.classlist.sort.should == %w{one two}.sort
-        end
+        @compiler.classlist.sort.should == %w{one two}.sort
     end
 
-    describe Puppet::Parser::Compiler, " when initializing" do
+    describe "when initializing" do
 
         it "should set its node attribute" do
             @compiler.node.should equal(@node)
@@ -82,12 +79,16 @@ describe Puppet::Parser::Compiler do
         end
 
         it "should detect when ast nodes are present" do
-            @parser.nodes["testing"] = "yay"
+            @parser.expects(:nodes?).returns true
             @compiler.ast_nodes?.should be_true
         end
+
+        it "should copy the parser version to the catalog" do
+            @compiler.catalog.version.should == @parser.version
+        end
     end
 
-    describe Puppet::Parser::Compiler, "when managing scopes" do
+    describe "when managing scopes" do
 
         it "should create a top scope" do
             @compiler.topscope.should be_instance_of(Puppet::Parser::Scope)
@@ -109,7 +110,7 @@ describe Puppet::Parser::Compiler do
         end
     end
 
-    describe Puppet::Parser::Compiler, " when compiling" do
+    describe "when compiling" do
 
         def compile_methods
             [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated,
@@ -142,22 +143,12 @@ describe Puppet::Parser::Compiler do
             @compiler.class.publicize_methods(:evaluate_node_classes) { @compiler.evaluate_node_classes }
         end
 
-        it "should enable ast_nodes if the parser has any nodes" do
-            @parser.expects(:nodes).returns(:one => :yay)
-            @compiler.ast_nodes?.should be_true
-        end
-
-        it "should disable ast_nodes if the parser has no nodes" do
-            @parser.expects(:nodes).returns({})
-            @compiler.ast_nodes?.should be_false
-        end
-
         it "should evaluate the main class if it exists" do
             compile_stub(:evaluate_main)
             main_class = mock 'main_class'
             main_class.expects(:evaluate_code).with { |r| r.is_a?(Puppet::Parser::Resource) }
             @compiler.topscope.expects(:source=).with(main_class)
-            @parser.stubs(:findclass).with("", "").returns(main_class)
+            @parser.stubs(:find_hostclass).with("", "").returns(main_class)
 
             @compiler.compile
         end
@@ -183,11 +174,11 @@ describe Puppet::Parser::Compiler do
         end
 
         it "should ignore builtin resources" do
-            resource = stub 'builtin', :ref => "File[testing]", :builtin? => true
+            resource = stub 'builtin', :ref => "File[testing]", :builtin? => true, :type => "file"
 
             @compiler.add_resource(@scope, resource)
             resource.expects(:evaluate).never
-        
+
             @compiler.compile
         end
 
@@ -198,15 +189,15 @@ describe Puppet::Parser::Compiler do
 
             # We have to now mark the resource as evaluated
             resource.expects(:evaluate).with { |*whatever| resource.evaluated = true }
-        
+
             @compiler.compile
         end
 
         it "should not evaluate already-evaluated resources" do
-            resource = stub 'already_evaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => true, :virtual? => false
+            resource = stub 'already_evaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => true, :virtual? => false, :type => "file"
             @compiler.add_resource(@scope, resource)
             resource.expects(:evaluate).never
-        
+
             @compiler.compile
         end
 
@@ -220,7 +211,7 @@ describe Puppet::Parser::Compiler do
             resource.expects(:evaluate).with { |*whatever| resource.evaluated = true; @compiler.add_resource(@scope, resource2) }
             resource2.expects(:evaluate).with { |*whatever| resource2.evaluated = true }
 
-        
+
             @compiler.compile
         end
 
@@ -232,60 +223,105 @@ describe Puppet::Parser::Compiler do
             @compiler.add_resource(@scope, resource)
 
             # And one that does not
-            dnf = stub "dnf", :ref => "File[dnf]"
+            dnf = stub "dnf", :ref => "File[dnf]", :type => "file"
 
             @compiler.add_resource(@scope, dnf)
 
             @compiler.send(:finish)
         end
 
+        it "should call finish() in add_resource order" do
+            resources = sequence('resources')
+
+            resource1 = Puppet::Parser::Resource.new :scope => @scope, :type => "file", :title => "finish1"
+            resource1.expects(:finish).in_sequence(resources)
+
+            @compiler.add_resource(@scope, resource1)
+
+            resource2 = Puppet::Parser::Resource.new :scope => @scope, :type => "file", :title => "finish2"
+            resource2.expects(:finish).in_sequence(resources)
+
+            @compiler.add_resource(@scope, resource2)
+
+            @compiler.send(:finish)
+        end
+
+        it "should return added resources in add order" do
+            resource1 = stub "1", :ref => "File[yay]", :type => "file"
+            @compiler.add_resource(@scope, resource1)
+            resource2 = stub "2", :ref => "File[youpi]", :type => "file"
+            @compiler.add_resource(@scope, resource2)
+
+            @compiler.resources.should == [resource1, resource2]
+        end
+
         it "should add resources that do not conflict with existing resources" do
-            resource = stub "noconflict", :ref => "File[yay]"
+            resource = CompilerTestResource.new(:file, "yay")
             @compiler.add_resource(@scope, resource)
 
             @compiler.catalog.should be_vertex(resource)
         end
 
         it "should fail to add resources that conflict with existing resources" do
-            type = stub 'faketype', :isomorphic? => true, :name => "mytype"
-            Puppet::Type.stubs(:type).with("mytype").returns(type)
+            file1 = Puppet::Type.type(:file).new :path => "/foo"
+            file2 = Puppet::Type.type(:file).new :path => "/foo"
 
-            resource1 = stub "iso1conflict", :ref => "Mytype[yay]", :type => "mytype", :file => "eh", :line => 0
-            resource2 = stub "iso2conflict", :ref => "Mytype[yay]", :type => "mytype", :file => "eh", :line => 0
+            @compiler.add_resource(@scope, file1)
+            lambda { @compiler.add_resource(@scope, file2) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
+        end
 
-            @compiler.add_resource(@scope, resource1)
-            lambda { @compiler.add_resource(@scope, resource2) }.should raise_error(ArgumentError)
+        it "should add an edge from the scope resource to the added resource" do
+            resource = stub "noconflict", :ref => "File[yay]", :type => "file"
+            @compiler.add_resource(@scope, resource)
+
+            @compiler.catalog.should be_edge(@scope.resource, resource)
+        end
+
+        it "should add edges from the class resources to the main class" do
+            main = CompilerTestResource.new(:class, :main)
+            @compiler.add_resource(@scope, main)
+            resource = CompilerTestResource.new(:class, "foo")
+            @compiler.add_resource(@scope, resource)
+
+            @compiler.catalog.should be_edge(main, resource)
+        end
+
+        it "should just add edges to the scope resource for the class resources when no main class can be found" do
+            resource = CompilerTestResource.new(:class, "foo")
+            @compiler.add_resource(@scope, resource)
+
+            @compiler.catalog.should be_edge(@scope.resource, resource)
         end
 
         it "should have a method for looking up resources" do
-            resource = stub 'resource', :ref => "Yay[foo]"
+            resource = stub 'resource', :ref => "Yay[foo]", :type => "file"
             @compiler.add_resource(@scope, resource)
             @compiler.findresource("Yay[foo]").should equal(resource)
         end
 
         it "should be able to look resources up by type and title" do
-            resource = stub 'resource', :ref => "Yay[foo]"
+            resource = stub 'resource', :ref => "Yay[foo]", :type => "file"
             @compiler.add_resource(@scope, resource)
             @compiler.findresource("Yay", "foo").should equal(resource)
         end
 
         it "should not evaluate virtual defined resources" do
-            resource = stub 'notevaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => false, :virtual? => true
+            resource = stub 'notevaluated', :ref => "File[testing]", :builtin? => false, :evaluated? => false, :virtual? => true, :type => "file"
             @compiler.add_resource(@scope, resource)
 
             resource.expects(:evaluate).never
-        
+
             @compiler.compile
         end
     end
 
-    describe Puppet::Parser::Compiler, " when evaluating collections" do
+    describe "when evaluating collections" do
 
         it "should evaluate each collection" do
             2.times { |i|
                 coll = mock 'coll%s' % i
                 @compiler.add_collection(coll)
-            
+
                 # This is the hard part -- we have to emulate the fact that
                 # collections delete themselves if they are done evaluating.
                 coll.expects(:evaluate).with do
@@ -324,7 +360,7 @@ describe Puppet::Parser::Compiler do
         end
     end
 
-    describe Puppet::Parser::Compiler, "when told to evaluate missing classes" do
+    describe "when told to evaluate missing classes" do
 
         it "should fail if there's no source listed for the scope" do
             scope = stub 'scope', :source => nil
@@ -333,18 +369,18 @@ describe Puppet::Parser::Compiler do
 
         it "should tag the catalog with the name of each not-found class" do
             @compiler.catalog.expects(:tag).with("notfound")
-            @scope.expects(:findclass).with("notfound").returns(nil)
+            @scope.expects(:find_hostclass).with("notfound").returns(nil)
             @compiler.evaluate_classes(%w{notfound}, @scope)
         end
     end
 
-    describe Puppet::Parser::Compiler, " when evaluating found classes" do
+    describe "when evaluating found classes" do
 
         before do
             @class = stub 'class', :classname => "my::class"
-            @scope.stubs(:findclass).with("myclass").returns(@class)
+            @scope.stubs(:find_hostclass).with("myclass").returns(@class)
 
-            @resource = stub 'resource', :ref => "Class[myclass]"
+            @resource = stub 'resource', :ref => "Class[myclass]", :type => "file"
         end
 
         it "should evaluate each class" do
@@ -387,11 +423,21 @@ describe Puppet::Parser::Compiler do
             @compiler.evaluate_classes(%w{myclass}, @scope, false)
         end
 
+        it "should skip classes previously evaluated with different capitalization" do
+            @compiler.catalog.stubs(:tag)
+            @scope.stubs(:find_hostclass).with("MyClass").returns(@class)
+            @compiler.expects(:class_scope).with(@class).returns("something")
+            @compiler.expects(:add_resource).never
+            @resource.expects(:evaluate).never
+            Puppet::Parser::Resource.expects(:new).never
+            @compiler.evaluate_classes(%w{MyClass}, @scope, false)
+        end
+
         it "should return the list of found classes" do
             @compiler.catalog.stubs(:tag)
 
             @compiler.stubs(:add_resource)
-            @scope.stubs(:findclass).with("notfound").returns(nil)
+            @scope.stubs(:find_hostclass).with("notfound").returns(nil)
 
             Puppet::Parser::Resource.stubs(:new).returns(@resource)
             @class.stubs :evaluate
@@ -399,7 +445,7 @@ describe Puppet::Parser::Compiler do
         end
     end
 
-    describe Puppet::Parser::Compiler, " when evaluating AST nodes with no AST nodes present" do
+    describe "when evaluating AST nodes with no AST nodes present" do
 
         it "should do nothing" do
             @compiler.expects(:ast_nodes?).returns(false)
@@ -410,21 +456,19 @@ describe Puppet::Parser::Compiler do
         end
     end
 
-    describe Puppet::Parser::Compiler, " when evaluating AST nodes with AST nodes present" do
+    describe "when evaluating AST nodes with AST nodes present" do
 
         before do
-            @nodes = mock 'node_hash'
-            @compiler.stubs(:ast_nodes?).returns(true)
-            @compiler.parser.stubs(:nodes).returns(@nodes)
+            @compiler.parser.stubs(:nodes?).returns true
 
             # Set some names for our test
             @node.stubs(:names).returns(%w{a b c})
-            @nodes.stubs(:[]).with("a").returns(nil)
-            @nodes.stubs(:[]).with("b").returns(nil)
-            @nodes.stubs(:[]).with("c").returns(nil)
+            @compiler.parser.stubs(:node).with("a").returns(nil)
+            @compiler.parser.stubs(:node).with("b").returns(nil)
+            @compiler.parser.stubs(:node).with("c").returns(nil)
 
             # It should check this last, of course.
-            @nodes.stubs(:[]).with("default").returns(nil)
+            @compiler.parser.stubs(:node).with("default").returns(nil)
         end
 
         it "should fail if the named node cannot be found" do
@@ -433,9 +477,9 @@ describe Puppet::Parser::Compiler do
 
         it "should evaluate the first node class matching the node name" do
             node_class = stub 'node', :classname => "c", :evaluate_code => nil
-            @nodes.stubs(:[]).with("c").returns(node_class)
+            @compiler.parser.stubs(:node).with("c").returns(node_class)
 
-            node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil
+            node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
             node_class.expects(:evaluate).returns(node_resource)
 
             @compiler.compile
@@ -443,9 +487,9 @@ describe Puppet::Parser::Compiler do
 
         it "should match the default node if no matching node can be found" do
             node_class = stub 'node', :classname => "default", :evaluate_code => nil
-            @nodes.stubs(:[]).with("default").returns(node_class)
+            @compiler.parser.stubs(:node).with("default").returns(node_class)
 
-            node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil
+            node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil, :type => "node"
             node_class.expects(:evaluate).returns(node_resource)
 
             @compiler.compile
@@ -453,9 +497,9 @@ describe Puppet::Parser::Compiler do
 
         it "should evaluate the node resource immediately rather than using lazy evaluation" do
             node_class = stub 'node', :classname => "c"
-            @nodes.stubs(:[]).with("c").returns(node_class)
+            @compiler.parser.stubs(:node).with("c").returns(node_class)
 
-            node_resource = stub 'node resource', :ref => "Node[c]"
+            node_resource = stub 'node resource', :ref => "Node[c]", :type => "node"
             node_class.expects(:evaluate).returns(node_resource)
 
             node_resource.expects(:evaluate)
@@ -464,10 +508,10 @@ describe Puppet::Parser::Compiler do
         end
 
         it "should set the node's scope as the top scope" do
-            node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil
+            node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
             node_class = stub 'node', :classname => "c", :evaluate => node_resource
 
-            @nodes.stubs(:[]).with("c").returns(node_class)
+            @compiler.parser.stubs(:node).with("c").returns(node_class)
 
             # The #evaluate method normally does this.
             scope = stub 'scope', :source => "mysource"
@@ -480,31 +524,11 @@ describe Puppet::Parser::Compiler do
         end
     end
 
-    describe Puppet::Parser::Compiler, "when storing compiled resources" do
-
-        it "should store the resources" do
-            Puppet.features.expects(:rails?).returns(true)
-            Puppet::Rails.expects(:connect)
-
-            @compiler.catalog.expects(:vertices).returns(:resources)
-
-            @compiler.expects(:store_to_active_record).with(@node, :resources)
-            @compiler.send(:store)
-        end
-
-        it "should store to active_record" do
-            @node.expects(:name).returns("myname")
-            Puppet::Rails::Host.stubs(:transaction).yields
-            Puppet::Rails::Host.expects(:store).with(@node, :resources)
-            @compiler.send(:store_to_active_record, @node, :resources)
-        end
-    end
-
-    describe Puppet::Parser::Compiler, "when managing resource overrides" do
+    describe "when managing resource overrides" do
 
         before do
-            @override = stub 'override', :ref => "My[ref]"
-            @resource = stub 'resource', :ref => "My[ref]", :builtin? => true
+            @override = stub 'override', :ref => "My[ref]", :type => "my"
+            @resource = stub 'resource', :ref => "My[ref]", :builtin? => true, :type => "my"
         end
 
         it "should be able to store overrides" do
@@ -541,7 +565,7 @@ describe Puppet::Parser::Compiler do
     end
 
     # #620 - Nodes and classes should conflict, else classes don't get evaluated
-    describe Puppet::Parser::Compiler, "when evaluating nodes and classes with the same name (#620)" do
+    describe "when evaluating nodes and classes with the same name (#620)" do
 
         before do
             @node = stub :nodescope? => true

data/spec/unit/parser/files.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/parser/files'
+
+describe Puppet::Parser::Files do
+    it "should have a method for finding a template" do
+        Puppet::Parser::Files.should respond_to(:find_template)
+    end
+
+    it "should have a method for finding manifests" do
+        Puppet::Parser::Files.should respond_to(:find_manifests)
+    end
+
+    describe "when searching for templates" do
+        it "should return fully-qualified templates directly" do
+            Puppet::Parser::Files.expects(:modulepath).never
+            Puppet::Parser::Files.find_template("/my/template").should == "/my/template"
+        end
+
+        it "should return the template from the first found module" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
+
+            mod.expects(:template).returns("/one/mymod/templates/mytemplate")
+            Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
+        end
+
+        it "should return the file in the templatedir if it exists" do
+            Puppet.settings.expects(:value).with(:templatedir, nil).returns("/my/templates")
+            Puppet[:modulepath] = "/one:/two"
+            File.stubs(:directory?).returns(true)
+            FileTest.stubs(:exist?).returns(true)
+            Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/my/templates/mymod/mytemplate"
+        end
+
+        it "should not raise an error if no valid templatedir exists and the template exists in a module" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
+
+            mod.expects(:template).returns("/one/mymod/templates/mytemplate")
+            Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(nil)
+
+            Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
+        end
+
+        it "should return unqualified templates if they exist in the template dir" do
+            FileTest.stubs(:exist?).returns true
+            Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
+            Puppet::Parser::Files.find_template("mytemplate").should == "/my/templates/mytemplate"
+        end
+
+        it "should only return templates if they actually exist" do
+            FileTest.expects(:exist?).with("/my/templates/mytemplate").returns true
+            Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
+            Puppet::Parser::Files.find_template("mytemplate").should == "/my/templates/mytemplate"
+        end
+
+        it "should return nil when asked for a template that doesn't exist" do
+            FileTest.expects(:exist?).with("/my/templates/mytemplate").returns false
+            Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
+            Puppet::Parser::Files.find_template("mytemplate").should be_nil
+        end
+
+        it "should search in the template directories before modules" do
+            FileTest.stubs(:exist?).returns true
+            Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
+            Puppet::Module.expects(:find).never
+            Puppet::Parser::Files.find_template("mytemplate")
+        end
+
+        it "should accept relative templatedirs" do
+            FileTest.stubs(:exist?).returns true
+            Puppet[:templatedir] = "my/templates"
+            File.expects(:directory?).with(File.join(Dir.getwd,"my/templates")).returns(true)
+            Puppet::Parser::Files.find_template("mytemplate").should == File.join(Dir.getwd,"my/templates/mytemplate")
+        end
+
+        it "should use the environment templatedir if no module is found and an environment is specified" do
+            FileTest.stubs(:exist?).returns true
+            Puppet::Parser::Files.stubs(:templatepath).with("myenv").returns(["/myenv/templates"])
+            Puppet::Parser::Files.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
+        end
+
+        it "should use first dir from environment templatedir if no module is found and an environment is specified" do
+            FileTest.stubs(:exist?).returns true
+            Puppet::Parser::Files.stubs(:templatepath).with("myenv").returns(["/myenv/templates", "/two/templates"])
+            Puppet::Parser::Files.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
+        end
+
+        it "should use a valid dir when templatedir is a path for unqualified templates and the first dir contains template" do
+            Puppet::Parser::Files.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
+            FileTest.expects(:exist?).with("/one/templates/mytemplate").returns(true)
+            Puppet::Parser::Files.find_template("mytemplate").should == "/one/templates/mytemplate"
+        end
+
+        it "should use a valid dir when templatedir is a path for unqualified templates and only second dir contains template" do
+            Puppet::Parser::Files.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
+            FileTest.expects(:exist?).with("/one/templates/mytemplate").returns(false)
+            FileTest.expects(:exist?).with("/two/templates/mytemplate").returns(true)
+            Puppet::Parser::Files.find_template("mytemplate").should == "/two/templates/mytemplate"
+        end
+
+        it "should use the node environment if specified" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new("myenv").expects(:module).with("mymod").returns mod
+
+            mod.expects(:template).returns("/my/modules/mymod/templates/envtemplate")
+
+            Puppet::Parser::Files.find_template("mymod/envtemplate", "myenv").should == "/my/modules/mymod/templates/envtemplate"
+        end
+
+        it "should return nil if no template can be found" do
+            Puppet::Parser::Files.find_template("foomod/envtemplate", "myenv").should be_nil
+        end
+
+        after { Puppet.settings.clear }
+    end
+
+    describe "when searching for manifests" do
+        it "should ignore invalid modules" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new.expects(:module).with("mymod").raises Puppet::Module::InvalidName
+            Puppet.expects(:value).with(:modulepath).never
+            Dir.stubs(:glob).returns %w{foo}
+
+            Puppet::Parser::Files.find_manifests("mymod/init.pp").should == %w{foo}
+        end
+    end
+
+    describe "when searching for manifests when no module is found" do
+        before do
+            File.stubs(:find).returns(nil)
+        end
+
+        it "should not look for modules when paths are fully qualified" do
+            Puppet.expects(:value).with(:modulepath).never
+            file = "/fully/qualified/file.pp"
+            Dir.stubs(:glob).with(file).returns([file])
+            Puppet::Parser::Files.find_manifests(file)
+        end
+
+        it "should directly return fully qualified files" do
+            file = "/fully/qualified/file.pp"
+            Dir.stubs(:glob).with(file).returns([file])
+            Puppet::Parser::Files.find_manifests(file).should == [file]
+        end
+
+        it "should match against provided fully qualified patterns" do
+            pattern = "/fully/qualified/pattern/*"
+            Dir.expects(:glob).with(pattern).returns(%w{my file list})
+            Puppet::Parser::Files.find_manifests(pattern).should == %w{my file list}
+        end
+
+        it "should look for files relative to the current directory" do
+            cwd = Dir.getwd
+            Dir.expects(:glob).with("#{cwd}/foobar/init.pp").returns(["#{cwd}/foobar/init.pp"])
+            Puppet::Parser::Files.find_manifests("foobar/init.pp").should == ["#{cwd}/foobar/init.pp"]
+        end
+
+        it "should only return files, not directories" do
+            pattern = "/fully/qualified/pattern/*"
+            file = "/my/file"
+            dir = "/my/directory"
+            Dir.expects(:glob).with(pattern).returns([file, dir])
+            FileTest.expects(:directory?).with(file).returns(false)
+            FileTest.expects(:directory?).with(dir).returns(true)
+            Puppet::Parser::Files.find_manifests(pattern).should == [file]
+        end
+    end
+
+    describe "when searching for manifests in a found module" do
+        it "should return the manifests from the first found module" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
+            mod.expects(:match_manifests).with("init.pp").returns(%w{/one/mymod/manifests/init.pp})
+            Puppet::Parser::Files.find_manifests("mymod/init.pp").should == ["/one/mymod/manifests/init.pp"]
+        end
+
+        it "should use the node environment if specified" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new("myenv").expects(:module).with("mymod").returns mod
+            mod.expects(:match_manifests).with("init.pp").returns(%w{/one/mymod/manifests/init.pp})
+            Puppet::Parser::Files.find_manifests("mymod/init.pp", :environment => "myenv").should == ["/one/mymod/manifests/init.pp"]
+        end
+
+        after { Puppet.settings.clear }
+    end
+end