def test_get_protocolinfo(self, get_protocolinfo_mock): """ Exercises the get_protocolinfo() method. """ # use the handy mocked protocolinfo response get_protocolinfo_mock.return_value = mocking.get_protocolinfo_response( ) # compare the str representation of these object, because the class # does not have, nor need, a direct comparison operator self.assertEqual(str(mocking.get_protocolinfo_response()), str(self.controller.get_protocolinfo())) # raise an exception in the stem.connection.get_protocolinfo() call get_protocolinfo_mock.side_effect = ProtocolError # get a default value when the call fails self.assertEqual( 'default returned', self.controller.get_protocolinfo(default='default returned')) # no default value, accept the error self.assertRaises(ProtocolError, self.controller.get_protocolinfo)
def test_get_protocolinfo(self, get_protocolinfo_mock): """ Exercises the get_protocolinfo() method. """ # use the handy mocked protocolinfo response get_protocolinfo_mock.return_value = mocking.get_protocolinfo_response() # compare the str representation of these object, because the class # does not have, nor need, a direct comparison operator self.assertEqual( str(mocking.get_protocolinfo_response()), str(self.controller.get_protocolinfo()) ) # raise an exception in the stem.connection.get_protocolinfo() call get_protocolinfo_mock.side_effect = ProtocolError # get a default value when the call fails self.assertEqual( "default returned", self.controller.get_protocolinfo(default = "default returned") ) # no default value, accept the error self.assertRaises(ProtocolError, self.controller.get_protocolinfo)
def test_get_protocolinfo(self): """ Exercises the get_protocolinfo() method. """ # Use the handy mocked protocolinfo response. mocking.mock(stem.connection.get_protocolinfo, mocking.return_value(mocking.get_protocolinfo_response())) # Compare the str representation of these object, because the class # does not have, nor need, a direct comparison operator. self.assertEqual(str(mocking.get_protocolinfo_response()), str(self.controller.get_protocolinfo())) # Raise an exception in the stem.connection.get_protocolinfo() call. mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(ProtocolError)) # Get a default value when the call fails. self.assertEqual( "default returned", self.controller.get_protocolinfo(default="default returned")) # No default value, accept the error. self.assertRaises(ProtocolError, self.controller.get_protocolinfo)
def test_get_protocolinfo(self): """ Exercises the get_protocolinfo() method. """ # Use the handy mocked protocolinfo response. mocking.mock(stem.connection.get_protocolinfo, mocking.return_value( mocking.get_protocolinfo_response() )) # Compare the str representation of these object, because the class # does not have, nor need, a direct comparison operator. self.assertEqual(str(mocking.get_protocolinfo_response()), str(self.controller.get_protocolinfo())) # Raise an exception in the stem.connection.get_protocolinfo() call. mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(ProtocolError)) # Get a default value when the call fails. self.assertEqual( "default returned", self.controller.get_protocolinfo(default = "default returned") ) # No default value, accept the error. self.assertRaises(ProtocolError, self.controller.get_protocolinfo)
def test_with_get_protocolinfo(self): """ Tests the authenticate() function when it needs to make a get_protocolinfo. """ # tests where get_protocolinfo succeeds 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 an exception raised_exc = stem.ProtocolError(None) mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(raised_exc)) self.assertRaises(stem.connection.IncorrectSocketType, stem.connection.authenticate, None) raised_exc = stem.SocketError(None) mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(raised_exc)) self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None)
def test_with_get_protocolinfo(self): """ Tests the authenticate() function when it needs to make a get_protocolinfo. """ # tests where get_protocolinfo succeeds 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 an exception raised_exc = stem.ProtocolError(None) mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(raised_exc)) self.assertRaises(stem.connection.IncorrectSocketType, stem.connection.authenticate, None) raised_exc = stem.SocketError(None) mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(raised_exc)) self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None)
def test_with_get_protocolinfo(self, get_protocolinfo_mock): """ Tests the authenticate() function when it needs to make a get_protocolinfo. """ # tests where get_protocolinfo succeeds get_protocolinfo_mock.return_value = mocking.get_protocolinfo_response( auth_methods = (stem.connection.AuthMethod.NONE, ), ) stem.connection.authenticate(None) # tests where get_protocolinfo raises an exception get_protocolinfo_mock.side_effect = stem.ProtocolError self.assertRaises(stem.connection.IncorrectSocketType, stem.connection.authenticate, None) get_protocolinfo_mock.side_effect = stem.SocketError self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None)
def test_all_use_cases(self, authenticate_safecookie_mock, authenticate_cookie_mock, authenticate_password_mock, authenticate_none_mock): """ Does basic validation that all valid use cases for the PROTOCOLINFO input and dependent functions result in either success or a AuthenticationFailed subclass being raised. """ # mute the logger for this test since otherwise the output is overwhelming stem_logger = log.get_logger() stem_logger.setLevel(log.logging_level(None)) # exceptions that the authentication functions are documented to raise all_auth_none_exc = (None, stem.connection.OpenAuthRejected(None)) all_auth_password_exc = (None, stem.connection.PasswordAuthRejected(None), stem.connection.IncorrectPassword(None)) all_auth_cookie_exc = ( None, stem.connection.IncorrectCookieSize(None, False, None), stem.connection.UnreadableCookieFile(None, False, None), stem.connection.CookieAuthRejected(None, False, None), stem.connection.IncorrectCookieValue(None, False, None), stem.connection.UnrecognizedAuthChallengeMethod(None, None, None), stem.connection.AuthChallengeFailed(None, None), stem.connection.AuthSecurityFailure(None, None), stem.connection.InvalidClientNonce(None, None)) # authentication functions might raise a controller error when # 'suppress_ctl_errors' is False, so including those control_exc = (stem.ProtocolError(None), stem.SocketError(None), stem.SocketClosed(None)) all_auth_none_exc += control_exc all_auth_password_exc += control_exc all_auth_cookie_exc += control_exc auth_method_combinations = mocking.get_all_combinations( [ stem.connection.AuthMethod.NONE, stem.connection.AuthMethod.PASSWORD, stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.SAFECOOKIE, stem.connection.AuthMethod.UNKNOWN, ], include_empty=True) for protocolinfo_auth_methods in 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 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. # # This implementation is slightly inaccurate in a couple regards... # a. it raises safecookie exceptions from authenticate_cookie() # b. exceptions raised by authenticate_cookie() and # authenticate_safecookie() are always the same # # However, adding another loop for safe_cookie exceptions means # multiplying our runtime many fold. This exercises everything that # matters so the above inaccuracies seem fine. expect_success = False auth_mocks = { stem.connection.AuthMethod.NONE: (authenticate_none_mock, auth_none_exc), stem.connection.AuthMethod.PASSWORD: (authenticate_password_mock, auth_password_exc), stem.connection.AuthMethod.COOKIE: (authenticate_cookie_mock, auth_cookie_exc), stem.connection.AuthMethod.SAFECOOKIE: (authenticate_safecookie_mock, auth_cookie_exc), } for auth_method in auth_mocks: auth_mock, 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. auth_mock.side_effect = None expect_success |= auth_method in protocolinfo_auth_methods else: auth_mock.side_effect = raised_exc if expect_success: stem.connection.authenticate( None, 'blah', None, protocolinfo_arg) else: self.assertRaises( stem.connection.AuthenticationFailure, stem.connection.authenticate, None, 'blah', None, protocolinfo_arg) # revert logging back to normal stem_logger.setLevel(log.logging_level(log.TRACE))
def test_all_use_cases(self): """ Does basic validation that all valid use cases for the PROTOCOLINFO input and dependent functions result in either success or a AuthenticationFailed subclass being raised. """ # mute the logger for this test since otherwise the output is overwhelming stem_logger = log.get_logger() stem_logger.setLevel(log.logging_level(None)) # exceptions that the authentication functions are documented to raise all_auth_none_exc = (None, stem.connection.OpenAuthRejected(None)) all_auth_password_exc = (None, stem.connection.PasswordAuthRejected(None), stem.connection.IncorrectPassword(None)) all_auth_cookie_exc = (None, stem.connection.IncorrectCookieSize(None, None), stem.connection.UnreadableCookieFile(None, None), stem.connection.CookieAuthRejected(None, None), stem.connection.IncorrectCookieValue(None, None)) # authentication functions might raise a controller error when # 'suppress_ctl_errors' is False, so including those control_exc = ( stem.socket.ProtocolError(None), stem.socket.SocketError(None), stem.socket.SocketClosed(None)) 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 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 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", None, protocolinfo_arg) else: self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None, "blah", None, protocolinfo_arg) # revert logging back to normal stem_logger.setLevel(log.logging_level(log.TRACE))
def test_all_use_cases(self): """ Does basic validation that all valid use cases for the PROTOCOLINFO input and dependent functions result in either success or a AuthenticationFailed subclass being raised. """ # mute the logger for this test since otherwise the output is overwhelming stem_logger = log.get_logger() stem_logger.setLevel(log.logging_level(None)) # exceptions that the authentication functions are documented to raise all_auth_none_exc = (None, stem.connection.OpenAuthRejected(None)) all_auth_password_exc = ( None, stem.connection.PasswordAuthRejected(None), stem.connection.IncorrectPassword(None)) all_auth_cookie_exc = ( None, stem.connection.IncorrectCookieSize(None, False, None), stem.connection.UnreadableCookieFile(None, False, None), stem.connection.CookieAuthRejected(None, False, None), stem.connection.IncorrectCookieValue(None, False, None), stem.connection.UnrecognizedAuthChallengeMethod(None, None, None), stem.connection.AuthChallengeFailed(None, None), stem.connection.AuthSecurityFailure(None, None), stem.connection.InvalidClientNonce(None, None)) # authentication functions might raise a controller error when # 'suppress_ctl_errors' is False, so including those control_exc = ( stem.ProtocolError(None), stem.SocketError(None), stem.SocketClosed(None)) all_auth_none_exc += control_exc all_auth_password_exc += control_exc all_auth_cookie_exc += control_exc auth_method_combinations = mocking.get_all_combinations([ stem.connection.AuthMethod.NONE, stem.connection.AuthMethod.PASSWORD, stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.SAFECOOKIE, stem.connection.AuthMethod.UNKNOWN, ], include_empty = True) for protocolinfo_auth_methods in 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 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. # # This implementation is slightly inaccurate in a couple regards... # a. it raises safecookie exceptions from authenticate_cookie() # b. exceptions raised by authenticate_cookie() and # authenticate_safecookie() are always the same # # However, adding another loop for safe_cookie exceptions means # multiplying our runtime many fold. This exercises everything that # matters so the above inaccuracies seem fine. expect_success = False 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), stem.connection.AuthMethod.SAFECOOKIE: (stem.connection.authenticate_safecookie, 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", None, protocolinfo_arg) else: self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None, "blah", None, protocolinfo_arg) # revert logging back to normal stem_logger.setLevel(log.logging_level(log.TRACE))
def test_all_use_cases(self, authenticate_safecookie_mock, authenticate_cookie_mock, authenticate_password_mock, authenticate_none_mock): """ Does basic validation that all valid use cases for the PROTOCOLINFO input and dependent functions result in either success or a AuthenticationFailed subclass being raised. """ # mute the logger for this test since otherwise the output is overwhelming stem_logger = log.get_logger() stem_logger.setLevel(log.logging_level(None)) # exceptions that the authentication functions are documented to raise all_auth_none_exc = ( None, stem.connection.OpenAuthRejected(None), stem.ControllerError(None)) all_auth_password_exc = ( None, stem.connection.PasswordAuthRejected(None), stem.connection.IncorrectPassword(None), stem.ControllerError(None)) all_auth_cookie_exc = ( None, stem.connection.CookieAuthRejected(None, False, None), stem.connection.IncorrectCookieValue(None, False, None), stem.connection.IncorrectCookieSize(None, False, None), stem.connection.UnreadableCookieFile(None, False, None), stem.connection.AuthChallengeFailed(None, None), stem.ControllerError(None)) auth_method_combinations = mocking.get_all_combinations([ stem.connection.AuthMethod.NONE, stem.connection.AuthMethod.PASSWORD, stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.SAFECOOKIE, stem.connection.AuthMethod.UNKNOWN, ], include_empty = True) protocolinfo = mocking.get_protocolinfo_response(cookie_path = '/tmp/blah') for auth_methods in auth_method_combinations: 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: # Skip iteration if it's to test exceptions for authentication # we're not using. if auth_none_exc and stem.connection.AuthMethod.NONE not in auth_methods: continue elif auth_password_exc and stem.connection.AuthMethod.PASSWORD not in auth_methods: continue elif auth_cookie_exc and stem.connection.AuthMethod.COOKIE not in auth_methods and stem.connection.AuthMethod.SAFECOOKIE not in auth_methods: continue # Determine if the authenticate() call will succeed and mock each # of the authenticate_* function to raise its given exception. # # This implementation is slightly inaccurate in a couple regards... # a. it raises safecookie exceptions from authenticate_cookie() # b. exceptions raised by authenticate_cookie() and # authenticate_safecookie() are always the same # # However, adding another loop for safe_cookie exceptions means # multiplying our runtime many fold. This exercises everything that # matters so the above inaccuracies seem fine. expect_success = False protocolinfo.auth_methods = auth_methods for auth_method in auth_methods: if auth_method == stem.connection.AuthMethod.NONE: auth_mock, raised_exc = authenticate_none_mock, auth_none_exc elif auth_method == stem.connection.AuthMethod.PASSWORD: auth_mock, raised_exc = authenticate_password_mock, auth_password_exc elif auth_method == stem.connection.AuthMethod.COOKIE: auth_mock, raised_exc = authenticate_cookie_mock, auth_cookie_exc elif auth_method == stem.connection.AuthMethod.SAFECOOKIE: auth_mock, raised_exc = authenticate_safecookie_mock, auth_cookie_exc if raised_exc: auth_mock.side_effect = raised_exc else: auth_mock.side_effect = None expect_success = True if expect_success: stem.connection.authenticate(None, 'blah', None, protocolinfo) else: self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None, 'blah', None, protocolinfo) # revert logging back to normal stem_logger.setLevel(log.logging_level(log.TRACE))