def test_starttls(self):
self.t = TransportMock(self,
self.protocol,
with_starttls=True,
loop=self.loop)
self.assertTrue(self.t.can_starttls())
fut = asyncio.Future()
def connection_made(transport):
fut.set_result(None)
self.protocol.connection_made = connection_made
ssl_context = unittest.mock.Mock()
post_handshake_callback = CoroutineMock()
post_handshake_callback.return_value = None
async def late_starttls():
await fut
await self.t.starttls(ssl_context, post_handshake_callback)
run_coroutine_with_peer(
late_starttls(),
self.t.run_test(
[TransportMock.STARTTLS(ssl_context,
post_handshake_callback)]))
post_handshake_callback.assert_called_once_with(self.t)
def test__handle_command_raises_forbidden_for_disallowed_node(self):
handler = CoroutineMock()
handler.return_value = unittest.mock.sentinel.result
is_allowed = unittest.mock.Mock()
is_allowed.return_value = False
self.s.register_stateless_command(
"node",
"Command name",
handler,
is_allowed=is_allowed,
)
req = aioxmpp.IQ(type_=aioxmpp.IQType.SET,
from_=TEST_PEER_JID,
to=TEST_LOCAL_JID,
payload=adhoc_xso.Command("node", ))
with self.assertRaises(aioxmpp.errors.XMPPCancelError) as ctx:
run_coroutine(self.s._handle_command(req))
is_allowed.assert_called_once_with(req.from_)
self.assertEqual(
ctx.exception.condition,
aioxmpp.ErrorCondition.FORBIDDEN,
)
handler.assert_not_called()
def test__handle_command_dispatches_to_command(self):
handler = CoroutineMock()
handler.return_value = unittest.mock.sentinel.result
self.s.register_stateless_command(
"node",
"Command name",
handler,
)
req = aioxmpp.IQ(
type_=aioxmpp.IQType.SET,
from_=TEST_PEER_JID,
to=TEST_LOCAL_JID,
payload=adhoc_xso.Command(
"node",
)
)
result = run_coroutine(self.s._handle_command(req))
handler.assert_called_once_with(req)
self.assertEqual(
result,
unittest.mock.sentinel.result,
)
def test_return_value(self):
m = CoroutineMock()
m.return_value = "foobar"
self.assertEqual(
"foobar",
run_coroutine(m())
)
def test_connect_and_fire(self):
coro = CoroutineMock()
coro.return_value = True
signal = SyncAdHocSignal()
signal.connect(coro)
run_coroutine(signal.fire(1, 2, foo="bar"))
self.assertSequenceEqual([
unittest.mock.call(1, 2, foo="bar"),
], coro.mock_calls)
def test_connect_and_fire(self):
coro = CoroutineMock()
coro.return_value = True
signal = SyncAdHocSignal()
signal.connect(coro)
run_coroutine(signal.fire(1, 2, foo="bar"))
self.assertSequenceEqual(
[
unittest.mock.call(1, 2, foo="bar"),
],
coro.mock_calls
)
def test_fire_removes_on_false_result(self):
coro = CoroutineMock()
coro.return_value = False
signal = SyncAdHocSignal()
signal.connect(coro)
run_coroutine(signal.fire(1, 2, foo="bar"))
self.assertSequenceEqual([
unittest.mock.call(1, 2, foo="bar"),
], coro.mock_calls)
coro.reset_mock()
run_coroutine(signal.fire(1, 2, foo="bar"))
self.assertSequenceEqual([], coro.mock_calls)
def test_starttls(self):
ssl_context = unittest.mock.MagicMock()
post_handshake_callback = CoroutineMock()
post_handshake_callback.return_value = None
self.xmlstream.transport = object()
run_coroutine(
asyncio.gather(
self.xmlstream.starttls(ssl_context, post_handshake_callback),
self.xmlstream.run_test([
XMLStreamMock.STARTTLS(ssl_context,
post_handshake_callback)
], )))
post_handshake_callback.assert_called_once_with(
self.xmlstream.transport)
def test_context_connect(self):
signal = SyncAdHocSignal()
coro = CoroutineMock()
coro.return_value = True
with signal.context_connect(coro):
run_coroutine(signal("foo"))
run_coroutine(signal("bar"))
with signal.context_connect(coro) as token:
run_coroutine(signal("baz"))
signal.disconnect(token)
run_coroutine(signal("fnord"))
self.assertSequenceEqual([
unittest.mock.call("foo"),
unittest.mock.call("baz"),
], coro.mock_calls)
def test_context_connect(self):
signal = SyncAdHocSignal()
coro = CoroutineMock()
coro.return_value = True
with signal.context_connect(coro):
run_coroutine(signal("foo"))
run_coroutine(signal("bar"))
with signal.context_connect(coro) as token:
run_coroutine(signal("baz"))
signal.disconnect(token)
run_coroutine(signal("fnord"))
self.assertSequenceEqual(
[
unittest.mock.call("foo"),
unittest.mock.call("baz"),
],
coro.mock_calls
)
def test_fire_removes_on_false_result(self):
coro = CoroutineMock()
coro.return_value = False
signal = SyncAdHocSignal()
signal.connect(coro)
run_coroutine(signal.fire(1, 2, foo="bar"))
self.assertSequenceEqual(
[
unittest.mock.call(1, 2, foo="bar"),
],
coro.mock_calls
)
coro.reset_mock()
run_coroutine(signal.fire(1, 2, foo="bar"))
self.assertSequenceEqual(
[
],
coro.mock_calls
)
def test__fetch_avatar_and_emit_signal(self):
fetch_func = CoroutineMock()
fetch_func.return_value = unittest.mock.Mock(spec=Qt.QPicture)
