Use result code constants in tests

Author: mtodd

test/integration/test_bind.rb

@@ -9,8 +9,8 @@ def test_bind_anonymous_fail
     refute @ldap.bind(method: :simple, username: "uid=user1,ou=People,dc=rubyldap,dc=com", password: ""), @ldap.get_operation_result.inspect
 
     result = @ldap.get_operation_result
-    assert_equal 53, result.code
-    assert_equal "Unwilling to perform", result.message
+    assert_equal Net::LDAP::ResultCodeUnwillingToPerform, result.code
+    assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeUnwillingToPerform], result.message
     assert_equal "unauthenticated bind (DN with no password) disallowed",
       result.error_message
     assert_equal "", result.matched_dn

test/integration/test_delete.rb

@@ -25,7 +25,7 @@ def test_delete
     refute @ldap.search(base: @dn, scope: Net::LDAP::SearchScope_BaseObject)
 
     result = @ldap.get_operation_result
-    assert_equal 32, result.code
-    assert_equal Net::LDAP::ResultStrings[32], result.message
+    assert_equal Net::LDAP::ResultCodeNoSuchObject, result.code
+    assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeNoSuchObject], result.message
   end
 end

test/integration/test_return_codes.rb

@@ -8,31 +8,31 @@ def test_operations_error
     refute @ldap.search(filter: "cn=operationsError", base: "ou=Retcodes,dc=rubyldap,dc=com")
     assert result = @ldap.get_operation_result
 
-    assert_equal 1, result.code
-    assert_equal Net::LDAP::ResultStrings[1], result.message
+    assert_equal Net::LDAP::ResultCodeOperationsError, result.code
+    assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeOperationsError], result.message
   end
 
   def test_protocol_error
     refute @ldap.search(filter: "cn=protocolError", base: "ou=Retcodes,dc=rubyldap,dc=com")
     assert result = @ldap.get_operation_result
 
-    assert_equal 2, result.code
-    assert_equal Net::LDAP::ResultStrings[2], result.message
+    assert_equal Net::LDAP::ResultCodeProtocolError, result.code
+    assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeProtocolError], result.message
   end
 
   def test_time_limit_exceeded
     assert @ldap.search(filter: "cn=timeLimitExceeded", base: "ou=Retcodes,dc=rubyldap,dc=com")
     assert result = @ldap.get_operation_result
 
-    assert_equal 3, result.code
-    assert_equal Net::LDAP::ResultStrings[3], result.message
+    assert_equal Net::LDAP::ResultCodeTimeLimitExceeded, result.code
+    assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeTimeLimitExceeded], result.message
   end
 
   def test_size_limit_exceeded
     assert @ldap.search(filter: "cn=sizeLimitExceeded", base: "ou=Retcodes,dc=rubyldap,dc=com")
     assert result = @ldap.get_operation_result
 
-    assert_equal 4, result.code
-    assert_equal Net::LDAP::ResultStrings[4], result.message
+    assert_equal Net::LDAP::ResultCodeSizeLimitExceeded, result.code
+    assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeSizeLimitExceeded], result.message
   end
 end

test/test_ldap.rb

@@ -28,10 +28,10 @@ def test_instrument_bind
   def test_instrument_search
     events = @service.subscribe "search.net_ldap"
 
-    flexmock(@connection).should_receive(:bind).and_return(flexmock(:bind_result, :result_code => 0))
+    flexmock(@connection).should_receive(:bind).and_return(flexmock(:bind_result, :result_code => Net::LDAP::ResultCodeSuccess))
     flexmock(@connection).should_receive(:search).with(Hash, Proc).
                 yields(entry = Net::LDAP::Entry.new("uid=user1,ou=users,dc=example,dc=com")).
-                and_return(flexmock(:search_result, :success? => true, :result_code => 0))
+                and_return(flexmock(:search_result, :success? => true, :result_code => Net::LDAP::ResultCodeSuccess))
 
     refute_nil @subject.search(:filter => "(uid=user1)")
 
@@ -44,10 +44,10 @@ def test_instrument_search
   def test_instrument_search_with_size
     events = @service.subscribe "search.net_ldap"
 
