treequel 1.0.4 → 1.1.0

data/spec/treequel/branch_spec.rb

@@ -6,6 +6,7 @@ BEGIN {
 
 	libdir = basedir + "lib"
 
+	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
 	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
 }
 
@@ -29,6 +30,7 @@ describe Treequel::Branch do
 	include Treequel::SpecHelpers,
 	        Treequel::Matchers
 
+
 	before( :all ) do
 		setup_logging( :fatal )
 	end
@@ -68,6 +70,12 @@ describe Treequel::Branch do
 		branch.entry.should == entry
 	end
 
+	it "raises an exception if constructed with something other than a Hash entry" do
+		expect {
+			Treequel::Branch.new( @directory, TEST_PEOPLE_DN, 18 )
+		}.to raise_exception( ArgumentError, /can't cast/i )
+	end
+
 	it "can be configured to include operational attributes for all future instances" do
 		Treequel::Branch.include_operational_attrs = false
 		Treequel::Branch.new( @directory, TEST_PEOPLE_DN ).include_operational_attrs?.should be_false
@@ -89,7 +97,8 @@ describe Treequel::Branch do
 			@schema.stub!( :attribute_types ).
 				and_return({ :cn => :a_value, :ou => :a_value })
 
-			@attribute_type = mock( "schema attribute type object" )
+			@syntax = stub( "attribute ldapSyntax object", :oid => OIDS::STRING_SYNTAX )
+			@attribute_type = mock( "schema attribute type object", :syntax => @syntax )
 		end
 
 
@@ -110,6 +119,11 @@ describe Treequel::Branch do
 			@branch.split_dn( 2 ).should include( TEST_HOSTS_RDN, TEST_BASE_DN )
 		end
 
+		it "can return itself as an ldap:// URI" do
+			@directory.should_receive( :uri ).and_return( URI.parse("ldap://#{TEST_HOST}/#{TEST_BASE_DN}") )
+			@branch.uri.to_s.should == "ldap://#{TEST_HOST}/#{TEST_HOSTS_DN}?"
+		end
+
 		it "are Comparable if they are siblings" do
 			sibling = Treequel::Branch.new( @directory, TEST_PEOPLE_DN )
 
@@ -182,6 +196,19 @@ describe Treequel::Branch do
 		end
 
 
+		it "can fetch a child entry by RDN" do
+			res = @branch.get_child( 'cn=surprise' )
+			res.should be_a( Treequel::Branch )
+			res.dn.should == [ 'cn=surprise', @branch.dn ].join( ',' )
+		end
+
+		it "can fetch a child entry by RDN if its DN is the empty String" do
+			@branch.dn = ''
+			res = @branch.get_child( 'cn=surprise' )
+			res.should be_a( Treequel::Branch )
+			res.dn.should == 'cn=surprise'
+		end
+
 		it "create sub-branches for messages that match valid attributeType OIDs" do
 			@schema.should_receive( :attribute_types ).twice.
 				and_return({ :cn => :a_value, :ou => :a_value })
@@ -287,17 +314,19 @@ describe Treequel::Branch do
 
 		it "knows which objectClasses it has" do
 			oc_attr = mock( "objectClass attributeType object" )
+			string_syntax = stub( "string ldapSyntax object", :oid => OIDS::STRING_SYNTAX )
 			@schema.should_receive( :attribute_types ).and_return({ :objectClass => oc_attr })
 			oc_attr.should_receive( :single? ).and_return( false )
-			oc_attr.should_receive( :syntax_oid ).and_return( OIDS::STRING_SYNTAX )
+			oc_attr.should_receive( :syntax ).at_least( :once ).
+				and_return( string_syntax )
 
 			@entry.should_receive( :[] ).with( 'objectClass' ).at_least( :once ).
 				and_return([ 'organizationalUnit', 'extensibleObject' ])
 
-			@directory.should_receive( :convert_syntax_value ).
+			@directory.should_receive( :convert_to_object ).
 				with( OIDS::STRING_SYNTAX, 'organizationalUnit' ).
 				and_return( 'organizationalUnit' )
-			@directory.should_receive( :convert_syntax_value ).
+			@directory.should_receive( :convert_to_object ).
 				with( OIDS::STRING_SYNTAX, 'extensibleObject' ).
 				and_return( 'extensibleObject' )
 
@@ -309,6 +338,42 @@ describe Treequel::Branch do
 			@branch.object_classes.should == [ :ou_objectclass, :extobj_objectclass ]
 		end
 
+		it "knows what operational attributes it has" do
+			op_attrs = MINIMAL_OPERATIONAL_ATTRIBUTES.inject({}) do |hash, oa|
+				hash[ oa ] = mock("#{oa} attributeType object")
+				hash
+			end
+			@schema.should_receive( :operational_attribute_types ).and_return( op_attrs.values )
+
+			@branch.operational_attribute_types.should == op_attrs.values
+		end
+
+		it "knows what the OIDs of its operational attributes are" do
+			op_attrs = MINIMAL_OPERATIONAL_ATTRIBUTES.inject({}) do |hash, oa|
+				hash[ oa ] = stub("#{oa} attributeType object", :oid => :an_oid )
+				hash
+			end
+			@schema.should_receive( :operational_attribute_types ).at_least( :once ).
+				and_return( op_attrs.values )
+
+			@branch.operational_attribute_oids.should have( op_attrs.length ).members
+			@branch.operational_attribute_oids.should include( :an_oid )
+		end
+
+		it "can return the set of all its MUST attributes' OIDs based on which objectClasses " +
+		   "it has" do
+			oc1 = mock( "first objectclass" )
+			oc2 = mock( "second objectclass" )
+
+			@branch.should_receive( :object_classes ).and_return([ oc1, oc2 ])
+			oc1.should_receive( :must_oids ).at_least( :once ).and_return([ :oid1, :oid2 ])
+			oc2.should_receive( :must_oids ).at_least( :once ).and_return([ :oid1, :oid3 ])
+
+			must_oids = @branch.must_oids
+			must_oids.should have( 3 ).members
+			must_oids.should include( :oid1, :oid2, :oid3 )
+		end
+
 		it "can return the set of all its MUST attributeTypes based on which objectClasses it has" do
 			oc1 = mock( "first objectclass" )
 			oc2 = mock( "second objectclass" )
@@ -323,7 +388,7 @@ describe Treequel::Branch do
 		end
 
 		it "can return a Hash pre-populated with pairs that correspond to its MUST attributes" do
-			cn_attrtype = mock( "cn attribute type", :single? => true )
+			cn_attrtype = mock( "cn attribute type", :single? => false )
 			l_attrtype = mock( "l attribute type", :single? => true )
 			objectClass_attrtype = mock( "objectClass attribute type", :single? => false )
 
@@ -335,10 +400,24 @@ describe Treequel::Branch do
 				and_return([ cn_attrtype, l_attrtype, objectClass_attrtype ])
 
 			@branch.must_attributes_hash.
-				should == { :cn => '', :l => '', :objectClass => [:top] }
+				should == { :cn => [''], :l => '', :objectClass => [:top] }
 		end
 
 
+		it "can return the set of all its MAY attributes' OIDs based on which objectClasses " +
+		   "it has" do
+			oc1 = mock( "first objectclass" )
+			oc2 = mock( "second objectclass" )
+
+			@branch.should_receive( :object_classes ).and_return([ oc1, oc2 ])
+			oc1.should_receive( :may_oids ).at_least( :once ).and_return([ :oid1, :oid2 ])
+			oc2.should_receive( :may_oids ).at_least( :once ).and_return([ :oid1, :oid3 ])
+
+			must_oids = @branch.may_oids
+			must_oids.should have( 3 ).members
+			must_oids.should include( :oid1, :oid2, :oid3 )
+		end
+
 		it "can return the set of all its MAY attributeTypes based on which objectClasses it has" do
 			oc1 = mock( "first objectclass" )
 			oc2 = mock( "second objectclass" )
@@ -352,20 +431,67 @@ describe Treequel::Branch do
 			must_attrs.should include( :description, :mobilePhone, :chunktype )
 		end
 
+		it "can return a Hash pre-populated with pairs that correspond to its MAY attributes" do
+			cn_attrtype = mock( "cn attribute type", :single? => false )
+			l_attrtype = mock( "l attribute type", :single? => true )
+
+			cn_attrtype.should_receive( :name ).at_least( :once ).and_return( :cn )
+			l_attrtype.should_receive( :name ).at_least( :once ).and_return( :l )
+
+			@branch.should_receive( :may_attribute_types ).at_least( :once ).
+				and_return([ cn_attrtype, l_attrtype ])
+
+			@branch.may_attributes_hash.
+				should == { :cn => [], :l => nil }
+		end
+
 		it "can return the set of all of its valid attributeTypes, which is a union of its " +
-		   "MUST and MAY attributes" do
+		   "MUST and MAY attributes plus the directory's operational attributes" do
 			@branch.should_receive( :must_attribute_types ).
 				and_return([ :cn, :l, :uid ])
 			@branch.should_receive( :may_attribute_types ).
 				and_return([ :description, :mobilePhone, :chunktype ])
+			@branch.should_receive( :operational_attribute_types ).
+				and_return([ :createTimestamp, :creatorsName ])
 
 			all_attrs = @branch.valid_attribute_types
 
-			all_attrs.should have( 6 ).members
-			all_attrs.should include( :cn, :uid, :l, :description, :mobilePhone, :chunktype )
+			all_attrs.should have( 8 ).members
+			all_attrs.should include( :cn, :uid, :l, :description, :mobilePhone,
+				:chunktype, :createTimestamp, :creatorsName )
+		end
+
+		it "can return a Hash pre-populated with pairs that correspond to all of its valid " +
+		   "attributes" do
+			@branch.should_receive( :must_attributes_hash ).at_least( :once ).
+				and_return({ :cn => [''], :l => '', :objectClass => [:top] })
+			@branch.should_receive( :may_attributes_hash ).at_least( :once ).
+				and_return({ :description => nil, :givenName => [], :cn => nil })
+
+			@branch.valid_attributes_hash.should == {
+				:cn => [''],
+				:l => '',
+				:objectClass => [:top],
+				:description => nil,
+				:givenName => [],
+			}
+		end
+
+
+		it "can return the set of all of its valid attribute OIDs, which is a union of its " +
+		   "MUST and MAY attribute OIDs" do
+			@branch.should_receive( :must_oids ).
+				and_return([ :must_oid1, :must_oid2 ])
+			@branch.should_receive( :may_oids ).
+				and_return([ :may_oid1, :may_oid2, :must_oid1 ])
+
+			all_attr_oids = @branch.valid_attribute_oids
+
+			all_attr_oids.should have( 4 ).members
+			all_attr_oids.should include( :must_oid1, :must_oid2, :may_oid1, :may_oid2 )
 		end
 
-		it "knows if a attribute is valid given its objectClasses" do
+		it "knows if an attribute is valid given its objectClasses" do
 			attrtype = mock( "attribute type object" )
 
 			@branch.should_receive( :valid_attribute_types ).
@@ -487,6 +613,12 @@ describe Treequel::Branch do
 			@branch.delete( :objectClass => ['apple-user',:inetOrgPerson], :cn => [] )
 		end
 
+		it "deletes its entry entirely if no attributes are specified" do
+			@directory.should_receive( :delete ).with( @branch )
+			@branch.delete
+		end
+
+
 		it "knows how to represent its DN as an RFC1781-style UFN" do
 			@branch.to_ufn.should =~ /Hosts, acme\.com/i
 		end
@@ -505,6 +637,82 @@ describe Treequel::Branch do
 		end
 
 
+		LONG_TEST_VALUE = 'A poet once said, "The whole universe is in ' +
+			'a glass of wine." We will probably never know in what sense ' +
+			'he meant that, for poets do not write to be understood. But ' +
+			'it is true that if we look at a glass of wine closely enough ' +
+			'we see the entire universe.'
+
+		it "knows how to split long lines in LDIF output" do
+			@entry.should_receive( :keys ).and_return([ 'description', 'l' ])
+			@entry.should_receive( :[] ).with( 'description' ).
+				and_return([ LONG_TEST_VALUE ])
+			@entry.should_receive( :[] ).with( 'l' ).
+				and_return([ 'Antartica', 'Galapagos' ])
+
+			ldif = @branch.to_ldif( 20 )
+			val = ldif[ /(description: (?:[^\n]|\n )+)/, 1 ]
+			lines = val.split( /\n/ )
+
+			lines.first.should =~ /.{20}/
+			lines[1..-2].each do |line|
+				line.should =~ / .{19}/
+			end
+			lines.last.should =~ / .{1,19}/
+		end
+
+
+		LONG_BINARY_TEST_VALUE = ( <<-END_VALUE ).gsub( /^\t{2}/, '' )
+		Once there came a man
+		Who said,
+		"Range me all men of the world in rows."
+		And instantly
+		There was terrific clamour among the people
+		Against being ranged in rows.
+		There was a loud quarrel, world-wide.
+		It endured for ages;
+		And blood was shed
+		By those who would not stand in rows,
+		And by those who pined to stand in rows.
+		Eventually, the man went to death, weeping.
+		And those who staid in bloody scuffle
+		Knew not the great simplicity.
+		END_VALUE
+
+		it "knows how to split long binary lines in LDIF output" do
+			@entry.should_receive( :keys ).and_return([ 'description', 'l' ])
+			@entry.should_receive( :[] ).with( 'description' ).
+				and_return([ LONG_BINARY_TEST_VALUE ])
+			@entry.should_receive( :[] ).with( 'l' ).
+				and_return([ 'Antartica', 'Galapagos' ])
+
+			ldif = @branch.to_ldif( 20 )
+			ldif.scan( /^description/ ).length.should == 1
+
+			val = ldif[ /^(description:: (?:[^\n]|\n )+)/, 1 ]
+			lines = val.split( /\n/ )
+			lines.first.should =~ /.{20}/
+			lines[1..-2].each do |line|
+				line.should =~ / .{19}/
+			end
+			lines.last.should =~ / .{1,19}/
+		end
+
+
+		it "knows how to represent itself as a Hash" do
+			@entry.should_receive( :keys ).and_return([ 'description', 'dn', 'l' ])
+			@entry.should_receive( :[] ).with( 'description' ).
+				and_return([ 'A chilly little penguin.' ])
+			@entry.should_receive( :[] ).with( 'l' ).
+				and_return([ 'Antartica', 'Galapagos' ])
+
+			@branch.to_hash.should == {
+				'description' => ['A chilly little penguin.'],
+				'l' => [ 'Antartica', 'Galapagos' ],
+				'dn' => TEST_HOSTS_DN,
+			}
+		end
+
 		it "returns a Treequel::BranchCollection with equivalent Branchsets if added to another " +
 		   "Branch" do
 			other_branch = Treequel::Branch.new( @directory, TEST_SUBHOSTS_DN )
@@ -527,8 +735,8 @@ describe Treequel::Branch do
 				@entry.should_receive( :[] ).with( 'glumpy' ).at_least( :once ).
 					and_return([ 'glumpa1', 'glumpa2' ])
 
-				@attribute_type.stub!( :syntax_oid ).and_return( OIDS::STRING_SYNTAX )
-				@directory.stub!( :convert_syntax_value ).and_return {|_,str| str }
+				@attribute_type.stub!( :syntax ).and_return( @syntax )
+				@directory.stub!( :convert_to_object ).and_return {|_,str| str }
 
 				@branch[ :glumpy ].should == [ 'glumpa1', 'glumpa2' ]
 			end
@@ -539,8 +747,8 @@ describe Treequel::Branch do
 				@entry.should_receive( :[] ).with( 'glumpy' ).at_least( :once ).
 					and_return([ 'glumpa1' ])
 
-				@attribute_type.stub!( :syntax_oid ).and_return( OIDS::STRING_SYNTAX )
-				@directory.stub!( :convert_syntax_value ).and_return {|_,str| str }
+				@attribute_type.stub!( :syntax ).and_return( @syntax )
+				@directory.stub!( :convert_to_object ).and_return {|_,str| str }
 
 				@branch[ :glumpy ].should == 'glumpa1'
 			end
@@ -560,8 +768,8 @@ describe Treequel::Branch do
 			it "caches the value fetched from its entry" do
 				@schema.stub!( :attribute_types ).and_return({ :glump => @attribute_type })
 				@attribute_type.stub!( :single? ).and_return( true )
-				@attribute_type.stub!( :syntax_oid ).and_return( OIDS::STRING_SYNTAX )
-				@directory.stub!( :convert_syntax_value ).and_return {|_,str| str }
+				@attribute_type.stub!( :syntax ).and_return( @syntax )
+				@directory.stub!( :convert_to_object ).and_return {|_,str| str }
 				@entry.should_receive( :[] ).with( 'glump' ).once.and_return( [:a_value] )
 				2.times { @branch[ :glump ] }
 			end
@@ -571,8 +779,8 @@ describe Treequel::Branch do
 				@attribute_type.should_receive( :single? ).and_return( true )
 				@entry.should_receive( :[] ).with( 'bvector' ).at_least( :once ).
 					and_return([ '010011010101B' ])
-				@attribute_type.should_receive( :syntax_oid ).and_return( OIDS::BIT_STRING_SYNTAX )
-				@directory.should_receive( :convert_syntax_value ).
+				@syntax.stub!( :oid ).and_return( OIDS::BIT_STRING_SYNTAX )
+				@directory.should_receive( :convert_to_object ).
 					with( OIDS::BIT_STRING_SYNTAX, '010011010101B' ).
 					and_return( 1237 )
 
@@ -599,11 +807,12 @@ describe Treequel::Branch do
 			it "clears the cache after a successful write" do
 				@schema.stub!( :attribute_types ).and_return({ :glorpy => @attribute_type })
 				@attribute_type.stub!( :single? ).and_return( true )
-				@attribute_type.stub!( :syntax_oid ).and_return( OIDS::STRING_SYNTAX )
-				@directory.stub!( :convert_syntax_value ).and_return {|_,val| val }
+				@attribute_type.stub!( :syntax ).and_return( @syntax )
+				@directory.stub!( :convert_to_object ).and_return {|_,val| val }
 				@entry.should_receive( :[] ).with( 'glorpy' ).and_return( [:firstval], [:secondval] )
 
 				@directory.should_receive( :modify ).with( @branch, {'glorpy' => ['chunks']} )
+				@directory.stub!( :convert_to_attribute ).and_return {|_,val| val }
 				@entry.should_receive( :[]= ).with( 'glorpy', ['chunks'] )
 
 				@branch[ :glorpy ].should == :firstval

data/spec/treequel/branchcollection_spec.rb

@@ -6,22 +6,15 @@ BEGIN {
 
 	libdir = basedir + "lib"
 
+	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
 	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
 }
 
-begin
-	require 'spec'
-	require 'spec/lib/constants'
-	require 'spec/lib/helpers'
+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
+require 'treequel/branchcollection'
 
 
 include Treequel::TestConstants
@@ -42,7 +35,7 @@ describe Treequel::BranchCollection do
 	end
 
 	before( :each ) do
-		@directory = mock( "treequel directory ")
+		@directory = mock( "treequel directory", :registered_controls => [] )
 	end
 
 	it "can be instantiated without any branchsets" do
@@ -51,8 +44,10 @@ describe Treequel::BranchCollection do
 	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 )
