puppet 0.25.5 → 2.6.0

data/spec/unit/indirector/key/ca_spec.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-3-7.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/key/ca'
+
+describe Puppet::SSL::Key::Ca do
+  it "should have documentation" do
+    Puppet::SSL::Key::Ca.doc.should be_instance_of(String)
+  end
+
+  it "should use the :privatekeydir as the collection directory" do
+    Puppet.settings.expects(:value).with(:privatekeydir).returns "/key/dir"
+    Puppet::SSL::Key::Ca.collection_directory.should == "/key/dir"
+  end
+
+  it "should store the ca key at the :cakey location" do
+    Puppet.settings.stubs(:use)
+    Puppet.settings.stubs(:value).returns "whatever"
+    Puppet.settings.stubs(:value).with(:cakey).returns "/ca/key"
+    file = Puppet::SSL::Key::Ca.new
+    file.stubs(:ca?).returns true
+    file.path("whatever").should == "/ca/key"
+  end
+end

data/spec/unit/indirector/key/file_spec.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-3-7.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/key/file'
+
+describe Puppet::SSL::Key::File do
+  it "should have documentation" do
+    Puppet::SSL::Key::File.doc.should be_instance_of(String)
+  end
+
+  it "should use the :privatekeydir as the collection directory" do
+    Puppet.settings.expects(:value).with(:privatekeydir).returns "/key/dir"
+    Puppet::SSL::Key::File.collection_directory.should == "/key/dir"
+  end
+
+  it "should store the ca key at the :cakey location" do
+    Puppet.settings.stubs(:use)
+    Puppet.settings.stubs(:value).returns "whatever"
+    Puppet.settings.stubs(:value).with(:cakey).returns "/ca/key"
+    file = Puppet::SSL::Key::File.new
+    file.stubs(:ca?).returns true
+    file.path("whatever").should == "/ca/key"
+  end
+
+  describe "when choosing the path for the public key" do
+    it "should use the :capub setting location if the key is for the certificate authority" do
+      Puppet.settings.stubs(:value).returns "/fake/dir"
+      Puppet.settings.stubs(:value).with(:capub).returns "/ca/pubkey"
+      Puppet.settings.stubs(:use)
+
+      @searcher = Puppet::SSL::Key::File.new
+      @searcher.stubs(:ca?).returns true
+      @searcher.public_key_path("whatever").should == "/ca/pubkey"
+    end
+
+    it "should use the host name plus '.pem' in :publickeydir for normal hosts" do
+      Puppet.settings.stubs(:value).with(:privatekeydir).returns "/private/key/dir"
+      Puppet.settings.stubs(:value).with(:publickeydir).returns "/public/key/dir"
+      Puppet.settings.stubs(:use)
+
+      @searcher = Puppet::SSL::Key::File.new
+      @searcher.stubs(:ca?).returns false
+      @searcher.public_key_path("whatever").should == "/public/key/dir/whatever.pem"
+    end
+  end
+
+  describe "when managing private keys" do
+    before do
+      @searcher = Puppet::SSL::Key::File.new
+
+      @private_key_path = File.join("/fake/key/path")
+      @public_key_path = File.join("/other/fake/key/path")
+
+      @searcher.stubs(:public_key_path).returns @public_key_path
+      @searcher.stubs(:path).returns @private_key_path
+
+      FileTest.stubs(:directory?).returns true
+      FileTest.stubs(:writable?).returns true
+
+      @public_key = stub 'public_key'
+      @real_key = stub 'sslkey', :public_key => @public_key
+
+      @key = stub 'key', :name => "myname", :content => @real_key
+
+      @request = stub 'request', :key => "myname", :instance => @key
+    end
+
+    it "should save the public key when saving the private key" do
+      Puppet.settings.stubs(:writesub)
+
+      fh = mock 'filehandle'
+
+      Puppet.settings.expects(:writesub).with(:publickeydir, @public_key_path).yields fh
+      @public_key.expects(:to_pem).returns "my pem"
+
+      fh.expects(:print).with "my pem"
+
+      @searcher.save(@request)
+    end
+
+    it "should destroy the public key when destroying the private key" do
+      File.stubs(:unlink).with(@private_key_path)
+      FileTest.stubs(:exist?).with(@private_key_path).returns true
+      FileTest.expects(:exist?).with(@public_key_path).returns true
+      File.expects(:unlink).with(@public_key_path)
+
+      @searcher.destroy(@request)
+    end
+
+    it "should not fail if the public key does not exist when deleting the private key" do
+      File.stubs(:unlink).with(@private_key_path)
+
+      FileTest.stubs(:exist?).with(@private_key_path).returns true
+      FileTest.expects(:exist?).with(@public_key_path).returns false
+      File.expects(:unlink).with(@public_key_path).never
+
+      @searcher.destroy(@request)
+    end
+  end
+end

