treequel 1.11.0 → 1.12.0

data/spec/treequel/mixins_spec.rb

@@ -1,33 +1,12 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+#encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-
-	libdir = basedir + "lib"
-	extdir = basedir + "ext"
-
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
-	$LOAD_PATH.unshift( extdir ) unless $LOAD_PATH.include?( extdir )
-}
-
-require 'rspec'
-
-require 'spec/lib/constants'
-require 'spec/lib/helpers'
+require_relative '../spec_helpers'
 
 require 'treequel'
 require 'treequel/mixins'
 
 
-include Treequel::TestConstants
-include Treequel::Constants
-
-#####################################################################
-###	C O N T E X T S
-#####################################################################
-
 describe Treequel, "mixin" do
 
 	describe Treequel::Loggable, "mixed into a class" do
@@ -49,7 +28,7 @@ describe Treequel, "mixin" do
 
 		it "is able to output to the log via its #log method" do
 			@obj.log_test_message( :debug, "debugging message" )
-			@log_output.last.should =~ /debugging message/i
+			expect( @log_output.last ).to match( /debugging message/i )
 		end
 	end
 
@@ -65,15 +44,15 @@ describe Treequel, "mixin" do
 
 			result = Treequel::HashUtilities.stringify_keys( testhash )
 
-			result.should be_an_instance_of( Hash )
-			result.should_not be_equal( testhash )
-			result.should == {
+			expect( result ).to be_an_instance_of( Hash )
+			expect( result ).to_not be_equal( testhash )
+			expect( result ).to eq(
 				'foo' => 1,
 				'bar' => {
 					'klang' => 'klong',
 					'barang' => { 'kerklang' => 'dumdumdum' },
 				}
-			}
+			)
 		end
 
 
@@ -88,15 +67,15 @@ describe Treequel, "mixin" do
 
 			result = Treequel::HashUtilities.symbolify_keys( testhash )
 
-			result.should be_an_instance_of( Hash )
-			result.should_not be_equal( testhash )
-			result.should == {
+			expect( result ).to be_an_instance_of( Hash )
+			expect( result ).to_not be_equal( testhash )
+			expect( result ).to eq(
 				:foo => 1,
 				:bar => {
 					:klang => 'klong',
 					:barang => { :kerklang => 'dumdumdum' },
 				}
-			}
+			)
 		end
 
 		it "includes a function that can be used as the key-collision callback for " +
@@ -117,15 +96,15 @@ describe Treequel, "mixin" do
 				}
 			}
 
-			hash1.merge( hash2, &Treequel::HashUtilities.method(:merge_recursively) ).should == {
+			expect( hash1.merge( hash2, &Treequel::HashUtilities.method(:merge_recursively) ) ).to eq(
 				:foo => 1,
 				:bar => [:one, :locke],
 				:baz => {
 					:glom => [:chunker, :plunker],
 					:trim => :liquor,
 				},
-				:klong => 88.8,
-			}
+				:klong => 88.8
+			)
 		end
 
 	end
@@ -137,9 +116,9 @@ describe Treequel, "mixin" do
 
 			result = Treequel::ArrayUtilities.stringify_array( testarray )
 
-			result.should be_an_instance_of( Array )
-			result.should_not be_equal( testarray )
-			result.should == ['a', 'b', 'c', ['d', 'e', ['f', 'g']]]
+			expect( result ).to be_an_instance_of( Array )
+			expect( result ).to_not be_equal( testarray )
+			expect( result ).to eq( ['a', 'b', 'c', ['d', 'e', ['f', 'g']]] )
 		end
 
 
@@ -148,19 +127,13 @@ describe Treequel, "mixin" do
 
 			result = Treequel::ArrayUtilities.symbolify_array( testarray )
 
-			result.should be_an_instance_of( Array )
-			result.should_not be_equal( testarray )
-			result.should == [:a, :b, :c, [:d, :e, [:f, :g]]]
+			expect( result ).to be_an_instance_of( Array )
+			expect( result ).to_not be_equal( testarray )
+			expect( result ).to eq( [:a, :b, :c, [:d, :e, [:f, :g]]] )
 		end
 	end
 
 	describe Treequel::AttributeDeclarations do
-		before( :all ) do
-			setup_logging( :fatal )
-		end
-		after( :all ) do
-			reset_logging()
-		end
 
 		describe "predicate attribute declaration" do
 			before( :all ) do
@@ -176,31 +149,24 @@ describe Treequel, "mixin" do
 			end
 
 			it "creates a plain predicate method" do
