def test__getitem__(self):
class FakeFeature(xso.XSO):
TAG = ("uri:foo", "foo")
class NotAFeature(xso.XSO):
TAG = ("uri:foo", "bar")
instance = FakeFeature()
features = nonza.StreamFeatures()
features.features[FakeFeature.TAG].append(instance)
self.assertIs(
instance,
features[FakeFeature]
)
with self.assertRaises(KeyError) as ctx:
features[NotAFeature]
self.assertEqual(
(NotAFeature,),
ctx.exception.args
)
self.assertIsNone(ctx.exception.__cause__)
self.assertTrue(ctx.exception.__suppress_context__)
def __init__(self):
super().__init__([
"stream",
"start",
"stop",
"set_presence",
"local_jid",
"enqueue",
])
self.established = True
self.stream_features = nonza.StreamFeatures()
self.stream.on_message_received = callbacks.AdHocSignal()
self.stream.on_presence_received = callbacks.AdHocSignal()
self.stream.on_stream_destroyed = callbacks.AdHocSignal()
self.stream.app_inbound_message_filter = FilterMock()
self.stream.app_inbound_presence_filter = FilterMock()
self.stream.app_outbound_message_filter = FilterMock()
self.stream.app_outbound_presence_filter = FilterMock()
self.stream.service_inbound_message_filter = FilterMock()
self.stream.service_inbound_presence_filter = FilterMock()
self.stream.service_outbound_message_filter = FilterMock()
self.stream.service_outbound_presence_filter = FilterMock()
self.stream.on_stream_destroyed = callbacks.AdHocSignal()
self.stream.send_iq_and_wait_for_reply.side_effect = \
AssertionError("use of deprecated function")
self.stream.send.side_effect = \
AssertionError("use of deprecated function")
self.stream.enqueue.side_effect = \
AssertionError("use of deprecated function")
self.send = CoroutineMock()
self.stream.enqueue_stanza = self.stream.enqueue
self.mock_services = {}
def test_receive_stream_features_into_future(self):
fut = self.xmlstream.features_future()
obj = nonza.StreamFeatures()
run_coroutine(
self.xmlstream.run_test([], stimulus=XMLStreamMock.Receive(obj)))
self.assertTrue(fut.done())
self.assertIs(fut.result(), obj)
def test_has_feature(self):
class FakeFeature(xso.XSO):
TAG = ("uri:foo", "foo")
class NotAFeature(xso.XSO):
TAG = ("uri:foo", "bar")
features = nonza.StreamFeatures()
features.features[FakeFeature.TAG].append(FakeFeature())
self.assertTrue(features.has_feature(FakeFeature))
self.assertFalse(features.has_feature(NotAFeature))
def __init__(self):
super().__init__([
"stream",
"start",
"stop",
"set_presence",
])
self.established = True
self.stream_features = nonza.StreamFeatures()
self.stream.send_iq_and_wait_for_reply = CoroutineMock()
self.mock_services = {}
def test_iter_features(self):
class FakeFeatureA(xso.XSO):
TAG = ("uri:foo", "foo")
class FakeFeatureB(xso.XSO):
TAG = ("uri:foo", "bar")
instance1, instance2 = FakeFeatureA(), FakeFeatureB()
features = nonza.StreamFeatures()
features[...] = instance1
features[...] = instance2
self.assertSetEqual({instance1, instance2}, set(features))
def test___delitem__(self):
class FakeFeature(xso.XSO):
TAG = ("uri:foo", "foo")
instance = FakeFeature()
features = nonza.StreamFeatures()
features.features[FakeFeature.TAG].append(instance)
del features[FakeFeature]
with self.assertRaises(KeyError):
features[FakeFeature]
with self.assertRaises(KeyError):
del features[FakeFeature]
def test_get_feature(self):
class FakeFeature(xso.XSO):
TAG = ("uri:foo", "foo")
class NotAFeature(xso.XSO):
TAG = ("uri:foo", "bar")
instance = FakeFeature()
default = object()
features = nonza.StreamFeatures()
features.features[FakeFeature.TAG].append(instance)
self.assertIs(instance, features.get_feature(FakeFeature))
self.assertIsNone(features.get_feature(NotAFeature))
self.assertIs(default,
features.get_feature(NotAFeature, default=default))
def test___setitem__(self):
class FakeFeature(xso.XSO):
TAG = ("uri:foo", "foo")
class NotAFeature(xso.XSO):
TAG = ("uri:foo", "foo") # using the same tag here!
instance = FakeFeature()
features = nonza.StreamFeatures()
features[...] = instance
self.assertIs(instance, features[FakeFeature])
with self.assertRaisesRegex(ValueError, "incorrect XSO class"):
features[NotAFeature] = instance
del features[FakeFeature]
def test_contains(self):
features = nonza.StreamFeatures()
with self.assertRaisesRegex(TypeError,
"membership test not supported"):
"foo" in features
def test_connect_with_failed_starttls_and_without_required(self):
captured_features_future = None
def capture_future(*args, features_future=None, **kwargs):
nonlocal captured_features_future
captured_features_future = features_future
return base.protocol
features = nonza.StreamFeatures()
features[...] = nonza.StartTLSFeature()
features_future = asyncio.Future()
features_future.set_result(
features
)
base = unittest.mock.Mock()
base.protocol.starttls = CoroutineMock()
base.create_starttls_connection = CoroutineMock()
base.create_starttls_connection.return_value = (
unittest.mock.sentinel.transport,
base.protocol,
)
base.metadata.tls_required = False
base.XMLStream.return_value = base.protocol
base.XMLStream.side_effect = capture_future
base.Future.return_value = features_future
base.send_and_wait_for = CoroutineMock()
base.send_and_wait_for.return_value = unittest.mock.Mock(
spec=nonza.StartTLSFailure,
)
with contextlib.ExitStack() as stack:
stack.enter_context(
unittest.mock.patch(
"asyncio.Future",
new=base.Future,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.ssl_transport.create_starttls_connection",
new=base.create_starttls_connection,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.XMLStream",
new=base.XMLStream,
)
)
StartTLS_nonza = stack.enter_context(
unittest.mock.patch(
"aioxmpp.nonza.StartTLS",
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.send_and_wait_for",
new=base.send_and_wait_for,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.send_stream_error_and_close",
new=base.send_stream_error_and_close
)
)
stack.enter_context(
unittest.mock.patch(
"asyncio.async",
new=base.async_,
)
)
result = run_coroutine(self.c.connect(
unittest.mock.sentinel.loop,
base.metadata,
unittest.mock.sentinel.domain,
unittest.mock.sentinel.host,
unittest.mock.sentinel.port,
unittest.mock.sentinel.timeout,
))
self.assertSequenceEqual(
base.mock_calls,
[
unittest.mock.call.Future(
loop=unittest.mock.sentinel.loop,
),
unittest.mock.call.XMLStream(
to=unittest.mock.sentinel.domain,
features_future=features_future,
base_logger=None,
),
unittest.mock.call.create_starttls_connection(
unittest.mock.sentinel.loop,
unittest.mock.ANY,
host=unittest.mock.sentinel.host,
port=unittest.mock.sentinel.port,
peer_hostname=unittest.mock.sentinel.host,
server_hostname=unittest.mock.sentinel.domain,
use_starttls=True,
),
unittest.mock.call.send_and_wait_for(
base.protocol,
[
StartTLS_nonza(),
],
[
nonza.StartTLSFailure,
nonza.StartTLSProceed,
]
)
]
)
self.assertEqual(
result,
(
unittest.mock.sentinel.transport,
base.protocol,
features,
)
)
def test_connect_successful(self):
captured_features_future = None
def capture_future(*args, features_future=None, **kwargs):
nonlocal captured_features_future
captured_features_future = features_future
return base.protocol
features = nonza.StreamFeatures()
features[...] = nonza.StartTLSFeature()
features_future = asyncio.Future()
features_future.set_result(
features
)
base = unittest.mock.Mock()
base.protocol.starttls = CoroutineMock()
base.create_starttls_connection = CoroutineMock()
base.create_starttls_connection.return_value = (
unittest.mock.sentinel.transport,
base.protocol,
)
base.metadata.tls_required = True
base.XMLStream.return_value = base.protocol
base.XMLStream.side_effect = capture_future
base.Future.return_value = features_future
base.send_and_wait_for = CoroutineMock()
base.send_and_wait_for.return_value = unittest.mock.Mock(
spec=nonza.StartTLSProceed,
)
base.certificate_verifier.pre_handshake = CoroutineMock()
base.metadata.certificate_verifier_factory.return_value = \
base.certificate_verifier
base.metadata.ssl_context_factory.return_value = \
unittest.mock.sentinel.ssl_context
base.reset_stream_and_get_features = CoroutineMock()
base.reset_stream_and_get_features.return_value = \
unittest.mock.sentinel.reset
base.async_.return_value = unittest.mock.sentinel.features_future
with contextlib.ExitStack() as stack:
stack.enter_context(
unittest.mock.patch(
"asyncio.Future",
new=base.Future,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.ssl_transport.create_starttls_connection",
new=base.create_starttls_connection,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.XMLStream",
new=base.XMLStream,
)
)
StartTLS_nonza = stack.enter_context(
unittest.mock.patch(
"aioxmpp.nonza.StartTLS",
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.send_and_wait_for",
new=base.send_and_wait_for,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.reset_stream_and_get_features",
new=base.reset_stream_and_get_features,
)
)
result = run_coroutine(self.c.connect(
unittest.mock.sentinel.loop,
base.metadata,
unittest.mock.sentinel.domain,
unittest.mock.sentinel.host,
unittest.mock.sentinel.port,
unittest.mock.sentinel.timeout,
base_logger=unittest.mock.sentinel.base_logger,
))
self.assertSequenceEqual(
base.mock_calls,
[
unittest.mock.call.Future(
loop=unittest.mock.sentinel.loop,
),
unittest.mock.call.XMLStream(
to=unittest.mock.sentinel.domain,
features_future=features_future,
base_logger=unittest.mock.sentinel.base_logger,
),
unittest.mock.call.create_starttls_connection(
unittest.mock.sentinel.loop,
unittest.mock.ANY,
host=unittest.mock.sentinel.host,
port=unittest.mock.sentinel.port,
peer_hostname=unittest.mock.sentinel.host,
server_hostname=unittest.mock.sentinel.domain,
use_starttls=True,
),
unittest.mock.call.send_and_wait_for(
base.protocol,
[
StartTLS_nonza(),
],
[
nonza.StartTLSFailure,
nonza.StartTLSProceed,
]
),
unittest.mock.call.metadata.certificate_verifier_factory(),
unittest.mock.call.certificate_verifier.pre_handshake(
unittest.mock.sentinel.domain,
unittest.mock.sentinel.host,
unittest.mock.sentinel.port,
base.metadata,
),
unittest.mock.call.metadata.ssl_context_factory(),
unittest.mock.call.certificate_verifier.setup_context(
unittest.mock.sentinel.ssl_context,
unittest.mock.sentinel.transport,
),
unittest.mock.call.protocol.starttls(
ssl_context=unittest.mock.sentinel.ssl_context,
post_handshake_callback=base.certificate_verifier.post_handshake,
),
unittest.mock.call.reset_stream_and_get_features(
base.protocol,
timeout=unittest.mock.sentinel.timeout,
),
]
)
self.assertEqual(
result,
(
unittest.mock.sentinel.transport,
base.protocol,
unittest.mock.sentinel.reset,
)
)
def test_connect_without_starttls_support_and_with_required(self):
captured_features_future = None
def capture_future(*args, features_future=None, **kwargs):
nonlocal captured_features_future
captured_features_future = features_future
return base.protocol
features = nonza.StreamFeatures()
features_future = asyncio.Future()
features_future.set_result(
features
)
base = unittest.mock.Mock()
base.protocol.starttls = CoroutineMock()
base.create_starttls_connection = CoroutineMock()
base.create_starttls_connection.return_value = (
base.transport,
base.protocol,
)
base.metadata.tls_required = True
base.XMLStream.return_value = base.protocol
base.XMLStream.side_effect = capture_future
base.Future.return_value = features_future
error_message = (
"STARTTLS not supported by server, but required by client"
)
with contextlib.ExitStack() as stack:
stack.enter_context(
unittest.mock.patch(
"asyncio.Future",
new=base.Future,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.ssl_transport.create_starttls_connection",
new=base.create_starttls_connection,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.XMLStream",
new=base.XMLStream,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.send_stream_error_and_close",
new=base.send_stream_error_and_close,
)
)
with self.assertRaisesRegex(errors.TLSUnavailable, error_message):
run_coroutine(self.c.connect(
unittest.mock.sentinel.loop,
base.metadata,
unittest.mock.sentinel.domain,
unittest.mock.sentinel.host,
unittest.mock.sentinel.port,
unittest.mock.sentinel.timeout,
))
self.assertSequenceEqual(
base.mock_calls,
[
unittest.mock.call.Future(
loop=unittest.mock.sentinel.loop,
),
unittest.mock.call.XMLStream(
to=unittest.mock.sentinel.domain,
features_future=features_future,
base_logger=None,
),
unittest.mock.call.create_starttls_connection(
unittest.mock.sentinel.loop,
unittest.mock.ANY,
host=unittest.mock.sentinel.host,
port=unittest.mock.sentinel.port,
peer_hostname=unittest.mock.sentinel.host,
server_hostname=unittest.mock.sentinel.domain,
use_starttls=True,
),
unittest.mock.call.send_stream_error_and_close(
base.protocol,
condition=(namespaces.streams, "policy-violation"),
text=error_message,
)
]
)
def test_abort_xmlstream_if_connect_fails(self):
captured_features_future = None
def capture_future(*args, features_future=None, **kwargs):
nonlocal captured_features_future
captured_features_future = features_future
return base.protocol
features = nonza.StreamFeatures()
features[...] = nonza.StartTLSFeature()
features_future = asyncio.Future()
features_future.set_result(
features
)
base = unittest.mock.Mock()
base.create_starttls_connection = CoroutineMock()
base.create_starttls_connection.side_effect = Exception()
base.XMLStream.return_value = base.protocol
base.XMLStream.side_effect = capture_future
base.Future.return_value = features_future
with contextlib.ExitStack() as stack:
stack.enter_context(
unittest.mock.patch(
"asyncio.Future",
new=base.Future,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.ssl_transport.create_starttls_connection",
new=base.create_starttls_connection,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.XMLStream",
new=base.XMLStream,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.send_and_wait_for",
new=base.send_and_wait_for,
)
)
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.reset_stream_and_get_features",
new=base.reset_stream_and_get_features,
)
)
with self.assertRaises(Exception):
run_coroutine(self.c.connect(
unittest.mock.sentinel.loop,
base.metadata,
unittest.mock.sentinel.domain,
unittest.mock.sentinel.host,
unittest.mock.sentinel.port,
unittest.mock.sentinel.timeout,
))
self.maxDiff = None
self.assertSequenceEqual(
base.mock_calls,
[
unittest.mock.call.Future(
loop=unittest.mock.sentinel.loop,
),
unittest.mock.call.XMLStream(
to=unittest.mock.sentinel.domain,
features_future=features_future,
base_logger=None,
),
unittest.mock.call.create_starttls_connection(
unittest.mock.sentinel.loop,
unittest.mock.ANY,
host=unittest.mock.sentinel.host,
port=unittest.mock.sentinel.port,
peer_hostname=unittest.mock.sentinel.host,
server_hostname=unittest.mock.sentinel.domain,
use_starttls=True,
),
unittest.mock.call.protocol.abort(),
]
)
def test_connect_without_starttls_support_and_with_required_error(self):
captured_features_future = None
def capture_future(*args, features_future=None, **kwargs):
nonlocal captured_features_future
captured_features_future = features_future
return base.protocol
features = nonza.StreamFeatures()
features_future = asyncio.Future()
features_future.set_result(features)
base = unittest.mock.Mock()
base.protocol.starttls = CoroutineMock()
base.create_starttls_connection = CoroutineMock()
base.create_starttls_connection.return_value = (
unittest.mock.sentinel.transport,
base.protocol,
)
base.metadata.tls_required = True
base.XMLStream.return_value = base.protocol
base.XMLStream.side_effect = capture_future
base.Future.return_value = features_future
base.send_and_wait_for = CoroutineMock()
base.send_and_wait_for.side_effect = errors.StreamError(
condition=errors.StreamErrorCondition.UNSUPPORTED_STANZA_TYPE, )
error_message = (
"STARTTLS not supported by server, but required by client")
with contextlib.ExitStack() as stack:
stack.enter_context(
unittest.mock.patch(
"asyncio.Future",
new=base.Future,
))
stack.enter_context(
unittest.mock.patch(
"aioxmpp.ssl_transport.create_starttls_connection",
new=base.create_starttls_connection,
))
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.XMLStream",
new=base.XMLStream,
))
StartTLS_nonza = stack.enter_context(
unittest.mock.patch("aioxmpp.nonza.StartTLS", ))
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.send_and_wait_for",
new=base.send_and_wait_for,
))
stack.enter_context(
unittest.mock.patch(
"aioxmpp.protocol.send_stream_error_and_close",
new=base.send_stream_error_and_close))
stack.enter_context(
unittest.mock.patch(
"asyncio.ensure_future",
new=base.async_,
))
stack.enter_context(
unittest.mock.patch("aioxmpp.connector.timedelta", ))
with self.assertRaisesRegex(errors.TLSUnavailable, error_message):
run_coroutine(
self.c.connect(
unittest.mock.sentinel.loop,
base.metadata,
unittest.mock.sentinel.domain,
unittest.mock.sentinel.host,
unittest.mock.sentinel.port,
unittest.mock.sentinel.timeout,
))
self.assertSequenceEqual(base.mock_calls, [
unittest.mock.call.Future(loop=unittest.mock.sentinel.loop, ),
unittest.mock.call.XMLStream(
to=unittest.mock.sentinel.domain,
features_future=features_future,
base_logger=None,
),
unittest.mock.call.create_starttls_connection(
unittest.mock.sentinel.loop,
unittest.mock.ANY,
host=unittest.mock.sentinel.host,
port=unittest.mock.sentinel.port,
peer_hostname=unittest.mock.sentinel.host,
server_hostname=unittest.mock.sentinel.domain,
use_starttls=True,
),
unittest.mock.call.send_and_wait_for(base.protocol, [
StartTLS_nonza(),
], [
nonza.StartTLSFailure,
nonza.StartTLSProceed,
])
])
