puppet 0.24.9 → 0.25.0

data/spec/unit/file_serving/mount/modules.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/file_serving/mount/modules'
+
+describe Puppet::FileServing::Mount::Modules do
+    before do
+        @mount = Puppet::FileServing::Mount::Modules.new("modules")
+
+        @environment = stub 'environment', :module => nil
+        @request = stub 'request', :environment => @environment
+    end
+
+    describe "when finding files" do
+        it "should use the provided environment to find the module" do
+            @environment.expects(:module)
+
+            @mount.find("foo", @request)
+        end
+
+        it "should treat the first field of the relative path as the module name" do
+            @environment.expects(:module).with("foo")
+            @mount.find("foo/bar/baz", @request)
+        end
+
+        it "should return nil if the specified module does not exist" do
+            @environment.expects(:module).with("foo").returns nil
+            @mount.find("foo/bar/baz", @request)
+        end
+
+        it "should return the file path from the module" do
+            mod = mock 'module'
+            mod.expects(:file).with("bar/baz").returns "eh"
+            @environment.expects(:module).with("foo").returns mod
+            @mount.find("foo/bar/baz", @request).should == "eh"
+        end
+    end
+
+    describe "when searching for files" do
+        it "should use the node's environment to search the module" do
+            @environment.expects(:module)
+
+            @mount.search("foo", @request)
+        end
+
+        it "should treat the first field of the relative path as the module name" do
+            @environment.expects(:module).with("foo")
+            @mount.search("foo/bar/baz", @request)
+        end
+
+        it "should return nil if the specified module does not exist" do
+            @environment.expects(:module).with("foo").returns nil
+            @mount.search("foo/bar/baz", @request)
+        end
+
+        it "should return the file path as an array from the module" do
+            mod = mock 'module'
+            mod.expects(:file).with("bar/baz").returns "eh"
+            @environment.expects(:module).with("foo").returns mod
+            @mount.search("foo/bar/baz", @request).should == ["eh"]
+        end
+    end
+end

data/spec/unit/file_serving/mount/plugins.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/file_serving/mount/plugins'
+
+describe Puppet::FileServing::Mount::Plugins do
+    before do
+        @mount = Puppet::FileServing::Mount::Plugins.new("plugins")
+
+        @environment = stub 'environment', :module => nil
+        @request = stub 'request', :environment => @environment
+    end
+
+    describe  "when finding files" do
+        it "should use the provided environment to find the modules" do
+            @environment.expects(:modules).returns []
+
+            @mount.find("foo", @request)
+        end
+
+        it "should return nil if no module can be found with a matching plugin" do
+            mod = mock 'module'
+            mod.stubs(:plugin).with("foo/bar").returns nil
+
+            @environment.stubs(:modules).returns [mod]
+            @mount.find("foo/bar", @request).should be_nil
+        end
+
+        it "should return the file path from the module" do
+            mod = mock 'module'
+            mod.stubs(:plugin).with("foo/bar").returns "eh"
+
+            @environment.stubs(:modules).returns [mod]
+            @mount.find("foo/bar", @request).should == "eh"
+        end
+    end
+
+    describe "when searching for files" do
+        it "should use the node's environment to find the modules" do
+            @environment.expects(:modules).returns []
+
+            @mount.search("foo", @request)
+        end
+
+        it "should return nil if no modules can be found that have plugins" do
+            mod = mock 'module'
+            mod.stubs(:plugins?).returns false
+
+            @environment.stubs(:modules).returns []
+            @mount.search("foo/bar", @request).should be_nil
+        end
+
+        it "should return the plugin paths for each module that has plugins" do
+            one = stub 'module', :plugins? => true, :plugin_directory => "/one"
+            two = stub 'module', :plugins? => true, :plugin_directory => "/two"
+
+            @environment.stubs(:modules).returns [one, two]
+            @mount.search("foo/bar", @request).should == %w{/one /two}
+        end
+    end
+end

data/spec/unit/file_serving/terminus_helper.rb

@@ -16,18 +16,30 @@ describe Puppet::FileServing::TerminusHelper do
         @helper.stubs(:model).returns(@model)
 
         @request = stub 'request', :key => "url", :options => {}
+
+        @fileset = stub 'fileset', :files => [], :path => "/my/file"
+        Puppet::FileServing::Fileset.stubs(:new).with("/my/file", {}).returns(@fileset)
     end
 
     it "should use a fileset to find paths" do