data/spec/unit/indirector/ldap_spec.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/indirector/ldap'
+
+describe Puppet::Indirector::Ldap do
+  before do
+    @indirection = stub 'indirection', :name => :testing
+    Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
+    @ldap_class = Class.new(Puppet::Indirector::Ldap) do
+      def self.to_s
+        "Testing::Mytype"
+      end
+    end
+
+    @connection = mock 'ldap'
+
+    @searcher = @ldap_class.new
+  end
+
+  describe "when searching ldap" do
+    before do
+      # Stub everything, and we can selectively replace with an expect as
+      # we need to for testing.
+      @searcher.stubs(:connection).returns(@connection)
+      @searcher.stubs(:search_filter).returns(:filter)
+      @searcher.stubs(:search_base).returns(:base)
+      @searcher.stubs(:process)
+
+      @request = stub 'request', :key => "yay"
+    end
+
+    it "should call the ldapsearch method with the search filter" do
+      @searcher.expects(:search_filter).with("yay").returns("yay's filter")
+      @searcher.expects(:ldapsearch).with("yay's filter")
+      @searcher.find @request
+    end
+
+    it "should fail if no block is passed to the ldapsearch method" do
+      proc { @searcher.ldapsearch("blah") }.should raise_error(ArgumentError)
+    end
+
+    it "should use the results of the ldapbase method as the ldap search base" do
+      @searcher.stubs(:search_base).returns("mybase")
+      @connection.expects(:search).with do |*args|
+        args[0].should == "mybase"
+        true
+      end
+      @searcher.find @request
+    end
+
+    it "should default to the value of the :search_base setting as the result of the ldapbase method" do
+      Puppet.expects(:[]).with(:ldapbase).returns("myldapbase")
+      searcher = @ldap_class.new
+      searcher.search_base.should == "myldapbase"
+    end
+
+    it "should use the results of the :search_attributes method as the list of attributes to return" do
+      @searcher.stubs(:search_attributes).returns(:myattrs)
+      @connection.expects(:search).with do |*args|
+        args[3].should == :myattrs
+        true
+      end
+      @searcher.find @request
+    end
+
+    it "should use depth 2 when searching" do
+      @connection.expects(:search).with do |*args|
+        args[1].should == 2
+        true
+      end
+      @searcher.find @request
+    end
+
+    it "should call process() on the first found entry" do
+      @connection.expects(:search).yields("myresult")
+      @searcher.expects(:process).with("myresult")
+      @searcher.find @request
+    end
+
+    it "should reconnect and retry the search if there is a failure" do
+      run = false
+      @connection.stubs(:search).with do |*args|
+        if run
+          true
+        else
+          run = true
+          raise "failed"
+        end
+      end.yields("myresult")
+      @searcher.expects(:process).with("myresult")
+
+      @searcher.find @request
+    end
+
+    it "should not reconnect on failure more than once" do
+      count = 0
+      @connection.stubs(:search).with do |*args|
+        count += 1
+        raise ArgumentError, "yay"
+      end
+      proc { @searcher.find(@request) }.should raise_error(Puppet::Error)
+      count.should == 2
+    end
+
+    it "should return true if an entry is found" do
+      @connection.expects(:search).yields("result")
+      @searcher.ldapsearch("whatever") { |r| }.should be_true
+    end
+  end
+
+  describe "when connecting to ldap" do
+    confine "LDAP is not available" => Puppet.features.ldap?
+
+    it "should create and start a Util::Ldap::Connection instance" do
+      conn = mock 'connection', :connection => "myconn", :start => nil
+      Puppet::Util::Ldap::Connection.expects(:instance).returns conn
+
+      @searcher.connection.should == "myconn"
+    end
+
+    it "should only create the ldap connection when asked for it the first time" do
+      conn = mock 'connection', :connection => "myconn", :start => nil
+      Puppet::Util::Ldap::Connection.expects(:instance).returns conn
+
+      @searcher.connection
+    end
+
+    it "should cache the connection" do
+      conn = mock 'connection', :connection => "myconn", :start => nil
+      Puppet::Util::Ldap::Connection.expects(:instance).returns conn
+
+      @searcher.connection.should equal(@searcher.connection)
+    end
+  end
+
+  describe "when reconnecting to ldap" do
+    confine "Not running on culain as root" => (Puppet.features.root? and Facter.value("hostname") == "culain")
+
+    it "should reconnect to ldap when connections are lost"
+  end
+end

