treequel 1.11.0 → 1.12.0

data/spec/treequel/branchcollection_spec.rb

@@ -1,213 +1,187 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+#encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
-}
-
-require 'rspec'
-
-require 'spec/lib/constants'
-require 'spec/lib/helpers'
+require_relative '../spec_helpers'
 
 require 'treequel/branchcollection'
 
 
-include Treequel::TestConstants
-
-#####################################################################
-###	C O N T E X T S
-#####################################################################
-
 describe Treequel::BranchCollection do
 	include Treequel::SpecHelpers
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 	before( :each ) do
-		@directory = mock( "treequel directory", :registered_controls => [] )
+		@directory = double( "treequel directory", :registered_controls => [] )
 	end
 
 	it "can be instantiated without any branchsets" do
 		collection = Treequel::BranchCollection.new
-		collection.all.should == []
+		expect( collection.all ).to eq( [] )
 	end
 
 	it "can be instantiated with one or more branchsets" do
-		branch1 = stub( "branch for branchset 1", :directory => @directory )
+		branch1 = double( "branch for branchset 1", :directory => @directory )
 		branchset1 = Treequel::Branchset.new( branch1 )
-		branch2 = stub( "branch for branchset 2", :directory => @directory )
+		branch2 = double( "branch for branchset 2", :directory => @directory )
 		branchset2 = Treequel::Branchset.new( branch2 )
 
 		collection = Treequel::BranchCollection.new( branchset1, branchset2 )
 
-		collection.branchsets.should include( branchset1, branchset2 )
+		expect( collection.branchsets ).to include( branchset1, branchset2 )
 	end
 
 	it "wraps any object that doesn't have an #each in a Branchset" do
-		branch1 = stub( "branch for branchset 1", :directory => @directory )
+		branch1 = double( "branch for branchset 1", :directory => @directory )
 		branchset1 = Treequel::Branchset.new( branch1 )
-		branch2 = stub( "branch for branchset 2", :directory => @directory )
+		branch2 = double( "branch for branchset 2", :directory => @directory )
 		branchset2 = Treequel::Branchset.new( branch2 )
 
-		Treequel::Branchset.should_receive( :new ).with( :non_branchset1 ).
+		expect( Treequel::Branchset ).to receive( :new ).with( :non_branchset1 ).
 			and_return( branchset1 )
-		Treequel::Branchset.should_receive( :new ).with( :non_branchset2 ).
+		expect( Treequel::Branchset ).to receive( :new ).with( :non_branchset2 ).
 			and_return( branchset2 )
 
 		collection = Treequel::BranchCollection.new( :non_branchset1, :non_branchset2 )
 
-		collection.branchsets.should include( branchset1, branchset2 )
+		expect( collection.branchsets ).to include( branchset1, branchset2 )
 	end
 
 	it "allows new Branchsets to be appended to it" do
-		branchset1 = mock( "branchset 1" )
-		branchset2 = mock( "branchset 2" )
+		branchset1 = double( "branchset 1" )
+		branchset2 = double( "branchset 2" )
 
 		collection = Treequel::BranchCollection.new
 		collection << branchset1 << branchset2
 
-		collection.should include( branchset1, branchset2 )
+		expect( collection ).to 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 )
+		branch1 = double( "branch 1", :branchset => :branchset1 )
+		branch2 = double( "branch 2", :branchset => :branchset2 )
 
 		collection = Treequel::BranchCollection.new
 		collection << branch1 << branch2
 
-		collection.should include( :branchset1, :branchset2 )
+		expect( collection ).to 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 )
-			@branch1 = mock( "branch1", :directory => @directory )
+			# @branchset1 = double( "branchset 1", :dn => 'cn=example1,dc=acme,dc=com', :each => 1 )
+			# @branchset2 = double( "branchset 2", :dn => 'cn=example2,dc=acme,dc=com', :each => 1 )
+			@branch1 = double( "branch1", :directory => @directory, :dn => '' )
 			@branchset1 = Treequel::Branchset.new( @branch1 )
 
-			@branch2 = mock( "branch2", :directory => @directory )
+			@branch2 = double( "branch2", :directory => @directory )
 			@branchset2 = Treequel::Branchset.new( @branch2 )
 
 			@collection = Treequel::BranchCollection.new( @branchset1, @branchset2 )
 		end
 
 		it "knows that it is empty if all of its branchsets are empty" do