-        fileset = mock 'fileset', :files => []
-        Puppet::FileServing::Fileset.expects(:new).with("/my/file", {}).returns(fileset)
+        @fileset = stub 'fileset', :files => [], :path => "/my/files"
+        Puppet::FileServing::Fileset.expects(:new).with { |key, options| key == "/my/file" }.returns(@fileset)
         @helper.path2instances(@request, "/my/file")
     end
 
-    it "should pass :recurse, :ignore, and :links settings on to the fileset if present" do
-        fileset = mock 'fileset', :files => []
-        Puppet::FileServing::Fileset.expects(:new).with("/my/file", :links => :a, :ignore => :b, :recurse => :c).returns(fileset)
-        @request.stubs(:options).returns(:links => :a, :ignore => :b, :recurse => :c)
+    it "should support finding across multiple paths by merging the filesets" do
+        first = stub 'fileset', :files => [], :path => "/first/file"
+        Puppet::FileServing::Fileset.expects(:new).with { |path, options| path == "/first/file" }.returns(first)
+        second = stub 'fileset', :files => [], :path => "/second/file"
+        Puppet::FileServing::Fileset.expects(:new).with { |path, options| path == "/second/file" }.returns(second)
+
+        Puppet::FileServing::Fileset.expects(:merge).with(first, second).returns({})
+
+        @helper.path2instances(@request, "/first/file", "/second/file")
+    end
+
+    it "should pass the indirection request to the Fileset at initialization" do
+        Puppet::FileServing::Fileset.expects(:new).with { |path, options| options == @request }.returns @fileset
         @helper.path2instances(@request, "/my/file")
     end
 
@@ -35,42 +47,42 @@ describe Puppet::FileServing::TerminusHelper do
         before do
             @request.stubs(:key).returns "puppet://host/mount/dir"
 
-            @fileset = mock 'fileset', :files => %w{one two}
-            Puppet::FileServing::Fileset.expects(:new).returns(@fileset)
-        end
+            @one = stub 'one', :links= => nil, :collect => nil
+            @two = stub 'two', :links= => nil, :collect => nil
 
-        it "should create an instance of the model for each path returned by the fileset" do
-            @model.expects(:new).returns(:one)
-            @model.expects(:new).returns(:two)
-            @helper.path2instances(@request, "/my/file").length.should == 2
-        end
-
-        it "should set each instance's key to be the original key plus the file-specific path" do
-            @model.expects(:new).with { |key, options| key == @request.key + "/one" }.returns(:one)
-            @model.expects(:new).with { |key, options| key == @request.key + "/two" }.returns(:two)
-            @helper.path2instances(@request, "/my/file")
+            @fileset = stub 'fileset', :files => %w{one two}, :path => "/my/file"
+            Puppet::FileServing::Fileset.stubs(:new).returns(@fileset)
         end
 
         it "should set each returned instance's path to the original path" do
-            @model.expects(:new).with { |key, options| options[:path] == "/my/file" }.returns(:one)
-            @model.expects(:new).with { |key, options| options[:path] == "/my/file" }.returns(:two)
+            @model.expects(:new).with { |key, options| key == "/my/file" }.returns(@one)
+            @model.expects(:new).with { |key, options| key == "/my/file" }.returns(@two)
             @helper.path2instances(@request, "/my/file")
         end
 
         it "should set each returned instance's relative path to the file-specific path" do
-            @model.expects(:new).with { |key, options| options[:relative_path] == "one" }.returns(:one)
-            @model.expects(:new).with { |key, options| options[:relative_path] == "two" }.returns(:two)
+            @model.expects(:new).with { |key, options| options[:relative_path] == "one" }.returns(@one)
+            @model.expects(:new).with { |key, options| options[:relative_path] == "two" }.returns(@two)
             @helper.path2instances(@request, "/my/file")
         end
 
         it "should set the links value on each instance if one is provided" do
-            one = mock 'one', :links= => :manage
-            two = mock 'two', :links= => :manage
-            @model.expects(:new).returns(one)
-            @model.expects(:new).returns(two)
+            @one.expects(:links=).with :manage
+            @two.expects(:links=).with :manage
+            @model.expects(:new).returns(@one)
+            @model.expects(:new).returns(@two)
 
             @request.options[:links] = :manage
             @helper.path2instances(@request, "/my/file")
         end
