def test_setOpenIDNamespace_deprecated(self):
message = Message()
warning_msg = "Method 'setOpenIDNamespace' is deprecated. Pass namespace to Message constructor instead."
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
message.setOpenIDNamespace(OPENID2_NS, False)
self.assertEqual(message.getOpenIDNamespace(), OPENID2_NS)
def test_public(self):
dh = DiffieHellman.fromDefaults()
self.setup_keys(dh, self.server_public_key, self.server_private_key)
warning_msg = "Attribute 'public' is deprecated. Use 'public_key' instead."
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
self.assertEqual(dh.public, base64ToLong(self.server_public_key))
def test_version(self):
warning_msg = "Module 'openid.extensions.draft.pape5' is deprecated in favor of 'openid.extensions.pape'."
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
from openid.extensions.draft import pape5
self.assertEqual(pape.Request, pape5.Request)
self.assertEqual(pape.Response, pape5.Response)
def test_normalized(self):
self.assertEqual(urinorm('http://example.com/'), 'http://example.com/')
warning_msg = "Binary input for urinorm is deprecated. Use text input instead."
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
self.assertEqual(urinorm(b'http://example.com/'),
'http://example.com/')
def test_no_warn_not_expected(self):
with ShouldAssert("sequence not as expected:\n\n"
"same:\n[]\n\n"
"expected:\n[<C:" + warn_module +
".UserWarning>args: ('foo',)</>]"
"\n\nactual:\n[]"):
with ShouldWarn(UserWarning('foo')):
pass
def test_multiple_warnings(self):
with ShouldRaise(AssertionError) as s:
with ShouldWarn(UserWarning('foo')):
warnings.warn('foo')
warnings.warn('bar')
content = str(s.raised)
self.assertTrue('foo' in content)
self.assertTrue('bar' in content)
def test_binary_input(self):
warning_msg = 'Conversion warning'
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
result = string_to_text('ěščřž'.encode('utf-8'), warning_msg)
self.assertIsInstance(result, six.text_type)
self.assertEqual(result, 'ěščřž')
def test_hasKey(self):
# Could reasonably return False instead of raising an
# exception. I'm not sure which one is more right, since this
# case should only happen when you're building a message from
# scratch and so have no default namespace.
warning_msg = "UndefinedOpenIDNamespace exception is deprecated."
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
self.assertRaises(UndefinedOpenIDNamespace, self.msg.hasKey, OPENID_NS, 'foo')
def test_minimal_bad(self):
with ShouldAssert("sequence not as expected:\n\n"
"same:\n[]\n\n"
"expected:\n"
"[<C:" + warn_module +
".DeprecationWarning(failed)>wrong type</>]\n\n"
"actual:\n[UserWarning('foo'" + comma + ")]"):
with ShouldWarn(DeprecationWarning):
warnings.warn('foo')
def test_init_no_confirmation_method(self):
with ShouldWarn(
DeprecationWarning(
"Argument confirmation_method will be required.")):
warnings.simplefilter('always')
public_response = PublicResponse(sentinel.object_type,
sentinel.public_request_id,
sentinel.request_type,
sentinel.handle)
self.assertIsNone(public_response.confirmation_method)
def test_delArg(self):
# Could reasonably raise KeyError instead of raising
# UndefinedOpenIDNamespace. I'm not sure which one is more
# right, since this case should only happen when you're
# building a message from scratch and so have no default
# namespace.
warning_msg = "UndefinedOpenIDNamespace exception is deprecated."
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
self.assertRaises(UndefinedOpenIDNamespace, self.msg.delArg, OPENID_NS, 'key')
def test_no_warn_not_expected(self):
with ShouldRaise(
AssertionError("sequence not as expected:\n\n"
"same:\n[]\n\n"
"expected:\n[\n <C:" + warn_module +
".UserWarning>\n"
" args:('foo',)\n </C>]"
"\n\nactual:\n[]")):
with ShouldWarn(UserWarning('foo')):
pass
def test_minimal_bad(self):
with ShouldRaise(
AssertionError("sequence not as expected:\n\n"
"same:\n[]\n\n"
"expected:\n"
"[<C(failed):" + warn_module +
".DeprecationWarning>wrong type</C>]\n\n"
"actual:\n[UserWarning('foo',)]")):
with ShouldWarn(DeprecationWarning):
warnings.warn('foo')
def test_getSharedSecret(self):
# Test the deprecated method
consumer_dh = DiffieHellman.fromDefaults()
self.setup_keys(consumer_dh, self.consumer_public_key,
self.consumer_private_key)
warning_msg = "Method 'getSharedSecret' is deprecated in favor of '_get_shared_secret'."
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
self.assertEqual(
consumer_dh.getSharedSecret(self.server_public_key),
base64ToLong(self.shared_secret))
def test_modulus(self):
dh = DiffieHellman.fromDefaults()
modulus = int(
'155172898181473697471232257763715539915724801966915404479707795314057629378541917580651227423698'
'188993727816152646631438561595825688188889951272158842675419950341258706556549803580104870537681'
'476726513255747040765857479291291572334510643245094715007229621094194349783925984760375594985848'
'253359305585439638443')
warning_msg = "Modulus property will return base64 encoded string."
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
self.assertEqual(dh.modulus, modulus)
def test_maximal_bad(self):
with ShouldAssert(
"sequence not as expected:\n\n"
"same:\n[]\n\n"
"expected:\n[\n"
"<C(failed):" + warn_module + ".DeprecationWarning>\n"
"attributes differ:\n"
"'args': ('bar',) (Comparison) != ('foo',) (actual)\n</C>]\n\n"
"actual:\n[DeprecationWarning('foo'" + comma + ")]"):
with ShouldWarn(DeprecationWarning('bar')):
warnings.warn_explicit('foo', DeprecationWarning, 'bar.py', 42,
'bar_module')
def test_maximal_bad(self):
with ShouldRaise(
AssertionError("sequence not as expected:\n\n"
"same:\n[]\n\n"
"expected:\n[\n"
" <C(failed):" + warn_module +
".DeprecationWarning>\n"
" args:('bar',) != ('foo',)"
"\n </C>]\n\n"
"actual:\n[DeprecationWarning('foo',)]")):
with ShouldWarn(DeprecationWarning('bar')):
warnings.warn_explicit('foo', DeprecationWarning, 'bar.py', 42,
'bar_module')
def test_filter_missing(self):
if PY3:
type_repr = 'builtins.DeprecationWarning'
else:
type_repr = 'exceptions.DeprecationWarning'
with ShouldAssert("sequence not as expected:\n\n"
"same:\n[]\n\n"
"expected:\n[<C:{}>]\n\n"
"actual:\n[]".format(type_repr)):
with ShouldWarn(DeprecationWarning,
message="This function is deprecated."):
warnings.warn("This utility is deprecated.",
DeprecationWarning)
def test_maximal_explore(self):
with ShouldWarn() as recorded:
warnings.warn_explicit('foo', DeprecationWarning, 'bar.py', 42,
'bar_module')
compare(len(recorded), expected=1)
compare(
C(warnings.WarningMessage,
_category_name='DeprecationWarning',
category=DeprecationWarning,
file=None,
filename='bar.py',
line=None,
lineno=42,
message=C(DeprecationWarning('foo'))), recorded[0])
def test_xorSecret(self):
# Test key exchange - deprecated method
server_dh = DiffieHellman.fromDefaults()
self.setup_keys(server_dh, self.server_public_key,
self.server_private_key)
def sha256(value):
digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
digest.update(value)
return digest.finalize()
warning_msg = "Method 'xorSecret' is deprecated, use 'xor_secret' instead."
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
secret = server_dh.xorSecret(
base64ToLong(self.consumer_public_key),
base64.b64decode(self.secret), sha256)
self.assertEqual(secret, base64.b64decode(self.mac_key))
def test_maximal_explore(self):
with ShouldWarn() as recorded:
warnings.warn_explicit('foo', DeprecationWarning, 'bar.py', 42,
'bar_module')
compare(len(recorded), expected=1)
expected_attrs = dict(
_category_name='DeprecationWarning',
category=DeprecationWarning,
file=None,
filename='bar.py',
line=None,
lineno=42,
message=C(DeprecationWarning('foo')),
)
if PY_36_PLUS:
expected_attrs['source'] = None
compare(expected=C(warnings.WarningMessage, **expected_attrs),
actual=recorded[0])
def test_registrars_old_context(self):
# Test deprecated `_registrar_row` works correctly
registrar = make_registrar()
WHOIS.get_registrars.return_value = [registrar]
WHOIS.get_registrar_groups.return_value = []
WHOIS.get_registrar_certification_list.return_value = []
warn_msg = (
"Method 'RegistrarListView._registrar_row' is deprecated in favor of "
"'RegistrarListView.get_registrar_context'.")
with ShouldWarn(DeprecationWarning(warn_msg)):
warnings.simplefilter('always')
response = self.client.get(reverse('registrars_custom'))
self.assertContains(response, "List of registrars")
self.assertEqual(len(response.context['registrars']), 1)
self.assertTrue(response.context['registrars'][0]['custom'])
self.assertEqual(WHOIS.mock_calls, [
call.get_registrars(),
call.get_registrar_certification_list(),
call.get_registrar_groups()
])
def test_corba_get_object_text(self):
corba_obj = CorbaNameServiceClient()
with patch('pyfco.name_service.installTransientExceptionHandler', autospec=True), \
patch('pyfco.name_service.CORBA.ORB_init', autospec=True) as init_mock, \
patch.object(CosNaming, "NameComponent") as mock_name_component, \
ShouldWarn(DeprecationWarning("Passing 'name' as six.binary_type is deprecated. "
"Please pass six.text_type.")):
corba_obj.get_object(b"Logger", "ccRegTest.Logger")
if six.PY2: # pragma: no cover
name_calls = [call('fred'.encode(), 'context'.encode()),
call('Logger'.encode(), 'Object'.encode())]
init_calls = [call(['-ORBnativeCharCodeSet'.encode(), 'UTF-8'.encode()])]
else: # pragma: no cover
name_calls = [call('fred', 'context'),
call('Logger', 'Object')]
init_calls = [call(['-ORBnativeCharCodeSet', 'UTF-8'])]
self.assertEqual(mock_name_component.mock_calls, name_calls)
init_calls.extend([call().string_to_object('corbaname::localhost'),
call().string_to_object()._narrow(CosNaming.NamingContext),
call().string_to_object()._narrow().resolve([mock_name_component(), mock_name_component()]),
call().string_to_object()._narrow().resolve()._narrow('ccRegTest.Logger')])
self.assertEqual(init_mock.mock_calls, init_calls)
def test_openid_namespace_invalid(self):
invalid_things = [
# Empty string is not okay here.
'',
# Good guess! But wrong.
'http://openid.net/signon/2.0',
# What?
'http://specs%\\\r2Eopenid.net/auth/2.0',
# Too much escapings!
'http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0',
# This is a Type URI, not a openid.ns value.
'http://specs.openid.net/auth/2.0/signon',
]
warning_msg = "Method 'setOpenIDNamespace' is deprecated. Pass namespace to Message constructor instead."
for x in invalid_things:
self.assertRaises(InvalidOpenIDNamespace, Message, x, False)
# Test also deprecated setOpenIDNamespace
message = Message()
with ShouldWarn(DeprecationWarning(warning_msg)):
warnings.simplefilter('always')
self.assertRaises(InvalidOpenIDNamespace, message.setOpenIDNamespace, x, False)
def test_maximal_ok(self):
with ShouldWarn(DeprecationWarning('foo')):
warnings.warn_explicit('foo', DeprecationWarning, 'bar.py', 42,
'bar_module')
def test_minimal_ok(self):
with ShouldWarn(UserWarning):
warnings.warn('foo')
def test_filters_removed(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
with ShouldWarn(UserWarning("foo")):
warnings.warn('foo')
def test_init_host_port_bytes(self):
with ShouldWarn(DeprecationWarning("Passing 'host_port' as six.binary_type is deprecated. "
"Please pass six.text_type.")):
corba_obj = CorbaNameServiceClient(host_port=b'test')
self.assertIsInstance(corba_obj.host_port, six.text_type)
def test_warn_expected(self):
with warnings.catch_warnings(record=True) as backstop:
with ShouldWarn(UserWarning('foo')):
warnings.warn('foo')
compare(len(backstop), expected=0)
def test_filter_present(self):
with ShouldWarn(DeprecationWarning,
message="This function is deprecated."):
warnings.warn("This utility is deprecated.", DeprecationWarning)
warnings.warn("This function is deprecated.", DeprecationWarning)