treequel 1.0.0

data/spec/treequel/branchcollection_spec.rb

@@ -0,0 +1,213 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+
+	libdir = basedir + "lib"
+
+	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+}
+
+begin
+	require 'spec'
+	require 'spec/lib/constants'
+	require 'spec/lib/helpers'
+
+	require 'treequel/branchcollection'
+rescue LoadError
+	unless Object.const_defined?( :Gem )
+		require 'rubygems'
+		retry
+	end
+	raise
+end
+
+
+include Treequel::TestConstants
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Treequel::BranchCollection do
+	include Treequel::SpecHelpers
+
+	before( :all ) do
+		setup_logging( :debug )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+	before( :each ) do
+		@directory = mock( "treequel directory ")
+	end
+
+	it "can be instantiated without any branchsets" do
+		collection = Treequel::BranchCollection.new
+		collection.all.should == []
+	end
+
+	it "can be instantiated with one or more branchsets" do
+		branchset1 = stub( "branchset 1", :dn => 'cn=example1,dc=acme,dc=com', :each => 1 )
+		branchset2 = stub( "branchset 2", :dn => 'cn=example2,dc=acme,dc=com', :each => 1 )
+
+		collection = Treequel::BranchCollection.new( branchset1, branchset2 )
+
+		collection.branchsets.should include( branchset1, branchset2 )
+	end
+
+	it "wraps any object that doesn't have an #each in a Branchset" do
+		non_branchset1 = stub( "non-branchset 1" )
+		non_branchset2 = stub( "non-branchset 2" )
+		branchset1 = stub( "branchset 1", :dn => 'cn=example1,dc=acme,dc=com' )
+		branchset2 = stub( "branchset 2", :dn => 'cn=example2,dc=acme,dc=com' )
+
+		Treequel::Branchset.should_receive( :new ).with( non_branchset1 ).
+			and_return( branchset1 )
+		Treequel::Branchset.should_receive( :new ).with( non_branchset2 ).
+			and_return( branchset2 )
+
+		collection = Treequel::BranchCollection.new( non_branchset1, non_branchset2 )
+
+		collection.branchsets.should include( branchset1, branchset2 )
+	end
+
+	it "allows new Branchsets to be appended to it" do
+		branchset1 = mock( "branchset 1" )
+		branchset2 = mock( "branchset 2" )
+
+		collection = Treequel::BranchCollection.new
+		collection << branchset1 << branchset2
+
+		collection.should include( branchset1, branchset2 )
+	end
+
+	it "allows new Branches to be appended to it" do
+		branch1 = mock( "branch 1", :branchset => :branchset1 )
+		branch2 = mock( "branch 2", :branchset => :branchset2 )
+
+		collection = Treequel::BranchCollection.new
+		collection << branch1 << branch2
+
+		collection.should include( :branchset1, :branchset2 )
+	end
+
+
+	describe "instance with two Branchsets" do
+
+		before( :each ) do
+			@branchset1 = mock( "branchset 1", :dn => 'cn=example1,dc=acme,dc=com', :each => 1 )
+			@branchset2 = mock( "branchset 2", :dn => 'cn=example2,dc=acme,dc=com', :each => 1 )
+
+			@collection = Treequel::BranchCollection.new( @branchset1, @branchset2 )
+		end
+
+		it "fetches all of the results from each of its branchsets if asked for all results" do
+			@branchset1.should_receive( :each ).and_yield( :bs1_stuff )
+			@branchset2.should_receive( :each ).and_yield( :bs2_stuff )
+
+			@collection.all.should == [ :bs1_stuff, :bs2_stuff ]
+		end
+
+		it "fetches the first Branch returned by any of its branchsets when asked" do
+			@branchset1.should_receive( :first ).and_return( nil )
+			@branchset2.should_receive( :first ).and_return( :a_branch )
+
+			@collection.first.should == :a_branch
+		end
+
+		it "returns a clone of itself with an additional Branchset if a Branchset is added to it" do
+			branchset3 = mock( "branchset 3", :dn => 'cn=example3,dc=acme,dc=com', :each => 1 )
+			new_collection = @collection + branchset3
+
+			new_collection.should be_an_instance_of( Treequel::BranchCollection )
+			new_collection.should include( @branchset1, @branchset2, branchset3 )
+		end
+
+		it "returns a clone of itself with an additional Branchset if a Branch is added to it" do
+			branchset3 = mock( "branchset 3", :dn => 'cn=example3,dc=acme,dc=com', :each => 1 )
+			branch3 = mock( "branch 3", :branchset => branchset3 )
+			new_collection = @collection + branch3
+
+			new_collection.should be_an_instance_of( Treequel::BranchCollection )
+			new_collection.should include( @branchset1, @branchset2, branchset3 )
+		end
+
+		it "returns a clone of itself with both collections' Branchsets if a BranchCollection is " +
+		   "added to it" do
+			branchset3 = stub( "branchset 3", :dn => 'cn=example3,dc=acme,dc=com', :each => 1 )
+			branchset4 = stub( "branchset 4", :dn => 'cn=example4,dc=acme,dc=com', :each => 1 )
+			other_collection = Treequel::BranchCollection.new( branchset3, branchset4 )
+
+			new_collection = @collection + other_collection
+
+			new_collection.should be_an_instance_of( Treequel::BranchCollection )
+			new_collection.should include( @branchset1, @branchset2, branchset3, branchset4 )
+		end
+
+		it "returns a new BranchCollection with the union of Branchsets if it is ORed with " +
+		   "another BranchCollection" do
+			branchset3 = stub( "branchset 3", :dn => 'cn=example3,dc=acme,dc=com', :each => 1 )
+			branchset4 = stub( "branchset 4", :dn => 'cn=example4,dc=acme,dc=com', :each => 1 )
+			other_collection = Treequel::BranchCollection.new( branchset3, branchset4 )
+
+			new_collection = @collection | other_collection
+
+			new_collection.should be_an_instance_of( Treequel::BranchCollection )
+			new_collection.should include( @branchset1, @branchset2, branchset3, branchset4 )
+		end
+
+		it "returns a new BranchCollection with the intersection of Branchsets if it is ANDed with " +
+		   "another BranchCollection" do
+			branchset3 = stub( "branchset 3", :dn => 'cn=example3,dc=acme,dc=com', :each => 1 )
+			branchset4 = stub( "branchset 4", :dn => 'cn=example4,dc=acme,dc=com', :each => 1 )
+			other_collection = Treequel::BranchCollection.new( @branchset2, branchset3, branchset4 )
+			@collection << branchset4
+
+			new_collection = @collection & other_collection
+
+			new_collection.should be_an_instance_of( Treequel::BranchCollection )
+			new_collection.should include( @branchset2, branchset4 )
+		end
+
+		it "can create a clone of itself with filtered branchsets" do
+			filtered_branchset1 = stub( "branchset 3", :dn => 'cn=example3,dc=acme,dc=com', :each => 1 )
+			filtered_branchset2 = stub( "branchset 4", :dn => 'cn=example4,dc=acme,dc=com', :each => 1 )
+			@branchset1.should_receive( :filter ).with( :cn => 'chunkalicious' ).
+				and_return( filtered_branchset1 )
+			@branchset2.should_receive( :filter ).with( :cn => 'chunkalicious' ).
+				and_return( filtered_branchset2 )
+
+			filtered_collection = @collection.filter( :cn => 'chunkalicious' )
+			filtered_collection.should_not be_equal( @collection )
+			filtered_collection.should include( filtered_branchset1, filtered_branchset2 )
+		end
+
+		# it "can create a clone of itself with ordered branchsets" do
+		# 	ordered_branchset1 = stub( "branchset 3", :dn => 'cn=example3,dc=acme,dc=com', :each => 1 )
+		# 	ordered_branchset2 = stub( "branchset 4", :dn => 'cn=example4,dc=acme,dc=com', :each => 1 )
+		# 	@branchset1.should_receive( :order ).with( :cn ).
+		# 		and_return( ordered_branchset1 )
+		# 	@branchset2.should_receive( :order ).with( :cn ).
+		# 		and_return( ordered_branchset2 )
+		# 
+		# 	ordered_collection = @collection.order( :cn )
+		# 	ordered_collection.should_not be_equal( @collection )
+		# 	ordered_collection.should include( ordered_branchset1, ordered_branchset2 )
+		# end
+		# 
+		it "can return the base DNs of all of its branchsets" do
+			@branchset1.should_receive( :base_dn ).and_return( :branchset1_basedn )
+			@branchset2.should_receive( :base_dn ).and_return( :branchset2_basedn )
+			@collection.base_dns.should == [ :branchset1_basedn, :branchset2_basedn ]
+		end
+
+	end
+
+end
+
+
+# vim: set nosta noet ts=4 sw=4:

