treequel 1.11.0 → 1.12.0

data/spec/treequel/schema/table_spec.rb

@@ -1,19 +1,8 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+#encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+require_relative '../../spec_helpers'
 
-	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 'yaml'
 require 'ldap'
@@ -21,126 +10,109 @@ require 'ldap/schema'
 require 'treequel/schema'
 
 
-include Treequel::TestConstants
-include Treequel::Constants
-
-#####################################################################
-###	C O N T E X T S
-#####################################################################
-
 describe Treequel::Schema::Table do
 	include Treequel::SpecHelpers
 
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	before( :each ) do
-		@table = Treequel::Schema::Table.new
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
+	let( :table ) { described_class.new }
 
 
 	it "allows setting/fetching case-insensitively" do
-		@table['organizationalRole'] = :or
-		@table["apple-preset-computer-list"] = :applepreset
-		@table.deltaCRL = :deltacrl
-
-		@table['organizationalrole'].should == :or
-		@table[:organizationalrole].should == :or
-		@table.organizationalRole.should == :or
-		@table.organizationalrole.should == :or
-
-		@table[:"apple-preset-computer-list"].should == :applepreset
-		@table['apple-preset-computer-list'].should == :applepreset
-		@table[:apple_preset_computer_list].should == :applepreset
-		@table.apple_preset_computer_list.should == :applepreset
-
-		@table['deltacrl'].should == :deltacrl
-		@table[:deltaCRL].should == :deltacrl
-		@table[:deltacrl].should == :deltacrl
-		@table.deltaCRL.should == :deltacrl
-		@table.deltacrl.should == :deltacrl
+		table['organizationalRole'] = :or
+		table["apple-preset-computer-list"] = :applepreset
+		table.deltaCRL = :deltacrl
+
+		expect( table['organizationalrole'] ).to eq( :or )
+		expect( table[:organizationalrole] ).to eq( :or )
+		expect( table.organizationalRole ).to eq( :or )
+		expect( table.organizationalrole ).to eq( :or )
+
+		expect( table[:"apple-preset-computer-list"] ).to eq( :applepreset )
+		expect( table['apple-preset-computer-list'] ).to eq( :applepreset )
+		expect( table[:apple_preset_computer_list] ).to eq( :applepreset )
+		expect( table.apple_preset_computer_list ).to eq( :applepreset )
+
+		expect( table['deltacrl'] ).to eq( :deltacrl )
+		expect( table[:deltaCRL] ).to eq( :deltacrl )
+		expect( table[:deltacrl] ).to eq( :deltacrl )
+		expect( table.deltaCRL ).to eq( :deltacrl )
+		expect( table.deltacrl ).to eq( :deltacrl )
 
 	end
 
 
 	it "doesn't try to normalize numeric OIDs" do
-		@table['1.3.6.1.4.1.4203.666.11.1.4.2.1.2'] = :an_oid
-		@table['1.3.6.1.4.1.4203.666.11.1.4.2.1.2'].should == :an_oid
-		@table['13614142036661114212'].should_not == :an_oid
-		@table.keys.should include( '1.3.6.1.4.1.4203.666.11.1.4.2.1.2' )
+		table['1.3.6.1.4.1.4203.666.11.1.4.2.1.2'] = :an_oid
+		expect( table['1.3.6.1.4.1.4203.666.11.1.4.2.1.2'] ).to eq( :an_oid )
+		expect( table['13614142036661114212'] ).to_not eq( :an_oid )
+		expect( table.keys ).to include( '1.3.6.1.4.1.4203.666.11.1.4.2.1.2' )
 	end
 
 
 	it "merges other Tables" do
 		othertable = Treequel::Schema::Table.new
 
-		@table['ou'] = 'thing'
-		@table['cn'] = 'chunker'
+		table['ou'] = 'thing'
+		table['cn'] = 'chunker'
 
 		othertable['cn'] = 'phunker'
 
-		ot = @table.merge( othertable )
-		ot['ou'].should == 'thing'
-		ot['cn'].should == 'phunker'
+		ot = table.merge( othertable )
+		expect( ot['ou'] ).to eq( 'thing' )
+		expect( ot['cn'] ).to eq( 'phunker' )
 	end
 
 
 	it "merges hashes after normalizing keys" do
-		@table['ou'] = 'thing'
-		@table['apple-computer-list'] = 'trishtrash'
+		table['ou'] = 'thing'
+		table['apple-computer-list'] = 'trishtrash'
 
 		hash = { 'apple-computer-list' => 'pinhash' }
 
-		ot = @table.merge( hash )
-		ot['ou'].should == 'thing'
-		ot['apple-computer-list'].should == 'pinhash'
+		ot = table.merge( hash )
+		expect( ot['ou'] ).to eq( 'thing' )
+		expect( ot['apple-computer-list'] ).to eq( 'pinhash' )
 	end
 
 
 	it "dupes its inner hash when duped" do
-		newtable = @table.dup
+		newtable = table.dup
 
 		newtable[:cn] = 'god'