-			@branchset1.should_receive( :empty? ).and_return( true )
-			@branchset2.should_receive( :empty? ).and_return( true )
+			expect( @branchset1 ).to receive( :empty? ).and_return( true )
+			expect( @branchset2 ).to receive( :empty? ).and_return( true )
 
-			@collection.should be_empty()
+			expect( @collection ).to be_empty()
 		end
 
 		it "knows that it is not empty if one of its branchsets has matching entries" do
-			@branchset1.should_receive( :empty? ).and_return( true )
-			@branchset2.should_receive( :empty? ).and_return( false )
+			expect( @branchset1 ).to receive( :empty? ).and_return( true )
+			expect( @branchset2 ).to receive( :empty? ).and_return( false )
 
-			@collection.should_not be_empty()
+			expect( @collection ).to_not be_empty()
 		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 )
+			expect( @branchset1 ).to receive( :each ).and_yield( :bs1_stuff )
+			expect( @branchset2 ).to receive( :each ).and_yield( :bs2_stuff )
 
-			@collection.all.should == [ :bs1_stuff, :bs2_stuff ]
+			expect( @collection.all ).to eq( [ :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 )
+			expect( @branchset1 ).to receive( :first ).and_return( nil )
+			expect( @branchset2 ).to receive( :first ).and_return( :a_branch )
 
-			@collection.first.should == :a_branch
+			expect( @collection.first ).to eq( :a_branch )
 		end
 
 		it "returns a clone of itself with an additional Branchset if a Branchset is added to it" do
-			branch3 = mock( "branch 3", :directory => @directory )
+			branch3 = double( "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 )
+			expect( new_collection ).to be_an_instance_of( Treequel::BranchCollection )
+			expect( new_collection ).to include( @branchset1, @branchset2, branchset3 )
 		end
 
 		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] )
+			expect( @branchset1 ).to receive( :each ).and_yield( :bs1_stuff )
+			expect( @branchset2 ).to receive( :each ).and_yield( :bs2_stuff )
+			added_branch = double( "added branch", :directory => @directory )
+			expect( added_branch ).to receive( :to_ary ).and_return( [added_branch] )
 
 			results = @collection + added_branch
 
-			results.should have( 3 ).members
-			results.should include( :bs1_stuff, :bs2_stuff, added_branch )
+			expect( results.length ).to eq( 3 )
+			expect( results ).to 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 )
+			results_branch1 = double( "results branch 1", :dn => TEST_PERSON_DN )
+			results_branch2 = double( "results branch 2", :dn => TEST_PERSON2_DN )
+			subtracted_branch = double( "subtracted branch", :dn => TEST_PERSON_DN )
 
-			@branchset1.should_receive( :each ).and_yield( results_branch1 )
-			@branchset2.should_receive( :each ).and_yield( results_branch2 )
+			expect( @branchset1 ).to receive( :each ).and_yield( results_branch1 )
+			expect( @branchset2 ).to 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 )
+			expect( results.length ).to eq( 1 )
+			expect( results ).to_not include( subtracted_branch )
+			expect( results ).to_not include( results_branch1 )
 		end
 
 		it "returns a clone of itself with both collections' Branchsets if a BranchCollection is " +
 		   "added to it" do
-			branch3 = stub( "branch for branchset 3", :directory => @directory )
+			branch3 = double( "branch for branchset 3", :directory => @directory )
 			branchset3 = Treequel::Branchset.new( branch3 )
-			branch4 = stub( "branch for branchset 4", :directory => @directory )
+			branch4 = double( "branch for branchset 4", :directory => @directory )
 			branchset4 = Treequel::Branchset.new( branch4 )
 
 			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 )
+			expect( new_collection ).to be_an_instance_of( Treequel::BranchCollection )
+			expect( new_collection ).to include( @branchset1, @branchset2, branchset3, branchset4 )
 		end
 
 		it "returns a new BranchCollection with the union of Branchsets if it is ORed with " +
 		   "another BranchCollection" do