-				@testclass.new( true ).should be_testable()
-				@testclass.new( false ).should_not be_testable()
-				@testclass.new( 1 ).should be_testable()
-				@testclass.new( :something_else ).should be_testable()
+				expect( @testclass.new( true ) ).to be_testable()
+				expect( @testclass.new( false ) ).to_not be_testable()
+				expect( @testclass.new( 1 ) ).to be_testable()
+				expect( @testclass.new( :something_else ) ).to be_testable()
 			end
 
 			it "creates a mutator" do
 				obj = @testclass.new( true )
 				obj.testable = false
-				obj.should_not be_testable()
+				expect( obj ).to_not be_testable()
 				obj.testable = true
-				obj.should be_testable()
+				expect( obj ).to be_testable()
 			end
 		end
 	end
 
 	describe Treequel::Delegation do
 
-		before( :all ) do
-			setup_logging( :fatal )
-		end
-		after( :all ) do
-			reset_logging()
-		end
-
 		describe "method delegation" do
 			before( :all ) do
 				@testclass = Class.new do
@@ -220,35 +186,35 @@ describe Treequel, "mixin" do
 			end
 
 			before( :each ) do
-				@subobj = mock( "delegate" )
+				@subobj = double( "delegate" )
 				@obj = @testclass.new( @subobj )
 			end
 
 
 			it "can be used to set up delegation through a method" do
-				@subobj.should_receive( :delegated_method )
+				expect( @subobj ).to receive( :delegated_method )
 				@obj.delegated_method
 			end
 
 			it "passes any arguments through to the delegate object's method" do
-				@subobj.should_receive( :delegated_method ).with( :arg1, :arg2 )
+				expect( @subobj ).to receive( :delegated_method ).with( :arg1, :arg2 )
 				@obj.delegated_method( :arg1, :arg2 )
 			end
 
 			it "allows delegation to the delegate object's method with a block" do
-				@subobj.should_receive( :delegated_method ).with( :arg1 ).
+				expect( @subobj ).to receive( :delegated_method ).with( :arg1 ).
 					and_yield( :the_block_argument )
 				blockarg = nil
 				@obj.delegated_method( :arg1 ) {|arg| blockarg = arg }
-				blockarg.should == :the_block_argument
+				expect( blockarg ).to eq( :the_block_argument )
 			end
 
 			it "reports errors from its caller's perspective", :ruby_18 do
 				begin
 					@obj.erroring_delegated_method
 				rescue NoMethodError => err