-		@table.should_not include( :cn )
-		@table.should be_empty()
+		expect( table ).to_not include( :cn )
+		expect( table ).to be_empty()
 	end
 
 
 	it "provides a case-insensitive version of #values_at" do
-		@table[:cn]               = 'contra_rules'
-		@table[:d]                = 'ghosty'
-		@table[:porntipsGuzzardo] = 'cha-ching'
-
-		results = @table.values_at( :CN, 'PornTipsGuzzARDO' )
-		results.should include( 'contra_rules' )
-		results.should include( 'cha-ching' )
-		results.should_not include( 'ghosty' )
+		table[:cn]               = 'contra_rules'
+		table[:d]                = 'ghosty'
+		table[:porntipsGuzzardo] = 'cha-ching'
+
+		results = table.values_at( :CN, 'PornTipsGuzzARDO' )
+		expect( results ).to include( 'contra_rules' )
+		expect( results ).to include( 'cha-ching' )
+		expect( results ).to_not include( 'ghosty' )
 	end
 
 	it "can iterate over its members" do
-		@table[:cn]               = 'contra_rules'
-		@table[:d]                = 'ghosty'
-		@table[:porntipsGuzzardo] = 'cha-ching'
+		table[:cn]               = 'contra_rules'
+		table[:d]                = 'ghosty'
+		table[:porntipsGuzzardo] = 'cha-ching'
 
 		collection = []
-		@table.each {|k,v| collection << [k,v] }
-		collection.transpose[0].should include( :cn, :d, :porntipsguzzardo )
-		collection.transpose[1].should include( 'contra_rules', 'ghosty', 'cha-ching' )
+		table.each {|k,v| collection << [k,v] }
+		expect( collection.transpose[0] ).to include( :cn, :d, :porntipsguzzardo )
+		expect( collection.transpose[1] ).to include( 'contra_rules', 'ghosty', 'cha-ching' )
 	end
 
 	it "is Enumerable" do
-		@table[:cn]               = 'contra_rules'
-		@table[:d]                = 'ghosty'
-		@table[:porntipsGuzzardo] = 'cha-ching'
+		table[:cn]               = 'contra_rules'
+		table[:d]                = 'ghosty'
+		table[:porntipsGuzzardo] = 'cha-ching'
 
 		collection = []
-		@table.any? {|k,v| v.index('o') }.should == true
+		expect( table.any? {|k,v| v.index('o') } ).to eq( true )
 	end
 
 end

data/spec/treequel/schema_spec.rb

@@ -1,18 +1,8 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+#encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+require_relative '../spec_helpers'
 
-	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 'yaml'
 require 'ldap'
@@ -24,7 +14,6 @@ describe Treequel::Schema do
 	include Treequel::SpecHelpers
 
 	before( :all ) do
-		setup_logging( :warn )
 		@datadir = Pathname( __FILE__ ).dirname.parent + 'data'
 	end
 
@@ -36,10 +25,6 @@ describe Treequel::Schema do
 		Treequel::Schema.strict_parse_mode = @strict_flag
 	end
 
-	after( :all ) do
-		reset_logging()
-	end
-
 	### Constants
 
 	# Some simple parser-testing values
@@ -67,23 +52,23 @@ describe Treequel::Schema do
 	### Examples
 
 	it "defaults to lenient schema-parsing" do
-		Treequel::Schema.should be_lenient()
+		expect( Treequel::Schema ).to be_lenient()
 	end
 
 	it "can be told to propagate schema-parsing failures for easier problem-detection" do
 		Treequel::Schema.strict_parse_mode = true
-		Treequel::Schema.should_not be_lenient()
+		expect( Treequel::Schema ).to_not be_lenient()
 	end
 
 
 	it "doesn't propagate parse errors while in lenient schema-parsing mode" do
 		schema = Treequel::Schema.new( 'objectClasses'   => [BAD_OBJECTCLASS],
-		                               'attributeTypes'  => [], 
-		                               'ldapSyntaxes'    => [], 
-		                               'matchingRules'   => [], 
+		                               'attributeTypes'  => [],
+		                               'ldapSyntaxes'    => [],
+		                               'matchingRules'   => [],
 		                               'matchingRuleUse' => [] )
-		schema.should be_a( Treequel::Schema )
-		schema.object_classes.keys.should_not include( 'slpService' )
+		expect( schema ).to be_a( Treequel::Schema )
+		expect( schema.object_classes.keys ).to_not include( 'slpService' )
 	end
 
 	it "propagates parse errors while in strict schema-parsing mode" do
@@ -95,12 +80,12 @@ describe Treequel::Schema do
 
 	it "can parse a valid oidlist" do
 		oids = Treequel::Schema.parse_oids( TEST_OIDLIST )
-		oids.should have(3).members
-		oids.should == [ :objectClass, :objectCaste, TEST_NUMERICOID ]
+		expect( oids.length ).to eq( 3 )
+		expect( oids ).to eq( [ :objectClass, :objectCaste, TEST_NUMERICOID ] )
 	end
 
 	it "returns an empty Array if oidlist it's asked to parse is nil" do