+		branch1 = stub( "branch for branchset 1", :directory => @directory )
+		branchset1 = Treequel::Branchset.new( branch1 )
+		branch2 = stub( "branch for branchset 2", :directory => @directory )
+		branchset2 = Treequel::Branchset.new( branch2 )
 
 		collection = Treequel::BranchCollection.new( branchset1, branchset2 )
 
@@ -60,17 +55,17 @@ describe Treequel::BranchCollection do
 	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' )
+		branch1 = stub( "branch for branchset 1", :directory => @directory )
+		branchset1 = Treequel::Branchset.new( branch1 )
+		branch2 = stub( "branch for branchset 2", :directory => @directory )
+		branchset2 = Treequel::Branchset.new( branch2 )
 
-		Treequel::Branchset.should_receive( :new ).with( non_branchset1 ).
+		Treequel::Branchset.should_receive( :new ).with( :non_branchset1 ).
 			and_return( branchset1 )
-		Treequel::Branchset.should_receive( :new ).with( non_branchset2 ).
+		Treequel::Branchset.should_receive( :new ).with( :non_branchset2 ).
 			and_return( branchset2 )
 
-		collection = Treequel::BranchCollection.new( non_branchset1, non_branchset2 )
+		collection = Treequel::BranchCollection.new( :non_branchset1, :non_branchset2 )
 
 		collection.branchsets.should include( branchset1, branchset2 )
 	end
