diff --git a/sleekxmpp/basexmpp.py b/sleekxmpp/basexmpp.py
index 1e8441a..23579fa 100644
--- a/sleekxmpp/basexmpp.py
+++ b/sleekxmpp/basexmpp.py
@@ -15,6 +15,7 @@ import logging
import sleekxmpp
from sleekxmpp import plugins
+from sleekxmpp.roster import MultiRoster
from sleekxmpp.stanza import Message, Presence, Iq, Error
from sleekxmpp.stanza.roster import Roster
from sleekxmpp.stanza.nick import Nick
@@ -84,7 +85,7 @@ class BaseXMPP(XMLStream):
send_presence_subscribe -- Send a subscription request.
"""
- def __init__(self, default_ns='jabber:client'):
+ def __init__(self, jid='', default_ns='jabber:client'):
"""
Adapt an XML stream for use with XMPP.
@@ -113,10 +114,13 @@ class BaseXMPP(XMLStream):
self.default_ns = default_ns
self.stream_ns = 'http://etherx.jabber.org/streams'
- self.boundjid = JID("")
+ self.boundjid = JID(jid)
self.plugin = {}
+ self.rosters = MultiRoster(self)
+ self.rosters.add(self.boundjid.bare)
self.roster = {}
+
self.is_component = False
self.auto_authorize = True
self.auto_subscribe = True
@@ -133,10 +137,20 @@ class BaseXMPP(XMLStream):
MatchXPath("{%s}presence" % self.default_ns),
self._handle_presence))
- self.add_event_handler('presence_subscribe',
- self._handle_subscribe)
self.add_event_handler('disconnected',
self._handle_disconnected)
+ self.add_event_handler('presence_available', self._handle_available)
+ self.add_event_handler('presence_dnd', self._handle_available)
+ self.add_event_handler('presence_xa', self._handle_available)
+ self.add_event_handler('presence_chat', self._handle_available)
+ self.add_event_handler('presence_away', self._handle_available)
+ self.add_event_handler('presence_unavailable', self._handle_unavailable)
+ self.add_event_handler('presence_subscribe', self._handle_subscribe)
+ self.add_event_handler('presence_subscribed', self._handle_subscribed)
+ self.add_event_handler('presence_unsubscribe', self._handle_unsubscribe)
+ self.add_event_handler('presence_unsubscribed', self._handle_unsubscribed)
+ self.add_event_handler('presence_probe', self._handle_probe)
+ self.add_event_handler('roster_subscription_request', self._handle_new_subscription)
# Set up the XML stream with XMPP's root stanzas.
self.registerStanza(Message)
@@ -528,12 +542,50 @@ class BaseXMPP(XMLStream):
"""Process incoming message stanzas."""
self.event('message', msg)
+ def _handle_available(self, presence):
+ self.rosters[presence['to'].bare][presence['from'].bare].handle_available(presence)
+
+ def _handle_unavailable(self, presence):
+ self.rosters[presence['to'].bare][presence['from'].bare].handle_unavailable(presence)
+
+ def _handle_new_subscription(self, stanza):
+ logging.debug(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
+ roster = self.rosters[stanza['to'].bare]
+ item = self.rosters[stanza['to'].bare][stanza['from'].bare]
+ if item['whitelisted']:
+ item.authorize()
+ elif roster.auto_authorize:
+ item.authorize()
+ if roster.auto_subscribe:
+ item.subscribe()
+ elif roster.auto_authorize == False:
+ item.unauthorize()
+
+ def _handle_removed_subscription(self, presence):
+ self.rosters[presence['to'].bare][presence['from'].bare].unauthorize()
+
+ def _handle_subscribe(self, stanza):
+ self.rosters[stanza['to'].bare][stanza['from'].bare].handle_subscribe(stanza)
+
+ def _handle_subscribed(self, stanza):
+ self.rosters[stanza['to'].bare][stanza['from'].bare].handle_subscribed(stanza)
+
+ def _handle_unsubscribe(self, stanza):
+ self.rosters[stanza['to'].bare][stanza['from'].bare].handle_unsubscribe(stanza)
+
+ def _handle_unsubscribed(self, stanza):
+ self.rosters[stanza['to'].bare][stanza['from'].bare].handle_unsubscribed(stanza)
+
+ def _handle_probe(self, stanza):
+ self.rosteritems[stanza['to'].bare][stanza['from'].bare].handle_probe(stanza)
+
def _handle_presence(self, presence):
"""
Process incoming presence stanzas.
Update the roster with presence information.
"""
+ logging.debug(presence['type'])
self.event("presence_%s" % presence['type'], presence)
# Check for changes in subscription state.
@@ -544,97 +596,8 @@ class BaseXMPP(XMLStream):
elif not presence['type'] in ('available', 'unavailable') and \
not presence['type'] in presence.showtypes:
return
-
- # Strip the information from the stanza.
- jid = presence['from'].bare
- resource = presence['from'].resource
- show = presence['type']
- status = presence['status']
- priority = presence['priority']
-
- was_offline = False
- got_online = False
- old_roster = self.roster.get(jid, {}).get(resource, {})
-
- # Create a new roster entry if needed.
- if not jid in self.roster:
- self.roster[jid] = {'groups': [],
- 'name': '',
- 'subscription': 'none',
- 'presence': {},
- 'in_roster': False}
-
- # Alias to simplify some references.
- connections = self.roster[jid]['presence']
-
- # Determine if the user has just come online.
- if not resource in connections:
- if show == 'available' or show in presence.showtypes:
- got_online = True
- was_offline = True
- connections[resource] = {}
-
- if connections[resource].get('show', 'unavailable') == 'unavailable':
- was_offline = True
-
- # Update the roster's state for this JID's resource.
- connections[resource] = {'show': show,
- 'status': status,
- 'priority': priority}
-
- name = self.roster[jid].get('name', '')
-
- # Remove unneeded state information after a resource
- # disconnects. Determine if this was the last connection
- # for the JID.
- if show == 'unavailable':
- logging.debug("%s %s got offline" % (jid, resource))
- del connections[resource]
-
- if not connections and not self.roster[jid]['in_roster']:
- del self.roster[jid]
- if not was_offline:
- self.event("got_offline", presence)
- else:
- return False
-
- name = '(%s) ' % name if name else ''
-
- # Presence state has changed.
self.event("changed_status", presence)
- if got_online:
- self.event("got_online", presence)
- logging.debug("STATUS: %s%s/%s[%s]: %s" % (name, jid, resource,
- show, status))
- def _handle_subscribe(self, presence):
- """
- Automatically managage subscription requests.
-
- Subscription behavior is controlled by the settings
- self.auto_authorize and self.auto_subscribe.
-
- auto_auth auto_sub Result:
- True True Create bi-directional subsriptions.
- True False Create only directed subscriptions.
- False * Decline all subscriptions.
- None * Disable automatic handling and use
- a custom handler.
- """
- presence.reply()
- presence['to'] = presence['to'].bare
-
- # We are using trinary logic, so conditions have to be
- # more explicit than usual.
- if self.auto_authorize == True:
- presence['type'] = 'subscribed'
- presence.send()
- if self.auto_subscribe:
- presence['type'] = 'subscribe'
- presence.send()
- elif self.auto_authorize == False:
- presence['type'] = 'unsubscribed'
- presence.send()
# Restore the old, lowercased name for backwards compatibility.
basexmpp = BaseXMPP
diff --git a/sleekxmpp/clientxmpp.py b/sleekxmpp/clientxmpp.py
index dc4d0e4..4bf759e 100644
--- a/sleekxmpp/clientxmpp.py
+++ b/sleekxmpp/clientxmpp.py
@@ -63,7 +63,7 @@ class ClientXMPP(BaseXMPP):
when calling register_plugins.
escape_quotes -- Deprecated.
"""
- BaseXMPP.__init__(self, 'jabber:client')
+ BaseXMPP.__init__(self, jid, 'jabber:client')
# To comply with PEP8, method names now use underscores.
# Deprecated method names are re-mapped for backwards compatibility.
@@ -72,7 +72,6 @@ class ClientXMPP(BaseXMPP):
self.getRoster = self.get_roster
self.registerFeature = self.register_feature
- self.set_jid(jid)
self.password = password
self.escape_quotes = escape_quotes
self.plugin_config = plugin_config
@@ -418,13 +417,13 @@ class ClientXMPP(BaseXMPP):
"""
if iq['type'] == 'set' or (iq['type'] == 'result' and request):
for jid in iq['roster']['items']:
- if not jid in self.roster:
- self.roster[jid] = {'groups': [],
- 'name': '',
- 'subscription': 'none',
- 'presence': {},
- 'in_roster': True}
- self.roster[jid].update(iq['roster']['items'][jid])
+ item = iq['roster']['items'][jid]
+ roster = self.rosters[iq['to'].bare]
+ roster[jid]['name'] = item['name']
+ roster[jid]['groups'] = item['groups']
+ roster[jid]['from'] = item['subscription'] in ['from', 'both']
+ roster[jid]['to'] = item['subscription'] in ['to', 'both']
+ roster[jid]['pending_out'] = (item['ask'] == 'subscribe')
self.event("roster_update", iq)
if iq['type'] == 'set':
diff --git a/sleekxmpp/componentxmpp.py b/sleekxmpp/componentxmpp.py
index 3fcb88d..ec3d1a0 100644
--- a/sleekxmpp/componentxmpp.py
+++ b/sleekxmpp/componentxmpp.py
@@ -55,7 +55,7 @@ class ComponentXMPP(BaseXMPP):
default_ns = 'jabber:client'
else:
default_ns = 'jabber:component:accept'
- BaseXMPP.__init__(self, default_ns)
+ BaseXMPP.__init__(self, jid, default_ns)
self.auto_authorize = None
self.stream_header = "" % (
@@ -65,8 +65,8 @@ class ComponentXMPP(BaseXMPP):
self.stream_footer = ""
self.server_host = host
self.server_port = port
- self.set_jid(jid)
self.secret = secret
+
self.plugin_config = plugin_config
self.plugin_whitelist = plugin_whitelist
self.is_component = True
diff --git a/sleekxmpp/roster.py b/sleekxmpp/roster.py
new file mode 100644
index 0000000..32fd5c0
--- /dev/null
+++ b/sleekxmpp/roster.py
@@ -0,0 +1,374 @@
+import logging
+
+
+class MultiRoster(object):
+
+ def __init__(self, xmpp, datastore=None):
+ self.xmpp = xmpp
+ self.datastore = datastore
+ self._rosters = {}
+
+ def __getitem__(self, key):
+ if key not in self._rosters:
+ self.add(key)
+ return self._rosters[key]
+
+ def keys(self):
+ return self._rosters.keys()
+
+ def __iter__(self):
+ return self._rosters.__iter__()
+
+ def add(self, node):
+ if node not in self._rosters:
+ self._rosters[node] = Roster(self.xmpp, node, self.datastore)
+
+class Roster(object):
+
+ def __init__(self, xmpp, jid, datastore=None):
+ self.xmpp = xmpp
+ self.jid = jid
+ self.datastore = datastore
+ self.auto_authorize = True
+ self.auto_subscribe = True
+ self._jids = {}
+
+ def __getitem__(self, key):
+ if key not in self._jids:
+ self.add(key, save=True)
+ return self._jids[key]
+
+ def keys(self):
+ return self._jids.keys()
+
+ def __iter__(self):
+ return self._jids.__iter__()
+
+ def add(self, jid, name='', groups=None, afrom=False, ato=False,
+ pending_in=False, pending_out=False, whitelisted=False,
+ save=False):
+ state = {'name': name,
+ 'groups': groups or [],
+ 'from': afrom,
+ 'to': ato,
+ 'pending_in': pending_in,
+ 'pending_out': pending_out,
+ 'whitelisted': whitelisted,
+ 'subscription': 'none'}
+ self._jids[jid] = RosterItem(self.xmpp, jid, self.jid,
+ state=state, datastore=self.datastore)
+ if save:
+ self._jids[jid].save()
+
+ def subscribe(self, jid):
+ self._jids[jid].subscribe()
+
+ def unsubscribe(self, jid):
+ self._jids[jid].unsubscribe()
+
+ def remove(self, jid):
+ self._jids[jid].remove()
+ if not self.xmpp.is_component:
+ self.update(jid, subscription='remove')
+
+ def update(self, jid, name=None, subscription=None, groups=[]):
+ self._jids[jid]['name'] = name
+ self._jids[jid]['groups'] = group
+ self._jids[jid].save()
+
+ if not self.xmpp.is_component:
+ iq = self.Iq()
+ iq['type'] = 'set'
+ iq['roster']['items'] = {jid: {'name': name,
+ 'subscription': subscription,
+ 'groups': groups}}
+ response = iq.send()
+ return response and response['type'] == 'result'
+
+ def presence(self, jid, resource=None):
+ if resource is None:
+ return self._jids[jid].resources
+
+ default_presence = {'status': '',
+ 'priority': 0,
+ 'show': ''}
+ return self._jids[jid].resources.get(resource,
+ default_presence)
+
+
+class RosterItem(object):
+
+ def __init__(self, xmpp, jid, owner=None,
+ state=None, datastore=None):
+ self.xmpp = xmpp
+ self.jid = jid
+ self.owner = owner or self.xmpp.jid
+ self.last_status = None
+ self.resources = {}
+ self.datastore = datastore
+
+ self._state = state or {
+ 'from': False,
+ 'to': False,
+ 'pending_in': False,
+ 'pending_out': False,
+ 'whitelisted': False,
+ 'subscription': 'none',
+ 'name': '',
+ 'groups': []}
+ self._datastore_state = {}
+ self.load()
+
+ def load(self):
+ if self.datastore:
+ item = self.datastore.load(self.owner, self.jid,
+ self._datastore_state)
+ if item:
+ self['name'] = item['name']
+ self['groups'] = item['groups']
+ self['from'] = item['from']
+ self['to'] = item['to']
+ self['whitelisted'] = item['whitelisted']
+ self['pending_out'] = item['pending_out']
+ self['pending_in'] = item['pending_in']
+ self['subscription'] = self._subscription()
+ return self._state
+ return None
+
+ def save(self):
+ if self.datastore:
+ self.datastore.save(self.owner, self.jid,
+ self._state, self._datastore_state)
+
+ def __getitem__(self, key):
+ if key in self._state:
+ if key == 'subscription':
+ return self._subscription()
+ return self._state[key]
+ else:
+ raise KeyError
+
+ def __setitem__(self, key, value):
+ print "%s: %s" % (key, value)
+ if key in self._state:
+ if key in ['name', 'subscription', 'groups']:
+ self._state[key] = value
+ else:
+ value = str(value).lower()
+ self._state[key] = value in ('true', '1', 'on', 'yes')
+ else:
+ raise KeyError
+
+ def _subscription(self):
+ if self['to'] and self['from']:
+ return 'both'
+ elif self['from']:
+ return 'from'
+ elif self['to']:
+ return 'to'
+ else:
+ return 'none'
+
+ def remove(self):
+ "Remove the jids subscription, inform it if it is subscribed, and unwhitelist it"
+ if self['to']:
+ p = self.xmpp.Presence()
+ p['to'] = self.jid
+ p['type'] = ['unsubscribe']
+ if self.xmpp.is_component:
+ p['from'] = self.owner
+ p.send()
+ self['to'] = False
+ self['whitelisted'] = False
+ self.save()
+
+ def subscribe(self):
+ p = self.xmpp.Presence()
+ p['to'] = self.jid
+ p['type'] = 'subscribe'
+ if self.xmpp.is_component:
+ p['from'] = self.owner
+ self['pending_out'] = True
+ self.save()
+ p.send()
+
+ def authorize(self):
+ self['from'] = True
+ self['pending_in'] = False
+ self.save()
+ self._subscribed()
+ self.send_last_presence()
+
+ def unauthorize(self):
+ self['from'] = False
+ self['pending_in'] = False
+ self.save()
+ self._unsubscribed()
+ p = self.xmpp.Presence()
+ p['to'] = self.jid
+ p['type'] = 'unavailable'
+ if self.xmpp.is_component:
+ p['from'] = self.owner
+ p.send()
+
+ def _subscribed(self):
+ p = self.xmpp.Presence()
+ p['to'] = self.jid
+ p['type'] = 'subscribed'
+ if self.xmpp.is_component:
+ p['from'] = self.owner
+ p.send()
+
+ def unsubscribe(self):
+ p = self.xmpp.Presence()
+ p['to'] = self.jid
+ p['type'] = 'unsubscribe'
+ if self.xmpp.is_component:
+ p['from'] = self.owner
+ self.save()
+ p.send()
+
+ def _unsubscribed(self):
+ p = self.xmpp.Presence()
+ p['to'] = self.jid
+ p['type'] = 'unsubscribed'
+ if self.xmpp.is_component:
+ p['from'] = self.owner
+ p.send()
+
+ def send_presence(self, ptype='available', status=None):
+ p = self.xmpp.Presence()
+ p['to'] = self.jid
+ p['type'] = ptype
+ p['status'] = status
+ if self.xmpp.is_component:
+ p['from'] = self.owner
+ self.last_status = p
+ p.send()
+
+ def send_last_presence(self):
+ if self.last_status is None:
+ self.send_presence()
+ else:
+ self.last_status.send()
+
+ def handle_available(self, presence):
+ resource = presence['from'].resource
+ data = {'status': presence['status'],
+ 'show': presence['show'],
+ 'priority': presence['priority']}
+ if not self.resources:
+ self.xmpp.event('got_online', presence)
+ if resource not in self.resources:
+ self.resources[resource] = {}
+ self.resources[resource].update(data)
+
+ def handle_unavailable(self, presence):
+ resource = presence['from'].resource
+ if not self.resources:
+ return
+ if resource in self.resources:
+ del self.resources[resource]
+ if not self.resources:
+ self.xmpp.event('got_offline', presence)
+
+ def handle_subscribe(self, presence):
+ """
+ +------------------------------------------------------------------+
+ | EXISTING STATE | DELIVER? | NEW STATE |
+ +------------------------------------------------------------------+
+ | "None" | yes | "None + Pending In" |
+ | "None + Pending Out" | yes | "None + Pending Out/In" |
+ | "None + Pending In" | no | no state change |
+ | "None + Pending Out/In" | no | no state change |
+ | "To" | yes | "To + Pending In" |
+ | "To + Pending In" | no | no state change |
+ | "From" | no * | no state change |
+ | "From + Pending Out" | no * | no state change |
+ | "Both" | no * | no state change |
+ +------------------------------------------------------------------+
+ """
+ if not self['from'] and not self['pending_in']:
+ self['pending_in'] = True
+ self.xmpp.event('roster_subscription_request', presence)
+ elif self['from']:
+ self._subscribed()
+ self.save()
+
+ def handle_subscribed(self, presence):
+ """
+ +------------------------------------------------------------------+
+ | EXISTING STATE | DELIVER? | NEW STATE |
+ +------------------------------------------------------------------+
+ | "None" | no | no state change |
+ | "None + Pending Out" | yes | "To" |
+ | "None + Pending In" | no | no state change |
+ | "None + Pending Out/In" | yes | "To + Pending In" |
+ | "To" | no | no state change |
+ | "To + Pending In" | no | no state change |
+ | "From" | no | no state change |
+ | "From + Pending Out" | yes | "Both" |
+ | "Both" | no | no state change |
+ +------------------------------------------------------------------+
+ """
+ if not self['to'] and self['pending_out']:
+ self['pending_out'] = False
+ self['to'] = True
+ self.xmpp.event('roster_subscription_authorized', presence)
+ self.save()
+
+ def handle_unsubscribe(self, presence):
+ """
+ +------------------------------------------------------------------+
+ | EXISTING STATE | DELIVER? | NEW STATE |
+ +------------------------------------------------------------------+
+ | "None" | no | no state change |
+ | "None + Pending Out" | no | no state change |
+ | "None + Pending In" | yes * | "None" |
+ | "None + Pending Out/In" | yes * | "None + Pending Out" |
+ | "To" | no | no state change |
+ | "To + Pending In" | yes * | "To" |
+ | "From" | yes * | "None" |
+ | "From + Pending Out" | yes * | "None + Pending Out |
+ | "Both" | yes * | "To" |
+ +------------------------------------------------------------------+
+ """
+ if not self['from'] and self['pending_in']:
+ self['pending_in'] = False
+ self._unsubscribed()
+ elif self['from']:
+ self['from'] = False
+ self._unsubscribed()
+ self.xmpp.event('roster_subscription_remove', presence)
+ self.save()
+
+ def handle_unsubscribed(self, presence):
+ """
+ +------------------------------------------------------------------+
+ | EXISTING STATE | DELIVER? | NEW STATE |
+ +------------------------------------------------------------------+
+ | "None" | no | no state change |
+ | "None + Pending Out" | yes | "None" |
+ | "None + Pending In" | no | no state change |
+ | "None + Pending Out/In" | yes | "None + Pending In" |
+ | "To" | yes | "None" |
+ | "To + Pending In" | yes | "None + Pending In" |
+ | "From" | no | no state change |
+ | "From + Pending Out" | yes | "From" |
+ | "Both" | yes | "From" |
+ +------------------------------------------------------------------
+ """
+ if not self['to'] and self['pending_out']:
+ self['pending_out'] = False
+ elif self['to'] and not self['pending_out']:
+ self['to'] = False
+ self.xmpp.event('roster_subscription_removed', presence)
+ self.save()
+
+ def handle_probe(self, presence):
+ if self['to']:
+ self.send_last_presence()
+ if self['pending_out']:
+ self.subscribe()
+ if not self['to']:
+ self._unsubscribed()
diff --git a/sleekxmpp/stanza/roster.py b/sleekxmpp/stanza/roster.py
index 8f154a2..57ea62b 100644
--- a/sleekxmpp/stanza/roster.py
+++ b/sleekxmpp/stanza/roster.py
@@ -106,6 +106,8 @@ class Roster(ElementBase):
item = {}
item['name'] = itemxml.get('name', '')
item['subscription'] = itemxml.get('subscription', '')
+ item['ask'] = itemxml.get('ask', '')
+ item['approved'] = itemxml.get('approved', '')
item['groups'] = []
groupsxml = itemxml.findall('{jabber:iq:roster}group')
if groupsxml is not None:
diff --git a/sleekxmpp/test/sleektest.py b/sleekxmpp/test/sleektest.py
index 2901e59..cf38e78 100644
--- a/sleekxmpp/test/sleektest.py
+++ b/sleekxmpp/test/sleektest.py
@@ -138,6 +138,33 @@ class SleekTest(unittest.TestCase):
self.assertEqual(str(jid), string,
"String does not match: %s" % str(jid))
+ def check_roster(self, owner, jid, name=None, subscription=None,
+ afrom=None, ato=None, pending_out=None, pending_in=None,
+ groups=None):
+ roster = self.xmpp.rosters[owner][jid]
+ print roster._state
+ if name is not None:
+ self.assertEqual(roster['name'], name,
+ "Incorrect name value: %s" % roster['name'])
+ if subscription is not None:
+ self.assertEqual(roster['subscription'], subscription,
+ "Incorrect subscription: %s" % roster['subscription'])
+ if afrom is not None:
+ self.assertEqual(roster['from'], afrom,
+ "Incorrect from state: %s" % roster['from'])
+ if ato is not None:
+ self.assertEqual(roster['to'], ato,
+ "Incorrect to state: %s" % roster['to'])
+ if pending_out is not None:
+ self.assertEqual(roster['pending_out'], pending_out,
+ "Incorrect pending_out state: %s" % roster['pending_out'])
+ if pending_in is not None:
+ self.assertEqual(roster['pending_in'], pending_out,
+ "Incorrect pending_in state: %s" % roster['pending_in'])
+ if groups is not None:
+ self.assertEqual(roster['groups'], groups,
+ "Incorrect groups: %s" % roster['groups'])
+
# ------------------------------------------------------------------
# Methods for comparing stanza objects to XML strings
diff --git a/tests/test_stanza_roster.py b/tests/test_stanza_roster.py
index a0e5798..443eab3 100644
--- a/tests/test_stanza_roster.py
+++ b/tests/test_stanza_roster.py
@@ -48,10 +48,14 @@ class TestRosterStanzas(SleekTest):
'user@example.com': {
'name': 'User',
'subscription': 'both',
+ 'ask': '',
+ 'approved': '',
'groups': ['Friends', 'Coworkers']},
'otheruser@example.com': {
'name': 'Other User',
'subscription': 'both',
+ 'ask': '',
+ 'approved': '',
'groups': []}}
debug = "Roster items don't match after retrieval."
debug += "\nReturned: %s" % str(iq['roster']['items'])
diff --git a/tests/test_stream_presence.py b/tests/test_stream_presence.py
index ca67f1d..c873799 100644
--- a/tests/test_stream_presence.py
+++ b/tests/test_stream_presence.py
@@ -30,7 +30,9 @@ class TestStreamPresence(SleekTest):
self.xmpp.add_event_handler('presence_unavailable', unavailable)
self.stream_recv("""
-
+
""")
# Give event queue time to process.
@@ -68,12 +70,14 @@ class TestStreamPresence(SleekTest):
# Contact comes online.
self.stream_recv("""
-
+
""")
# Contact goes offline, should trigger got_offline.
self.stream_recv("""
""")
@@ -99,7 +103,8 @@ class TestStreamPresence(SleekTest):
self.xmpp.add_event_handler('got_online', got_online)
self.stream_recv("""
-
+
""")
# Give event queue time to process.
@@ -136,15 +141,23 @@ class TestStreamPresence(SleekTest):
self.xmpp.auto_subscribe = True
self.stream_recv("""
-
+
""")
self.stream_send_presence("""
-
+
""")
self.stream_send_presence("""
-
+
+ """)
+
+ self.stream_send_presence("""
+
""")
expected = set(('presence_subscribe', 'changed_subscription'))
@@ -170,14 +183,17 @@ class TestStreamPresence(SleekTest):
presence_subscribe)
# With this setting we should reject all subscriptions.
- self.xmpp.auto_authorize = False
+ self.xmpp.rosters['tester@localhost'].auto_authorize = False
self.stream_recv("""
-
+
""")
self.stream_send_presence("""
-
+
""")
expected = set(('presence_subscribe', 'changed_subscription'))
diff --git a/tests/test_stream_roster.py b/tests/test_stream_roster.py
index 6eda7e3..67da6e6 100644
--- a/tests/test_stream_roster.py
+++ b/tests/test_stream_roster.py
@@ -13,8 +13,7 @@ class TestStreamRoster(SleekTest):
def testGetRoster(self):
"""Test handling roster requests."""
- self.stream_start(mode='client')
- self.failUnless(self.xmpp.roster == {}, "Initial roster not empty.")
+ self.stream_start(mode='client', jid='tester@localhost')
# Since get_roster blocks, we need to run it in a thread.
t = threading.Thread(name='get_roster', target=self.xmpp.get_roster)
@@ -26,11 +25,12 @@ class TestStreamRoster(SleekTest):
""")
self.stream_recv("""
-
+
-
+ subscription="from"
+ ask="subscribe">
Friends
Examples
@@ -41,21 +41,20 @@ class TestStreamRoster(SleekTest):
# Wait for get_roster to return.
t.join()
- roster = {'user@localhost': {'name': 'User',
- 'subscription': 'both',
- 'groups': ['Friends', 'Examples'],
- 'presence': {},
- 'in_roster': True}}
- self.failUnless(self.xmpp.roster == roster,
- "Unexpected roster values: %s" % self.xmpp.roster)
+ print self.xmpp.rosters['tester@localhost']['user@localhost']._state
+ self.check_roster('tester@localhost', 'user@localhost',
+ name='User',
+ subscription='from',
+ afrom=True,
+ pending_out=True,
+ groups=['Friends', 'Examples'])
def testRosterSet(self):
"""Test handling pushed roster updates."""
- self.stream_start(mode='client')
- self.failUnless(self.xmpp.roster == {}, "Initial roster not empty.")
+ self.stream_start(mode='client', jid='tester@localhost')
self.stream_recv("""
-
+
-
""")
- roster = {'user@localhost': {'name': 'User',
- 'subscription': 'both',
- 'groups': ['Friends', 'Examples'],
- 'presence': {},
- 'in_roster': True}}
- self.failUnless(self.xmpp.roster == roster,
- "Unexpected roster values: %s" % self.xmpp.roster)
-
-
+ self.check_roster('tester@localhost', 'user@localhost',
+ name='User',
+ subscription='both',
+ groups=['Friends', 'Examples'])
suite = unittest.TestLoader().loadTestsFromTestCase(TestStreamRoster)