2011-05-20 21:42:40 +00:00
|
|
|
# -*- encoding:utf8 -*-
|
|
|
|
|
2010-10-24 16:53:14 +00:00
|
|
|
from sleekxmpp.test import *
|
|
|
|
import time
|
|
|
|
import threading
|
|
|
|
|
|
|
|
|
|
|
|
class TestStreamRoster(SleekTest):
|
|
|
|
"""
|
|
|
|
Test handling roster updates.
|
|
|
|
"""
|
|
|
|
|
|
|
|
def tearDown(self):
|
|
|
|
self.stream_close()
|
|
|
|
|
|
|
|
def testGetRoster(self):
|
|
|
|
"""Test handling roster requests."""
|
2010-10-27 03:47:17 +00:00
|
|
|
self.stream_start(mode='client', jid='tester@localhost')
|
2010-10-24 16:53:14 +00:00
|
|
|
|
Resolve timeout errors for get_roster.
See issue #89
Using get_roster will now return the same types of values as
Iq.send. If a timeout occurs, then the event 'roster_timeout'
will be fired. A successful call to get_roster will also
raise the 'roster_received' event.
To ensure that the get_roster call was successful, here
is a pattern to follow:
def __init__(self, ...):
...
self.add_event_handler('session_start', self.session_start)
self.add_event_handler('roster_timeout', self.roster_timeout)
self.add_event_handler('roster_received', self.roster_received)
def session_start(self, e):
self.send_presence()
self.get_roster()
def roster_timeout(self, e):
# Optionally increase the timeout period
self.get_roster(timeout=self.response_timeout * 2)
def roster_received(self, iq):
# Do stuff, roster has been initialized.
...
2011-05-20 16:56:00 +00:00
|
|
|
events = []
|
|
|
|
|
|
|
|
def roster_received(iq):
|
|
|
|
events.append('roster_received')
|
|
|
|
|
|
|
|
self.xmpp.add_event_handler('roster_received', roster_received)
|
|
|
|
|
2010-10-24 16:53:14 +00:00
|
|
|
# Since get_roster blocks, we need to run it in a thread.
|
|
|
|
t = threading.Thread(name='get_roster', target=self.xmpp.get_roster)
|
|
|
|
t.start()
|
|
|
|
|
2010-11-05 18:45:58 +00:00
|
|
|
self.send("""
|
2010-10-24 16:53:14 +00:00
|
|
|
<iq type="get" id="1">
|
|
|
|
<query xmlns="jabber:iq:roster" />
|
|
|
|
</iq>
|
|
|
|
""")
|
2010-11-05 18:45:58 +00:00
|
|
|
self.recv("""
|
2010-10-27 03:47:17 +00:00
|
|
|
<iq to='tester@localhost' type="result" id="1">
|
2010-10-24 16:53:14 +00:00
|
|
|
<query xmlns="jabber:iq:roster">
|
|
|
|
<item jid="user@localhost"
|
|
|
|
name="User"
|
2010-10-27 03:47:17 +00:00
|
|
|
subscription="from"
|
|
|
|
ask="subscribe">
|
2010-10-24 16:53:14 +00:00
|
|
|
<group>Friends</group>
|
|
|
|
<group>Examples</group>
|
|
|
|
</item>
|
|
|
|
</query>
|
|
|
|
</iq>
|
|
|
|
""")
|
|
|
|
|
|
|
|
# Wait for get_roster to return.
|
|
|
|
t.join()
|
|
|
|
|
2010-10-27 03:47:17 +00:00
|
|
|
self.check_roster('tester@localhost', 'user@localhost',
|
|
|
|
name='User',
|
|
|
|
subscription='from',
|
|
|
|
afrom=True,
|
|
|
|
pending_out=True,
|
|
|
|
groups=['Friends', 'Examples'])
|
2010-10-24 16:53:14 +00:00
|
|
|
|
Resolve timeout errors for get_roster.
See issue #89
Using get_roster will now return the same types of values as
Iq.send. If a timeout occurs, then the event 'roster_timeout'
will be fired. A successful call to get_roster will also
raise the 'roster_received' event.
To ensure that the get_roster call was successful, here
is a pattern to follow:
def __init__(self, ...):
...
self.add_event_handler('session_start', self.session_start)
self.add_event_handler('roster_timeout', self.roster_timeout)
self.add_event_handler('roster_received', self.roster_received)
def session_start(self, e):
self.send_presence()
self.get_roster()
def roster_timeout(self, e):
# Optionally increase the timeout period
self.get_roster(timeout=self.response_timeout * 2)
def roster_received(self, iq):
# Do stuff, roster has been initialized.
...
2011-05-20 16:56:00 +00:00
|
|
|
# Give the event queue time to process.
|
|
|
|
time.sleep(.1)
|
|
|
|
|
|
|
|
self.failUnless('roster_received' in events,
|
|
|
|
"Roster received event not triggered: %s" % events)
|
2010-10-24 16:53:14 +00:00
|
|
|
|
|
|
|
def testRosterSet(self):
|
|
|
|
"""Test handling pushed roster updates."""
|
|
|
|
self.stream_start(mode='client')
|
Resolve timeout errors for get_roster.
See issue #89
Using get_roster will now return the same types of values as
Iq.send. If a timeout occurs, then the event 'roster_timeout'
will be fired. A successful call to get_roster will also
raise the 'roster_received' event.
To ensure that the get_roster call was successful, here
is a pattern to follow:
def __init__(self, ...):
...
self.add_event_handler('session_start', self.session_start)
self.add_event_handler('roster_timeout', self.roster_timeout)
self.add_event_handler('roster_received', self.roster_received)
def session_start(self, e):
self.send_presence()
self.get_roster()
def roster_timeout(self, e):
# Optionally increase the timeout period
self.get_roster(timeout=self.response_timeout * 2)
def roster_received(self, iq):
# Do stuff, roster has been initialized.
...
2011-05-20 16:56:00 +00:00
|
|
|
events = []
|
|
|
|
|
|
|
|
def roster_update(e):
|
|
|
|
events.append('roster_update')
|
|
|
|
|
|
|
|
self.xmpp.add_event_handler('roster_update', roster_update)
|
2010-10-24 16:53:14 +00:00
|
|
|
|
2010-11-05 18:45:58 +00:00
|
|
|
self.recv("""
|
2010-10-27 03:47:17 +00:00
|
|
|
<iq to='tester@localhost' type="set" id="1">
|
2010-10-24 16:53:14 +00:00
|
|
|
<query xmlns="jabber:iq:roster">
|
|
|
|
<item jid="user@localhost"
|
|
|
|
name="User"
|
|
|
|
subscription="both">
|
|
|
|
<group>Friends</group>
|
|
|
|
<group>Examples</group>
|
|
|
|
</item>
|
|
|
|
</query>
|
|
|
|
</iq>
|
|
|
|
""")
|
2010-11-05 18:45:58 +00:00
|
|
|
self.send("""
|
2010-10-24 16:53:14 +00:00
|
|
|
<iq type="result" id="1">
|
|
|
|
<query xmlns="jabber:iq:roster" />
|
|
|
|
</iq>
|
|
|
|
""")
|
|
|
|
|
2010-10-27 03:47:17 +00:00
|
|
|
self.check_roster('tester@localhost', 'user@localhost',
|
|
|
|
name='User',
|
|
|
|
subscription='both',
|
|
|
|
groups=['Friends', 'Examples'])
|
2010-10-24 16:53:14 +00:00
|
|
|
|
Resolve timeout errors for get_roster.
See issue #89
Using get_roster will now return the same types of values as
Iq.send. If a timeout occurs, then the event 'roster_timeout'
will be fired. A successful call to get_roster will also
raise the 'roster_received' event.
To ensure that the get_roster call was successful, here
is a pattern to follow:
def __init__(self, ...):
...
self.add_event_handler('session_start', self.session_start)
self.add_event_handler('roster_timeout', self.roster_timeout)
self.add_event_handler('roster_received', self.roster_received)
def session_start(self, e):
self.send_presence()
self.get_roster()
def roster_timeout(self, e):
# Optionally increase the timeout period
self.get_roster(timeout=self.response_timeout * 2)
def roster_received(self, iq):
# Do stuff, roster has been initialized.
...
2011-05-20 16:56:00 +00:00
|
|
|
# Give the event queue time to process.
|
|
|
|
time.sleep(.1)
|
|
|
|
|
|
|
|
self.failUnless('roster_update' in events,
|
|
|
|
"Roster updated event not triggered: %s" % events)
|
|
|
|
|
|
|
|
def testRosterTimeout(self):
|
|
|
|
"""Test handling a timed out roster request."""
|
|
|
|
self.stream_start()
|
|
|
|
events = []
|
|
|
|
|
|
|
|
def roster_timeout(event):
|
|
|
|
events.append('roster_timeout')
|
|
|
|
|
|
|
|
self.xmpp.add_event_handler('roster_timeout', roster_timeout)
|
|
|
|
self.xmpp.get_roster(timeout=0)
|
|
|
|
|
|
|
|
# Give the event queue time to process.
|
|
|
|
time.sleep(.1)
|
|
|
|
|
|
|
|
self.failUnless(events == ['roster_timeout'],
|
|
|
|
"Roster timeout event not triggered: %s." % events)
|
|
|
|
|
|
|
|
def testRosterCallback(self):
|
|
|
|
"""Test handling a roster request callback."""
|
|
|
|
self.stream_start()
|
|
|
|
events = []
|
|
|
|
|
|
|
|
def roster_callback(iq):
|
|
|
|
events.append('roster_callback')
|
|
|
|
|
|
|
|
# Since get_roster blocks, we need to run it in a thread.
|
|
|
|
t = threading.Thread(name='get_roster',
|
|
|
|
target=self.xmpp.get_roster,
|
|
|
|
kwargs={'callback': roster_callback})
|
|
|
|
t.start()
|
|
|
|
|
|
|
|
self.send("""
|
|
|
|
<iq type="get" id="1">
|
|
|
|
<query xmlns="jabber:iq:roster" />
|
|
|
|
</iq>
|
|
|
|
""")
|
|
|
|
self.recv("""
|
|
|
|
<iq type="result" id="1">
|
|
|
|
<query xmlns="jabber:iq:roster">
|
|
|
|
<item jid="user@localhost"
|
|
|
|
name="User"
|
|
|
|
subscription="both">
|
|
|
|
<group>Friends</group>
|
|
|
|
<group>Examples</group>
|
|
|
|
</item>
|
|
|
|
</query>
|
|
|
|
</iq>
|
|
|
|
""")
|
|
|
|
|
|
|
|
# Wait for get_roster to return.
|
|
|
|
t.join()
|
|
|
|
|
|
|
|
# Give the event queue time to process.
|
|
|
|
time.sleep(.1)
|
2010-10-24 16:53:14 +00:00
|
|
|
|
Resolve timeout errors for get_roster.
See issue #89
Using get_roster will now return the same types of values as
Iq.send. If a timeout occurs, then the event 'roster_timeout'
will be fired. A successful call to get_roster will also
raise the 'roster_received' event.
To ensure that the get_roster call was successful, here
is a pattern to follow:
def __init__(self, ...):
...
self.add_event_handler('session_start', self.session_start)
self.add_event_handler('roster_timeout', self.roster_timeout)
self.add_event_handler('roster_received', self.roster_received)
def session_start(self, e):
self.send_presence()
self.get_roster()
def roster_timeout(self, e):
# Optionally increase the timeout period
self.get_roster(timeout=self.response_timeout * 2)
def roster_received(self, iq):
# Do stuff, roster has been initialized.
...
2011-05-20 16:56:00 +00:00
|
|
|
self.failUnless(events == ['roster_callback'],
|
|
|
|
"Roster timeout event not triggered: %s." % events)
|
2010-10-24 16:53:14 +00:00
|
|
|
|
2011-05-20 21:42:40 +00:00
|
|
|
def testRosterUnicode(self):
|
|
|
|
"""Test that JIDs with Unicode values are handled properly."""
|
|
|
|
self.stream_start()
|
|
|
|
self.recv("""
|
|
|
|
<iq to="tester@localhost" type="set" id="1">
|
|
|
|
<query xmlns="jabber:iq:roster">
|
|
|
|
<item jid="andré@foo" subscription="both">
|
|
|
|
<group>Unicode</group>
|
|
|
|
</item>
|
|
|
|
</query>
|
|
|
|
</iq>
|
|
|
|
""")
|
|
|
|
|
|
|
|
# Give the event queue time to process.
|
|
|
|
time.sleep(.1)
|
|
|
|
|
|
|
|
roster = {'andré@foo': {
|
|
|
|
'name': '',
|
|
|
|
'subscription': 'both',
|
|
|
|
'groups': ['Unicode'],
|
|
|
|
'presence': {},
|
|
|
|
'in_roster': True}}
|
|
|
|
self.failUnless(self.xmpp.roster == roster,
|
|
|
|
"Unexpected roster values: %s" % self.xmpp.roster)
|
|
|
|
|
|
|
|
self.recv("""
|
|
|
|
<presence from="andré@foo/bar" />
|
|
|
|
""")
|
|
|
|
|
|
|
|
# Give the event queue time to process.
|
|
|
|
time.sleep(.1)
|
|
|
|
|
|
|
|
roster = {'andré@foo': {
|
|
|
|
'name': '',
|
|
|
|
'subscription': 'both',
|
|
|
|
'groups': ['Unicode'],
|
|
|
|
'presence': {
|
|
|
|
'bar':{'priority':0,
|
|
|
|
'status':'',
|
|
|
|
'show':'available'}},
|
|
|
|
'in_roster': True}}
|
|
|
|
self.failUnless(self.xmpp.roster == roster,
|
|
|
|
"Unexpected roster values: %s" % self.xmpp.roster)
|
|
|
|
|
2010-10-24 16:53:14 +00:00
|
|
|
|
|
|
|
suite = unittest.TestLoader().loadTestsFromTestCase(TestStreamRoster)
|