-		Treequel::Schema.parse_oids( nil ).should == []
+		expect( Treequel::Schema.parse_oids( nil ) ).to eq( [] )
 	end
 
 	it "raises an exception if it's asked to parse an invalid oidlist" do
@@ -111,13 +96,13 @@ describe Treequel::Schema do
 
 
 	it "keeps a numeric OID as a String when parsing it" do
-		Treequel::Schema.parse_oid( TEST_NUMERICOID ).should be_a( String )
-		Treequel::Schema.parse_oid( TEST_NUMERICOID ).should == TEST_NUMERICOID
+		expect( Treequel::Schema.parse_oid( TEST_NUMERICOID ) ).to be_a( String )
+		expect( Treequel::Schema.parse_oid( TEST_NUMERICOID ) ).to eq( TEST_NUMERICOID )
 	end
 
 	it "transforms a named OID as a Symbol when parsing it" do
-		Treequel::Schema.parse_oid( TEST_DESCR ).should be_a( Symbol )
-		Treequel::Schema.parse_oid( TEST_DESCR ).should == TEST_DESCR.to_sym
+		expect( Treequel::Schema.parse_oid( TEST_DESCR ) ).to be_a( Symbol )
+		expect( Treequel::Schema.parse_oid( TEST_DESCR ) ).to eq( TEST_DESCR.to_sym )
 	end
 
 
@@ -132,11 +117,11 @@ describe Treequel::Schema do
 		end
 
 		it "can parse the schema structure returned from LDAP::Conn#schema" do
-			@schema.object_classes.values.uniq.should have( @hash['objectClasses'].length ).members
-			@schema.attribute_types.values.uniq.should have( @hash['attributeTypes'].length ).members
-			@schema.matching_rules.values.uniq.should have( @hash['matchingRules'].length ).members
-			@schema.matching_rule_uses.values.uniq.should have( @hash['matchingRuleUse'].length ).members
-			@schema.ldap_syntaxes.values.uniq.should have( @hash['ldapSyntaxes'].length ).members
+			expect( @schema.object_classes.values.uniq.length ).to eq( @hash['objectClasses'].length )
+			expect( @schema.attribute_types.values.uniq.length ).to eq( @hash['attributeTypes'].length )
+			expect( @schema.matching_rules.values.uniq.length ).to eq( @hash['matchingRules'].length )
+			expect( @schema.matching_rule_uses.values.uniq.length ).to eq( @hash['matchingRuleUse'].length )
+			expect( @schema.ldap_syntaxes.values.uniq.length ).to eq( @hash['ldapSyntaxes'].length )
 
 			dirop_count = @hash['attributeTypes'].
 				count {|type| type.index('USAGE directoryOperation') }
@@ -146,7 +131,7 @@ describe Treequel::Schema do
 				count {|type| type.index('USAGE distributedOperation') }
 			op_attrcount = dirop_count + dsaop_count + distop_count
 
-			@schema.operational_attribute_types.should have( op_attrcount ).members
+			expect( @schema.operational_attribute_types.length ).to eq( op_attrcount )
 		end
 
 
@@ -160,7 +145,7 @@ describe Treequel::Schema do
 				schema = Treequel::Schema.new( schemahash )
 			end.join
 
-			schema.should be_an_instance_of( Treequel::Schema )
+			expect( schema ).to be_an_instance_of( Treequel::Schema )
 		end
 	end
 
@@ -174,14 +159,14 @@ describe Treequel::Schema do
 		end
 
 		it "can parse an ActiveDirectory schema structure, too" do
-			@schema.object_classes.values.uniq.should have( @hash['objectClasses'].length ).members
-			@schema.attribute_types.values.uniq.should have( @hash['attributeTypes'].length ).members
+			expect( @schema.object_classes.values.uniq.length ).to eq( @hash['objectClasses'].length )
+			expect( @schema.attribute_types.values.uniq.length ).to eq( @hash['attributeTypes'].length )
 
 			# AD doesn't have these in its subSchema
-			@schema.matching_rules.should be_empty()
-			@schema.matching_rule_uses.should be_empty()
-			@schema.ldap_syntaxes.should be_empty()
-			@schema.operational_attribute_types.should be_empty()
+			expect( @schema.matching_rules ).to be_empty()
+			expect( @schema.matching_rule_uses ).to be_empty()
+			expect( @schema.ldap_syntaxes ).to be_empty()
+			expect( @schema.operational_attribute_types ).to be_empty()
 		end
 
 	end
@@ -189,7 +174,7 @@ describe Treequel::Schema do
 
 	# Dumped from an OpenDS 2.2 server with the included 'test data' -- dunno if that's
 	# representative of schemas one would find in the wild, but it doesn't parse as-is
-	# currently because of (at least) the objectClasses from RFCs 2696, 3112, 3712, and 
+	# currently because of (at least) the objectClasses from RFCs 2696, 3112, 3712, and
 	# draft-howard-rfc2307bi
 	context "OpenDS schema" do
 