data/spec/unit/indirector/memory_spec.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/indirector/memory'
+
+require 'shared_behaviours/memory_terminus'
+
+describe Puppet::Indirector::Memory do
+  it_should_behave_like "A Memory Terminus"
+
+  before do
+    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)
+
+    @memory_class = Class.new(Puppet::Indirector::Memory) do
+      def self.to_s
+        "Mystuff::Testing"
+      end
+    end
+
+    @searcher = @memory_class.new
+    @name = "me"
+    @instance = stub 'instance', :name => @name
+
+    @request = stub 'request', :key => @name, :instance => @instance
+  end
+end

data/spec/unit/indirector/node/active_record_spec.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/node'
+require 'spec/lib/puppet_spec/files.rb'
+
+describe "Puppet::Node::ActiveRecord" do
+  include PuppetSpec::Files
+
+  confine "Missing Rails" => Puppet.features.rails?
+  confine "Missing sqlite" => Puppet.features.sqlite?
+  before do
+    require 'puppet/indirector/node/active_record'
+  end
+
+  it "should be a subclass of the ActiveRecord terminus class" do
+    Puppet::Node::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
+  end
+
+  it "should use Puppet::Rails::Host as its ActiveRecord model" do
+    Puppet::Node::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
+  end
+
+  it "should call fact_merge when a node is found" do
+    db_instance = stub 'db_instance'
+    Puppet::Node::ActiveRecord.ar_model.expects(:find_by_name).returns db_instance
+
+    node = Puppet::Node.new("foo")
+    db_instance.expects(:to_puppet).returns node
+
+    Puppet[:statedir] = tmpdir('active_record_tmp')
+    Puppet[:railslog] = '$statedir/rails.log'
+    ar = Puppet::Node::ActiveRecord.new
+
+    node.expects(:fact_merge)
+
+    request = Puppet::Indirector::Request.new(:node, :find, "what.ever")
+    ar.find(request)
+  end
+end