+
+        it "should collect the instance's attributes" do
+            @one.expects(:collect)
+            @two.expects(:collect)
+            @model.expects(:new).returns(@one)
+            @model.expects(:new).returns(@two)
+
+            @helper.path2instances(@request, "/my/file")
+        end
     end
 end

data/spec/unit/indirector.rb

@@ -36,7 +36,7 @@ describe Puppet::Indirector, "when registering an indirection" do
         @indirection = @thingie.indirects(:test)
         @indirection.should be_instance_of(Puppet::Indirector::Indirection)
     end
-    
+
     it "should not allow a model to register under multiple names" do
         # Keep track of the indirection instance so we can delete it on cleanup
         @indirection = @thingie.indirects :first
@@ -54,6 +54,11 @@ describe Puppet::Indirector, "when registering an indirection" do
         @indirection = @thingie.indirects :first, :some => :options
     end
 
+    it "should extend the class with the Format Handler" do
+        @indirection = @thingie.indirects :first
+        @thingie.metaclass.ancestors.should be_include(Puppet::Network::FormatHandler)
+    end
+
     after do
         @indirection.delete if @indirection
     end

data/spec/unit/indirector/active_record.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/indirector/active_record'
+
+describe Puppet::Indirector::ActiveRecord do
+    before do
+        Puppet::Rails.stubs(:init)
+
+        Puppet::Indirector::Terminus.stubs(:register_terminus_class)
+        @model = mock 'model'
+        @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
+        Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
+
+        @active_record_class = Class.new(Puppet::Indirector::ActiveRecord) do
+            def self.to_s
+                "Mystuff::Testing"
+            end
+        end
+
+        @ar_model = mock 'ar_model'
+
+        @active_record_class.use_ar_model @ar_model
+        @terminus = @active_record_class.new
+
+        @name = "me"
+        @instance = stub 'instance', :name => @name
+
+        @request = stub 'request', :key => @name, :instance => @instance
+    end
+
+    it "should allow declaration of an ActiveRecord model to use" do
+        @active_record_class.use_ar_model "foo"
+        @active_record_class.ar_model.should == "foo"
+    end
+
+    describe "when initializing" do
+        it "should init Rails" do
+            Puppet::Rails.expects(:init)
+            @active_record_class.new
+        end
+    end
+
+    describe "when finding an instance" do
+        it "should use the ActiveRecord model to find the instance" do
+            @ar_model.expects(:find_by_name).with(@name)
+
+            @terminus.find(@request)
+        end
+
+        it "should return nil if no instance is found" do
+            @ar_model.expects(:find_by_name).with(@name).returns nil
+            @terminus.find(@request).should be_nil
+        end
+
+        it "should convert the instance to a Puppet object if it is found" do
+            instance = mock 'rails_instance'
+            instance.expects(:to_puppet).returns "mypuppet"
+
+            @ar_model.expects(:find_by_name).with(@name).returns instance
+            @terminus.find(@request).should == "mypuppet"
+        end
+    end
+
+    describe "when saving an instance" do
+        it "should use the ActiveRecord model to convert the instance into a Rails object and then save that rails object" do
+            rails_object = mock 'rails_object'
+            @ar_model.expects(:from_puppet).with(@instance).returns rails_object
+
+            rails_object.expects(:save)
+
+            @terminus.save(@request)
+        end
+    end
+end