@@ -202,17 +187,20 @@ describe Treequel::Schema do
 		it "can parse an OpenDS schema structure, too" do
 			@schema = Treequel::Schema.new( @schemahash )
 
-			@schema.object_classes.values.uniq.should have( @hash['objectClasses'].length ).members
-			@schema.attribute_types.values.uniq.should have( @hash['attributeTypes'].length ).members
-			@schema.matching_rules.values.uniq.should have( @hash['matchingRules'].length ).members
-			@schema.ldap_syntaxes.values.uniq.should have( @hash['ldapSyntaxes'].length ).members
+			expect( @schema.object_classes.values.uniq.length ).to eq( @hash['objectClasses'].length )
+			expect( @schema.attribute_types.values.uniq.length ).to eq( @hash['attributeTypes'].length )
+			expect( @schema.matching_rules.values.uniq.length ).to eq( @hash['matchingRules'].length )
+			expect( @schema.ldap_syntaxes.values.uniq.length ).to eq( @hash['ldapSyntaxes'].length )
 
-			@schema.matching_rule_uses.should be_empty()
+			expect( @schema.matching_rule_uses ).to be_empty()
 
-			# Not yet supported			
-			# @schema.dit_structure_rules.values.uniq.should have( @hash['dITStructureRules'].length ).members
-			# @schema.dit_content_rules.values.uniq.should have( @hash['dITContentRules'].length ).members
-			# @schema.name_forms.values.uniq.should have( @hash['nameForms'].length ).members
+			# Not yet supported
+			# expect( @schema.dit_structure_rules.values.uniq.length ).
+			# 	to eq( @hash['dITStructureRules'].length )
+			# expect( @schema.dit_content_rules.values.uniq.length ).
+			# 	to eq( @hash['dITContentRules'].length )
+			# expect( @schema.name_forms.values.uniq.length ).
+			# 	to eq( @hash['nameForms'].length )
 
 			dirop_count = @hash['attributeTypes'].
 				count {|type| type.index('USAGE directoryOperation') }
@@ -222,7 +210,7 @@ describe Treequel::Schema do
 				count {|type| type.index('USAGE distributedOperation') }
 			op_attrcount = dirop_count + dsaop_count + distop_count
 
-			@schema.operational_attribute_types.should have( op_attrcount ).members
+			expect( @schema.operational_attribute_types.length ).to eq( op_attrcount )
 		end
 
 	end
@@ -239,13 +227,13 @@ describe Treequel::Schema do
 		end
 
 		it "can parse schema artifacts from ticket 11" do
-			@schema.attribute_types.values.uniq.should have( @hash['attributeTypes'].length ).members
-			@schema.matching_rules.values.uniq.should have( @hash['matchingRules'].length ).members
+			expect( @schema.attribute_types.values.uniq.length ).to eq( @hash['attributeTypes'].length )
+			expect( @schema.matching_rules.values.uniq.length ).to eq( @hash['matchingRules'].length )
 
 			dsaop_count = @hash['attributeTypes'].
 				count {|type| type.index('USAGE dsaOperation') }
 
-			@schema.operational_attribute_types.should have( dsaop_count ).members
+			expect( @schema.operational_attribute_types.length ).to eq( dsaop_count )
 		end
 
 	end

data/spec/treequel_spec.rb

@@ -1,47 +1,21 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+#encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.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'
 require 'treequel/directory'
 
-include Treequel::TestConstants
-
-
-#####################################################################
-###	C O N T E X T S
-#####################################################################
 
 describe Treequel do
 	include Treequel::SpecHelpers
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 	it "should know if its default logger is replaced" do
 		begin
 			Treequel.reset_logger
-			Treequel.should be_using_default_logger
+			expect( Treequel ).to be_using_default_logger
 			Treequel.logger = Logger.new( $stderr )
-			Treequel.should_not be_using_default_logger
+			expect( Treequel ).to_not be_using_default_logger
 		ensure
 			Treequel.reset_logger
 		end
@@ -49,65 +23,70 @@ describe Treequel do
 
 
 	it "returns a version string if asked" do
-		Treequel.version_string.should =~ /\w+ [\d.]+/
+		expect( Treequel.version_string ).to match( /\w+ [\d.]+/ )
 	end
 
 
 	it "returns a version string with a build number if asked" do
-		Treequel.version_string(true).should =~ /\w+ [\d.]+ \(build [[:xdigit:]]+\)/
+		expect( Treequel.version_string(true) ).to match( /\w+ [\d.]+ \(build [[:xdigit:]]+\)/ )
 	end
 
 
 	it "provides a convenience method for creating directory objects" do
-		Treequel::Directory.should_receive( :new ).and_return( :a_directory )
-		Treequel.directory.should == :a_directory
+		expect( Treequel::Directory ).to receive( :new ).and_return( :a_directory )
+		expect( Treequel.directory ).to eq( :a_directory )
 	end
 
 	it "accepts an LDAP url as the argument to the directory convenience method" do