-			branch3 = stub( "branch for branchset 3", :directory => @directory )
+			branch3 = double( "branch for branchset 3", :directory => @directory )
 			branchset3 = Treequel::Branchset.new( branch3 )
-			branch4 = stub( "branch for branchset 4", :directory => @directory )
+			branch4 = double( "branch for branchset 4", :directory => @directory )
 			branchset4 = Treequel::Branchset.new( branch4 )
 
 			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 )
+			expect( new_collection ).to be_an_instance_of( Treequel::BranchCollection )
+			expect( new_collection ).to include( @branchset1, @branchset2, branchset3, branchset4 )
 		end
 
 		it "returns a new BranchCollection with the intersection of Branchsets if it is ANDed with " +
 		   "another BranchCollection" do
-			branch3 = stub( "branch for branchset 3", :directory => @directory )
+			branch3 = double( "branch for branchset 3", :directory => @directory )
 			branchset3 = Treequel::Branchset.new( branch3 )
-			branch4 = stub( "branch for branchset 4", :directory => @directory )
+			branch4 = double( "branch for branchset 4", :directory => @directory )
 			branchset4 = Treequel::Branchset.new( branch4 )
 
 			other_collection = Treequel::BranchCollection.new( @branchset2, branchset3, branchset4 )
@@ -215,52 +189,38 @@ describe Treequel::BranchCollection do
 
 			new_collection = @collection & other_collection
 
-			new_collection.should be_an_instance_of( Treequel::BranchCollection )
-			new_collection.should include( @branchset2, branchset4 )
+			expect( new_collection ).to be_an_instance_of( Treequel::BranchCollection )
+			expect( new_collection ).to include( @branchset2, branchset4 )
 		end
 
 		it "can create a clone of itself with filtered branchsets" do
-			branch3 = stub( "branch for branchset 3", :directory => @directory )
+			branch3 = double( "branch for branchset 3", :directory => @directory )
 			filtered_branchset1 = Treequel::Branchset.new( branch3 )
-			branch4 = stub( "branch for branchset 4", :directory => @directory )
+			branch4 = double( "branch for branchset 4", :directory => @directory )
 			filtered_branchset2 = Treequel::Branchset.new( branch4 )
 
-			@branchset1.should_receive( :filter ).with( :cn => 'chunkalicious' ).
+			expect( @branchset1 ).to receive( :filter ).with( :cn => 'chunkalicious' ).
 				and_return( filtered_branchset1 )
-			@branchset2.should_receive( :filter ).with( :cn => 'chunkalicious' ).
+			expect( @branchset2 ).to 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 )
+			expect( filtered_collection ).to_not be_equal( @collection )
+			expect( filtered_collection ).to include( filtered_branchset1, filtered_branchset2 )
 		end
 
 		it "raises a reasonable exception if one of its delegates returns a non-branchset" do
 			filter = Treequel::Filter.new
-			@branchset1.stub( :filter ).and_return( filter )
 
 			expect {
 				@collection.filter
 			}.to raise_exception( ArgumentError, /0 for 1/ )
 		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 ]
+			expect( @branchset1 ).to receive( :base_dn ).and_return( :branchset1_basedn )
+			expect( @branchset2 ).to receive( :base_dn ).and_return( :branchset2_basedn )
+			expect( @collection.base_dns ).to eq( [ :branchset1_basedn, :branchset2_basedn ] )
 		end
 
 	end

data/spec/treequel/branchset_spec.rb

@@ -1,29 +1,13 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+#encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
-}
-
-require 'rspec'
-
-require 'spec/lib/constants'
-require 'spec/lib/helpers'
+require_relative '../spec_helpers'
 
 require 'treequel/branchset'
 require 'treequel/branchcollection'
 require 'treequel/control'
 
 
-#####################################################################
-###	C O N T E X T S
-#####################################################################
-
 describe Treequel::Branchset do
 
 	DEFAULT_PARAMS = {
@@ -35,14 +19,6 @@ describe Treequel::Branchset do
 	}
 
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 	before( :each ) do
 		@conn = double( "LDAP connection", :set_option => true, :bound? => false )
 		@directory = get_fixtured_directory( @conn )
@@ -57,51 +33,51 @@ describe Treequel::Branchset do
 		end
 
 		it "is Enumerable" do