data/spec/unit/indirector/catalog/active_record.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+
+describe "Puppet::Resource::Catalog::ActiveRecord" do
+    confine "Missing Rails" => Puppet.features.rails?
+
+    before do
+        require 'puppet/indirector/catalog/active_record'
+        Puppet.features.stubs(:rails?).returns true
+        Puppet::Rails.stubs(:init)
+        @terminus = Puppet::Resource::Catalog::ActiveRecord.new
+    end
+
+    it "should be a subclass of the ActiveRecord terminus class" do
+        Puppet::Resource::Catalog::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
+    end
+
+    it "should use Puppet::Rails::Host as its ActiveRecord model" do
+        Puppet::Resource::Catalog::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
+    end
+
+    describe "when finding an instance" do
+        before do
+            @request = stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
+        end
+
+        # This hack is here because we don't want to look in the db unless we actually want
+        # to look in the db, but our indirection architecture in 0.24.x isn't flexible
+        # enough to tune that via configuration.
+        it "should return nil unless ':cache_integration_hack' is set to true" do
+            @request.options[:cache_integration_hack] = false
+            Puppet::Rails::Host.expects(:find_by_name).never
+            @terminus.find(@request).should be_nil
+        end
+
+        it "should use the Hosts ActiveRecord class to find the host" do
+            Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
+            @terminus.find(@request)
+        end
+
+        it "should return nil if no host instance can be found" do
+            Puppet::Rails::Host.expects(:find_by_name).returns nil
+
+            @terminus.find(@request).should be_nil
+        end
+
+        it "should return a catalog with the same name as the host if the host can be found" do
+            host = stub 'host', :name => "foo", :resources => []
+            Puppet::Rails::Host.expects(:find_by_name).returns host
+
+            result = @terminus.find(@request)
+            result.should be_instance_of(Puppet::Resource::Catalog)
+            result.name.should == "foo"
+        end
+
+        it "should set each of the host's resources as a transportable resource within the catalog" do
+            host = stub 'host', :name => "foo"
+            Puppet::Rails::Host.expects(:find_by_name).returns host
+
+            res1 = mock 'res1', :to_transportable => "trans_res1"
+            res2 = mock 'res2', :to_transportable => "trans_res2"
+
+            host.expects(:resources).returns [res1, res2]
+
+            catalog = stub 'catalog'
+            Puppet::Resource::Catalog.expects(:new).returns catalog
+
+            catalog.expects(:add_resource).with "trans_res1"
+            catalog.expects(:add_resource).with "trans_res2"
+
+            @terminus.find(@request)
+        end
+    end
+
+    describe "when saving an instance" do
+        before do
+            @host = stub 'host', :name => "foo", :save => nil, :merge_resources => nil, :last_compile= => nil
+            @host.stubs(:railsmark).yields
+
+            Puppet::Rails::Host.stubs(:find_by_name).returns @host
+            @catalog = Puppet::Resource::Catalog.new("foo")
+            @request = stub 'request', :key => "foo", :instance => @catalog
+        end
+
+        it "should find the Rails host with the same name" do
+            Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
+
+            @terminus.save(@request)
+        end
+
+        it "should create a new Rails host if none can be found" do
+            Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
+
+            Puppet::Rails::Host.expects(:create).with(:name => "foo").returns @host
+
+            @terminus.save(@request)
+        end
+
+        it "should set the catalog vertices as resources on the Rails host instance" do
+            @catalog.expects(:vertices).returns "foo"
+            @host.expects(:merge_resources).with("foo")
+
+            @terminus.save(@request)
+        end
+
+        it "should set the last compile time on the host" do
+            now = Time.now
+            Time.expects(:now).returns now
+            @host.expects(:last_compile=).with now
+
+            @terminus.save(@request)
+        end
+
+        it "should save the Rails host instance" do
+            @host.expects(:save)
+
+            @terminus.save(@request)
+        end
+    end
+end

data/spec/unit/indirector/catalog/compiler.rb

@@ -7,150 +7,254 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/indirector/catalog/compiler'
 
-describe Puppet::Node::Catalog::Compiler do
-    before do
-        Puppet.expects(:version).returns(1)
-        Facter.expects(:value).with('fqdn').returns("my.server.com")
-        Facter.expects(:value).with('ipaddress').returns("my.ip.address")
-    end
+describe Puppet::Resource::Catalog::Compiler do
+    describe "when initializing" do
+        before do
+            Puppet.expects(:version).returns(1)
+            Facter.expects(:value).with('fqdn').returns("my.server.com")
+            Facter.expects(:value).with('ipaddress').returns("my.ip.address")
+        end
 
-    it "should gather data about itself" do
-        Puppet::Node::Catalog::Compiler.new
-    end
+        it "should gather data about itself" do
+            Puppet::Resource::Catalog::Compiler.new
+        end
 
-    it "should cache the server metadata and reuse it" do
-        compiler = Puppet::Node::Catalog::Compiler.new
-        node1 = stub 'node1', :merge => nil
-        node2 = stub 'node2', :merge => nil
-        compiler.stubs(:compile)
-        Puppet::Node.stubs(:find).with('node1').returns(node1)
-        Puppet::Node.stubs(:find).with('node2').returns(node2)
+        it "should cache the server metadata and reuse it" do
+            compiler = Puppet::Resource::Catalog::Compiler.new
+            node1 = stub 'node1', :merge => nil
+            node2 = stub 'node2', :merge => nil
+            compiler.stubs(:compile)
+            Puppet::Node.stubs(:find).with('node1').returns(node1)
+            Puppet::Node.stubs(:find).with('node2').returns(node2)
 
