[tor-commits] [stem/master] Rewrite of authentication unit tests

atagar at torproject.org atagar at torproject.org
Fri Jan 27 17:29:57 UTC 2012


commit 39e9f0cfdf8efd6cd8445e33feaeb9dd4a44d92f
Author: Damian Johnson <atagar at torproject.org>
Date:   Fri Jan 27 09:24:59 2012 -0800

    Rewrite of authentication unit tests
    
    The unit tests for stem.connection.authenticate* functions were the first to
    use the decent style of mocking that was later used as the basis of the mocking
    module. Using the module to clean up the unit test and making a stab at making
    the tests less confusing.
---
 test/mocking.py                        |   43 +++++++++
 test/unit/connection/authentication.py |  152 +++++++++++++++-----------------
 2 files changed, 113 insertions(+), 82 deletions(-)

diff --git a/test/mocking.py b/test/mocking.py
index 740bcb7..f6bf98c 100644
--- a/test/mocking.py
+++ b/test/mocking.py
@@ -1,10 +1,27 @@
 """
 Helper functions for creating mock objects and monkey patching to help with
 testing.
+
+Mocking Functions
+  no_op           - does nothing
+  return_value    - returns a given value
+  return_true     - returns True
+  return_false    - returns False
+  return_none     - returns None
+  raise_exception - raises an exception when called
+
+mock - replaces a function with an alternative implementation
+revert_mocking - reverts any changes made by the mock function
+
+get_protocolinfo_response - provides a ProtocolInfoResponse instance
 """
 
 import inspect
 import itertools
+import StringIO
+
+import stem.connection
+import stem.socket
 
 # Once we've mocked a function we can't rely on its __module__ or __name__
 # attributes, so instead we associate a unique 'mock_id' attribute that maps
@@ -28,6 +45,10 @@ def return_true(): return return_value(True)
 def return_false(): return return_value(False)
 def return_none(): return return_value(None)
 
+def raise_exception(exception):
+  def _raise(*args): raise exception
+  return _raise
+
 def mock(target, mock_call):
   """
   Mocks the given function, saving the initial implementation so it can be
@@ -73,3 +94,25 @@ def revert_mocking():
   
   MOCK_STATE.clear()
 
+def get_protocolinfo_response(**attributes):
+  """
+  Provides a ProtocolInfoResponse, customized with the given attributes. The
+  base instance is minimal, with its version set to one and everything else
+  left with the default.
+  
+  Arguments:
+    attributes (dict) - attributes to customize the the 
+  
+  Returns:
+    stem.connection.ProtocolInfoResponse instance
+  """
+  
+  control_message = "250-PROTOCOLINFO 1\r\n250 OK\r\n"
+  protocolinfo_response = stem.socket.recv_message(StringIO.StringIO(control_message))
+  stem.connection.ProtocolInfoResponse.convert(protocolinfo_response)
+  
+  for attr in attributes:
+    protocolinfo_response.__dict__[attr] = attributes[attr]
+  
+  return protocolinfo_response
+
diff --git a/test/unit/connection/authentication.py b/test/unit/connection/authentication.py
index ba56ccd..0b3a60e 100644
--- a/test/unit/connection/authentication.py
+++ b/test/unit/connection/authentication.py
@@ -2,36 +2,11 @@
 Unit tests for the stem.connection.authenticate function.
 """
 
-import StringIO
-import functools
 import unittest
 
 import stem.connection
 import stem.util.log as log