@@ -99,8 +94,13 @@ describe Treequel::BranchCollection do
 	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 )
+			# @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 )
+			@branch1 = mock( "branch1", :directory => @directory )
+			@branchset1 = Treequel::Branchset.new( @branch1 )
+
+			@branch2 = mock( "branch2", :directory => @directory )
+			@branchset2 = Treequel::Branchset.new( @branch2 )
 
 			@collection = Treequel::BranchCollection.new( @branchset1, @branchset2 )
 		end
@@ -134,26 +134,51 @@ describe Treequel::BranchCollection do
 		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 )
+			branch3 = mock( "branch 3", :directory => @directory )
+			branchset3 = Treequel::Branchset.new( branch3 )
+
 			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
+		it "returns all of the results from each of its branchsets plus the added branch if a " +
+		   "Branch is added to it" do
+			@branchset1.should_receive( :each ).and_yield( :bs1_stuff )
+			@branchset2.should_receive( :each ).and_yield( :bs2_stuff )
+			added_branch = stub( "added branch", :directory => @directory )
+			added_branch.stub!( :to_ary ).and_return( [added_branch] )
 
-			new_collection.should be_an_instance_of( Treequel::BranchCollection )
-			new_collection.should include( @branchset1, @branchset2, branchset3 )
+			results = @collection + added_branch
+
+			results.should have( 3 ).members
+			results.should include( :bs1_stuff, :bs2_stuff, added_branch )
+		end
+
+		it "returns all of the results from each of its branchsets minus the subtracted branch " +
+		   "if a Branch is subtracted from it" do
+			results_branch1 = stub( "results branch 1", :dn => TEST_PERSON_DN )
+			results_branch2 = stub( "results branch 2", :dn => TEST_PERSON2_DN )
+			subtracted_branch = stub( "subtracted branch", :dn => TEST_PERSON_DN )
+
+			@branchset1.should_receive( :each ).and_yield( results_branch1 )
+			@branchset2.should_receive( :each ).and_yield( results_branch2 )
+
+			results = @collection - subtracted_branch
+
+			results.should have( 1 ).members
+			results.should_not include( subtracted_branch )
+			results.should_not include( results_branch1 )
 		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 )