-        compiler.find(stub('request', :key => 'node1', :options => {}))
-        compiler.find(stub('node2request', :key => 'node2', :options => {}))
-    end
+            compiler.find(stub('request', :node => 'node1', :options => {}))
+            compiler.find(stub('node2request', :node => 'node2', :options => {}))
+        end
 
-    it "should provide a method for determining if the catalog is networked" do
-        compiler = Puppet::Node::Catalog::Compiler.new
-        compiler.should respond_to(:networked?)
+        it "should provide a method for determining if the catalog is networked" do
+            compiler = Puppet::Resource::Catalog::Compiler.new
+            compiler.should respond_to(:networked?)
+        end
     end
-end
 
-describe Puppet::Node::Catalog::Compiler, " when creating the interpreter" do
-    before do
-        # This gets pretty annoying on a plane where we have no IP address
-        Facter.stubs(:value).returns("whatever")
-        @compiler = Puppet::Node::Catalog::Compiler.new
-    end
+    describe "when creating the interpreter" do
+        before do
+            # This gets pretty annoying on a plane where we have no IP address
+            Facter.stubs(:value).returns("whatever")
+            @compiler = Puppet::Resource::Catalog::Compiler.new
+        end
 
-    it "should not create the interpreter until it is asked for the first time" do
-        interp = mock 'interp'
-        Puppet::Parser::Interpreter.expects(:new).with().returns(interp)
-        @compiler.interpreter.should equal(interp)
-    end
+        it "should not create the interpreter until it is asked for the first time" do
+            interp = mock 'interp'
+            Puppet::Parser::Interpreter.expects(:new).with().returns(interp)
+            @compiler.interpreter.should equal(interp)
+        end
 
-    it "should use the same interpreter for all compiles" do
-        interp = mock 'interp'
-        Puppet::Parser::Interpreter.expects(:new).with().returns(interp)
-        @compiler.interpreter.should equal(interp)
-        @compiler.interpreter.should equal(interp)
+        it "should use the same interpreter for all compiles" do
+            interp = mock 'interp'
+            Puppet::Parser::Interpreter.expects(:new).with().returns(interp)
+            @compiler.interpreter.should equal(interp)
+            @compiler.interpreter.should equal(interp)
+        end
     end
-end
 
-describe Puppet::Node::Catalog::Compiler, " when finding nodes" do
-    before do
-        Facter.stubs(:value).returns("whatever")
-        @compiler = Puppet::Node::Catalog::Compiler.new
-        @name = "me"
-        @node = mock 'node'
-        @request = stub 'request', :key => @name, :options => {}
-        @compiler.stubs(:compile)
-    end
+    describe "when finding catalogs" do
+        before do
+            Facter.stubs(:value).returns("whatever")
+            env = stub 'environment', :name => "yay"
+            Puppet::Node::Environment.stubs(:new).returns(env)
 
-    it "should look node information up via the Node class with the provided key" do
-        @node.stubs :merge 
-        Puppet::Node.expects(:find).with(@name).returns(@node)
-        @compiler.find(@request)
-    end
-end
+            @compiler = Puppet::Resource::Catalog::Compiler.new
+            @name = "me"
+            @node = Puppet::Node.new @name
+            @node.stubs(:merge)
+            @request = stub 'request', :key => "does not matter", :node => @name, :options => {}
+        end
 
-describe Puppet::Node::Catalog::Compiler, " after finding nodes" do
-    before do
-        Puppet.expects(:version).returns(1)
-        Facter.expects(:value).with('fqdn').returns("my.server.com")
-        Facter.expects(:value).with('ipaddress').returns("my.ip.address")
-        @compiler = Puppet::Node::Catalog::Compiler.new
-        @name = "me"
-        @node = mock 'node'
-        @request = stub 'request', :key => @name, :options => {}
-        @compiler.stubs(:compile)
-        Puppet::Node.stubs(:find).with(@name).returns(@node)
-    end
+        it "should directly use provided nodes" do
+            Puppet::Node.expects(:find).never
+            @compiler.expects(:compile).with(@node)
+            @request.stubs(:options).returns(:use_node => @node)
+            @compiler.find(@request)
+        end
 
-    it "should add the server's Puppet version to the node's parameters as 'serverversion'" do
-        @node.expects(:merge).with { |args| args["serverversion"] == "1" }
-        @compiler.find(@request)
-    end
+        it "should use the request's node name if no explicit node is provided" do
+            Puppet::Node.expects(:find).with(@name).returns(@node)
+            @compiler.expects(:compile).with(@node)
+            @compiler.find(@request)
+        end
 
-    it "should add the server's fqdn to the node's parameters as 'servername'" do
-        @node.expects(:merge).with { |args| args["servername"] == "my.server.com" }
-        @compiler.find(@request)
-    end
+        it "should use the provided node name if no explicit node is provided and no authenticated node information is available" do
+            @request.expects(:node).returns nil
+            @request.expects(:key).returns "my_node"
 
-    it "should add the server's IP address to the node's parameters as 'serverip'" do
-        @node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" }
-        @compiler.find(@request)
-    end
-end
+            Puppet::Node.expects(:find).with("my_node").returns @node
+            @compiler.expects(:compile).with(@node)
+            @compiler.find(@request)
+        end
 
-describe Puppet::Node::Catalog::Compiler, " when creating catalogs" do
-    before do
-        Facter.stubs(:value).returns("whatever")
-        env = stub 'environment', :name => "yay"
-        Puppet::Node::Environment.stubs(:new).returns(env)
-
-        @compiler = Puppet::Node::Catalog::Compiler.new
-        @name = "me"
-        @node = Puppet::Node.new @name
-        @node.stubs(:merge)
-        @request = stub 'request', :key => @name, :options => {}
-    end
+        it "should fail if no node is passed and none can be found" do
+            Puppet::Node.stubs(:find).with(@name).returns(nil)
+            proc { @compiler.find(@request) }.should raise_error(ArgumentError)
+        end
+
+        it "should fail intelligently when searching for a node raises an exception" do
+            Puppet::Node.stubs(:find).with(@name).raises "eh"
+            proc { @compiler.find(@request) }.should raise_error(Puppet::Error)
+        end
+
+        it "should pass the found node to the interpreter for compiling" do
+            Puppet::Node.expects(:find).with(@name).returns(@node)
+            config = mock 'config'
+            @compiler.interpreter.expects(:compile).with(@node)
+            @compiler.find(@request)
+        end
+
+        it "should extract and save any facts from the request" do
+            @compiler.expects(:extract_facts_from_request).with(@request)
+            @compiler.interpreter.stubs(:compile)
+            @compiler.find(@request)
+        end
+
+        it "should return the results of compiling as the catalog" do
+            Puppet::Node.stubs(:find).returns(@node)
+            config = mock 'config'
+            result = mock 'result'
+
+            @compiler.interpreter.expects(:compile).with(@node).returns(result)
+            @compiler.find(@request).should equal(result)
+        end
 
-    it "should directly use provided nodes" do
-        Puppet::Node.expects(:find).never
-        @compiler.expects(:compile).with(@node)
-        @request.stubs(:options).returns(:use_node => @node)
-        @compiler.find(@request)
+        it "should benchmark the compile process" do
+            Puppet::Node.stubs(:find).returns(@node)
+            @compiler.stubs(:networked?).returns(true)
+            @compiler.expects(:benchmark).with do |level, message|
+                level == :notice and message =~ /^Compiled catalog/
+            end
+            @compiler.interpreter.stubs(:compile).with(@node)
+            @compiler.find(@request)
+        end
     end
 
-    it "should fail if no node is passed and none can be found" do
-        Puppet::Node.stubs(:find).with(@name).returns(nil)
-        proc { @compiler.find(@request) }.should raise_error(ArgumentError)
+    describe "when extracting facts from the request" do
+        before do
+            @compiler = Puppet::Resource::Catalog::Compiler.new
+            @request = stub 'request', :options => {}
+
+            @facts = stub 'facts', :save => nil
+        end
+
+        it "should do nothing if no facts are provided" do
+            Puppet::Node::Facts.expects(:convert_from).never
+            @request.options[:facts] = nil
+
+            @compiler.extract_facts_from_request(@request)
+        end
+
+        it "should use the Facts class to deserialize the provided facts" do
+            @request.options[:facts_format] = "foo"
+            @request.options[:facts] = "bar"
+            Puppet::Node::Facts.expects(:convert_from).returns @facts
+
+            @compiler.extract_facts_from_request(@request)
+        end
+
+        it "should use the provided fact format" do
+            @request.options[:facts_format] = "foo"
+            @request.options[:facts] = "bar"
+            Puppet::Node::Facts.expects(:convert_from).with { |format, text| format == "foo" }.returns @facts
+
+            @compiler.extract_facts_from_request(@request)
+        end
+
+        it "should convert the facts into a fact instance and save it" do
+            @request.options[:facts_format] = "foo"
+            @request.options[:facts] = "bar"
+            Puppet::Node::Facts.expects(:convert_from).returns @facts
+
+            @facts.expects(:save)
+
+            @compiler.extract_facts_from_request(@request)
+        end
     end
 