-		Treequel::Directory.should_receive( :new ).
+		expect( Treequel::Directory ).to receive( :new ).
 			with({ :host => 'ldap.example.com', :base_dn => 'dc=example,dc=com', :port => 389 }).
 			and_return( :a_directory )
-		Treequel.directory( 'ldap://ldap.example.com/dc=example,dc=com' ).should == :a_directory
+		expect( Treequel.directory( 'ldap://ldap.example.com/dc=example,dc=com' ) ).to eq( :a_directory )
 	end
 
 	it "raises an exception if #directory is called with a non-ldap URL" do
-		lambda {
+		expect {
 			Treequel.directory( 'http://example.com/' )
-		}.should raise_error( ArgumentError, /ldap url/i )
+		}.to raise_error( ArgumentError, /ldap url/i )
 	end
 
 	it "accepts an options hash as the argument to the directory convenience method" do
 		opts = { :host => 'ldap.example.com', :base_dn => 'dc=example,dc=com' }
-		Treequel::Directory.should_receive( :new ).with( opts ).
+		expect( Treequel::Directory ).to receive( :new ).with( opts ).
 			and_return( :a_directory )
-		Treequel.directory( opts ).should == :a_directory
+		expect( Treequel.directory( opts ) ).to eq( :a_directory )
 	end
 
 	it "can build an options hash from an LDAP URL" do
-		Treequel.make_options_from_uri( 'ldap://ldap.example.com/dc=example,dc=com' ).should ==
-			{ :host => 'ldap.example.com', :base_dn => 'dc=example,dc=com', :port => 389 }
+		expect( Treequel.make_options_from_uri('ldap://ldap.example.com/dc=example,dc=com') ).
+			to include( :host => 'ldap.example.com', :base_dn => 'dc=example,dc=com', :port => 389 )
 	end
 
 	it "can build an options hash from an LDAPS URL" do
-		Treequel.make_options_from_uri( 'ldaps://ldap.example.com/dc=example,dc=com' ).should ==
-			{ :host => 'ldap.example.com', :base_dn => 'dc=example,dc=com', :port => 636, :connect_type => :ssl }
+		expect( Treequel.make_options_from_uri('ldaps://ldap.example.com/dc=example,dc=com') ).
+			to include(
+				 :host => 'ldap.example.com',
+				 :base_dn => 'dc=example,dc=com',
+				 :port => 636,
+				 :connect_type => :ssl
+			)
 	end
 
 	it "can build an options hash from an LDAP URL without a host" do
-		Treequel.make_options_from_uri( 'ldap:///dc=example,dc=com' ).should ==
-			{ :base_dn => 'dc=example,dc=com', :port => 389 }
+		expect( Treequel.make_options_from_uri('ldap:///dc=example,dc=com') ).
+			to include( :base_dn => 'dc=example,dc=com', :port => 389 )
 	end
 
 	it "uses the LDAPS port for ldaps:// URIs" do
-		Treequel.make_options_from_uri( 'ldaps:///dc=example,dc=com' ).should ==
-			{ :base_dn => 'dc=example,dc=com', :connect_type => :ssl, :port => 636 }
+		expect( Treequel.make_options_from_uri('ldaps:///dc=example,dc=com') ).
+			to include( :base_dn => 'dc=example,dc=com', :connect_type => :ssl, :port => 636 )
 	end
 
 	# [?<attrs>[?<scope>[?<filter>[?<extensions>]]]]
 	it "can build an options hash from an LDAP URL with extra stuff" do
 		uri = 'ldap:///dc=example,dc=com?uid=jrandom,ou=People?l?one?!bindname=cn=auth'
-		Treequel.make_options_from_uri( uri ).should ==
-			{ :base_dn => 'dc=example,dc=com', :port => 389 }
+		expect( Treequel.make_options_from_uri( uri ) ).
+			to include( :base_dn => 'dc=example,dc=com', :port => 389 )
 	end
 
 	it "accepts a combination of URL and options hash as the argument to the directory " +
@@ -124,7 +103,7 @@ describe Treequel do
 			:pass         => pass,
 		}
 
-		Treequel::Directory.should_receive( :new ).
+		expect( Treequel::Directory ).to receive( :new ).
 			with( options_hash ).
 			and_return( :a_directory )
 
@@ -139,28 +118,24 @@ describe Treequel do
 	end
 
 	it "provides a convenience method for creating directory objects from the system LDAP config" do
-		Treequel.should_receive( :find_configfile ).and_return( :a_configfile_path )
-		Treequel.should_receive( :read_opts_from_config ).with( :a_configfile_path ).
+		expect( Treequel ).to receive( :find_configfile ).and_return( :a_configfile_path )
+		expect( Treequel ).to receive( :read_opts_from_config ).with( :a_configfile_path ).
 			and_return({ :configfile_opts => 1 })
-		Treequel.should_receive( :read_opts_from_environment ).
+		expect( Treequel ).to receive( :read_opts_from_environment ).
 			and_return({ :environment_opts => 1 })
 
 		merged_config = Treequel::Directory::DEFAULT_OPTIONS.
 			merge({ :configfile_opts => 1, :environment_opts => 1 })
 