-    flexmock(@connection).should_receive(:bind).and_return(flexmock(:bind_result, :result_code => 0))
+    flexmock(@connection).should_receive(:bind).and_return(flexmock(:bind_result, :result_code => Net::LDAP::ResultCodeSuccess))
     flexmock(@connection).should_receive(:search).with(Hash, Proc).
                 yields(entry = Net::LDAP::Entry.new("uid=user1,ou=users,dc=example,dc=com")).
-                and_return(flexmock(:search_result, :success? => true, :result_code => 4))
+                and_return(flexmock(:search_result, :success? => true, :result_code => Net::LDAP::ResultCodeSizeLimitExceeded))
 
     refute_nil @subject.search(:filter => "(uid=user1)", :size => 1)
 

test/test_ldap_connection.rb

@@ -77,7 +77,7 @@ def setup
   end
 
   def test_error_failed_operation
-    ber = Net::BER::BerIdentifiedArray.new([53, "", "The provided password value was rejected by a password validator:  The provided password did not contain enough characters from the character set 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.  The minimum number of characters from that set that must be present in user passwords is 1"])
+    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeUnwillingToPerform, "", "The provided password value was rejected by a password validator:  The provided password did not contain enough characters from the character set 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.  The minimum number of characters from that set that must be present in user passwords is 1"])
     ber.ber_identifier = Net::LDAP::PDU::ModifyResponse
     @tcp_socket.should_receive(:read_ber).and_return([2, ber])
 
@@ -87,7 +87,7 @@ def test_error_failed_operation
   end
 
   def test_no_error_on_success
-    ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
+    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
     ber.ber_identifier = Net::LDAP::PDU::ModifyResponse
     @tcp_socket.should_receive(:read_ber).and_return([2, ber])
 
@@ -111,7 +111,7 @@ def setup
   end
 
   def test_write_net_ldap_connection_event
-    ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
+    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
     ber.ber_identifier = Net::LDAP::PDU::BindResult
     read_result = [2, ber]
     @tcp_socket.should_receive(:read_ber).and_return(read_result)
@@ -128,7 +128,7 @@ def test_write_net_ldap_connection_event
   end
 
   def test_read_net_ldap_connection_event
-    ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
+    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
     ber.ber_identifier = Net::LDAP::PDU::BindResult
     read_result = [2, ber]
     @tcp_socket.should_receive(:read_ber).and_return(read_result)
@@ -145,7 +145,7 @@ def test_read_net_ldap_connection_event
   end
 
   def test_parse_pdu_net_ldap_connection_event
-    ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
+    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
     ber.ber_identifier = Net::LDAP::PDU::BindResult
     read_result = [2, ber]
     @tcp_socket.should_receive(:read_ber).and_return(read_result)
@@ -163,11 +163,11 @@ def test_parse_pdu_net_ldap_connection_event
     assert_equal Net::LDAP::PDU::BindResult, payload[:app_tag]
     assert_equal 2, payload[:message_id]
     pdu = payload[:pdu]
-    assert_equal 0, pdu.result_code
+    assert_equal Net::LDAP::ResultCodeSuccess, pdu.result_code
   end
 
   def test_bind_net_ldap_connection_event
-    ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
+    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
     ber.ber_identifier = Net::LDAP::PDU::BindResult
     bind_result = [2, ber]
     @tcp_socket.should_receive(:read_ber).and_return(bind_result)
@@ -192,7 +192,7 @@ def test_search_net_ldap_connection_event
     search_data_ber.ber_identifier = Net::LDAP::PDU::SearchReturnedData
     search_data = [1, search_data_ber]
     # search result (end of results)
-    search_result_ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
+    search_result_ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
     search_result_ber.ber_identifier = Net::LDAP::PDU::SearchResult
     search_result = [1, search_result_ber]
     @tcp_socket.should_receive(:read_ber).and_return(search_data).

test/test_search.rb

@@ -4,7 +4,7 @@
 class TestSearch < Test::Unit::TestCase
   class FakeConnection
     def search(args)
-      OpenStruct.new(:result_code => 1, :message => "error", :success? => false)
+      OpenStruct.new(:result_code => Net::LDAP::ResultCodeOperationsError, :message => "error", :success? => false)
     end
   end