-					err.message.should =~ /nonexistant_method/
-					err.backtrace.first.should =~ /#{__FILE__}/
+					expect( err.message ).to match( /nonexistant_method/ )
+					expect( err.backtrace.first ).to match( /#{__FILE__}/ )
 				rescue ::Exception => err
 					fail "Expected a NoMethodError, but got a %p (%s)" % [ err.class, err.message ]
 				else
@@ -274,35 +240,35 @@ describe Treequel, "mixin" do
 			end
 
 			before( :each ) do
-				@subobj = mock( "delegate" )
+				@subobj = double( "delegate" )
 				@obj = @testclass.new( @subobj )
 			end
 
 
 			it "can be used to set up delegation through a method" do
-				@subobj.should_receive( :delegated_method )
+				expect( @subobj ).to receive( :delegated_method )
 				@obj.delegated_method
 			end
 
 			it "passes any arguments through to the delegate's method" do
-				@subobj.should_receive( :delegated_method ).with( :arg1, :arg2 )
+				expect( @subobj ).to receive( :delegated_method ).with( :arg1, :arg2 )
 				@obj.delegated_method( :arg1, :arg2 )
 			end
 
 			it "allows delegation to the delegate's method with a block" do
-				@subobj.should_receive( :delegated_method ).with( :arg1 ).
+				expect( @subobj ).to receive( :delegated_method ).with( :arg1 ).
 					and_yield( :the_block_argument )
 				blockarg = nil
 				@obj.delegated_method( :arg1 ) {|arg| blockarg = arg }
-				blockarg.should == :the_block_argument
+				expect( blockarg ).to eq( :the_block_argument )
 			end
 
 			it "reports errors from its caller's perspective", :ruby_18 do
 				begin
 					@obj.erroring_delegated_method
 				rescue NoMethodError => err
-					err.message.should =~ /`erroring_delegated_method' for nil/
-					err.backtrace.first.should =~ /#{__FILE__}/
+					expect( err.message ).to match( /`erroring_delegated_method' for nil/ )
+					expect( err.backtrace.first ).to match( /#{__FILE__}/ )
 				rescue ::Exception => err
 					fail "Expected a NoMethodError, but got a %p (%s)" % [ err.class, err.message ]
 				else
@@ -318,19 +284,19 @@ describe Treequel, "mixin" do
 
 		describe "key normalization" do
 			it "downcases" do
-				Treequel::Normalization.normalize_key( :logonTime ).should == :logontime
+				expect( Treequel::Normalization.normalize_key( :logonTime ) ).to eq( :logontime )
 			end
 
 			it "symbolifies" do
-				Treequel::Normalization.normalize_key( 'cn' ).should == :cn
+				expect( Treequel::Normalization.normalize_key( 'cn' ) ).to eq( :cn )
 			end
 
 			it "strips invalid characters" do
-				Treequel::Normalization.normalize_key( 'given name' ).should == :givenname
+				expect( Treequel::Normalization.normalize_key( 'given name' ) ).to eq( :givenname )
 			end
 
 			it "converts hyphens to underscores" do
-				Treequel::Normalization.normalize_key( 'apple-nickname' ).should == :apple_nickname
+				expect( Treequel::Normalization.normalize_key( 'apple-nickname' ) ).to eq( :apple_nickname )
 			end
 		end
 
@@ -343,12 +309,12 @@ describe Treequel, "mixin" do
 					'apple-nickname' => 'a nickname',
 				}
 
-				Treequel::Normalization.normalize_hash( hash ).should == {
+				expect( Treequel::Normalization.normalize_hash( hash ) ).to eq(
 					:logontime      => 'a logon time',
 					:cn             => 'a common name',
 					:givenname      => 'a given name',
 					:apple_nickname => 'a nickname',
-				}
+				)
 			end
 		end
 	end

data/spec/treequel/model/errors_spec.rb

@@ -1,48 +1,24 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+#encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.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/helpers'
+require_relative '../../spec_helpers'
 
 require 'treequel/model'
 require 'treequel/model/errors'
 require 'treequel/branchset'
 
 
-
-#####################################################################
-###	C O N T E X T S
-#####################################################################
-
 describe Treequel::Model::Errors do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
 	before( :each ) do
 		@errors = Treequel::Model::Errors.new
 	end
 
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "allows the addition of errors" do
 		@errors.add( :cn, "Not a common name." )
-		@errors[:cn].should have( 1 ).member
-		@errors[:cn].should include( "Not a common name." )
+		expect( @errors[:cn].length ).to eq( 1 )
+		expect( @errors[:cn] ).to include( "Not a common name." )
 	end
 
 	it "knows how many errors there are" do
@@ -50,25 +26,25 @@ describe Treequel::Model::Errors do
 		@errors.add( :description, "must be this tall to ride" )
 		@errors.add( :description, "must have at least one value" )
 
-		@errors.count.should == 3
+		expect( @errors.count ).to eq( 3 )
 	end
 
 	it "is empty if there haven't been any errors registered" do
-		@errors.should be_empty()
+		expect( @errors ).to be_empty()
 	end
 
 	it "isn't empty if there have been errors registered" do
 		@errors.add( :uid, 'duplicate value' )
-		@errors.should_not be_empty()
+		expect( @errors ).to_not be_empty()
 	end
 
 	it "can build an array of error messages" do
 		@errors.add( :l, "is not a valid location" )
 		@errors.add( [:givenName, :sn, :displayName], "must be unique" )
 
-		@errors.full_messages.should have( 2 ).members
-		@errors.full_messages.should include( "givenName and sn and displayName must be unique" )
-		@errors.full_messages.should include( "l is not a valid location" )
+		expect( @errors.full_messages.length ).to eq( 2 )
+		expect( @errors.full_messages ).to include( "givenName and sn and displayName must be unique" )
+		expect( @errors.full_messages ).to include( "l is not a valid location" )
 	end
 
 end

data/spec/treequel/model/objectclass_spec.rb

@@ -1,37 +1,17 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+#encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.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/helpers'
+require_relative '../../spec_helpers'
 
 require 'treequel/model'
 require 'treequel/model/objectclass'
 require 'treequel/branchset'
 
 
-
-#####################################################################
-###	C O N T E X T S
-#####################################################################
-
 describe Treequel::Model::ObjectClass do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
 	before( :each ) do
-		@conn = mock( "ldap connection object" )
+		@conn = double( "ldap connection object" )
 		@directory = get_fixtured_directory( @conn )
 		Treequel::Model.directory = @directory
 	end
@@ -42,13 +22,9 @@ describe Treequel::Model::ObjectClass do
 		Treequel::Model.base_registry.clear
 	end
 
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "outputs a warning when it is included instead of used to extend a Module" do
-		Treequel::Model::ObjectClass.should_receive( :warn ).
+		expect( Treequel::Model::ObjectClass ).to receive( :warn ).
 			with( /extending.*rather than appending/i )
 		mixin = Module.new do
 			include Treequel::Model::ObjectClass
@@ -64,7 +40,7 @@ describe Treequel::Model::ObjectClass do
 				model_objectclasses :inetOrgPerson
 			end
 
-			mixin.model_objectclasses.should == [:inetOrgPerson]
+			expect( mixin.model_objectclasses ).to eq( [:inetOrgPerson] )
 		end
 
 		it "can declare a required objectClass as a String" do
@@ -73,7 +49,7 @@ describe Treequel::Model::ObjectClass do
 				model_objectclasses 'apple-computer-list'
 			end
 
-			mixin.model_objectclasses.should == [:'apple-computer-list']
+			expect( mixin.model_objectclasses ).to eq( [:'apple-computer-list'] )
 		end
 
 		it "can declare multiple required objectClasses" do
@@ -82,18 +58,18 @@ describe Treequel::Model::ObjectClass do
 				model_objectclasses :inetOrgPerson, :acmeAccount
 			end
 
-			mixin.model_objectclasses.should == [ :inetOrgPerson, :acmeAccount ]
+			expect( mixin.model_objectclasses ).to eq( [ :inetOrgPerson, :acmeAccount ] )
 		end
 
 		it "can declare a single base" do
 			mixin = Module.new do
 				extend Treequel::Model::ObjectClass,
-				       Treequel::TestConstants
+				       Treequel::SpecConstants
 				model_objectclasses :device
 				model_bases TEST_PHONES_DN
 			end
 
-			mixin.model_bases.should == [TEST_PHONES_DN]
+			expect( mixin.model_bases ).to eq( [TEST_PHONES_DN] )
 		end
 
 		it "can declare a base with spaces" do
@@ -103,19 +79,19 @@ describe Treequel::Model::ObjectClass do
 				model_bases 'ou=phones, dc=acme, dc=com'
 			end
 
-			mixin.model_bases.should == ['ou=phones,dc=acme,dc=com']
+			expect( mixin.model_bases ).to eq( ['ou=phones,dc=acme,dc=com'] )
 		end
 
 		it "can declare multiple bases" do
 			mixin = Module.new do
 				extend Treequel::Model::ObjectClass,
-				       Treequel::TestConstants
+				       Treequel::SpecConstants
 				model_objectclasses :ipHost
 				model_bases TEST_HOSTS_DN,
 				            TEST_SUBHOSTS_DN
 			end
 
-			mixin.model_bases.should include( TEST_HOSTS_DN, TEST_SUBHOSTS_DN )
+			expect( mixin.model_bases ).to include( TEST_HOSTS_DN, TEST_SUBHOSTS_DN )
 		end
 
 		it "raises an exception when creating a search for a mixin that hasn't declared " +
@@ -134,7 +110,7 @@ describe Treequel::Model::ObjectClass do
 				extend Treequel::Model::ObjectClass
 			end
 
-			mixin.model_class.should == Treequel::Model
+			expect( mixin.model_class ).to eq( Treequel::Model )
 		end
 
 		it "can declare a model class other than Treequel::Model" do
@@ -144,7 +120,7 @@ describe Treequel::Model::ObjectClass do
 				model_class MyModel
 			end
 
-			mixin.model_class.should == MyModel
+			expect( mixin.model_class ).to eq( MyModel )
 		end
 
 		it "re-registers objectClasses that have already been declared when declaring a " +
@@ -157,8 +133,8 @@ describe Treequel::Model::ObjectClass do
 				model_class MyModel
 			end
 
-			Treequel::Model.objectclass_registry[:inetOrgPerson].should_not include( mixin )
-			MyModel.objectclass_registry[:inetOrgPerson].should include( mixin )
+			expect( Treequel::Model.objectclass_registry[:inetOrgPerson] ).to_not include( mixin )
+			expect( MyModel.objectclass_registry[:inetOrgPerson] ).to include( mixin )
 		end
 
 		it "re-registers bases that have already been declared when declaring a " +
@@ -171,8 +147,8 @@ describe Treequel::Model::ObjectClass do
 				model_class MyModel
 			end
 
-			Treequel::Model.base_registry['ou=people,dc=acme,dc=com'].should_not include( mixin )
-			MyModel.base_registry['ou=people,dc=acme,dc=com'].should include( mixin )
+			expect( Treequel::Model.base_registry['ou=people,dc=acme,dc=com'] ).to_not include( mixin )
+			expect( MyModel.base_registry['ou=people,dc=acme,dc=com'] ).to include( mixin )
 		end
 
 		it "re-registers bases that have already been declared when declaring a " +
@@ -185,13 +161,13 @@ describe Treequel::Model::ObjectClass do
 				model_class MyModel
 			end
 
-			Treequel::Model.base_registry['ou=people,dc=acme,dc=com'].should_not include( mixin )
-			MyModel.base_registry['ou=people,dc=acme,dc=com'].should include( mixin )
+			expect( Treequel::Model.base_registry['ou=people,dc=acme,dc=com'] ).to_not include( mixin )
+			expect( MyModel.base_registry['ou=people,dc=acme,dc=com'] ).to include( mixin )
 		end
 
 		it "uses the directory associated with its model_class instead of Treequel::Model's if " +
 		   "its model_class is set when creating a search Branchset"  do
-			conn = mock( "ldap connection object" )
+			conn = double( "ldap connection object" )
 			directory = get_fixtured_directory( conn )
 
 			class MyModel < Treequel::Model; end
@@ -205,8 +181,8 @@ describe Treequel::Model::ObjectClass do
 
 			result = mixin.search
 
-			result.should be_a( Treequel::Branchset )
-			result.branch.directory.should == directory
+			expect( result ).to be_a( Treequel::Branchset )
+			expect( result.branch.directory ).to eq( directory )
 		end
 
 		it "delegates Branchset methods through the Branchset returned by its #search method" do
@@ -215,13 +191,13 @@ describe Treequel::Model::ObjectClass do
 				model_objectclasses :inetOrgPerson
 			end
 
-			mixin.filter( :mail ).should be_a( Treequel::Branchset )
+			expect( mixin.filter( :mail ) ).to be_a( Treequel::Branchset )
 		end
 
 		it "delegates Branchset Enumerable methods through the Branchset returned by its " +
 		   "#search method" do
-			@conn.stub( :bound? ).and_return( true )
-			@conn.should_receive( :search_ext2 ).
+			expect( @conn ).to receive( :bound? ).and_return( true )
+			expect( @conn ).to receive( :search_ext2 ).
 				with( TEST_BASE_DN, LDAP::LDAP_SCOPE_SUBTREE, "(objectClass=inetOrgPerson)",
 			          [], false, [], [], 0, 0, 1, "", nil ).
 				and_return([ TEST_PERSON_ENTRY ])
@@ -233,9 +209,9 @@ describe Treequel::Model::ObjectClass do
 
 			result = mixin.first
 
-			result.should be_a( Treequel::Model )
-			result.should be_a( mixin )
-			result.dn.should == TEST_PERSON_ENTRY['dn'].first
+			expect( result ).to be_a( Treequel::Model )
+			expect( result ).to be_a( mixin )
+			expect( result.dn ).to eq( TEST_PERSON_ENTRY['dn'].first )
 		end
 
 	end
@@ -249,9 +225,9 @@ describe Treequel::Model::ObjectClass do
 			end
 
 			result = mixin.create( TEST_PERSON_DN )
-			result.should be_a( Treequel::Model )
-			result[:objectClass].should include( 'inetOrgPerson' )
-			result[TEST_PERSON_DN_ATTR].should == [ TEST_PERSON_DN_VALUE ]
+			expect( result ).to be_a( Treequel::Model )
+			expect( result[:objectClass] ).to include( 'inetOrgPerson' )
+			expect( result[TEST_PERSON_DN_ATTR] ).to eq( [ TEST_PERSON_DN_VALUE ] )
 		end
 
 		it "can instantiate a new model object with its declared objectClasses in a directory " +
@@ -262,9 +238,9 @@ describe Treequel::Model::ObjectClass do
 			end
 
 			result = mixin.create( @directory, TEST_PERSON_DN )
-			result.should be_a( Treequel::Model )
-			result[:objectClass].should include( 'inetOrgPerson' )
-			result[TEST_PERSON_DN_ATTR].should == [ TEST_PERSON_DN_VALUE ]
+			expect( result ).to be_a( Treequel::Model )
+			expect( result[:objectClass] ).to include( 'inetOrgPerson' )
+			expect( result[TEST_PERSON_DN_ATTR] ).to eq( [ TEST_PERSON_DN_VALUE ] )
 		end
 
 		it "doesn't add the extracted DN attribute if it's already present in the entry" do
@@ -275,10 +251,10 @@ describe Treequel::Model::ObjectClass do
 
 			result = mixin.create( TEST_PERSON_DN,
 				TEST_PERSON_DN_ATTR => [TEST_PERSON_DN_VALUE] )
-			result.should be_a( Treequel::Model )
-			result[:objectClass].should include( 'inetOrgPerson' )
-			result[TEST_PERSON_DN_ATTR].should have( 1 ).member
-			result[TEST_PERSON_DN_ATTR].should == [ TEST_PERSON_DN_VALUE ]
+			expect( result ).to be_a( Treequel::Model )
+			expect( result[:objectClass] ).to include( 'inetOrgPerson' )
+			expect( result[TEST_PERSON_DN_ATTR].length ).to eq( 1 )
+			expect( result[TEST_PERSON_DN_ATTR] ).to eq( [ TEST_PERSON_DN_VALUE ] )
 		end
 
 		it "merges objectClasses passed to the creation method" do
@@ -289,11 +265,11 @@ describe Treequel::Model::ObjectClass do
 
 			result = mixin.create( TEST_PERSON_DN,
 				:objectClass => [:person, :inetOrgPerson] )
-			result.should be_a( Treequel::Model )
-			result[:objectClass].should have( 2 ).members
-			result[:objectClass].should include( 'inetOrgPerson', 'person' )
-			result[TEST_PERSON_DN_ATTR].should have( 1 ).member
-			result[TEST_PERSON_DN_ATTR].should include( TEST_PERSON_DN_VALUE )
+			expect( result ).to be_a( Treequel::Model )
+			expect( result[:objectClass].length ).to eq( 2 )
+			expect( result[:objectClass] ).to include( 'inetOrgPerson', 'person' )
+			expect( result[TEST_PERSON_DN_ATTR].length ).to eq( 1 )
+			expect( result[TEST_PERSON_DN_ATTR] ).to include( TEST_PERSON_DN_VALUE )
 		end
 
 		it "handles the creation of objects with multi-value DNs" do
@@ -303,11 +279,11 @@ describe Treequel::Model::ObjectClass do
 			end
 
 			result = mixin.create( TEST_HOST_MULTIVALUE_DN )
-			result.should be_a( Treequel::Model )
-			result[:objectClass].should have( 3 ).members
-			result[:objectClass].should include( 'ipHost', 'ieee802Device', 'device' )
-			result[TEST_HOST_MULTIVALUE_DN_ATTR1].should include( TEST_HOST_MULTIVALUE_DN_VALUE1 )
-			result[TEST_HOST_MULTIVALUE_DN_ATTR2].should include( TEST_HOST_MULTIVALUE_DN_VALUE2 )
+			expect( result ).to be_a( Treequel::Model )
+			expect( result[:objectClass].length ).to eq( 3 )
+			expect( result[:objectClass] ).to include( 'ipHost', 'ieee802Device', 'device' )
+			expect( result[TEST_HOST_MULTIVALUE_DN_ATTR1] ).to include( TEST_HOST_MULTIVALUE_DN_VALUE1 )
+			expect( result[TEST_HOST_MULTIVALUE_DN_ATTR2] ).to include( TEST_HOST_MULTIVALUE_DN_VALUE2 )
 		end
 
 	end
@@ -315,7 +291,7 @@ describe Treequel::Model::ObjectClass do
 	context "module that has one required objectClass declared" do
 
 		before( :each ) do
-			@conn = mock( "ldap connection object" )
+			@conn = double( "ldap connection object" )
 			@directory = get_fixtured_directory( @conn )
 			Treequel::Model.directory = @directory
 
@@ -331,35 +307,33 @@ describe Treequel::Model::ObjectClass do
 
 
 		it "is returned as one of the mixins for entries with only that objectClass" do
-			Treequel::Model.mixins_for_objectclasses( :inetOrgPerson ).
-				should include( @mixin )
+			expect( Treequel::Model.mixins_for_objectclasses(:inetOrgPerson) ).to include( @mixin )
 		end
 
 		it "is not returned in the list of mixins to apply to an entry without that objectClass" do
-			Treequel::Model.mixins_for_objectclasses( :device ).
-				should_not include( @mixin )
+			expect( Treequel::Model.mixins_for_objectclasses(:device) ).to_not include( @mixin )
 		end
 
 		it "can create a Branchset that will search for applicable entries"  do
 			result = @mixin.search
 
-			result.should be_a( Treequel::Branchset )
-			result.base_dn.should == TEST_BASE_DN
-			result.filter.to_s.should == '(objectClass=inetOrgPerson)'
-			result.branch.directory.should == @directory
+			expect( result ).to be_a( Treequel::Branchset )
+			expect( result.base_dn ).to eq( TEST_BASE_DN )
+			expect( result.filter.to_s ).to eq( '(objectClass=inetOrgPerson)' )
+			expect( result.branch.directory ).to eq( @directory )
 		end
 
 		it "can create a Branchset that will search for applicable entries in a Directory other " +
 		   "than the one set for Treequel::Model"  do
-			conn = mock( "second ldap connection object" )
+			conn = double( "second ldap connection object" )
 			directory = get_fixtured_directory( conn )
 
 			result = @mixin.search( directory )
 
-			result.should be_a( Treequel::Branchset )
-			result.base_dn.should == TEST_BASE_DN
-			result.filter.to_s.should == '(objectClass=inetOrgPerson)'
-			result.branch.directory.should == directory
+			expect( result ).to be_a( Treequel::Branchset )
+			expect( result.base_dn ).to eq( TEST_BASE_DN )
+			expect( result.filter.to_s ).to eq( '(objectClass=inetOrgPerson)' )
+			expect( result.branch.directory ).to eq( directory )
 		end
 
 	end
@@ -380,36 +354,34 @@ describe Treequel::Model::ObjectClass do
 
 		it "is returned as one of the mixins to apply to entries with all of its required " +
 		     "objectClasses" do
-			Treequel::Model.mixins_for_objectclasses( :device, :ipHost ).
-				should include( @mixin )
+			expect( Treequel::Model.mixins_for_objectclasses(:device, :ipHost) ).to include( @mixin )
 		end
 
 		it "is not returned in the list of mixins to apply to an entry with only one of its " +
 		     "objectClasses" do
-			Treequel::Model.mixins_for_objectclasses( :device ).
-				should_not include( @mixin )
+			expect( Treequel::Model.mixins_for_objectclasses(:device) ).to_not include( @mixin )
 		end
 
 		it "can create a Branchset that will search for applicable entries"  do
 			result = @mixin.search
 
-			result.should be_a( Treequel::Branchset )
-			result.base_dn.should == TEST_BASE_DN
-			result.filter.to_s.should == '(&(objectClass=device)(objectClass=ipHost))'
-			result.branch.directory.should == @directory
+			expect( result ).to be_a( Treequel::Branchset )
+			expect( result.base_dn ).to eq( TEST_BASE_DN )
+			expect( result.filter.to_s ).to eq( '(&(objectClass=device)(objectClass=ipHost))' )
+			expect( result.branch.directory ).to eq( @directory )
 		end
 
 		it "can create a Branchset that will search for applicable entries in a Directory other " +
 		   "than the one set for Treequel::Model"  do
-			conn = mock( "second ldap connection object" )
+			conn = double( "second ldap connection object" )
 			directory = get_fixtured_directory( conn )
 
 			result = @mixin.search( directory )
 
-			result.should be_a( Treequel::Branchset )
-			result.base_dn.should == TEST_BASE_DN
-			result.filter.to_s.should == '(&(objectClass=device)(objectClass=ipHost))'
-			result.branch.directory.should == directory
+			expect( result ).to be_a( Treequel::Branchset )
+			expect( result.base_dn ).to eq( TEST_BASE_DN )
+			expect( result.filter.to_s ).to eq( '(&(objectClass=device)(objectClass=ipHost))' )
+			expect( result.branch.directory ).to eq( directory )
 		end
 
 	end
@@ -418,7 +390,7 @@ describe Treequel::Model::ObjectClass do
 		before( :each ) do
 			@mixin = Module.new do
 				extend Treequel::Model::ObjectClass,
-				       Treequel::TestConstants
+				       Treequel::SpecConstants
 				model_bases TEST_PEOPLE_DN
 			end
 		end
@@ -429,36 +401,34 @@ describe Treequel::Model::ObjectClass do
 
 
 		it "is returned as one of the mixins to apply to an entry that is a child of its base" do
-			Treequel::Model.mixins_for_dn( TEST_PERSON_DN ).
-				should include( @mixin )
+			expect( Treequel::Model.mixins_for_dn(TEST_PERSON_DN) ).to include( @mixin )
 		end
 
 		it "is not returned as one of the mixins to apply to an entry that is not a child of " +
 		   "its base" do
-			Treequel::Model.mixins_for_dn( TEST_ROOM_DN ).
-				should_not include( @mixin )
+			expect( Treequel::Model.mixins_for_dn(TEST_ROOM_DN) ).to_not include( @mixin )
 		end
 
 		it "can create a Branchset that will search for applicable entries"  do
 			result = @mixin.search
 
-			result.should be_a( Treequel::Branchset )
-			result.base_dn.should == TEST_PEOPLE_DN
-			result.filter.to_s.should == '(objectClass=*)'
-			result.branch.directory.should == @directory
+			expect( result ).to be_a( Treequel::Branchset )
+			expect( result.base_dn ).to eq( TEST_PEOPLE_DN )
+			expect( result.filter.to_s ).to eq( '(objectClass=*)' )
+			expect( result.branch.directory ).to eq( @directory )
 		end
 
 		it "can create a Branchset that will search for applicable entries in a Directory other " +
 		   "than the one set for Treequel::Model"  do
-			conn = mock( "second ldap connection object" )
+			conn = double( "second ldap connection object" )
 			directory = get_fixtured_directory( conn )
 
 			result = @mixin.search( directory )
 
-			result.should be_a( Treequel::Branchset )
-			result.base_dn.should == TEST_PEOPLE_DN
-			result.filter.to_s.should == '(objectClass=*)'
-			result.branch.directory.should == directory
+			expect( result ).to be_a( Treequel::Branchset )
+			expect( result.base_dn ).to eq( TEST_PEOPLE_DN )
+			expect( result.filter.to_s ).to eq( '(objectClass=*)' )
+			expect( result.branch.directory ).to eq( directory )
 		end
 
 	end
@@ -467,7 +437,7 @@ describe Treequel::Model::ObjectClass do
 		before( :each ) do
 			@mixin = Module.new do
 				extend Treequel::Model::ObjectClass,
-				       Treequel::TestConstants
+				       Treequel::SpecConstants
 				model_bases TEST_HOSTS_DN,
 				            TEST_SUBHOSTS_DN
 			end
@@ -480,41 +450,39 @@ describe Treequel::Model::ObjectClass do
 
 		it "is returned as one of the mixins to apply to an entry that is a child of one of " +
 		   "its bases" do
-			Treequel::Model.mixins_for_dn( TEST_SUBHOST_DN ).
-				should include( @mixin )
+			expect( Treequel::Model.mixins_for_dn(TEST_SUBHOST_DN) ).to include( @mixin )
 		end
 
 		it "is not returned as one of the mixins to apply to an entry that is not a child of " +
 		   "its base" do
-			Treequel::Model.mixins_for_dn( TEST_PERSON_DN ).
-				should_not include( @mixin )
+			expect( Treequel::Model.mixins_for_dn(TEST_PERSON_DN) ).to_not include( @mixin )
 		end
 
 		it "can create a BranchCollection that will search for applicable entries"  do
 			result = @mixin.search
 
-			result.should be_a( Treequel::BranchCollection )
-			result.base_dns.should have( 2 ).members
-			result.base_dns.should include( TEST_HOSTS_DN, TEST_SUBHOSTS_DN )
+			expect( result ).to be_a( Treequel::BranchCollection )
+			expect( result.base_dns.length ).to eq( 2 )
+			expect( result.base_dns ).to include( TEST_HOSTS_DN, TEST_SUBHOSTS_DN )
 			result.branchsets.each do |brset|
-				brset.filter_string.should == '(objectClass=*)'
-				brset.branch.directory.should == @directory
+				expect( brset.filter_string ).to eq( '(objectClass=*)' )
+				expect( brset.branch.directory ).to eq( @directory )
 			end
 		end
 
 		it "can create a BranchCollection that will search for applicable entries in a Directory " +
 		   " other than the one set for Treequel::Model"  do
-			conn = mock( "second ldap connection object" )
+			conn = double( "second ldap connection object" )
 			directory = get_fixtured_directory( conn )
 
 			result = @mixin.search( directory )
 
-			result.should be_a( Treequel::BranchCollection )
-			result.base_dns.should have( 2 ).members
-			result.base_dns.should include( TEST_HOSTS_DN, TEST_SUBHOSTS_DN )
+			expect( result ).to be_a( Treequel::BranchCollection )
+			expect( result.base_dns.length ).to eq( 2 )
+			expect( result.base_dns ).to include( TEST_HOSTS_DN, TEST_SUBHOSTS_DN )
 			result.branchsets.each do |brset|
-				brset.filter_string.should == '(objectClass=*)'
-				brset.branch.directory.should == directory
+				expect( brset.filter_string ).to eq( '(objectClass=*)' )
+				expect( brset.branch.directory ).to eq( directory )
 			end
 		end