-    it "should pass the found node to the interpreter for compiling" do
-        Puppet::Node.expects(:find).with(@name).returns(@node)
-        config = mock 'config'
-        @compiler.interpreter.expects(:compile).with(@node)
-        @compiler.find(@request)
+    describe "when finding nodes" do
+        before do
+            Facter.stubs(:value).returns("whatever")
+            @compiler = Puppet::Resource::Catalog::Compiler.new
+            @name = "me"
+            @node = mock 'node'
+            @request = stub 'request', :node => @name, :options => {}
+            @compiler.stubs(:compile)
+        end
+
+        it "should look node information up via the Node class with the provided key" do
+            @node.stubs :merge
+            Puppet::Node.expects(:find).with(@name).returns(@node)
+            @compiler.find(@request)
+        end
     end
 
-    it "should return the results of compiling as the catalog" do
-        Puppet::Node.stubs(:find).returns(@node)
-        config = mock 'config'
-        result = mock 'result'
+    describe "after finding nodes" do
+        before do
+            Puppet.expects(:version).returns(1)
+            Facter.expects(:value).with('fqdn').returns("my.server.com")
+            Facter.expects(:value).with('ipaddress').returns("my.ip.address")
+            @compiler = Puppet::Resource::Catalog::Compiler.new
+            @name = "me"
+            @node = mock 'node'
+            @request = stub 'request', :node => @name, :options => {}
+            @compiler.stubs(:compile)
+            Puppet::Node.stubs(:find).with(@name).returns(@node)
+        end
+
+        it "should add the server's Puppet version to the node's parameters as 'serverversion'" do
+            @node.expects(:merge).with { |args| args["serverversion"] == "1" }
+            @compiler.find(@request)
+        end
+
+        it "should add the server's fqdn to the node's parameters as 'servername'" do
+            @node.expects(:merge).with { |args| args["servername"] == "my.server.com" }
+            @compiler.find(@request)
+        end
 
-        @compiler.interpreter.expects(:compile).with(@node).returns(result)
-        @compiler.find(@request).should equal(result)
+        it "should add the server's IP address to the node's parameters as 'serverip'" do
+            @node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" }
+            @compiler.find(@request)
+        end
     end
 
-    it "should benchmark the compile process" do
-        Puppet::Node.stubs(:find).returns(@node)
-        @compiler.stubs(:networked?).returns(true)
-        @compiler.expects(:benchmark).with do |level, message|
-            level == :notice and message =~ /^Compiled catalog/
+    describe "when filtering resources" do
+        before :each do
+            @compiler = Puppet::Resource::Catalog::Compiler.new
+            @catalog = stub_everything 'catalog'
+            @catalog.stubs(:respond_to?).with(:filter).returns(true)
+        end
+
+        it "should delegate to the catalog instance filtering" do
+            @catalog.expects(:filter)
+            @compiler.filter(@catalog)
+        end
+
+        it "should filter out virtual resources" do
+            resource = mock 'resource', :virtual? => true
+            @catalog.stubs(:filter).yields(resource)
+
+            @compiler.filter(@catalog)
+        end
+
+        it "should return the same catalog if it doesn't support filtering" do
+            @catalog.stubs(:respond_to?).with(:filter).returns(false)
+
+            @compiler.filter(@catalog).should == @catalog
         end
-        @compiler.interpreter.stubs(:compile).with(@node)
-        @compiler.find(@request)
+
+        it "should return the filtered catalog" do
+            catalog = stub 'filtered catalog'
+            @catalog.stubs(:filter).returns(catalog)
+
+            @compiler.filter(@catalog).should == catalog
+        end
+
     end
 end