-
-# Functors to replace get_protocolinfo and authenticate_*. All of them take any
-# number of arguments.
-def no_op():
-  def _no_op(*args):
-    pass
-  
-  return _no_op
-
-def raise_exception(exception_type):
-  if not exception_type: return no_op()
-  
-  def _raise(exc_type, *args):
-    raise exc_type(None)
-  
-  return functools.partial(_raise, exception_type)
-
-def get_protocolinfo(auth_methods):
-  control_message = "250-PROTOCOLINFO 1\r\n250 OK\r\n"
-  protocolinfo_response = stem.socket.recv_message(StringIO.StringIO(control_message))
-  stem.connection.ProtocolInfoResponse.convert(protocolinfo_response)
-  protocolinfo_response.auth_methods = auth_methods
-  protocolinfo_response.cookie_path = "/tmp/blah"
-  return lambda *args: protocolinfo_response
+import test.mocking as mocking
 
 def _get_all_auth_method_combinations():
   """
@@ -63,25 +38,13 @@ class TestAuthenticate(unittest.TestCase):
   """
   
   def setUp(self):
-    # preserves all of the functors we'll need to monkey patch, and make them
-    # no-ops
-    
-    self.original_get_protocolinfo = stem.connection.get_protocolinfo
-    self.original_authenticate_none = stem.connection.authenticate_none
-    self.original_authenticate_password = stem.connection.authenticate_password
-    self.original_authenticate_cookie = stem.connection.authenticate_cookie
-    
-    stem.connection.get_protocolinfo = no_op()
-    stem.connection.authenticate_none = no_op()
-    stem.connection.authenticate_password = no_op()
-    stem.connection.authenticate_cookie = no_op()
+    mocking.mock(stem.connection.get_protocolinfo, mocking.no_op())
+    mocking.mock(stem.connection.authenticate_none, mocking.no_op())
+    mocking.mock(stem.connection.authenticate_password, mocking.no_op())
+    mocking.mock(stem.connection.authenticate_cookie, mocking.no_op())
   
   def tearDown(self):
-    # restore functions
-    stem.connection.get_protocolinfo = self.original_get_protocolinfo
-    stem.connection.authenticate_none = self.original_authenticate_none
-    stem.connection.authenticate_password = self.original_authenticate_password
-    stem.connection.authenticate_cookie = self.original_authenticate_cookie
+    mocking.revert_mocking()
   
   def test_with_get_protocolinfo(self):
     """
@@ -89,15 +52,20 @@ class TestAuthenticate(unittest.TestCase):
     """
     
     # tests where get_protocolinfo succeeds
-    stem.connection.get_protocolinfo = get_protocolinfo((stem.connection.AuthMethod.NONE, ))
+    protocolinfo_response = mocking.get_protocolinfo_response(
+      auth_methods = (stem.connection.AuthMethod.NONE, ),
+    )
+    
+    mocking.mock(stem.connection.get_protocolinfo, mocking.return_value(protocolinfo_response))
     stem.connection.authenticate(None)
     
-    # tests where get_protocolinfo raises a ProtocolError
-    stem.connection.get_protocolinfo = raise_exception(stem.socket.ProtocolError)
+    # tests where get_protocolinfo raises an exception
+    raised_exc = stem.socket.ProtocolError(None)
+    mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(raised_exc))
     self.assertRaises(stem.connection.IncorrectSocketType, stem.connection.authenticate, None)
     
-    # tests where get_protocolinfo raises a SocketError
-    stem.connection.get_protocolinfo = raise_exception(stem.socket.SocketError)
+    raised_exc = stem.socket.SocketError(None)
+    mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(raised_exc))
     self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None)
   
   def test_all_use_cases(self):
@@ -113,50 +81,70 @@ class TestAuthenticate(unittest.TestCase):
     stem_logger.setLevel(log.logging_level(None))
     
     # exceptions that the authentication functions are documented to raise
-    auth_none_exc_types = (None,
-      stem.connection.OpenAuthRejected)
+    all_auth_none_exc = (None,
+      stem.connection.OpenAuthRejected(None))
+    
+    all_auth_password_exc = (None,
+      stem.connection.PasswordAuthRejected(None),
+      stem.connection.IncorrectPassword(None))
     
-    auth_password_exc_types = (None,
-      stem.connection.PasswordAuthRejected,
-      stem.connection.IncorrectPassword)
+    all_auth_cookie_exc = (None,
+      stem.connection.IncorrectCookieSize(None),
+      stem.connection.UnreadableCookieFile(None),
+      stem.connection.CookieAuthRejected(None),
+      stem.connection.IncorrectCookieValue(None))
     