-		Treequel::Directory.should_receive( :new ).with( merged_config ).
+		expect( Treequel::Directory ).to receive( :new ).with( merged_config ).
 			and_return( :a_directory )
 
-		Treequel.directory_from_config.should == :a_directory
+		expect( Treequel.directory_from_config ).to eq( :a_directory )
 	end
 
 
 	describe "system LDAP config methods" do
 
-		before( :all ) do
-			setup_logging( :fatal )
-		end
-
 		before( :each ) do
 			ENV['LDAPCONF']   = nil
 			ENV['LDAPRC']     = nil
@@ -176,23 +151,23 @@ describe Treequel do
 		end
 
 		it "uses the LDAPCONF environment variable if it is set" do
-			configpath = mock( "configfile Pathname object" )
+			configpath = double( "configfile Pathname object" )
 			ENV['LDAPCONF'] = 'a_configfile_path'
 
-			Treequel.should_receive( :Pathname ).with( 'a_configfile_path' ).and_return( configpath )
-			configpath.should_receive( :expand_path ).and_return( configpath )
-			configpath.should_receive( :readable? ).and_return( true )
+			expect( Treequel ).to receive( :Pathname ).with( 'a_configfile_path' ).and_return( configpath )
+			expect( configpath ).to receive( :expand_path ).and_return( configpath )
+			expect( configpath ).to receive( :readable? ).and_return( true )
 
-			Treequel.find_configfile.should == configpath
+			expect( Treequel.find_configfile ).to eq( configpath )
 		end
 
 		it "raises an exception if the file specified in LDAPCONF isn't readable" do
-			configpath = mock( "configfile Pathname object" )
+			configpath = double( "configfile Pathname object" )
 			ENV['LDAPCONF'] = 'a_configfile_path'
 