-			@conn.should_receive( :search_ext2 ).
-				with( TEST_BASE_DN, LDAP::LDAP_SCOPE_SUBTREE, "(objectClass=*)", 
+			expect( @conn ).to receive( :search_ext2 ).
+				with( TEST_BASE_DN, LDAP::LDAP_SCOPE_SUBTREE, "(objectClass=*)",
 				      [], false, [], [], 0, 0, 0, "", nil ).
 				and_return([ TEST_HOSTS_ENTRY.dup ])
 
 			@branchset.all? {|b| b.dn }
 		end
 
-		# 
+		#
 		# #empty?
-		# 
+		#
 		it "is empty if it doesn't match at least one entry" do
-			@conn.should_receive( :search_ext2 ).
-				with( TEST_BASE_DN, LDAP::LDAP_SCOPE_SUBTREE, "(objectClass=*)", 
+			expect( @conn ).to receive( :search_ext2 ).
+				with( TEST_BASE_DN, LDAP::LDAP_SCOPE_SUBTREE, "(objectClass=*)",
 				      [], false, [], [], 0, 0, 1, "", nil ).
 				and_return([ ])
-			@branchset.should be_empty()
+			expect( @branchset ).to be_empty()
 		end
 
 		it "isn't empty if it matches at least one entry" do
-			@conn.should_receive( :search_ext2 ).
-				with( TEST_BASE_DN, LDAP::LDAP_SCOPE_SUBTREE, "(objectClass=*)", 
+			expect( @conn ).to receive( :search_ext2 ).
+				with( TEST_BASE_DN, LDAP::LDAP_SCOPE_SUBTREE, "(objectClass=*)",
 				      [], false, [], [], 0, 0, 1, "", nil ).
 				and_return([ TEST_HOSTS_ENTRY.dup ])
-			@branchset.should_not be_empty()
+			expect( @branchset ).to_not be_empty()
 		end
 
-		# 
+		#
 		# #map
-		# 
+		#
 		it "can be mapped into an Array of attribute values" do
-			@conn.should_receive( :search_ext2 ).
-				with( TEST_BASE_DN, LDAP::LDAP_SCOPE_SUBTREE, "(objectClass=*)", 
+			expect( @conn ).to receive( :search_ext2 ).
+				with( TEST_BASE_DN, LDAP::LDAP_SCOPE_SUBTREE, "(objectClass=*)",
 				      [], false, [], [], 0, 0, 0, "", nil ).
 				and_return([ TEST_HOSTS_ENTRY.dup, TEST_PEOPLE_ENTRY.dup ])
 
-			@branchset.map( :ou ).should == [ ['Hosts'], ['People'] ]
+			expect( @branchset.map( :ou ) ).to eq( [ ['Hosts'], ['People'] ] )
 		end
 
 
-		# 
+		#
 		# #to_hash
-		# 
+		#
 		it "can be mapped into a Hash of entries keyed by one of its attributes" do
-			@conn.should_receive( :search_ext2 ).
+			expect( @conn ).to receive( :search_ext2 ).
 				with( "dc=acme,dc=com", 2, "(objectClass=*)", [], false, [], [], 0, 0, 0, "", nil ).
 				and_return([ TEST_HOSTS_ENTRY.dup, TEST_PEOPLE_ENTRY.dup ])
 
@@ -110,22 +86,22 @@ describe Treequel::Branchset do
 			peoplehash = TEST_PEOPLE_ENTRY.dup
 			peoplehash.delete( 'dn' )
 
-			@branchset.to_hash( :ou ).should == {
+			expect( @branchset.to_hash( :ou ) ).to eq({
 				'Hosts'  => hosthash,
 				'People' => peoplehash,
-			}
+			})
 		end
 
 
 		it "can be mapped into a Hash of tuples using two attributes" do
-			@conn.should_receive( :search_ext2 ).
+			expect( @conn ).to receive( :search_ext2 ).
 				with( "dc=acme,dc=com", 2, "(objectClass=*)", [], false, [], [], 0, 0, 0, "", nil ).
 				and_return([ TEST_HOSTS_ENTRY.dup, TEST_PEOPLE_ENTRY.dup ])
 
-			@branchset.to_hash( :ou, :description ).should == {
+			expect( @branchset.to_hash( :ou, :description ) ).to eq({
 				'Hosts'  => TEST_HOSTS_ENTRY['description'].first,
 				'People' => TEST_PEOPLE_ENTRY['description'].first,
-			}
+			})
 		end
 
 		#
@@ -136,21 +112,21 @@ describe Treequel::Branchset do
 			other_branchset = Treequel::Branchset.new( other_branch )
 
 			result = @branchset + other_branchset
-			result.should be_a( Treequel::BranchCollection )
-			result.branchsets.should have( 2 ).members
-			result.branchsets.should include( @branchset, other_branchset )
+			expect( result ).to be_a( Treequel::BranchCollection )
+			expect( result.branchsets.length ).to eq( 2 )
+			expect( result.branchsets ).to include( @branchset, other_branchset )
 		end
 
 		it "returns the results of the search with the additional Branch if one is added to it" do
-			@conn.should_receive( :search_ext2 ).
+			expect( @conn ).to receive( :search_ext2 ).
 				with( "dc=acme,dc=com", 2, "(objectClass=*)", [], false, [], [], 0, 0, 0, "", nil ).
 				and_return([ TEST_HOSTS_ENTRY.dup, TEST_PEOPLE_ENTRY.dup ])
 
 			other_branch = @directory.ou( :netgroups )
 
 			result = @branchset + other_branch
-			result.should have( 3 ).members
-			result.should include( other_branch )
+			expect( result.length ).to eq( 3 )
+			expect( result ).to include( other_branch )
 		end
 
 		#
@@ -160,13 +136,13 @@ describe Treequel::Branchset do
 		     "subtracted from it" do
 				otherbranch = @directory.ou( :people )
 
-				@conn.should_receive( :search_ext2 ).
+				expect( @conn ).to receive( :search_ext2 ).
 					with( "dc=acme,dc=com", 2, "(objectClass=*)", [], false, [], [], 0, 0, 0, "", nil ).
 					and_return([ TEST_HOSTS_ENTRY.dup, TEST_PEOPLE_ENTRY.dup ])
 
 				result = @branchset - otherbranch
-				result.should have( 1 ).members
-				result.should_not include( otherbranch )
+				expect( result.length ).to eq( 1 )
+				expect( result ).to_not include( otherbranch )
 		end
 
 	end
@@ -179,53 +155,53 @@ describe Treequel::Branchset do
 
 		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
+			expect( newset ).to be_a( Treequel::Branchset )
+			expect( newset ).to_not equal( @branchset )
+			expect( newset.options ).to_not equal( @branchset.options )
+			expect( newset.scope ).to eq( :one )
 		end
 
 
-		# 
+		#
 		# #filter
-		# 
+		#
 
 		it "generates a valid filter string" do
-			@branchset.filter_string.should == '(objectClass=*)'
+			expect( @branchset.filter_string ).to eq( '(objectClass=*)' )
 		end
 
 
 		it "performs a search using the default filter and scope when all records are requested" do
-			@branch.should_receive( :search ).
+			expect( @branch ).to receive( :search ).
 				with( Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter, @params ).
 				and_yield( :matching_branches )
 
-			@branchset.all.should == [ :matching_branches ]
+			expect( @branchset.all ).to eq( [ :matching_branches ] )
 		end
 
 		it "performs a search using the default filter, scope, and a limit of 1 when the first " +
 		   "record is requested" do
 			params = @params.merge( :limit => 1 )
-			@branch.should_receive( :search ).
+			expect( @branch ).to receive( :search ).
 				with( Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter, params ).
 				and_return( [:first_matching_branch, :other_branches] )
 
-			@branchset.first.should == :first_matching_branch
+			expect( @branchset.first ).to eq( :first_matching_branch )
 		end
 
 		it "performs a search using the default filter, scope, and a limit of 5 when the first " +
 		   "five records are requested" do
 			params = @params.merge( :limit => 5 )
-			@branch.should_receive( :search ).
+			expect( @branch ).to receive( :search ).
 				with( Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter, params ).
 				and_return( [:branch1, :branch2, :branch3, :branch4, :branch5] )
 
-			@branchset.first( 5 ).should == [:branch1, :branch2, :branch3, :branch4, :branch5]
+			expect( @branchset.first( 5 ) ).to eq( [:branch1, :branch2, :branch3, :branch4, :branch5] )
 		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)'
+			expect( newset.filter_string ).to eq( '(clothing=pants)' )
 		end
 
 		#
@@ -237,7 +213,7 @@ describe Treequel::Branchset do
 			pantset = @branchset.filter( :clothing => 'pants' )
 			bothset = pantset.or( :clothing => 'shirt' )
 
-			bothset.filter_string.should == '(|(clothing=pants)(clothing=shirt))'
+			expect( bothset.filter_string ).to eq( '(|(clothing=pants)(clothing=shirt))' )
 		end
 
 		it "raises an exception if #or is invoked without an existing filter" do
@@ -255,174 +231,139 @@ describe Treequel::Branchset do
 			pantset = @branchset.filter( :clothing => 'pants' )
 			notsmallset = pantset.not( :size => 'small' )
 
-			notsmallset.filter_string.should == '(&(clothing=pants)(!(size=small)))'
+			expect( notsmallset.filter_string ).to eq( '(&(clothing=pants)(!(size=small)))' )
 		end
 
 
-		# 
+		#
 		# #scope
-		# 
+		#
 
 		it "provides a reader for its scope" do
-			@branchset.scope.should == :subtree
+			expect( @branchset.scope ).to eq( :subtree )
 		end
 
 		it "can return the DN of its base" do
-			@branch.should_receive( :dn ).and_return( :foo )
-			@branchset.base_dn.should == :foo
+			expect( @branch ).to receive( :dn ).and_return( :foo )
+			expect( @branchset.base_dn ).to eq( :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
+			expect( newset ).to be_a( Treequel::Branchset )
+			expect( newset ).to_not equal( @branchset )
+			expect( newset.options ).to_not equal( @branchset.options )
+			expect( newset.scope ).to eq( :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
+			expect( newset.scope ).to eq( :sub )
 		end
 
 		it "uses its scope setting as the scope to use when searching" do
 			@branchset.options[:scope] = :onelevel
-			@branch.should_receive( :search ).
+			expect( @branch ).to receive( :search ).
 				with( :onelevel, @branchset.filter, @params ).
 				and_yield( :matching_branches )
 
-			@branchset.all.should == [:matching_branches]
+			expect( @branchset.all ).to eq( [: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' ]
+			expect( newset.select ).to eq( [ '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 == []
+			expect( newset.select ).to eq( [] )
 		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' ]
+			expect( newset.select ).to eq( [ 'l', 'cn', 'uid', 'firstName', 'lastName' ] )
 		end
 
 		it "adding attributes via #select_more should work even if there was no current " +
 		   "attribute selection" do
 			newset = @branchset.select_more( :firstName, :uid, :lastName, :objectClass )
-			newset.select.should include( 'uid', 'firstName', 'lastName', 'objectClass' )
+			expect( newset.select ).to include( 'uid', 'firstName', 'lastName', 'objectClass' )
 		end
 
 		it "uses its selection as the list of attributes to fetch when searching" do
 			@branchset.options[:select] = [ :l, :cn, :uid ]
-			@branch.should_receive( :search ).
+			expect( @branch ).to receive( :search ).
 				with( Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter,
 				      @params.merge(:selectattrs => ['l', 'cn', 'uid']) ).
 				and_yield( :matching_branches )
 
-			@branchset.all.should == [:matching_branches]
+			expect( @branchset.all ).to eq( [: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
+			expect( newset.timeout ).to eq( 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
+			expect( newset.timeout ).to eq( 0 )
 		end
 
 		it "uses its timeout as the timeout values when searching" do
 			@branchset.options[:timeout] = 5.375
-			@branch.should_receive( :search ).
+			expect( @branch ).to receive( :search ).
 				with( 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
-
-		# 
+			expect( @branchset.all ).to eq( [: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
+			expect( newset.limit ).to eq( 5 )
 		end
 
 		it "can create a new branchset cloned from itself without a limit" do
 			newset = @branchset.without_limit
-			newset.limit.should == 0
+			expect( newset.limit ).to eq( 0 )
 		end
 
 		it "uses its limit as the limit when searching" do
 			@branchset.options[:limit] = 8
-			@branch.should_receive( :search ).
+			expect( @branch ).to receive( :search ).
 				with( Treequel::Branchset::DEFAULT_SCOPE, @branchset.filter,
 				      @params.merge(:limit => 8) ).
 				and_yield( :matching_branches )
 
-			@branchset.all.should == [:matching_branches]
+			expect( @branchset.all ).to eq( [:matching_branches] )
 		end
 
-		# 
+		#
 		# #as
-		# 
+		#
 		it "can create a new branchset cloned from itself that will return instances of a " +
 		   "different branch class" do
 			subclass = Class.new( Treequel::Branch )
-			@branch.stub( :directory ).and_return( :the_directory )
-			@branch.stub( :dn ).and_return( TEST_HOSTS_DN )
+			expect( @branch ).to receive( :directory ).and_return( :the_directory )
+			expect( @branch ).to receive( :dn ).at_least( :once ).and_return( TEST_HOSTS_DN )
 			newset = @branchset.as( subclass )
-			newset.branch.should be_an_instance_of( subclass )
+			expect( newset.branch ).to be_an_instance_of( subclass )
 		end
 
 
@@ -431,14 +372,14 @@ describe Treequel::Branchset do
 		#
 		it "can create a new branchset cloned from itself with a different base DN (String)" do
 			newset = @branchset.from( TEST_SUBHOSTS_DN )
-			newset.base_dn.should == TEST_SUBHOSTS_DN
+			expect( newset.base_dn ).to eq( TEST_SUBHOSTS_DN )
 		end
 
 		it "can create a new branchset cloned from itself with a different base DN " +
 		   "(Treequel::Branch)" do
 			branch = Treequel::Branch.new( @directory, TEST_SUBHOSTS_DN )
 			newset = @branchset.from( branch )
-			newset.base_dn.should == TEST_SUBHOSTS_DN
+			expect( newset.base_dn ).to eq( TEST_SUBHOSTS_DN )
 		end
 
 
@@ -447,7 +388,7 @@ describe Treequel::Branchset do
 		#
 		it "can create a new branchset cloned from itself with operational attributes selected" do
 			newset = @branchset.with_operational_attributes
-			newset.options[:select].should include( :+ )
+			expect( newset.options[:select] ).to include( :+ )
 		end
 
 
@@ -462,15 +403,15 @@ describe Treequel::Branchset do
 
 
 		it "generates a valid filter string" do
-			@branchset.filter_string.should == '(objectClass=*)'
+			expect( @branchset.filter_string ).to eq( '(objectClass=*)' )
 		end
 
 		it "performs a search using the default filter and scope when all records are requested" do
-			@branch.should_receive( :search ).
+			expect( @branch ).to receive( :search ).
 				with( :onelevel, @branchset.filter, @params ).
 				and_yield( :matching_branches )
 
-			@branchset.all.should == [:matching_branches]
+			expect( @branchset.all ).to eq( [:matching_branches] )
 		end
 
 	end
@@ -489,7 +430,7 @@ describe Treequel::Branchset do
 		end
 
 		before( :each ) do
-			@directory.stub( :registered_controls ).and_return([ @control ])
+			allow( @directory ).to receive( :registered_controls ).and_return([ @control ])
 		end
 
 		after( :each ) do
@@ -498,21 +439,21 @@ describe Treequel::Branchset do
 
 		it "extends instances of itself with any controls registered with its Branch's Directory" do
 			set = Treequel::Branchset.new( @branch )
-			set.should respond_to( :yep )
+			expect( set ).to respond_to( :yep )
 		end
 
 		it "appends client controls to search arguments" do
-			resultbranch = mock( "Result Branch" )
+			resultbranch = double( "Result Branch" )
 			set = Treequel::Branchset.new( @branch )
 
 			@params[:server_controls] = [:server_control]
 			@params[:client_controls] = [:client_control]
 
-			@branch.should_receive( :search ).
+			expect( @branch ).to receive( :search ).
 				with( Treequel::Branchset::DEFAULT_SCOPE, set.filter, @params ).
 				and_yield( resultbranch )
 
-			set.all.should == [ resultbranch ]
+			expect( set.all ).to eq( [ resultbranch ] )
 		end
 
 	end