data/spec/treequel/branchset_spec.rb

@@ -0,0 +1,376 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+
+	libdir = basedir + "lib"
+
+	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+}
+
+begin
+	require 'spec'
+	require 'spec/lib/constants'
+	require 'spec/lib/helpers'
+
+	require 'treequel/branchset'
+rescue LoadError
+	unless Object.const_defined?( :Gem )
+		require 'rubygems'
+		retry
+	end
+	raise
+end
+
+
+include Treequel::TestConstants
+include Treequel::Constants
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Treequel::Branchset do
+	include Treequel::SpecHelpers
+
+	class << self
+		alias_method :they, :it
+	end
+
+	DEFAULT_PARAMS = {
+		:limit       => 0,
+		:selectattrs => [],
+		:timeout     => 0,
+	}
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+	before( :each ) do
+		@directory = mock( "treequel directory ")
+		@branch = mock( "treequel branch", :dn => 'thedn' )
+		@params = DEFAULT_PARAMS.dup
+	end
+
+
+	describe "instances" do
+		before( :each ) do
+			@branchset = Treequel::Branchset.new( @branch )
+		end
+
+		they "are Enumerable" do
+			resultbranch = mock( "Result Branch" )
+
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter, @params ).
+				and_yield( resultbranch )
+			resultbranch.should_receive( :dn ).and_return( :its_dn )
+
+			@branchset.all? {|b| b.dn }
+		end
+
+		# 
+		# #map
+		# 
+		they "can be mapped into an Array of attribute values" do
+			resultbranch = mock( "Result Branch" )
+			resultbranch2 = mock( "Result Branch 2" )
+
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter, @params ).
+				and_yield( resultbranch ).and_yield( resultbranch2 )
+			resultbranch.should_receive( :[] ).with( :cn ).and_return([ :first_cn ])
+			resultbranch2.should_receive( :[] ).with( :cn ).and_return([ :second_cn ])
+
+			@branchset.map( :cn ).should == [[:first_cn], [:second_cn]]
+		end
+
+
+		# 
+		# #to_hash
+		# 
+		they "can be mapped into a Hash of entries keyed by one of their attributes" do
+			resultbranch = mock( "Result Branch" )
+			resultbranch2 = mock( "Result Branch 2" )
+
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter, @params ).
+				and_yield( resultbranch ).and_yield( resultbranch2 )
+
+			resultbranch.should_receive( :[] ).with( :email ).
+				and_return([ :first_email ])
+			resultbranch.should_receive( :entry ).and_return( :entry1 )
+			resultbranch2.should_receive( :[] ).with( :email ).
+				and_return([ :second_email, :second_second_email ])
+			resultbranch2.should_receive( :entry ).and_return( :entry2 )
+
+			@branchset.to_hash( :email ).should == {
+				:first_email => :entry1,
+				:second_email => :entry2,
+			}
+		end
+
+
+		they "can be mapped into a Hash of tuples using two attributes" do
+			resultbranch = mock( "Result Branch" )
+			resultbranch2 = mock( "Result Branch 2" )
+
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter, @params ).
+				and_yield( resultbranch ).and_yield( resultbranch2 )
+
+			resultbranch.should_receive( :[] ).with( :email ).
+				and_return([ :first_email ])
+			resultbranch.should_receive( :[] ).with( :cn ).
+				and_return([ :first_cn ])
+			resultbranch2.should_receive( :[] ).with( :email ).
+				and_return([ :second_email, :second_second_email ])
+			resultbranch2.should_receive( :[] ).with( :cn ).
+				and_return([ :second_cn, :second_second_cn ])
+
+			@branchset.to_hash( :email, :cn ).should == {
+				:first_email => :first_cn,
+				:second_email => :second_cn,
+			}
+		end
+	end
+
+	describe "instance with no filter, options, or scope set" do
+
+		before( :each ) do
+			@branchset = Treequel::Branchset.new( @branch )
+		end
+
+		it "can clone itself with merged options" do
+			newset = @branchset.clone( :scope => :one )
+			newset.should be_a( Treequel::Branchset )
+			newset.should_not equal( @branchset )
+			newset.options.should_not equal( @branchset.options )
+			newset.scope.should == :one
+		end
+
+
+		# 
+		# #filter
+		# 
+
+		it "generates a valid filter string" do
+			@branchset.filter_string.should == '(objectClass=*)'
+		end
+
+
+		it "performs a search using the default filter and scope when all records are requested" do
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter, @params ).
+				and_yield( :matching_branches )
+
+			@branchset.all.should == [ :matching_branches ]
+		end
+
+		it "performs a search using the default filter, scope, and a limit of 1 when the first " +
+		   "record is requested" do
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter,
+				      @params.merge(:limit => 1) ).
+				and_return( [:first_matching_branch, :other_branches] )
+
+			@branchset.first.should == :first_matching_branch
+		end
+
+		it "creates a new branchset cloned from itself with the specified filter" do
+			newset = @branchset.filter( :clothing, 'pants' )
+			newset.filter_string.should == '(clothing=pants)'
+		end
+
+		# 
+		# #scope
+		# 
+
+		it "provides a reader for its scope" do
+			@branchset.scope.should == :subtree
+		end
+
+		it "can return the DN of its base" do
+			@branch.should_receive( :dn ).and_return( :foo )
+			@branchset.base_dn.should == :foo
+		end
+
+		it "can create a new branchset cloned from itself with a different scope" do
+			newset = @branchset.scope( :onelevel )
+			newset.should be_a( Treequel::Branchset )
+			newset.should_not equal( @branchset )
+			newset.options.should_not equal( @branchset.options )
+			newset.scope.should == :onelevel
+		end
+
+		it "can create a new branchset cloned from itself with a different string scope" do
+			newset = @branchset.scope( 'sub' )
+			newset.scope.should == :sub
+		end
+
+		it "uses its scope setting as the scope to use when searching" do
+			@branchset.options[:scope] = :onelevel
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, :onelevel, @branchset.filter, @params ).
+				and_yield( :matching_branches )
+
+			@branchset.all.should == [:matching_branches]
+		end
+
+		# 
+		# #select
+		# 
+		it "can create a new branchset cloned from itself with an attribute selection" do
+			newset = @branchset.select( :l, :lastName, :disabled )
+			newset.select.should == [ 'l', 'lastName', 'disabled' ]
+		end
+
+		it "can create a new branchset cloned from itself with all attributes selected" do
+			newset = @branchset.select_all
+			newset.select.should == []
+		end
+
+		it "can create a new branchset cloned from itself with additional attributes selected" do
+			@branchset.options[:select] = [ :l, :cn, :uid ]
+			newset = @branchset.select_more( :firstName, :uid, :lastName )
+			newset.select.should == [ 'l', 'cn', 'uid', 'firstName', 'lastName' ]
+		end
+
+		it "uses its selection as the list of attributes to fetch when searching" do
+			@branchset.options[:select] = [ :l, :cn, :uid ]
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter,
+				      @params.merge(:selectattrs => ['l', 'cn', 'uid']) ).
+				and_yield( :matching_branches )
+
+			@branchset.all.should == [:matching_branches]
+		end
+
+		# 
+		# #timeout
+		# 
+
+		it "can create a new branchset cloned from itself with a timeout" do
+			newset = @branchset.timeout( 30 )
+			newset.timeout.should == 30.0
+		end
+
+		it "can create a new branchset cloned from itself without a timeout" do
+			@branchset.options[:timeout] = 5.375
+			newset = @branchset.without_timeout
+			newset.timeout.should == 0
+		end
+
+		it "uses its timeout as the timeout values when searching" do
+			@branchset.options[:timeout] = 5.375
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter,
+				      @params.merge(:timeout => 5.375) ).
+				and_yield( :matching_branches )
+
+			@branchset.all.should == [:matching_branches]
+		end
+
+		# 
+		# #order
+		# 
+
+		# it "can create a new branchset cloned from itself with a sort-order attribute" do
+		# 	newset = @branchset.order( :uid )
+		# 	newset.order.should == :uid
+		# end
+		# 
+		# it "converts a string sort-order attribute to a Symbol" do
+		# 	newset = @branchset.order( 'uid' )
+		# 	newset.order.should == :uid
+		# end
+		# 
+		# it "can set a sorting function instead of an attribute" do
+		# 	newset = @branchset.order {|branch| branch.uid }
+		# 	newset.order.should be_a( Proc )
+		# end
+		# 
+		# it "can create a new branchset cloned from itself without a sort-order attribute" do
+		# 	@branchset.options[:order] = :uid
+		# 	newset = @branchset.order( nil )
+		# 	newset.order.should == nil
+		# end
+		# 
+		# it "uses its order attribute list when searching" do
+		# 	@branchset.options[:order] = [ :uid ]
+		# 	@branch.should_receive( :directory ).and_return( @directory )
+		# 	@directory.should_receive( :search ).
+		# 		with( @branch, Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter,
+		# 		      @params.merge(:sortby => ['uid']) ).
+		# 		and_yield( :matching_branches )
+		# 
+		# 	@branchset.all.should == [:matching_branches]
+		# end
+
+		# 
+		# #limit
+		# 
+		it "can create a new branchset cloned from itself with a limit attribute" do
+			newset = @branchset.limit( 5 )
+			newset.limit.should == 5
+		end
+
+		it "can create a new branchset cloned from itself without a limit" do
+			newset = @branchset.without_limit
+			newset.limit.should == 0
+		end
+
+		it "uses its limit as the limit when searching" do
+			@branchset.options[:limit] = 8
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter,
+				      @params.merge(:limit => 8) ).
+				and_yield( :matching_branches )
+
+			@branchset.all.should == [:matching_branches]
+		end
+
+	end
+
+	describe "instance with no filter, and scope set to 'onelevel'" do
+
+		before( :each ) do
+			@branchset = Treequel::Branchset.new( @branch, :scope => :onelevel )
+		end
+
+
+		it "generates a valid filter string" do
+			@branchset.filter_string.should == '(objectClass=*)'
+		end
+
+		it "performs a search using the default filter and scope when all records are requested" do
+			@branch.should_receive( :directory ).and_return( @directory )
+			@directory.should_receive( :search ).
+				with( @branch, :onelevel, @branchset.filter, @params ).
+				and_yield( :matching_branches )
+
+			@branchset.all.should == [:matching_branches]
+		end
+
+	end
+
+end
+
+
+# vim: set nosta noet ts=4 sw=4: