source: ralphm-patches/message-stanza.patch @ 72:727b4d29c48e

Last change on this file since 72:727b4d29c48e was 72:727b4d29c48e, checked in by Ralph Meijer <ralphm@…>, 8 years ago

Major reworking of avatars, session manager and stanza handlers.

File size: 8.9 KB
  • wokkel/test/test_xmppim.py

    # HG changeset patch
    # Parent 4d9f583550dd048922d89ea09c60cd082b6c2c65
    
    diff --git a/wokkel/test/test_xmppim.py b/wokkel/test/test_xmppim.py
    a b  
    13361336        d = self.handleRequest(xml)
    13371337        d.addCallback(cb)
    13381338        return d
     1339
     1340
     1341
     1342class MessageTest(unittest.TestCase):
     1343    """
     1344    Tests for L{xmppim.Message}.
     1345    """
     1346
     1347    def test_defaultStanzaType(self):
     1348        """
     1349        The default stanza type is 'normal'.
     1350        """
     1351        message = xmppim.Message()
     1352        self.assertEqual('normal', message.stanzaType)
     1353
     1354
     1355    def test_fromElementStanzaTypeEmpty(self):
     1356        """
     1357        The empty stanza type is parsed as 'normal'.
     1358        """
     1359        xml = u"""<message/>"""
     1360        message = xmppim.Message.fromElement(parseXml(xml))
     1361        self.assertEqual('normal', message.stanzaType)
     1362
     1363
     1364    def test_fromElementStanzaTypeError(self):
     1365        """
     1366        The error stanza type is parsed as 'error'.
     1367        """
     1368        xml = u"""<message type='error'/>"""
     1369        message = xmppim.Message.fromElement(parseXml(xml))
     1370        self.assertEqual('error', message.stanzaType)
     1371
     1372
     1373    def test_fromElementBody(self):
     1374        """
     1375        The message body is parsed into the body attribute.
     1376        """
     1377        xml = u"""
     1378            <message>
     1379              <body>Hello</body>
     1380            </message>
     1381        """
     1382        message = xmppim.Message.fromElement(parseXml(xml))
     1383        self.assertEqual(u'Hello', message.body)
     1384
     1385
     1386    def test_fromElementSubject(self):
     1387        """
     1388        The message subject is parsed into the subject attribute.
     1389        """
     1390        xml = u"""
     1391            <message>
     1392              <subject>Greeting</subject>
     1393            </message>
     1394        """
     1395        message = xmppim.Message.fromElement(parseXml(xml))
     1396        self.assertEqual(u'Greeting', message.subject)
     1397
     1398
     1399    def test_toElement(self):
     1400        message = xmppim.Message(body=u'Hello', subject=u'Greeting')
     1401        message.stanzaType = u'chat'
     1402
     1403        element = message.toElement()
     1404
     1405        self.assertEqual(u'chat', element.getAttribute(u'type'))
     1406        self.assertEqual(u'Hello', unicode(element.body))
     1407        self.assertEqual(u'Greeting', unicode(element.subject))
     1408
     1409
     1410
     1411class MessageProtocolTest(unittest.TestCase):
     1412    """
     1413    Tests for L{xmppim.MessageProtocol}.
     1414    """
     1415
     1416    def setUp(self):
     1417        self.stub = XmlStreamStub()
     1418        self.protocol = xmppim.MessageProtocol()
     1419        self.protocol.makeConnection(self.stub.xmlstream)
     1420        self.protocol.connectionInitialized()
     1421
     1422
     1423    def test_messageReceived(self):
     1424        """
     1425        Message stanzas are observed.
     1426        """
     1427        received = []
     1428        self.patch(self.protocol, 'messageReceived', received.append)
     1429
     1430        xml = """
     1431          <message to='example.org'>
     1432            <body>Hello</body>
     1433          </message>
     1434        """
     1435
     1436        message = parseXml(xml)
     1437        self.stub.send(message)
     1438
     1439        self.assertEqual(1, len(received))
     1440        stanza = received[-1]
     1441        self.assertEqual(u'Hello', stanza.body)
     1442
     1443
     1444    def test_messageHandled(self):
     1445        """
     1446        Message stanzas marked as handled are ignored.
     1447        """
     1448        received = []
     1449        self.patch(self.protocol, 'messageReceived', received.append)
     1450
     1451        xml = """
     1452          <message to='example.org'>
     1453            <body>Hello</body>
     1454          </message>
     1455        """
     1456
     1457        message = parseXml(xml)
     1458        message.handled = True
     1459        self.stub.send(message)
     1460
     1461        self.assertEqual(0, len(received))
     1462
     1463
     1464    def test_onMessage(self):
     1465        """
     1466        The deprecated onMessage is called if present.
     1467        """
     1468        received = []
     1469        self.protocol.onMessage = received.append
     1470
     1471        xml = """
     1472          <message to='example.org'>
     1473            <body>Hello</body>
     1474          </message>
     1475        """
     1476
     1477        message = parseXml(xml)
     1478        self.stub.send(message)
     1479
     1480        self.assertEqual(1, len(received))
     1481        element = received[-1]
     1482        self.assertEqual(u'message', element.name)
     1483        self.assertEqual(u'normal', element['type'])
     1484
     1485        warnings = self.flushWarnings()
     1486        self.assertEqual(1, len(warnings))
     1487
     1488        self.assertEqual("wokkel.xmppim.MessageProtocol.onMessage "
     1489                         "was deprecated in Wokkel 0.8.0; "
     1490                         "please use MessageProtocol.messageReceived instead.",
     1491                         warnings[0]['message'])
     1492
     1493
     1494    def test_onMessageError(self):
     1495        """
     1496        The deprecated onMessage is not called for error messages.
     1497        """
     1498        received = []
     1499        self.protocol.onMessage = received.append
     1500
     1501        xml = """
     1502          <message to='example.org' type='error'>
     1503            <error type='cancel'>
     1504              <service-unavailable
     1505                  xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
     1506            </error>
     1507          </message>
     1508        """
     1509
     1510        message = parseXml(xml)
     1511        self.stub.send(message)
     1512
     1513        self.assertEqual(0, len(received))
     1514
     1515        warnings = self.flushWarnings()
     1516        self.assertEqual(1, len(warnings))
     1517
     1518        self.assertEqual("wokkel.xmppim.MessageProtocol.onMessage "
     1519                         "was deprecated in Wokkel 0.8.0; "
     1520                         "please use MessageProtocol.messageReceived instead.",
     1521                         warnings[0]['message'])
  • wokkel/xmppim.py

    diff --git a/wokkel/xmppim.py b/wokkel/xmppim.py
    a b  
    2020from wokkel.generic import ErrorStanza, Stanza, Request
    2121from wokkel.subprotocols import IQHandlerMixin
    2222from wokkel.subprotocols import XMPPHandler
     23from wokkel.subprotocols import asyncObserver
    2324
    2425NS_XML = 'http://www.w3.org/XML/1998/namespace'
    2526NS_ROSTER = 'jabber:iq:roster'
     
    10061007    A message stanza.
    10071008    """
    10081009
    1009     stanzaKind = 'message'
     1010    stanzaKind = u'message'
     1011    stanzaType = u'normal'
     1012    _messageTypes = u'normal', u'chat', u'headline', u'groupchat', u'error'
    10101013
    10111014    childParsers = {
    1012             (None, 'body'): '_childParser_body',
    1013             (None, 'subject'): '_childParser_subject',
     1015            (None, u'body'): '_childParser_body',
     1016            (None, u'subject'): '_childParser_subject',
    10141017            }
    10151018
    10161019    def __init__(self, recipient=None, sender=None, body=None, subject=None):
     
    10311034        element = Stanza.toElement(self)
    10321035
    10331036        if self.body:
    1034             element.addElement('body', content=self.body)
     1037            element.addElement(u'body', content=self.body)
    10351038        if self.subject:
    1036             element.addElement('subject', content=self.subject)
     1039            element.addElement(u'subject', content=self.subject)
    10371040
    10381041        return element
    10391042
    10401043
     1044    @classmethod
     1045    def fromElement(cls, element):
     1046        stanza = super(Message, cls).fromElement(element)
     1047        if stanza.stanzaType not in cls._messageTypes:
     1048            stanza.stanzaType = u'normal'
     1049        return stanza
     1050
     1051
    10411052
    10421053class MessageProtocol(XMPPHandler):
    10431054    """
    10441055    Generic XMPP subprotocol handler for incoming message stanzas.
     1056
     1057    @cvar stanzaFactory: The class to parse messages into. Its C{fromElement}
     1058        will be called with the received L{domish.Element}. Defaults to
     1059        L{Message}.
    10451060    """
    10461061
    1047     messageTypes = None, 'normal', 'chat', 'headline', 'groupchat'
     1062    stanzaFactory = Message
    10481063
    10491064    def connectionInitialized(self):
    10501065        self.xmlstream.addObserver("/message", self._onMessage)
    10511066
    1052     def _onMessage(self, message):
    1053         if message.handled:
    1054             return
    10551067
    1056         messageType = message.getAttribute("type")
     1068    @asyncObserver
     1069    def _onMessage(self, element):
     1070        stanza = self.stanzaFactory.fromElement(element)
     1071        return self.messageReceived(stanza)
    10571072
    1058         if messageType == 'error':
    1059             return
    10601073
    1061         if messageType not in self.messageTypes:
    1062             message["type"] = 'normal'
    1063 
    1064         self.onMessage(message)
    1065 
    1066     def onMessage(self, message):
     1074    def messageReceived(self, message):
    10671075        """
    10681076        Called when a message stanza was received.
     1077
     1078        Override this method to handle a message. To let other handlers
     1079        process this message, return C{False} (synchronously).
     1080
     1081        The caller of this method uses L{asyncObserver}, so that
     1082        deferreds can also be returned and exceptions are handled properly.
     1083
     1084        @rtype: L{bool} or L{Deferred}
    10691085        """
     1086        if hasattr(self, 'onMessage'):
     1087            warnings.warn(
     1088                "wokkel.xmppim.MessageProtocol.onMessage "
     1089                "was deprecated in Wokkel 0.8.0; "
     1090                "please use MessageProtocol.messageReceived instead.",
     1091                DeprecationWarning)
     1092
     1093            if message.stanzaType == u'error':
     1094                return False
     1095
     1096            if message.stanzaType == u'normal':
     1097                # Override stanza type for backwards compatibility.
     1098                message.element[u'type'] = u'normal'
     1099
     1100            self.onMessage(message.element)
     1101            return True
Note: See TracBrowser for help on using the repository browser.