def test_initial_roster_removes_contact_from_groups(self):
response = roster_xso.Query(items=[
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.assertSetEqual(
self.s.groups["group1"],
{self.s.items[self.user2]},
)
self.assertSetEqual(
self.s.groups["group2"],
{self.s.items[self.user2]},
)
self.assertSetEqual(
self.s.groups.get("group3", set()),
set(),
)
def test_update_from_xso_item(self):
xso_item = roster_xso.Item(jid=self.jid,
subscription="to",
ask="subscribe",
approved=False,
name="test",
groups=[
roster_xso.Group(name="foo"),
roster_xso.Group(name="bar"),
])
item = roster_service.Item(self.jid)
item.update_from_xso_item(xso_item)
self.assertEqual(xso_item.jid, item.jid)
self.assertEqual(xso_item.subscription, item.subscription)
self.assertEqual(xso_item.ask, item.ask)
self.assertEqual(xso_item.approved, item.approved)
self.assertEqual(xso_item.name, item.name)
self.assertSetEqual({"foo", "bar"}, item.groups)
xso_item = roster_xso.Item(jid=structs.JID.fromstr("*****@*****.**"),
subscription="from",
ask=None,
approved=True,
name="other test",
groups=[roster_xso.Group(name="a")])
item.update_from_xso_item(xso_item)
self.assertEqual(self.jid, item.jid)
self.assertEqual(xso_item.subscription, item.subscription)
self.assertEqual(xso_item.ask, item.ask)
self.assertEqual(xso_item.approved, item.approved)
self.assertEqual(xso_item.name, item.name)
self.assertSetEqual({"a"}, item.groups)
def test_initial_roster_fires_group_event(self):
response = roster_xso.Query(items=[
roster_xso.Item(jid=self.user2,
name="some bar user",
subscription="both",
groups={
roster_xso.Group(name="a"),
roster_xso.Group(name="b")
}),
roster_xso.Item(jid=self.user1,
name="some foo user",
subscription="both",
groups={
roster_xso.Group(name="a"),
roster_xso.Group(name="c")
})
],
ver="foobar")
self.cc.send.return_value = response
run_coroutine(self.cc.before_stream_established())
self.assertCountEqual(self.listener.on_group_added.mock_calls, [
unittest.mock.call("a"),
unittest.mock.call("b"),
unittest.mock.call("c"),
])
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_init(self):
jid = structs.JID.fromstr("*****@*****.**")
item = roster_xso.Item(jid)
self.assertEqual(item.jid, jid)
self.assertIsNone(item.name)
self.assertSequenceEqual([], item.groups)
self.assertEqual("none", item.subscription)
self.assertIs(False, item.approved)
self.assertIsNone(item.ask)
group = roster_xso.Group()
item = roster_xso.Item(
jid=jid,
name="foobar",
groups=(group,),
subscription="to",
approved=True,
ask="subscribe"
)
self.assertEqual(jid, item.jid)
self.assertEqual("foobar", item.name)
self.assertSequenceEqual([group], item.groups)
self.assertIsInstance(item.groups, xso_model.XSOList)
self.assertEqual("to", item.subscription)
self.assertIs(True, item.approved)
self.assertEqual("subscribe", item.ask)
def test_groups_update_fires_events(self):
request = roster_xso.Query(items=[
roster_xso.Item(
jid=self.user1,
groups=[roster_xso.Group(name="group4")],
)
])
added_cb = unittest.mock.Mock()
added_cb.return_value = False
removed_cb = unittest.mock.Mock()
removed_cb.return_value = False
with contextlib.ExitStack() as stack:
stack.enter_context(
self.s.on_entry_added_to_group.context_connect(added_cb))
stack.enter_context(
self.s.on_entry_removed_from_group.context_connect(removed_cb))
run_coroutine(
self.s.handle_roster_push(
stanza.IQ(structs.IQType.SET, payload=request)))
self.assertSequenceEqual([
unittest.mock.call(self.s.items[self.user1], "group4"),
], added_cb.mock_calls)
self.assertIn(unittest.mock.call(self.s.items[self.user1], "group1"),
removed_cb.mock_calls)
self.assertIn(unittest.mock.call(self.s.items[self.user1], "group3"),
removed_cb.mock_calls)
def test_on_group_added_for_existing_contact(self):
request = roster_xso.Query(items=[
roster_xso.Item(
jid=self.user2,
subscription="none",
groups={
roster_xso.Group(name="group1"),
roster_xso.Group(name="group2"),
roster_xso.Group(name="group4"),
},
),
],
ver="foobar")
iq = stanza.IQ(type_=structs.IQType.SET)
iq.payload = request
run_coroutine(self.s.handle_roster_push(iq))
self.listener.on_group_added.assert_called_once_with("group4")
def test_initial_roster_fires_group_removed_event_for_removed_contact(
self): # NOQA
response = roster_xso.Query(items=[
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.assertCountEqual(self.listener.on_group_removed.mock_calls, [
unittest.mock.call("group3"),
])
def test_on_group_added_for_new_contact(self):
new_jid = structs.JID.fromstr("*****@*****.**")
request = roster_xso.Query(items=[
roster_xso.Item(
jid=new_jid,
subscription="none",
groups={
roster_xso.Group(name="a"),
roster_xso.Group(name="group1"),
},
),
],
ver="foobar")
iq = stanza.IQ(type_=structs.IQType.SET)
iq.payload = request
run_coroutine(self.s.handle_roster_push(iq))
self.listener.on_group_added.assert_called_once_with("a")
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 test_groups_are_set_up_when_on_entry_added_fires(self):
fut = asyncio.Future()
def handler(item):
try:
for group in item.groups:
self.assertIn(group, self.s.groups)
self.assertIn(item, self.s.groups[group])
except Exception as exc:
fut.set_exception(exc)
else:
fut.set_result(None)
new_jid = structs.JID.fromstr("*****@*****.**")
request = roster_xso.Query(items=[
roster_xso.Item(
jid=new_jid,
subscription="none",
groups={
roster_xso.Group(name="a"),
roster_xso.Group(name="group1"),
},
),
],
ver="foobar")
iq = stanza.IQ(type_=structs.IQType.SET)
iq.payload = request
self.s.on_entry_added.connect(handler)
run_coroutine(self.s.handle_roster_push(iq))
run_coroutine(fut)
def test_groups_are_cleaned_up_up_when_on_entry_removed_fires_on_initial_roster(
self): # NOQA
response = roster_xso.Query(items=[
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")
fut = asyncio.Future()
def handler(item):
try:
for group in item.groups:
try:
members = self.s.groups[group]
except KeyError:
members = set()
self.assertNotIn(item, members)
except Exception as exc:
fut.set_exception(exc)
else:
fut.set_result(None)
self.cc.send.return_value = response
self.s.on_entry_removed.connect(handler)
run_coroutine(self.cc.before_stream_established())
run_coroutine(fut)
def test_update_groups_on_update(self):
request = roster_xso.Query(items=[
roster_xso.Item(
jid=self.user1,
groups=[roster_xso.Group(name="group4")],
)
])
run_coroutine(
self.s.handle_roster_push(stanza.IQ("set", payload=request)))
self.assertNotIn("group3", self.s.groups)
self.assertSetEqual({self.s.items[self.user2]},
self.s.groups["group1"])
self.assertSetEqual({self.s.items[self.user2]},
self.s.groups["group2"])
self.assertSetEqual({self.s.items[self.user1]},
self.s.groups["group4"])
def test_init(self):
g = roster_xso.Group()
self.assertIsNone(g.name)
g = roster_xso.Group(name="foobar")
self.assertEqual("foobar", g.name)