-			Treequel.should_receive( :Pathname ).with( 'a_configfile_path' ).and_return( configpath )
-			configpath.should_receive( :expand_path ).and_return( configpath )
-			configpath.should_receive( :readable? ).and_return( false )
+			expect( Treequel ).to receive( :Pathname ).with( 'a_configfile_path' ).and_return( configpath )
+			expect( configpath ).to receive( :expand_path ).and_return( configpath )
+			expect( configpath ).to receive( :readable? ).and_return( false )
 
 			expect {
 				Treequel.find_configfile
@@ -200,46 +175,46 @@ describe Treequel do
 		end
 
 		it "uses the LDAPRC environment variable if it is set and LDAPCONF isn't" do
-			configpath = mock( "configfile Pathname object" )
+			configpath = double( "configfile Pathname object" )
 			ENV['LDAPRC'] = 'a_configfile_path'
 
-			Treequel.should_receive( :Pathname ).with( 'a_configfile_path' ).and_return( configpath )
-			configpath.should_receive( :expand_path ).and_return( configpath )
-			configpath.should_receive( :readable? ).and_return( true )
+			expect( Treequel ).to receive( :Pathname ).with( 'a_configfile_path' ).and_return( configpath )
+			expect( configpath ).to receive( :expand_path ).and_return( configpath )
+			expect( configpath ).to receive( :readable? ).and_return( true )
 
-			Treequel.find_configfile.should == configpath
+			expect( Treequel.find_configfile ).to eq( configpath )
 		end
 
 		it "looks in the current user's HOME for the LDAPRC file if it isn't in the CWD" do
-			cwd_path = mock( "CWD configfile Pathname object" )
-			homedir_path = mock( "HOME configfile Pathname object" )
+			cwd_path = double( "CWD configfile Pathname object" )
+			homedir_path = double( "HOME configfile Pathname object" )
 			ENV['LDAPRC'] = 'a_configfile_path'
 
-			Treequel.should_receive( :Pathname ).with( 'a_configfile_path' ).and_return( cwd_path )
-			cwd_path.should_receive( :expand_path ).and_return( cwd_path )
-			cwd_path.should_receive( :readable? ).and_return( false )
+			expect( Treequel ).to receive( :Pathname ).with( 'a_configfile_path' ).and_return( cwd_path )
+			expect( cwd_path ).to receive( :expand_path ).and_return( cwd_path )
+			expect( cwd_path ).to receive( :readable? ).and_return( false )
 
-			Treequel.should_receive( :Pathname ).with( '~' ).and_return( homedir_path )
-			homedir_path.should_receive( :expand_path ).and_return( homedir_path )
-			homedir_path.should_receive( :+ ).with( 'a_configfile_path' ).and_return( homedir_path )
-			homedir_path.should_receive( :readable? ).and_return( true )
+			expect( Treequel ).to receive( :Pathname ).with( '~' ).and_return( homedir_path )
+			expect( homedir_path ).to receive( :expand_path ).and_return( homedir_path )
+			expect( homedir_path ).to receive( :+ ).with( 'a_configfile_path' ).and_return( homedir_path )
+			expect( homedir_path ).to receive( :readable? ).and_return( true )
 
-			Treequel.find_configfile.should == homedir_path
+			expect( Treequel.find_configfile ).to eq( homedir_path )
 		end
 
 		it "raises an exception if the file specified in LDAPRC isn't readable" do
-			cwd_path = mock( "CWD configfile Pathname object" )
-			homedir_path = mock( "HOME configfile Pathname object" )
+			cwd_path = double( "CWD configfile Pathname object" )
+			homedir_path = double( "HOME configfile Pathname object" )
 			ENV['LDAPRC'] = 'a_configfile_path'
 
-			Treequel.should_receive( :Pathname ).with( 'a_configfile_path' ).and_return( cwd_path )
-			cwd_path.should_receive( :expand_path ).and_return( cwd_path )
-			cwd_path.should_receive( :readable? ).and_return( false )
+			expect( Treequel ).to receive( :Pathname ).with( 'a_configfile_path' ).and_return( cwd_path )
+			expect( cwd_path ).to receive( :expand_path ).and_return( cwd_path )
+			expect( cwd_path ).to receive( :readable? ).and_return( false )
 
-			Treequel.should_receive( :Pathname ).with( '~' ).and_return( homedir_path )
-			homedir_path.should_receive( :expand_path ).and_return( homedir_path )
-			homedir_path.should_receive( :+ ).with( 'a_configfile_path' ).and_return( homedir_path )
-			homedir_path.should_receive( :readable? ).and_return( false )
+			expect( Treequel ).to receive( :Pathname ).with( '~' ).and_return( homedir_path )
+			expect( homedir_path ).to receive( :expand_path ).and_return( homedir_path )
+			expect( homedir_path ).to receive( :+ ).with( 'a_configfile_path' ).and_return( homedir_path )
+			expect( homedir_path ).to receive( :readable? ).and_return( false )
 
 			expect {
 				Treequel.find_configfile
@@ -250,127 +225,127 @@ describe Treequel do
 			pathmocks = []
 
 			Treequel::COMMON_LDAP_CONF_PATHS.each do |path|
-				pathname = mock( "pathname: #{path}" )
+				pathname = double( "pathname: #{path}" )
 				pathmocks << pathname
 			end
-			Treequel.should_receive( :Pathname ).and_return( *pathmocks )
+			expect( Treequel ).to receive( :Pathname ).and_return( *pathmocks )
 
 			# Index of the entry we're going to pretend exists
 			successful_index = 6
 			0.upto( successful_index ) do |i|
-				pathmocks[i].should_receive( :readable? ).and_return( i == successful_index )
+				expect( pathmocks[i] ).to receive( :readable? ).and_return( i == successful_index )
 			end
 
-			Treequel.find_configfile.should == pathmocks[ successful_index ]
+			expect( Treequel.find_configfile ).to eq( pathmocks[ successful_index ] )
 		end
 
-		# 
+		#
 		# OpenLDAP-style config
-		# 
+		#
 
 		it "maps the OpenLDAP URI directive to equivalent options" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "URI ldap://ldap.acme.com/dc=acme,dc=com" )
-			Treequel.read_opts_from_config( :a_configfile ).should ==
-				{ :port => 389, :base_dn => "dc=acme,dc=com", :host => "ldap.acme.com" }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to include( :port => 389, :base_dn => "dc=acme,dc=com", :host => "ldap.acme.com" )
 		end
 
 		it "maps the OpenLDAP BASE directive to the base_dn option" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "BASE dc=acme,dc=com" )
-			Treequel.read_opts_from_config( :a_configfile ).should == 
-				{ :base_dn => "dc=acme,dc=com" }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to include( :base_dn => "dc=acme,dc=com" )
 		end
 
 		it "maps the OpenLDAP BINDDN directive to the bind_dn option" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "BINDDN cn=admin,dc=acme,dc=com" )
-			Treequel.read_opts_from_config( :a_configfile ).should ==
-				{ :bind_dn => "cn=admin,dc=acme,dc=com" }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to include( :bind_dn => "cn=admin,dc=acme,dc=com" )
 		end
 
 		it "maps the OpenLDAP HOST directive to the host option" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "# Host file\nHOST ldap.acme.com\n\n" )
-			Treequel.read_opts_from_config( :a_configfile ).should ==
-				{ :host => 'ldap.acme.com' }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to include( :host => 'ldap.acme.com' )
 		end
 
 		it "maps the OpenLDAP PORT directive to the port option" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "PORT 389" )
-			Treequel.read_opts_from_config( :a_configfile ).should ==
-				{ :port => 389 }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to include( :port => 389 )
 		end
 
-		# 
+		#
 		# NSS-style config
-		# 
+		#
 
 		it "maps the nss-style uri directive to equivalent options" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "uri ldap://ldap.acme.com/dc=acme,dc=com" )
-			Treequel.read_opts_from_config( :a_configfile ).should ==
-				{ :port => 389, :base_dn => "dc=acme,dc=com", :host => "ldap.acme.com" }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to include( :port => 389, :base_dn => "dc=acme,dc=com", :host => "ldap.acme.com" )
 		end
 
 		it "maps the nss-style 'host' option correctly" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "host ldap.acme.com\n\n" )