+			branch3 = stub( "branch for branchset 3", :directory => @directory )
+			branchset3 = Treequel::Branchset.new( branch3 )
+			branch4 = stub( "branch for branchset 4", :directory => @directory )
+			branchset4 = Treequel::Branchset.new( branch4 )
+
 			other_collection = Treequel::BranchCollection.new( branchset3, branchset4 )
 
 			new_collection = @collection + other_collection
@@ -164,8 +189,11 @@ describe Treequel::BranchCollection do
 
 		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 )
+			branch3 = stub( "branch for branchset 3", :directory => @directory )
+			branchset3 = Treequel::Branchset.new( branch3 )
+			branch4 = stub( "branch for branchset 4", :directory => @directory )
+			branchset4 = Treequel::Branchset.new( branch4 )
+
 			other_collection = Treequel::BranchCollection.new( branchset3, branchset4 )
 
 			new_collection = @collection | other_collection
@@ -176,8 +204,11 @@ describe Treequel::BranchCollection do
 
 		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 )
+			branch3 = stub( "branch for branchset 3", :directory => @directory )
+			branchset3 = Treequel::Branchset.new( branch3 )
+			branch4 = stub( "branch for branchset 4", :directory => @directory )
+			branchset4 = Treequel::Branchset.new( branch4 )
+
 			other_collection = Treequel::BranchCollection.new( @branchset2, branchset3, branchset4 )
 			@collection << branchset4
 
@@ -188,8 +219,11 @@ describe Treequel::BranchCollection do
 		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 )
+			branch3 = stub( "branch for branchset 3", :directory => @directory )
+			filtered_branchset1 = Treequel::Branchset.new( branch3 )
+			branch4 = stub( "branch for branchset 4", :directory => @directory )
+			filtered_branchset2 = Treequel::Branchset.new( branch4 )
+
 			@branchset1.should_receive( :filter ).with( :cn => 'chunkalicious' ).
 				and_return( filtered_branchset1 )
 			@branchset2.should_receive( :filter ).with( :cn => 'chunkalicious' ).