-    auth_cookie_exc_types = (None,
-      stem.connection.IncorrectCookieSize,
-      stem.connection.UnreadableCookieFile,
-      stem.connection.CookieAuthRejected,
-      stem.connection.IncorrectCookieValue)
+    # authentication functions might raise a controller error when
+    # 'suppress_ctl_errors' is False, so including those
     
-    # auth functions don't suppress controller exceptions
-    control_exc_types = (
-      stem.socket.ProtocolError,
-      stem.socket.SocketError,
-      stem.socket.SocketClosed)
+    control_exc = (
+      stem.socket.ProtocolError(None),
+      stem.socket.SocketError(None),
+      stem.socket.SocketClosed(None))
     
-    for auth_methods in _get_all_auth_method_combinations():
-      protocolinfo_input = get_protocolinfo(auth_methods)()
+    all_auth_none_exc += control_exc
+    all_auth_password_exc += control_exc
+    all_auth_cookie_exc += control_exc
+    
+    for protocolinfo_auth_methods in _get_all_auth_method_combinations():
+      # protocolinfo input for the authenticate() call we'll be making
+      protocolinfo_arg = mocking.get_protocolinfo_response(
+        auth_methods = protocolinfo_auth_methods,
+        cookie_path = "/tmp/blah",
+      )
       
-      for auth_none_exc in auth_none_exc_types + control_exc_types:
-        for auth_password_exc in auth_password_exc_types + control_exc_types:
-          for auth_cookie_exc in auth_cookie_exc_types + control_exc_types:
-            stem.connection.authenticate_none = raise_exception(auth_none_exc)
-            stem.connection.authenticate_password = raise_exception(auth_password_exc)
-            stem.connection.authenticate_cookie = raise_exception(auth_cookie_exc)
-            
-            auth_tuple_set = (
-              (stem.connection.AuthMethod.NONE, auth_none_exc),
-              (stem.connection.AuthMethod.PASSWORD, auth_password_exc),
-              (stem.connection.AuthMethod.COOKIE, auth_cookie_exc))
+      for auth_none_exc in all_auth_none_exc:
+        for auth_password_exc in all_auth_password_exc:
+          for auth_cookie_exc in all_auth_cookie_exc:
+            # determine if the authenticate() call will succeed and mock each
+            # of the authenticate_* function to raise its given exception
             
             expect_success = False
-            for auth_type, auth_exc in auth_tuple_set:
-              if auth_type in auth_methods and not auth_exc:
-                expect_success = True
-                break
+            auth_mocks = {
+              stem.connection.AuthMethod.NONE:
+                (stem.connection.authenticate_none, auth_none_exc),
+              stem.connection.AuthMethod.PASSWORD:
+                (stem.connection.authenticate_password, auth_password_exc),
+              stem.connection.AuthMethod.COOKIE:
+                (stem.connection.authenticate_cookie, auth_cookie_exc),
+            }
+            
+            for auth_method in auth_mocks:
+              auth_function, raised_exc = auth_mocks[auth_method]
+              
+              if not raised_exc:
+                # Mocking this authentication method so it will succeed. If
+                # it's among the protocolinfo methods then expect success.
+                
+                mocking.mock(auth_function, mocking.no_op())
+                expect_success |= auth_method in protocolinfo_auth_methods
+              else:
+                mocking.mock(auth_function, mocking.raise_exception(raised_exc))
             
             if expect_success:
-              stem.connection.authenticate(None, "blah", protocolinfo_input)
+              stem.connection.authenticate(None, "blah", protocolinfo_arg)
             else:
-              self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None, "blah", protocolinfo_input)
+              self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None, "blah", protocolinfo_arg)
     
     # revert logging back to normal
     stem_logger.setLevel(log.logging_level(log.TRACE))



More information about the tor-commits mailing list