-			Treequel.read_opts_from_config( :a_configfile ).should ==
-				{ :host => 'ldap.acme.com' }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to include( :host => 'ldap.acme.com' )
 		end
 
 		it "maps the nss-style 'binddn' option correctly" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "binddn cn=superuser,dc=acme,dc=com" )
-			Treequel.read_opts_from_config( :a_configfile ).should == 
-				{ :bind_dn => "cn=superuser,dc=acme,dc=com" }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to eq( :bind_dn => "cn=superuser,dc=acme,dc=com" )
 		end
 
 		it "maps the nss-style 'bindpw' option correctly" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "# My totally awesome password" ).
 				and_yield( "bindpw a:password!" )
-			Treequel.read_opts_from_config( :a_configfile ).should == 
-				{ :pass => "a:password!" }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to eq( :pass => "a:password!" )
 		end
 
 		it "maps the nss-style 'base' option correctly" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "base dc=acme,dc=com" )
-			Treequel.read_opts_from_config( :a_configfile ).should == 
-				{ :base_dn => "dc=acme,dc=com" }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to eq( :base_dn => "dc=acme,dc=com" )
 		end
 
 		it "maps the nss-style 'ssl' option to the correct port and connect_type if it's 'off'" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "ssl  off" )
-			Treequel.read_opts_from_config( :a_configfile ).should == 
-				{ :port => 389, :connect_type => :plain }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to eq( :port => 389, :connect_type => :plain )
 		end
 
 		it "maps the nss-style 'ssl' option to the correct port and connect_type if " +
 		   "it's 'start_tls'" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( '' ).
 				and_yield( '# Use TLS' ).
 				and_yield( 'ssl start_tls' )
-			Treequel.read_opts_from_config( :a_configfile ).should == 
-				{ :port => 389, :connect_type => :tls }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to eq( :port => 389, :connect_type => :tls )
 		end
 
 		it "maps the nss-style 'ssl' option to the correct port and connect_type if " +
 		   "it's 'on'" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "\n# Use plain SSL\nssl on\n" )
-			Treequel.read_opts_from_config( :a_configfile ).should == 
-				{ :port => 636, :connect_type => :ssl }
+			expect( Treequel.read_opts_from_config(:a_configfile) ).
+				to eq( :port => 636, :connect_type => :ssl )
 		end
 
 		it "ignores nss-style 'ssl' option if it is set to something other than " +
 		   "'on', 'off', or 'start_tls'" do
-			IO.should_receive( :foreach ).with( :a_configfile ).
+			expect( IO ).to receive( :foreach ).with( :a_configfile ).
 				and_yield( "\n# Use alien-invasion protocol\nssl aliens\n" )
 
 			expect {
@@ -378,46 +353,46 @@ describe Treequel do
 			}.to_not raise_exception()
 		end
 
-		# 
+		#
 		# Environment
-		# 
+		#
 
 		it "maps the OpenLDAP LDAPURI environment variable to equivalent options" do
 			ENV['LDAPURI'] = 'ldaps://quomsohutch.linkerlinlinkin.org/o=linkerlickin'
-			Treequel.read_opts_from_environment.should == {
+			expect( Treequel.read_opts_from_environment ).to include(
 				:host         => 'quomsohutch.linkerlinlinkin.org',
 				:connect_type => :ssl,
 				:port         => 636,
 				:base_dn      => 'o=linkerlickin'
-			  }
+			)
 		end
 
 		it "maps the OpenLDAP LDAPBASE environment variable to the base_dn option" do
 			ENV['LDAPBASE'] = 'o=linkerlickin'
-			Treequel.read_opts_from_environment.should == {
+			expect( Treequel.read_opts_from_environment ).to include(
 				:base_dn => 'o=linkerlickin'
-			  }
+			)
 		end
 
 		it "maps the OpenLDAP LDAPBINDDN environment variable to the bind_dn option" do
 			ENV['LDAPBINDDN'] = 'cn=superuser,ou=people,o=linkerlickin'
-			Treequel.read_opts_from_environment.should == {
+			expect( Treequel.read_opts_from_environment ).to include(
 				:bind_dn => 'cn=superuser,ou=people,o=linkerlickin'
-			  }
+			)
 		end
 
 		it "maps the OpenLDAP LDAPHOST environment variable to the host option" do
 			ENV['LDAPHOST'] = 'quomsohutch.linkerlinlinkin.org'
-			Treequel.read_opts_from_environment.should == {
-				:host => 'quomsohutch.linkerlinlinkin.org',
-			  }
+			expect( Treequel.read_opts_from_environment ).to include(
+				:host => 'quomsohutch.linkerlinlinkin.org'
+			)
 		end
 
 		it "maps the OpenLDAP LDAPPORT environment variable to the port option" do
 			ENV['LDAPPORT'] = '636'
-			Treequel.read_opts_from_environment.should == {
-				:port => 636,
-			  }
+			expect( Treequel.read_opts_from_environment ).to include(
+				:port => 636
+			)
 		end
 	end