data/spec/unit/indirector/node/exec_spec.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/node/exec'
+
+describe Puppet::Node::Exec do
+  before do
+    @indirection = mock 'indirection'
+    Puppet.settings.stubs(:value).with(:external_nodes).returns("/echo")
+    @searcher = Puppet::Node::Exec.new
+  end
+
+  describe "when constructing the command to run" do
+    it "should use the external_node script as the command" do
+      Puppet.expects(:[]).with(:external_nodes).returns("/bin/echo")
+      @searcher.command.should == %w{/bin/echo}
+    end
+
+    it "should throw an exception if no external node command is set" do
+      Puppet.expects(:[]).with(:external_nodes).returns("none")
+      proc { @searcher.find(stub('request', :key => "foo")) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "when handling the results of the command" do
+    before do
+      @name = "yay"
+      @node = Puppet::Node.new(@name)
+      @node.stubs(:fact_merge)
+      Puppet::Node.expects(:new).with(@name).returns(@node)
+      @result = {}
+      # Use a local variable so the reference is usable in the execute definition.
+      result = @result
+      @searcher.meta_def(:execute) do |command|
+        return YAML.dump(result)
+      end
+
+      @request = stub 'request', :key => @name
+    end
+
+    it "should translate the YAML into a Node instance" do
+      # Use an empty hash
+      @searcher.find(@request).should equal(@node)
+    end
+
+    it "should set the resulting parameters as the node parameters" do
+      @result[:parameters] = {"a" => "b", "c" => "d"}
+      @searcher.find(@request)
+      @node.parameters.should == {"a" => "b", "c" => "d"}
+    end
+
+    it "should set the resulting classes as the node classes" do
+      @result[:classes] = %w{one two}
+      @searcher.find(@request)
+      @node.classes.should == [ 'one', 'two' ]
+    end
+
+    it "should merge the node's facts with its parameters" do
+      @node.expects(:fact_merge)
+      @searcher.find(@request)
+    end
+
+    it "should set the node's environment if one is provided" do
+      @result[:environment] = "yay"
+      @searcher.find(@request)
+      @node.environment.to_s.should == 'yay'
+    end
+  end
+end

data/spec/unit/indirector/node/ldap_spec.rb

@@ -0,0 +1,456 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/node/ldap'
+
+describe Puppet::Node::Ldap do
+  before do
+    Puppet::Node::Facts.stubs(:terminus_class).returns :yaml
+  end
+
+  describe "when searching for a single node" do
+    before :each do
+      @searcher = Puppet::Node::Ldap.new
+
+      @name = "mynode.domain.com"
+      @node = stub 'node', :name => @name, :name= => nil
+      @node.stub_everything
+
+      Puppet::Node.stubs(:new).returns(@node)
+
+      @request = stub 'request', :key => @name
+    end
+
+    it "should convert the hostname into a search filter" do
+      entry = stub 'entry', :dn => 'cn=mynode.domain.com,ou=hosts,dc=madstop,dc=com', :vals => %w{}, :to_hash => {"environment" => 'production'}
+      @searcher.expects(:ldapsearch).with("(&(objectclass=puppetClient)(cn=#{@name}))").yields entry
+      @searcher.name2hash(@name, 'production', 'parent')
+    end
+
+    it "should convert any found entry into a hash" do
+      entry = stub 'entry', :dn => 'cn=mynode.domain.com,ou=hosts,dc=madstop,dc=com', :vals => %w{}, :to_hash => {"environment" => 'production'}
+      @searcher.expects(:ldapsearch).with("(&(objectclass=puppetClient)(cn=#{@name}))").yields entry
+      myhash = {"myhash" => true, :environment => 'production'}
+      @searcher.expects(:entry2hash).with(entry).returns myhash
+      @searcher.name2hash(@name, 'production', 'parent').should == myhash
+    end
+
+    # This heavily tests our entry2hash method, so we don't have to stub out the stupid entry information any more.
+    describe "when an ldap entry is found" do
+      before do
+        @entry = stub 'entry', :dn => 'cn=mynode,ou=hosts,dc=madstop,dc=com', :vals => %w{}, :to_hash => {}
+        @searcher.stubs(:ldapsearch).yields @entry
+      end
+
+      it "should convert the entry to a hash" do
+        @searcher.entry2hash(@entry).should be_instance_of(Hash)
+      end
+
+      it "should add the entry's common name to the hash if fqdn if false" do
+        @searcher.entry2hash(@entry,fqdn = false)[:name].should == "mynode"
+      end
+
+      it "should add the entry's fqdn name to the hash if fqdn if true" do
+        @searcher.entry2hash(@entry,fqdn = true)[:name].should == "mynode.madstop.com"
+      end
+
+      it "should add all of the entry's classes to the hash" do
+        @entry.stubs(:vals).with("puppetclass").returns %w{one two}
+        @searcher.entry2hash(@entry)[:classes].should == %w{one two}
+      end
+
+      it "should deduplicate class values" do
+        @entry.stubs(:to_hash).returns({})
+        @searcher.stubs(:class_attributes).returns(%w{one two})
+        @entry.stubs(:vals).with("one").returns(%w{a b})
+        @entry.stubs(:vals).with("two").returns(%w{b c})
+        @searcher.entry2hash(@entry)[:classes].should == %w{a b c}
+      end
+
+      it "should add the entry's environment to the hash" do
+        @entry.stubs(:to_hash).returns("environment" => %w{production})
+        @searcher.entry2hash(@entry)[:environment].should == "production"
+      end
+
+      it "should add all stacked parameters as parameters in the hash" do
+        @entry.stubs(:vals).with("puppetvar").returns(%w{one=two three=four})
+        result = @searcher.entry2hash(@entry)
+        result[:parameters]["one"].should == "two"
+        result[:parameters]["three"].should == "four"
+      end
+
+      it "should not add the stacked parameter as a normal parameter" do
+        @entry.stubs(:vals).with("puppetvar").returns(%w{one=two three=four})
+        @entry.stubs(:to_hash).returns("puppetvar" => %w{one=two three=four})
+        @searcher.entry2hash(@entry)[:parameters]["puppetvar"].should be_nil
+      end
+
+      it "should add all other attributes as parameters in the hash" do
+        @entry.stubs(:to_hash).returns("foo" => %w{one two})
+        @searcher.entry2hash(@entry)[:parameters]["foo"].should == %w{one two}
+      end
+
+      it "should return single-value parameters as strings, not arrays" do
+        @entry.stubs(:to_hash).returns("foo" => %w{one})
+        @searcher.entry2hash(@entry)[:parameters]["foo"].should == "one"
+      end
+
+      it "should convert 'true' values to the boolean 'true'" do
+        @entry.stubs(:to_hash).returns({"one" => ["true"]})
+        @searcher.entry2hash(@entry)[:parameters]["one"].should == true
+      end
+
+      it "should convert 'false' values to the boolean 'false'" do
+        @entry.stubs(:to_hash).returns({"one" => ["false"]})
+        @searcher.entry2hash(@entry)[:parameters]["one"].should == false
+      end
+
+      it "should convert 'true' values to the boolean 'true' inside an array" do
+        @entry.stubs(:to_hash).returns({"one" => ["true", "other"]})
+        @searcher.entry2hash(@entry)[:parameters]["one"].should == [true, "other"]
+      end
+
+      it "should convert 'false' values to the boolean 'false' inside an array" do
+        @entry.stubs(:to_hash).returns({"one" => ["false", "other"]})
+        @searcher.entry2hash(@entry)[:parameters]["one"].should == [false, "other"]
+      end
+
+      it "should add the parent's name if present" do
+        @entry.stubs(:vals).with("parentnode").returns(%w{foo})
+        @searcher.entry2hash(@entry)[:parent].should == "foo"
+      end
+
+      it "should fail if more than one parent is specified" do
+        @entry.stubs(:vals).with("parentnode").returns(%w{foo})
+        @searcher.entry2hash(@entry)[:parent].should == "foo"
+      end
+    end
+
+    it "should search first for the provided key" do
+      @searcher.expects(:name2hash).with("mynode.domain.com", 'production', 'child').returns({})
+      @searcher.find(@request)
+    end
+
+    it "should search for the short version of the provided key if the key looks like a hostname and no results are found for the key itself" do
+      @searcher.expects(:name2hash).with("mynode.domain.com", 'production', 'child').returns(nil)
+      @searcher.expects(:name2hash).with("mynode", 'production', 'child').returns({})
+      @searcher.find(@request)
+    end
+
+    it "should search for default information if no information can be found for the key" do
+      @searcher.expects(:name2hash).with("mynode.domain.com", 'production', 'child').returns(nil)
+      @searcher.expects(:name2hash).with("mynode", 'production', 'child').returns(nil)
+      @searcher.expects(:name2hash).with("default", 'production', 'child').returns({})
+      @searcher.find(@request)
+    end
+
+    it "should return nil if no results are found in ldap" do
+      @searcher.stubs(:name2hash).returns nil
+      @searcher.find(@request).should be_nil
+    end
+
+    it "should return a node object if results are found in ldap" do
+      @searcher.stubs(:name2hash).returns({})
+      @searcher.find(@request).should equal(@node)
+    end
+
+    describe "and node information is found in LDAP" do
+      before do
+        @result = {}
+        @searcher.stubs(:name2hash).returns @result
+      end
+
+      it "should create the node with the correct name, even if it was found by a different name" do
+        @searcher.expects(:name2hash).with("mynode.domain.com", 'production', 'child').returns nil
+        @searcher.expects(:name2hash).with("mynode", 'production', 'child').returns @result
+
+        Puppet::Node.expects(:new).with("mynode.domain.com").returns @node
+        @searcher.find(@request)
+      end
+
+      it "should add any classes from ldap" do
+        @result[:classes] = %w{a b c d}
+        @node.expects(:classes=).with(%w{a b c d})
+        @searcher.find(@request)
+      end
+
+      it "should add all entry attributes as node parameters" do
+        @result[:parameters] = {"one" => "two", "three" => "four"}
+        @node.expects(:parameters=).with("one" => "two", "three" => "four")
+        @searcher.find(@request)
+      end
+
+      it "should set the node's environment to the environment of the results" do
+        @result[:environment] = "test"
+        @node.expects(:environment=).with("test")
+        @searcher.find(@request)
+      end
+
+      it "should retain false parameter values" do
+        @result[:parameters] = {}
+        @result[:parameters]["one"] = false
+        @node.expects(:parameters=).with("one" => false)
+        @searcher.find(@request)
+      end
+
+      it "should merge the node's facts after the parameters from ldap are assigned" do
+        # Make sure we've got data to start with, so the parameters are actually set.
+        @result[:parameters] = {}
+        @result[:parameters]["one"] = "yay"
+
+        # A hackish way to enforce order.
+        set = false
+        @node.expects(:parameters=).with { |*args| set = true }
+        @node.expects(:fact_merge).with { |*args| raise "Facts were merged before parameters were set" unless set; true }
+
+        @searcher.find(@request)
+      end
+
+      describe "and a parent node is specified" do
+        before do
+          @entry = {:classes => [], :parameters => {}}
+          @parent = {:classes => [], :parameters => {}}
+          @parent_parent = {:classes => [], :parameters => {}}
+
+          @searcher.stubs(:name2hash).with{|name, env, mode| name == @name}.returns(@entry)
+          @searcher.stubs(:name2hash).with{|name, env, mode| name == 'parent'}.returns(@parent)
+          @searcher.stubs(:name2hash).with{|name, env, mode| name == 'parent_parent'}.returns(@parent_parent)
+
+          @searcher.stubs(:parent_attribute).returns(:parent)
+        end
+
+        it "should search for the parent node" do
+          @entry[:parent] = "parent"
+
+          @searcher.find(@request)
+        end
+
+        it "should fail if the parent cannot be found" do
+          @entry[:parent] = "parent"
+
+          @searcher.expects(:name2hash).with('parent', 'production', 'parent').returns nil
+
+          proc { @searcher.find(@request) }.should raise_error(Puppet::Error)
+        end
+
+        it "should add any parent classes to the node's classes" do
+          @entry[:parent] = "parent"
+          @entry[:classes] = %w{a b}
+
+          @parent[:classes] = %w{c d}
+
+          @node.expects(:classes=).with(%w{a b c d})
+          @searcher.find(@request)
+        end
+
+        it "should add any parent parameters to the node's parameters" do
+          @entry[:parent] = "parent"
+          @entry[:parameters]["one"] = "two"
+
+          @parent[:parameters]["three"] = "four"
+
+          @node.expects(:parameters=).with("one" => "two", "three" => "four")
+          @searcher.find(@request)
+        end
+
+        it "should prefer node parameters over parent parameters" do
+          @entry[:parent] = "parent"
+          @entry[:parameters]["one"] = "two"
+
+          @parent[:parameters]["one"] = "three"
+
+          @node.expects(:parameters=).with("one" => "two")
+          @searcher.find(@request)
+        end
+
+        it "should use the parent's environment if the node has none" do
+          @entry[:parent] = "parent"
+
+          @parent[:environment] = "parent"
+
+          @node.stubs(:parameters=)
+          @node.expects(:environment=).with("parent")
+          @searcher.find(@request)
+        end
+
+        it "should prefer the node's environment to the parent's" do
+          @entry[:parent] = "parent"
+          @entry[:environment] = "child"
+
+          @parent[:environment] = "parent"
+
+          @node.stubs(:parameters=)
+          @node.expects(:environment=).with("child")
+          @searcher.find(@request)
+        end
+
+        it "should recursively look up parent information" do
+          @entry[:parent] = "parent"
+          @entry[:parameters]["one"] = "two"
+
+          @parent[:parent] = "parent_parent"
+          @parent[:parameters]["three"] = "four"
+
+          @parent_parent[:parameters]["five"] = "six"
+
+          @node.expects(:parameters=).with("one" => "two", "three" => "four", "five" => "six")
+          @searcher.find(@request)
+        end
+
+        it "should not allow loops in parent declarations" do
+          @entry[:parent] = "parent"
+          @parent[:parent] = @name
+          proc { @searcher.find(@request) }.should raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  describe "when searching for multiple nodes" do
+    before :each do
+      @searcher = Puppet::Node::Ldap.new
+      @options = {}
+      @request = stub 'request', :key => "foo", :options => @options
+
+      Puppet::Node::Facts.stubs(:terminus_class).returns :yaml
+    end
+
+    it "should find all nodes if no arguments are provided" do
+      @searcher.expects(:ldapsearch).with("(objectclass=puppetClient)")
+      # LAK:NOTE The search method requires an essentially bogus key.  It's
+      # an API problem that I don't really know how to fix.
+      @searcher.search @request
+    end
+
+    describe "and a class is specified" do
+      it "should find all nodes that are members of that class" do
+        @searcher.expects(:ldapsearch).with("(&(objectclass=puppetClient)(puppetclass=one))")
+
+        @options[:class] = "one"
+        @searcher.search @request
+      end
+    end
+
+    describe "multiple classes are specified" do
+      it "should find all nodes that are members of all classes" do
+        @searcher.expects(:ldapsearch).with("(&(objectclass=puppetClient)(puppetclass=one)(puppetclass=two))")
+        @options[:class] = %w{one two}
+        @searcher.search @request
+      end
+    end
+
+    it "should process each found entry" do
+      # .yields can't be used to yield multiple values :/
+      @searcher.expects(:ldapsearch).yields("one")
+      @searcher.expects(:entry2hash).with("one",nil).returns(:name => "foo")
+      @searcher.search @request
+    end
+
+    it "should return a node for each processed entry with the name from the entry" do
+      @searcher.expects(:ldapsearch).yields("whatever")
+      @searcher.expects(:entry2hash).with("whatever",nil).returns(:name => "foo")
+      result = @searcher.search(@request)
+      result[0].should be_instance_of(Puppet::Node)
+      result[0].name.should == "foo"
+    end
+
+    it "should merge each node's facts" do
+      node = mock 'node'
+      Puppet::Node.expects(:new).with("foo").returns node
+      node.expects(:fact_merge)
+      @searcher.stubs(:ldapsearch).yields("one")
+      @searcher.stubs(:entry2hash).with("one",nil).returns(:name => "foo")
+      @searcher.search(@request)
+    end
+
+    it "should pass the request's fqdn option to entry2hash" do
+      node = mock 'node'
+      @options[:fqdn] = :hello
+      Puppet::Node.stubs(:new).with("foo").returns node
+      node.stubs(:fact_merge)
+      @searcher.stubs(:ldapsearch).yields("one")
+      @searcher.expects(:entry2hash).with("one",:hello).returns(:name => "foo")
+      @searcher.search(@request)
+    end
+  end
+end
+
+describe Puppet::Node::Ldap, " when developing the search query" do
+  before do
+    @searcher = Puppet::Node::Ldap.new
+  end
+
+  it "should return the value of the :ldapclassattrs split on commas as the class attributes" do
+    Puppet.stubs(:[]).with(:ldapclassattrs).returns("one,two")
+    @searcher.class_attributes.should == %w{one two}
+  end
+
+  it "should return nil as the parent attribute if the :ldapparentattr is set to an empty string" do
+    Puppet.stubs(:[]).with(:ldapparentattr).returns("")
+    @searcher.parent_attribute.should be_nil
+  end
+
+  it "should return the value of the :ldapparentattr as the parent attribute" do
+    Puppet.stubs(:[]).with(:ldapparentattr).returns("pere")
+    @searcher.parent_attribute.should == "pere"
+  end
+
+  it "should use the value of the :ldapstring as the search filter" do
+    Puppet.stubs(:[]).with(:ldapstring).returns("mystring")
+    @searcher.search_filter("testing").should == "mystring"
+  end
+
+  it "should replace '%s' with the node name in the search filter if it is present" do
+    Puppet.stubs(:[]).with(:ldapstring).returns("my%sstring")
+    @searcher.search_filter("testing").should == "mytestingstring"
+  end
+
+  it "should not modify the global :ldapstring when replacing '%s' in the search filter" do
+    filter = mock 'filter'
+    filter.expects(:include?).with("%s").returns(true)
+    filter.expects(:gsub).with("%s", "testing").returns("mynewstring")
+    Puppet.stubs(:[]).with(:ldapstring).returns(filter)
+    @searcher.search_filter("testing").should == "mynewstring"
+  end
+end
+
+describe Puppet::Node::Ldap, " when deciding attributes to search for" do
+  before do
+    @searcher = Puppet::Node::Ldap.new
+  end
+
+  it "should use 'nil' if the :ldapattrs setting is 'all'" do
+    Puppet.stubs(:[]).with(:ldapattrs).returns("all")
+    @searcher.search_attributes.should be_nil
+  end
+
+  it "should split the value of :ldapattrs on commas and use the result as the attribute list" do
+    Puppet.stubs(:[]).with(:ldapattrs).returns("one,two")
+    @searcher.stubs(:class_attributes).returns([])
+    @searcher.stubs(:parent_attribute).returns(nil)
+    @searcher.search_attributes.should == %w{one two}
+  end
+
+  it "should add the class attributes to the search attributes if not returning all attributes" do
+    Puppet.stubs(:[]).with(:ldapattrs).returns("one,two")
+    @searcher.stubs(:class_attributes).returns(%w{three four})
+    @searcher.stubs(:parent_attribute).returns(nil)
+    # Sort them so i don't have to care about return order
+    @searcher.search_attributes.sort.should == %w{one two three four}.sort
+  end
+
+  it "should add the parent attribute to the search attributes if not returning all attributes" do
+    Puppet.stubs(:[]).with(:ldapattrs).returns("one,two")
+    @searcher.stubs(:class_attributes).returns([])
+    @searcher.stubs(:parent_attribute).returns("parent")
+    @searcher.search_attributes.sort.should == %w{one two parent}.sort
+  end
+
+  it "should not add nil parent attributes to the search attributes" do
+    Puppet.stubs(:[]).with(:ldapattrs).returns("one,two")
+    @searcher.stubs(:class_attributes).returns([])
+    @searcher.stubs(:parent_attribute).returns(nil)
+    @searcher.search_attributes.should == %w{one two}
+  end
+end