def setUp(self):
self.cc = make_connected_client()
self.cc.stream.send = CoroutineMock()
self.cc.stream.send.side_effect = AssertionError("not configured")
self.cc.local_jid = LOCAL_JID
deps = {
im_service.ConversationService: im_service.ConversationService(
self.cc
),
im_dispatcher.IMDispatcher: im_dispatcher.IMDispatcher(
self.cc
)
}
self.svc = unittest.mock.Mock(["client", "_conversation_left"])
self.svc.client = self.cc
self.s = p2p.Service(self.cc, dependencies=deps)
self.listener = unittest.mock.Mock()
for ev in ["on_conversation_new", "on_conversation_left"]:
listener = getattr(self.listener, ev)
signal = getattr(self.s, ev)
listener.return_value = None
signal.connect(listener)
for ev in ["on_conversation_added"]:
listener = getattr(self.listener, ev)
signal = getattr(deps[im_service.ConversationService], ev)
listener.return_value = None
signal.connect(listener)
def setUp(self):
self.cc = make_connected_client()
self.s = roster_service.Service(self.cc)
self.user1 = structs.JID.fromstr("*****@*****.**")
self.user2 = structs.JID.fromstr("*****@*****.**")
response = roster_xso.Query(
items=[
roster_xso.Item(
jid=self.user1,
groups=[
roster_xso.Group(name="group1"),
roster_xso.Group(name="group3"),
]
),
roster_xso.Item(
jid=self.user2,
name="some bar user",
subscription="both",
groups=[
roster_xso.Group(name="group1"),
roster_xso.Group(name="group2"),
]
)
],
ver="foobar"
)
self.cc.stream.send_iq_and_wait_for_reply.return_value = response
run_coroutine(self.cc.before_stream_established())
self.cc.stream.send_iq_and_wait_for_reply.reset_mock()
def setUp(self):
self.cc = make_connected_client()
self.s = vcard_service.VCardService(
self.cc,
dependencies={},
)
self.cc.mock_calls.clear()
def setUp(self):
self.cc = make_connected_client()
self.s = roster_service.Service(self.cc)
self.user1 = structs.JID.fromstr("*****@*****.**")
self.user2 = structs.JID.fromstr("*****@*****.**")
response = roster_xso.Query(items=[
roster_xso.Item(jid=self.user1,
groups=[
roster_xso.Group(name="group1"),
roster_xso.Group(name="group3"),
]),
roster_xso.Item(jid=self.user2,
name="some bar user",
subscription="both",
groups=[
roster_xso.Group(name="group1"),
roster_xso.Group(name="group2"),
])
],
ver="foobar")
self.cc.stream.send_iq_and_wait_for_reply.return_value = response
run_coroutine(self.cc.before_stream_established())
self.cc.stream.send_iq_and_wait_for_reply.reset_mock()
def test_attributes(self):
cc = make_connected_client()
self.assertTrue(hasattr(cc, "stream"))
self.assertTrue(hasattr(cc, "start"))
self.assertTrue(hasattr(cc, "stop"))
self.assertTrue(hasattr(cc, "established"))
self.assertTrue(hasattr(cc, "send"))
self.assertTrue(hasattr(cc, "enqueue"))
self.assertIs(cc.established, True)
self.assertIsInstance(cc.on_failure, callbacks.AdHocSignal)
self.assertIsInstance(cc.on_stopped, callbacks.AdHocSignal)
self.assertIsInstance(cc.on_stream_destroyed, callbacks.AdHocSignal)
self.assertIsInstance(cc.on_stream_established, callbacks.AdHocSignal)
self.assertIsInstance(cc.before_stream_established,
callbacks.SyncAdHocSignal)
self.assertEqual(timedelta(microseconds=100000),
cc.negotiation_timeout)
self.assertTrue(hasattr(cc.stream, "register_iq_response_future"))
self.assertTrue(hasattr(cc.stream, "register_iq_request_handler"))
self.assertTrue(hasattr(cc.stream, "register_message_callback"))
self.assertTrue(hasattr(cc.stream, "register_iq_response_callback"))
self.assertTrue(hasattr(cc.stream, "register_presence_callback"))
self.assertIsInstance(cc.send, CoroutineMock)
self.assertIsInstance(cc.stream_features, nonza.StreamFeatures)
self.assertIs(cc.stream.enqueue, cc.stream.enqueue_stanza)
def setUp(self):
self.cc = make_connected_client()
self.s = private_xml_service.PrivateXMLService(
self.cc,
dependencies={},
)
self.cc.mock_calls.clear()
def test_attributes(self):
cc = make_connected_client()
self.assertTrue(hasattr(cc, "stream"))
self.assertTrue(hasattr(cc, "start"))
self.assertTrue(hasattr(cc, "stop"))
self.assertTrue(hasattr(cc, "established"))
self.assertTrue(hasattr(cc, "send"))
self.assertTrue(hasattr(cc, "enqueue"))
self.assertIs(cc.established, True)
self.assertIsInstance(cc.on_failure, callbacks.AdHocSignal)
self.assertIsInstance(cc.on_stopped, callbacks.AdHocSignal)
self.assertIsInstance(cc.on_stream_destroyed, callbacks.AdHocSignal)
self.assertIsInstance(cc.on_stream_established, callbacks.AdHocSignal)
self.assertIsInstance(cc.before_stream_established,
callbacks.SyncAdHocSignal)
self.assertEqual(
timedelta(microseconds=100000),
cc.negotiation_timeout
)
self.assertTrue(hasattr(cc.stream, "register_iq_response_future"))
self.assertTrue(hasattr(cc.stream, "register_iq_request_handler"))
self.assertTrue(hasattr(cc.stream, "register_message_callback"))
self.assertTrue(hasattr(cc.stream, "register_iq_response_callback"))
self.assertTrue(hasattr(cc.stream, "register_presence_callback"))
self.assertIsInstance(cc.send, CoroutineMock)
self.assertIsInstance(cc.stream_features, nonza.StreamFeatures)
self.assertIs(cc.stream.enqueue, cc.stream.enqueue_stanza)
def setUp(self):
self.cc = make_connected_client()
self.listener = unittest.mock.Mock()
self.loop = asyncio.get_event_loop()
self.logger = logging.getLogger(".".join(
[type(self).__module__,
type(self).__qualname__]))
self.p = self_ping.MUCPinger(
unittest.mock.sentinel.ping_address,
self.cc,
self.listener.on_fresh,
self.listener.on_exited,
self.logger,
self.loop,
)
def no_jitter(v, amplitude):
return v
self.jitter_mock = unittest.mock.Mock(side_effect=no_jitter)
self.jitter_patch = unittest.mock.patch(
"aioxmpp.muc.self_ping._apply_jitter",
new=self.jitter_mock,
)
self.jitter_patch.start()
def setUp(self):
self.cc = make_connected_client()
self.s = vcard_service.VCardService(
self.cc,
dependencies={},
)
self.cc.mock_calls.clear()
def setUp(self):
self.cc = make_connected_client()
self.cc.send = CoroutineMock()
self.cc.send.side_effect = AssertionError("not configured")
self.cc.local_jid = LOCAL_JID
deps = {
im_service.ConversationService: im_service.ConversationService(
self.cc
),
im_dispatcher.IMDispatcher: im_dispatcher.IMDispatcher(
self.cc
)
}
self.svc = unittest.mock.Mock(["client", "_conversation_left"])
self.svc.client = self.cc
self.s = p2p.Service(self.cc, dependencies=deps)
self.listener = make_listener(self.s)
for ev in ["on_conversation_added"]:
listener = unittest.mock.Mock()
setattr(self.listener, ev, listener)
signal = getattr(deps[im_service.ConversationService], ev)
listener.return_value = None
signal.connect(listener)
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.disco_client = aioxmpp.DiscoClient(self.cc)
self.disco = aioxmpp.DiscoServer(self.cc)
self.pubsub = aioxmpp.PubSubClient(
self.cc, dependencies={aioxmpp.DiscoClient: self.disco_client})
self.pep = aioxmpp.PEPClient(self.cc,
dependencies={
aioxmpp.DiscoClient:
self.disco_client,
aioxmpp.DiscoServer: self.disco,
aioxmpp.PubSubClient: self.pubsub,
})
self.s = avatar_service.AvatarService(self.cc,
dependencies={
aioxmpp.DiscoClient:
self.disco_client,
aioxmpp.DiscoServer:
self.disco,
aioxmpp.PubSubClient:
self.pubsub,
aioxmpp.PEPClient: self.pep,
})
self.cc.mock_calls.clear()
def setUp(self):
self.cc = make_connected_client()
self.private_xml = PrivateXMLSimulator()
self.s = aioxmpp.bookmarks.BookmarkClient(
self.cc,
dependencies={
aioxmpp.private_xml.PrivateXMLService: self.private_xml
})
def setUp(self):
self.client = make_connected_client()
self.disco_server = unittest.mock.Mock()
self.s = version_svc.VersionServer(self.client,
dependencies={
aioxmpp.disco.DiscoServer:
self.disco_server,
})
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.s = ibb.IBBService(self.cc, )
protocol_factory = unittest.mock.Mock()
self.handle, self.protocol = run_coroutine(
self.s.open_session(protocol_factory, TEST_JID1))
self.cc.send.mock_calls.clear()
def setUp(self):
self.listener = unittest.mock.Mock()
self.cc = make_connected_client()
self.s = im_service.ConversationService(self.cc)
for ev in ["on_conversation_added"]:
handler = getattr(self.listener, ev)
handler.return_value = None
getattr(self.s, ev).connect(handler)
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_JID
self.disco_client = aioxmpp.DiscoClient(self.cc)
self.s = carbons_service.CarbonsClient(self.cc,
dependencies={
aioxmpp.DiscoClient:
self.disco_client,
})
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.disco = aioxmpp.DiscoClient(self.cc)
self.pubsub = aioxmpp.PubSubClient(
self.cc, dependencies={aioxmpp.DiscoClient: self.disco})
self.cc.mock_calls.clear()
def setUp(self):
self.client = make_connected_client()
self.disco_server = unittest.mock.Mock()
self.s = version_svc.VersionServer(
self.client,
dependencies={
aioxmpp.disco.DiscoServer: self.disco_server,
}
)
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.disco = aioxmpp.DiscoClient(self.cc)
self.s = blocking.BlockingClient(self.cc,
dependencies={
aioxmpp.DiscoClient: self.disco,
})
def test_summon_uses_services_dict(self):
cc = make_connected_client()
self.assertDictEqual({}, cc.mock_services)
instance = object()
cc.mock_services[object] = instance
self.assertIs(instance, cc.summon(object))
def setUp(self):
self.cc = make_connected_client()
self.presence_dispatcher = aioxmpp.dispatcher.SimplePresenceDispatcher(
self.cc,
)
self.s = presence_service.PresenceClient(self.cc, dependencies={
aioxmpp.dispatcher.SimplePresenceDispatcher:
self.presence_dispatcher,
})
def test_setup(self):
cc = make_connected_client()
s = disco_service.Service(cc)
self.assertSequenceEqual([
unittest.mock.call.stream.register_iq_request_coro(
"get", disco_xso.InfoQuery, s.handle_info_request),
unittest.mock.call.stream.register_iq_request_coro(
"get", disco_xso.ItemsQuery, s.handle_items_request)
], cc.mock_calls)
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_LOCAL_JID
self.disco_service = unittest.mock.Mock()
self.s = adhoc_service.AdHocServer(self.cc,
dependencies={
aioxmpp.disco.DiscoServer:
self.disco_service,
})
self.disco_service.reset_mock()
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_JID
self.disco_client = aioxmpp.DiscoClient(self.cc)
self.s = carbons_service.CarbonsClient(
self.cc,
dependencies={
aioxmpp.DiscoClient: self.disco_client,
}
)
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.disco = aioxmpp.DiscoClient(self.cc)
self.s = blocking.BlockingClient(
self.cc,
dependencies={
aioxmpp.DiscoClient: self.disco,
}
)
def setUp(self):
self.cc = make_connected_client()
self.disco_svr = aioxmpp.DiscoServer(self.cc)
self.t = aioxmpp.tracking.MessageTracker()
self.s = mdr_service.DeliveryReceiptsService(self.cc, dependencies={
aioxmpp.DiscoServer: self.disco_svr,
})
self.msg = unittest.mock.Mock(spec=aioxmpp.Message)
self.msg.xep0184_request_receipt = False
self.msg.to = TEST_TO
self.msg.id_ = "foo"
def setUp(self):
self.cc = make_connected_client()
self.disco_svr = aioxmpp.DiscoServer(self.cc)
self.t = aioxmpp.tracking.MessageTracker()
self.s = mdr_service.DeliveryReceiptsService(self.cc, dependencies={
aioxmpp.DiscoServer: self.disco_svr,
})
self.msg = unittest.mock.Mock(spec=aioxmpp.Message)
self.msg.xep0184_received = None
self.msg.xep0184_request_receipt = False
self.msg.to = TEST_TO
self.msg.id_ = "foo"
def test_summon_uses_services_dict(self):
cc = make_connected_client()
self.assertDictEqual(
{},
cc.mock_services
)
instance = object()
cc.mock_services[object] = instance
self.assertIs(instance, cc.summon(object))
def setUp(self):
self.cc = make_connected_client()
self.disco_service = unittest.mock.Mock()
self.disco_service.query_info = CoroutineMock()
self.disco_service.query_info.side_effect = AssertionError()
self.disco_service.query_items = CoroutineMock()
self.disco_service.query_items.side_effect = AssertionError()
self.c = adhoc_service.AdHocClient(self.cc,
dependencies={
aioxmpp.disco.DiscoClient:
self.disco_service,
})
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.disco_client = aioxmpp.DiscoClient(self.cc)
self.disco_server = aioxmpp.DiscoServer(self.cc)
self.s = hashes.HashService(self.cc,
dependencies={
aioxmpp.DiscoClient: self.disco_client,
aioxmpp.DiscoServer: self.disco_server,
})
self.cc.mock_calls.clear()
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.disco_client = aioxmpp.DiscoClient(self.cc)
self.disco_server = aioxmpp.DiscoServer(self.cc)
self.pubsub = aioxmpp.PubSubClient(self.cc, dependencies={
aioxmpp.DiscoClient: self.disco_client
})
self.s = pep.PEPClient(self.cc, dependencies={
aioxmpp.DiscoClient: self.disco_client,
aioxmpp.DiscoServer: self.disco_server,
aioxmpp.PubSubClient: self.pubsub,
})
def setUp(self):
self.listener = unittest.mock.Mock()
self.cc = make_connected_client()
self.cc.stream.send = CoroutineMock()
self.cc.local_jid = LOCAL_JID
self.svc = unittest.mock.Mock(["client", "_conversation_left"])
self.svc.client = self.cc
self.c = p2p.Conversation(self.svc, PEER_JID)
for ev in ["on_message"]:
listener = getattr(self.listener, ev)
signal = getattr(self.c, ev)
listener.return_value = None
signal.connect(listener)
def setUp(self):
self.monitor = unittest.mock.Mock(spec=aioxmpp.utils.AlivenessMonitor)
self.pinger = unittest.mock.Mock(spec=self_ping.MUCPinger)
self.pinger.ping_address = unittest.mock.sentinel.null_address
self.pinger.ping_timeout = unittest.mock.sentinel.null_tiemout
self.pinger.ping_interval = unittest.mock.sentinel.null_interval
self.listener = unittest.mock.Mock()
self.cc = make_connected_client()
loop = asyncio.get_event_loop()
self.logger = logging.getLogger(".".join(
[type(self).__module__,
type(self).__qualname__]))
with contextlib.ExitStack() as stack:
AlivenessMonitor = stack.enter_context(
unittest.mock.patch(
"aioxmpp.utils.AlivenessMonitor",
return_value=self.monitor,
))
MUCPinger = stack.enter_context(
unittest.mock.patch(
"aioxmpp.muc.self_ping.MUCPinger",
return_value=self.pinger,
))
self.m = self_ping.MUCMonitor(
unittest.mock.sentinel.ping_address,
self.cc,
self.listener.on_stale,
self.listener.on_fresh,
self.listener.on_exited,
logger=self.logger,
loop=loop,
)
AlivenessMonitor.assert_called_once_with(loop)
MUCPinger.assert_called_once_with(
unittest.mock.sentinel.ping_address,
self.cc,
self.m._pinger_fresh_detected,
self.m._pinger_exited_detected,
self.logger,
loop,
)
self.assertSequenceEqual(self.pinger.mock_calls, [])
def setUp(self):
self.disco = unittest.mock.Mock()
self.node = unittest.mock.Mock()
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.cc.query_info = CoroutineMock()
self.cc.query_info.side_effect = AssertionError
self.cc.query_items = CoroutineMock()
self.cc.query_items.side_effect = AssertionError
self.cc.mock_services[aioxmpp.disco.Service] = self.disco
with unittest.mock.patch("aioxmpp.disco.StaticNode") as Node:
Node.return_value = self.node
self.s = shim_service.Service(self.cc)
self.disco.mock_calls.clear()
self.cc.mock_calls.clear()
def setUp(self):
self.disco = unittest.mock.Mock()
self.node = unittest.mock.Mock()
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.cc.query_info = CoroutineMock()
self.cc.query_info.side_effect = AssertionError
self.cc.query_items = CoroutineMock()
self.cc.query_items.side_effect = AssertionError
self.cc.mock_services[aioxmpp.disco.Service] = self.disco
with unittest.mock.patch("aioxmpp.disco.StaticNode") as Node:
Node.return_value = self.node
self.s = shim_service.Service(self.cc)
self.disco.mock_calls.clear()
self.cc.mock_calls.clear()
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_LOCAL.replace(resource="we")
self.disco_client = aioxmpp.DiscoClient(self.cc)
self.carbons = aioxmpp.CarbonsClient(self.cc, dependencies={
aioxmpp.DiscoClient: self.disco_client,
})
self.s = dispatcher.IMDispatcher(self.cc, dependencies={
aioxmpp.CarbonsClient: self.carbons,
})
self.listener = unittest.mock.Mock()
for filter_ in ["message_filter", "presence_filter"]:
cb = getattr(self.listener, filter_)
cb.side_effect = lambda x, *args, **kwargs: x
filter_chain = getattr(self.s, filter_)
filter_chain.register(cb, 0)
def setUp(self):
self.listener = unittest.mock.Mock()
self.cc = make_connected_client()
self.cc.send = CoroutineMock()
self.cc.local_jid = LOCAL_JID
self.svc = unittest.mock.Mock(["client", "_conversation_left",
"logger"])
self.svc.client = self.cc
self.c = p2p.Conversation(self.svc, PEER_JID)
for ev in ["on_message"]:
listener = getattr(self.listener, ev)
signal = getattr(self.c, ev)
listener.return_value = None
signal.connect(listener)
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_LOCAL.replace(resource="we")
self.disco_client = aioxmpp.DiscoClient(self.cc)
self.carbons = aioxmpp.CarbonsClient(self.cc, dependencies={
aioxmpp.DiscoClient: self.disco_client,
})
self.s = dispatcher.IMDispatcher(self.cc, dependencies={
aioxmpp.CarbonsClient: self.carbons,
})
self.listener = unittest.mock.Mock()
for filter_ in ["message_filter", "presence_filter"]:
cb = getattr(self.listener, filter_)
cb.side_effect = lambda x, *args, **kwargs: x
filter_chain = getattr(self.s, filter_)
filter_chain.register(cb, 0)
def setUp(self):
self.cc = make_connected_client()
self.presence_dispatcher = aioxmpp.dispatcher.SimplePresenceDispatcher(
self.cc
)
self.dependencies = {
aioxmpp.dispatcher.SimplePresenceDispatcher:
self.presence_dispatcher,
}
self.s = roster_service.RosterClient(
self.cc,
dependencies=self.dependencies
)
self.user1 = structs.JID.fromstr("*****@*****.**")
self.user2 = structs.JID.fromstr("*****@*****.**")
response = roster_xso.Query(
items=[
roster_xso.Item(
jid=self.user1,
groups=[
roster_xso.Group(name="group1"),
roster_xso.Group(name="group3"),
]
),
roster_xso.Item(
jid=self.user2,
name="some bar user",
subscription="both",
groups=[
roster_xso.Group(name="group1"),
roster_xso.Group(name="group2"),
]
)
],
ver="foobar"
)
self.cc.send.return_value = response
run_coroutine(self.cc.before_stream_established())
self.cc.send.reset_mock()
self.listener = make_listener(self.s)
def setUp(self):
self.cc = make_connected_client()
self.s = disco_service.Service(self.cc)
self.cc.reset_mock()
self.request_iq = stanza.IQ(
"get",
from_=structs.JID.fromstr("[email protected]/res1"),
to=structs.JID.fromstr("[email protected]/res2"))
self.request_iq.autoset_id()
self.request_iq.payload = disco_xso.InfoQuery()
self.request_items_iq = stanza.IQ(
"get",
from_=structs.JID.fromstr("[email protected]/res1"),
to=structs.JID.fromstr("[email protected]/res2"))
self.request_items_iq.autoset_id()
self.request_items_iq.payload = disco_xso.ItemsQuery()
def setUp(self):
self.cc = make_connected_client()
self.s = disco_service.Service(self.cc)
self.cc.reset_mock()
self.request_iq = stanza.IQ(
structs.IQType.GET,
from_=structs.JID.fromstr("[email protected]/res1"),
to=structs.JID.fromstr("[email protected]/res2"))
self.request_iq.autoset_id()
self.request_iq.payload = disco_xso.InfoQuery()
self.request_items_iq = stanza.IQ(
structs.IQType.GET,
from_=structs.JID.fromstr("[email protected]/res1"),
to=structs.JID.fromstr("[email protected]/res2"))
self.request_items_iq.autoset_id()
self.request_items_iq.payload = disco_xso.ItemsQuery()
def test_init(self):
self.disco = unittest.mock.Mock()
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.cc.query_info = CoroutineMock()
self.cc.query_info.side_effect = AssertionError
self.cc.query_items = CoroutineMock()
self.cc.query_items.side_effect = AssertionError
self.cc.mock_services[aioxmpp.disco.Service] = self.disco
with unittest.mock.patch("aioxmpp.disco.StaticNode") as Node:
self.s = shim_service.Service(self.cc)
self.disco.register_feature.assert_called_with(
"http://jabber.org/protocol/shim")
self.disco.mount_node.assert_called_with(
"http://jabber.org/protocol/shim", Node())
def test_setup(self):
cc = make_connected_client()
s = disco_service.Service(cc)
self.assertSequenceEqual(
[
unittest.mock.call.stream.register_iq_request_coro(
structs.IQType.GET,
disco_xso.InfoQuery,
s.handle_info_request
),
unittest.mock.call.stream.register_iq_request_coro(
structs.IQType.GET,
disco_xso.ItemsQuery,
s.handle_items_request
)
],
cc.mock_calls
)
def setUp(self):
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.disco_client = aioxmpp.DiscoClient(self.cc)
self.disco = aioxmpp.DiscoServer(self.cc)
self.presence_dispatcher = aioxmpp.dispatcher.SimplePresenceDispatcher(
self.cc
)
self.presence_client = aioxmpp.PresenceClient(self.cc, dependencies={
aioxmpp.dispatcher.SimplePresenceDispatcher:
self.presence_dispatcher,
})
self.presence_server = aioxmpp.PresenceServer(self.cc)
self.vcard = aioxmpp.vcard.VCardService(self.cc)
self.pubsub = aioxmpp.PubSubClient(self.cc, dependencies={
aioxmpp.DiscoClient: self.disco_client
})
self.pep = aioxmpp.PEPClient(self.cc, dependencies={
aioxmpp.DiscoClient: self.disco_client,
aioxmpp.DiscoServer: self.disco,
aioxmpp.PubSubClient: self.pubsub,
})
self.s = avatar_service.AvatarService(self.cc, dependencies={
aioxmpp.DiscoClient: self.disco_client,
aioxmpp.DiscoServer: self.disco,
aioxmpp.PubSubClient: self.pubsub,
aioxmpp.PEPClient: self.pep,
aioxmpp.PresenceClient: self.presence_client,
aioxmpp.PresenceServer: self.presence_server,
aioxmpp.vcard.VCardService: self.vcard
})
self.pep._check_for_pep = CoroutineMock()
self.pep.available = CoroutineMock()
self.pep.available.return_value = True
self.cc.mock_calls.clear()
def test_init(self):
self.disco = unittest.mock.Mock()
self.cc = make_connected_client()
self.cc.local_jid = TEST_FROM
self.cc.query_info = CoroutineMock()
self.cc.query_info.side_effect = AssertionError
self.cc.query_items = CoroutineMock()
self.cc.query_items.side_effect = AssertionError
self.cc.mock_services[aioxmpp.disco.Service] = self.disco
with unittest.mock.patch("aioxmpp.disco.StaticNode") as Node:
self.s = shim_service.Service(self.cc)
self.disco.register_feature.assert_called_with(
"http://jabber.org/protocol/shim"
)
self.disco.mount_node.assert_called_with(
"http://jabber.org/protocol/shim",
Node()
)
def setUp(self):
self.cc = make_connected_client()
self.presence_dispatcher = aioxmpp.dispatcher.SimplePresenceDispatcher(
self.cc)
self.dependencies = {
aioxmpp.dispatcher.SimplePresenceDispatcher:
self.presence_dispatcher,
}
self.s = roster_service.RosterClient(self.cc,
dependencies=self.dependencies)
self.user1 = structs.JID.fromstr("*****@*****.**")
self.user2 = structs.JID.fromstr("*****@*****.**")
response = roster_xso.Query(items=[
roster_xso.Item(jid=self.user1,
groups=[
roster_xso.Group(name="group1"),
roster_xso.Group(name="group3"),
]),
roster_xso.Item(jid=self.user2,
name="some bar user",
subscription="both",
groups=[
roster_xso.Group(name="group1"),
roster_xso.Group(name="group2"),
])
],
ver="foobar")
self.cc.send.return_value = response
run_coroutine(self.cc.before_stream_established())
self.cc.send.reset_mock()
self.listener = make_listener(self.s)
def setUp(self):
self.cc = make_connected_client()
self.s = ibr_service.RegistrationService(self.cc)
def setUp(self):
self.cc = make_connected_client()
self.s = tracking.BasicTrackingService(self.cc)
def setUp(self):
self.client = make_connected_client()
self.client.send.return_value = unittest.mock.sentinel.slot
def setUp(self):
self.cc = make_connected_client()
self.s = presence_service.Service(self.cc)
def setUp(self):
self.cc = make_connected_client()
self.cc.send = CoroutineMock()
self.cc.send.return_value = None
self.s = presence_service.PresenceServer(self.cc)
def setUp(self):
self.cc = make_connected_client()
self.disco_server = unittest.mock.Mock()
self.s = ping_service.PingService(self.cc, dependencies={
aioxmpp.DiscoServer: self.disco_server
})
def test_summon_asserts_on_not_summoned_service(self):
cc = make_connected_client()
with self.assertRaises(AssertionError):
cc.summon(object)
def setUp(self):
self.cc = make_connected_client()
self.d = dispatcher.SimplePresenceDispatcher(self.cc)
def setUp(self):
self.cc = make_connected_client()
self.s = im_service.ConversationService(self.cc)
self.listener = make_listener(self.s)
