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_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))
