tests/test_stanza_xep_0009.py

   1 # -*- encoding:utf-8 -*-
   2
   3 """
   4     Slixmpp: The Slick XMPP Library
   5     Copyright (C) 2011 Nathanael C. Fritz, Dann Martens (TOMOTON).
   6     This file is part of Slixmpp.
   7
   8     See the file LICENSE for copying permission.
   9 """
  10
  11 from __future__ import unicode_literals
  12
  13 import base64
  14 import sys
  15
  16 from slixmpp.plugins.xep_0009.stanza.RPC import RPCQuery, MethodCall, \
  17     MethodResponse
  18 from slixmpp.plugins.xep_0009.binding import py2xml, xml2py, rpcbase64, \
  19     rpctime
  20 from slixmpp.stanza.iq import Iq
  21 from slixmpp.test.slixtest import SlixTest
  22 from slixmpp.xmlstream.stanzabase import register_stanza_plugin
  23 from slixmpp.xmlstream.tostring import tostring
  24 import unittest
  25
  26
  27 if sys.version_info > (3, 0):
  28     unicode = str
  29
  30
  31 class TestJabberRPC(SlixTest):
  32
  33     def setUp(self):
  34         register_stanza_plugin(Iq, RPCQuery)
  35         register_stanza_plugin(RPCQuery, MethodCall)
  36         register_stanza_plugin(RPCQuery, MethodResponse)
  37
  38     def testMethodCall(self):
  39         iq = self.Iq()
  40         iq['rpc_query']['method_call']['method_name'] = 'system.exit'
  41         iq['rpc_query']['method_call']['params'] = py2xml(*())
  42         self.check(iq, """
  43             <iq>
  44                 <query xmlns="jabber:iq:rpc">
  45                     <methodCall>
  46                         <methodName>system.exit</methodName>
  47                         <params />
  48                     </methodCall>
  49                 </query>
  50             </iq>
  51         """, use_values=False)
  52
  53     def testMethodResponse(self):
  54         iq = self.Iq()
  55         iq['rpc_query']['method_response']['params'] = py2xml(*())
  56         self.check(iq, """
  57             <iq>
  58                 <query xmlns="jabber:iq:rpc">
  59                     <methodResponse>
  60                         <params />
  61                     </methodResponse>
  62                 </query>
  63             </iq>
  64         """, use_values=False)
  65
  66     def testConvertNil(self):
  67         params = [None]
  68         params_xml = py2xml(*params)
  69         expected_xml = self.parse_xml("""
  70             <params xmlns="jabber:iq:rpc">
  71                 <param>
  72                     <value>
  73                         <nil />
  74                     </value>
  75                 </param>
  76             </params>
  77         """)
  78         self.assertTrue(self.compare(expected_xml, params_xml),
  79                         "Nil to XML conversion\nExpected: %s\nGot: %s" % (
  80                             tostring(expected_xml), tostring(params_xml)))
  81         self.assertEqual(params, xml2py(expected_xml),
  82                          "XML to nil conversion")
  83
  84     def testConvertBoolean(self):
  85         params = [True, False]
  86         params_xml = py2xml(*params)
  87         expected_xml = self.parse_xml("""
  88             <params xmlns="jabber:iq:rpc">
  89                 <param>
  90                     <value>
  91                         <boolean>1</boolean>
  92                     </value>
  93                 </param>
  94                 <param>
  95                     <value>
  96                         <boolean>0</boolean>
  97                     </value>
  98                 </param>
  99             </params>
 100         """)
 101         self.assertTrue(self.compare(expected_xml, params_xml),
 102                         "Boolean to XML conversion\nExpected: %s\nGot: %s" % (
 103                             tostring(expected_xml), tostring(params_xml)))
 104         self.assertEqual(params, xml2py(expected_xml),
 105                          "XML to boolean conversion")
 106
 107     def testConvertString(self):
 108         params = ["'This' & \"That\""]
 109         params_xml = py2xml(*params)
 110         expected_xml = self.parse_xml("""
 111             <params xmlns="jabber:iq:rpc">
 112                 <param>
 113                     <value>
 114                         <string>&apos;This&apos; &amp; &quot;That&quot;</string>
 115                     </value>
 116                 </param>
 117             </params>
 118         """)
 119         self.assertTrue(self.compare(expected_xml, params_xml),
 120                         "String to XML conversion\nExpected: %s\nGot: %s" % (
 121                             tostring(expected_xml), tostring(params_xml)))
 122         self.assertEqual(params, xml2py(expected_xml),
 123                         "XML to string conversion")
 124
 125     def testConvertUnicodeString(self):
 126         params = ["おはよう"]
 127         params_xml = py2xml(*params)
 128         expected_xml = self.parse_xml("""
 129             <params xmlns="jabber:iq:rpc">
 130                 <param>
 131                     <value>
 132                         <string>おはよう</string>
 133                     </value>
 134                 </param>
 135             </params>
 136         """)
 137         self.assertTrue(self.compare(expected_xml, params_xml),
 138                         "String to XML conversion\nExpected: %s\nGot: %s" % (
 139                             tostring(expected_xml), tostring(params_xml)))
 140         self.assertEqual(params, xml2py(expected_xml),
 141                         "XML to string conversion")
 142
 143     def testConvertInteger(self):
 144         params = [32767, -32768]
 145         params_xml = py2xml(*params)
 146         expected_xml = self.parse_xml("""
 147             <params xmlns="jabber:iq:rpc">
 148                 <param>
 149                     <value>
 150                         <i4>32767</i4>
 151                     </value>
 152                 </param>
 153                 <param>
 154                     <value>
 155                         <i4>-32768</i4>
 156                     </value>
 157                 </param>
 158             </params>
 159         """)
 160         alternate_xml = self.parse_xml("""
 161             <params xmlns="jabber:iq:rpc">
 162                 <param>
 163                     <value>
 164                         <int>32767</int>
 165                     </value>
 166                 </param>
 167                 <param>
 168                     <value>
 169                         <int>-32768</int>
 170                     </value>
 171                 </param>
 172             </params>
 173         """)
 174         self.assertTrue(self.compare(expected_xml, params_xml),
 175                         "Integer to XML conversion\nExpected: %s\nGot: %s" % (
 176                             tostring(expected_xml), tostring(params_xml)))
 177         self.assertEqual(params, xml2py(expected_xml),
 178                          "XML to boolean conversion")
 179         self.assertEqual(params, xml2py(alternate_xml),
 180                          "Alternate XML to boolean conversion")
 181
 182
 183     def testConvertDouble(self):
 184         params = [3.14159265]
 185         params_xml = py2xml(*params)
 186         expected_xml = self.parse_xml("""
 187             <params xmlns="jabber:iq:rpc">
 188                 <param>
 189                     <value>
 190                         <double>3.14159265</double>
 191                     </value>
 192                 </param>
 193             </params>
 194         """)
 195         self.assertTrue(self.compare(expected_xml, params_xml),
 196                         "Double to XML conversion\nExpected: %s\nGot: %s" % (
 197                             tostring(expected_xml), tostring(params_xml)))
 198         self.assertEqual(params, xml2py(expected_xml),
 199                          "XML to double conversion")
 200
 201     def testConvertBase64(self):
 202         params = [rpcbase64(base64.b64encode(b"Hello, world!"))]
 203         params_xml = py2xml(*params)
 204         expected_xml = self.parse_xml("""
 205             <params xmlns="jabber:iq:rpc">
 206                 <param>
 207                     <value>
 208                         <base64>SGVsbG8sIHdvcmxkIQ==</base64>
 209                     </value>
 210                 </param>
 211             </params>
 212         """)
 213         alternate_xml = self.parse_xml("""
 214             <params xmlns="jabber:iq:rpc">
 215                 <param>
 216                     <value>
 217                         <Base64>SGVsbG8sIHdvcmxkIQ==</Base64>
 218                     </value>
 219                 </param>
 220             </params>
 221         """)
 222         self.assertTrue(self.compare(expected_xml, params_xml),
 223                         "Base64 to XML conversion\nExpected: %s\nGot: %s" % (
 224                             tostring(expected_xml), tostring(params_xml)))
 225         self.assertEqual(list(map(lambda x: x.decode(), params)),
 226                          list(map(lambda x: x.decode(), xml2py(expected_xml))),
 227                          "XML to base64 conversion")
 228         self.assertEqual(list(map(lambda x: x.decode(), params)),
 229                          list(map(lambda x: x.decode(), xml2py(alternate_xml))),
 230                          "Alternate XML to base64 conversion")
 231
 232     def testConvertDateTime(self):
 233         params = [rpctime("20111220T01:50:00")]
 234         params_xml = py2xml(*params)
 235         expected_xml = self.parse_xml("""
 236             <params xmlns="jabber:iq:rpc">
 237                 <param>
 238                     <value>
 239                         <dateTime.iso8601>20111220T01:50:00</dateTime.iso8601>
 240                     </value>
 241                 </param>
 242             </params>
 243         """)
 244         self.assertTrue(self.compare(expected_xml, params_xml),
 245                         "DateTime to XML conversion\nExpected: %s\nGot: %s" % (
 246                             tostring(expected_xml), tostring(params_xml)))
 247         self.assertEqual(list(map(lambda x: x.iso8601(), params)),
 248                          list(map(lambda x: x.iso8601(), xml2py(expected_xml))),
 249                          None)
 250
 251     def testConvertArray(self):
 252         params = [[1,2,3], ('a', 'b', 'c')]
 253         params_xml = py2xml(*params)
 254         expected_xml = self.parse_xml("""
 255             <params xmlns="jabber:iq:rpc">
 256                 <param>
 257                     <value>
 258                         <array>
 259                             <data>
 260                                 <value><i4>1</i4></value>
 261                                 <value><i4>2</i4></value>
 262                                 <value><i4>3</i4></value>
 263                             </data>
 264                         </array>
 265                     </value>
 266                 </param>
 267                 <param>
 268                     <value>
 269                         <array>
 270                             <data>
 271                                 <value><string>a</string></value>
 272                                 <value><string>b</string></value>
 273                                 <value><string>c</string></value>
 274                             </data>
 275                         </array>
 276                     </value>
 277                 </param>
 278             </params>
 279         """)
 280         self.assertTrue(self.compare(expected_xml, params_xml),
 281                         "Array to XML conversion\nExpected: %s\nGot: %s" % (
 282                             tostring(expected_xml), tostring(params_xml)))
 283         self.assertEqual(list(map(list, params)), xml2py(expected_xml),
 284                          "XML to array conversion")
 285
 286     def testConvertStruct(self):
 287         params = [{"foo": "bar", "baz": False}]
 288         params_xml = py2xml(*params)
 289         expected_xml = self.parse_xml("""
 290             <params xmlns="jabber:iq:rpc">
 291                 <param>
 292                     <value>
 293                         <struct>
 294                             <member>
 295                                 <name>foo</name>
 296                                 <value><string>bar</string></value>
 297                             </member>
 298                             <member>
 299                                 <name>baz</name>
 300                                 <value><boolean>0</boolean></value>
 301                             </member>
 302                         </struct>
 303                     </value>
 304                 </param>
 305             </params>
 306         """)
 307         self.assertTrue(self.compare(expected_xml, params_xml),
 308                         "Struct to XML conversion\nExpected: %s\nGot: %s" % (
 309                             tostring(expected_xml), tostring(params_xml)))
 310         self.assertEqual(params, xml2py(expected_xml),
 311                          "XML to struct conversion")
 312
 313 suite = unittest.TestLoader().loadTestsFromTestCase(TestJabberRPC)
 314