tests/test_stream_xep_0050.py

   1 import time
   2 import logging
   3
   4 import unittest
   5 from slixmpp.test import SlixTest
   6 from slixmpp.xmlstream import ElementBase, register_stanza_plugin
   7
   8
   9 class TestAdHocCommands(SlixTest):
  10
  11     def setUp(self):
  12         self.stream_start(mode='client',
  13                           plugins=['xep_0030', 'xep_0004', 'xep_0050'])
  14
  15         # Real session IDs don't make for nice tests, so use
  16         # a dummy value.
  17         self.xmpp['xep_0050'].new_session = lambda: '_sessionid_'
  18
  19     def tearDown(self):
  20         self.stream_close()
  21
  22     def testInitialPayloadCommand(self):
  23         """Test a command with an initial payload."""
  24
  25         class TestPayload(ElementBase):
  26             name = 'foo'
  27             namespace = 'test'
  28             interfaces = set(['bar'])
  29             plugin_attrib = name
  30
  31         Command = self.xmpp['xep_0050'].stanza.Command
  32         register_stanza_plugin(Command, TestPayload, iterable=True)
  33
  34         def handle_command(iq, session):
  35             initial = session['payload']
  36             logging.debug(initial)
  37             new_payload = TestPayload()
  38             if initial:
  39                 new_payload['bar'] = 'Received: %s' % initial['bar']
  40             else:
  41                 new_payload['bar'] = 'Failed'
  42
  43             logging.debug(initial)
  44
  45             session['payload'] = new_payload
  46             session['next'] = None
  47             session['has_next'] = False
  48
  49             return session
  50
  51         self.xmpp['xep_0050'].add_command('tester@localhost', 'foo',
  52                                           'Do Foo', handle_command)
  53
  54         self.recv("""
  55           <iq id="11" type="set" to="tester@localhost" from="foo@bar">
  56             <command xmlns="http://jabber.org/protocol/commands"
  57                      node="foo"
  58                      action="execute">
  59               <foo xmlns="test" bar="baz" />
  60             </command>
  61           </iq>
  62         """)
  63
  64         self.send("""
  65           <iq id="11" type="result" to="foo@bar">
  66             <command xmlns="http://jabber.org/protocol/commands"
  67                      node="foo"
  68                      status="completed"
  69                      sessionid="_sessionid_">
  70               <foo xmlns="test" bar="Received: baz" />
  71             </command>
  72           </iq>
  73         """)
  74
  75     def testZeroStepCommand(self):
  76         """Test running a command with no steps."""
  77
  78         def handle_command(iq, session):
  79             form = self.xmpp['xep_0004'].makeForm(ftype='result')
  80             form.addField(var='foo', ftype='text-single',
  81                           label='Foo', value='bar')
  82
  83             session['payload'] = form
  84             session['next'] = None
  85             session['has_next'] = False
  86
  87             return session
  88
  89         self.xmpp['xep_0050'].add_command('tester@localhost', 'foo',
  90                                           'Do Foo', handle_command)
  91
  92         self.recv("""
  93           <iq id="11" type="set" to="tester@localhost" from="foo@bar">
  94             <command xmlns="http://jabber.org/protocol/commands"
  95                      node="foo"
  96                      action="execute" />
  97           </iq>
  98         """)
  99
 100         self.send("""
 101           <iq id="11" type="result" to="foo@bar">
 102             <command xmlns="http://jabber.org/protocol/commands"
 103                      node="foo"
 104                      status="completed"
 105                      sessionid="_sessionid_">
 106               <x xmlns="jabber:x:data" type="result">
 107                 <field var="foo" label="Foo" type="text-single">
 108                   <value>bar</value>
 109                 </field>
 110               </x>
 111             </command>
 112           </iq>
 113         """)
 114
 115     def testOneStepCommand(self):
 116         """Test running a single step command."""
 117         results = []
 118
 119         def handle_command(iq, session):
 120
 121             def handle_form(form, session):
 122                 results.append(form['values']['foo'])
 123
 124             form = self.xmpp['xep_0004'].makeForm('form')
 125             form.addField(var='foo', ftype='text-single', label='Foo')
 126
 127             session['payload'] = form
 128             session['next'] = handle_form
 129             session['has_next'] = False
 130
 131             return session
 132
 133         self.xmpp['xep_0050'].add_command('tester@localhost', 'foo',
 134                                           'Do Foo', handle_command)
 135
 136         self.recv("""
 137           <iq id="11" type="set" to="tester@localhost" from="foo@bar">
 138             <command xmlns="http://jabber.org/protocol/commands"
 139                      node="foo"
 140                      action="execute" />
 141           </iq>
 142         """)
 143
 144         self.send("""
 145           <iq id="11" type="result" to="foo@bar">
 146             <command xmlns="http://jabber.org/protocol/commands"
 147                      node="foo"
 148                      status="executing"
 149                      sessionid="_sessionid_">
 150               <actions>
 151                 <complete />
 152               </actions>
 153               <x xmlns="jabber:x:data" type="form">
 154                 <field var="foo" label="Foo" type="text-single" />
 155               </x>
 156             </command>
 157           </iq>
 158         """)
 159
 160         self.recv("""
 161           <iq id="12" type="set" to="tester@localhost" from="foo@bar">
 162             <command xmlns="http://jabber.org/protocol/commands"
 163                      node="foo"
 164                      action="complete"
 165                      sessionid="_sessionid_">
 166               <x xmlns="jabber:x:data" type="submit">
 167                 <field var="foo" label="Foo" type="text-single">
 168                   <value>blah</value>
 169                 </field>
 170               </x>
 171             </command>
 172           </iq>
 173         """)
 174
 175         self.send("""
 176           <iq id="12" type="result" to="foo@bar">
 177             <command xmlns="http://jabber.org/protocol/commands"
 178                      node="foo"
 179                      status="completed"
 180                      sessionid="_sessionid_" />
 181           </iq>
 182         """)
 183
 184         self.assertEqual(results, ['blah'],
 185                 "Command handler was not executed: %s" % results)
 186
 187     def testTwoStepCommand(self):
 188         """Test using a two-stage command."""
 189         results = []
 190
 191         def handle_command(iq, session):
 192
 193             def handle_step2(form, session):
 194                 results.append(form['values']['bar'])
 195
 196             def handle_step1(form, session):
 197                 results.append(form['values']['foo'])
 198
 199                 form = self.xmpp['xep_0004'].makeForm('form')
 200                 form.addField(var='bar', ftype='text-single', label='Bar')
 201
 202                 session['payload'] = form
 203                 session['next'] = handle_step2
 204                 session['has_next'] = False
 205
 206                 return session
 207
 208             form = self.xmpp['xep_0004'].makeForm('form')
 209             form.addField(var='foo', ftype='text-single', label='Foo')
 210
 211             session['payload'] = form
 212             session['next'] = handle_step1
 213             session['has_next'] = True
 214
 215             return session
 216
 217         self.xmpp['xep_0050'].add_command('tester@localhost', 'foo',
 218                                           'Do Foo', handle_command)
 219
 220         self.recv("""
 221           <iq id="11" type="set" to="tester@localhost" from="foo@bar">
 222             <command xmlns="http://jabber.org/protocol/commands"
 223                      node="foo"
 224                      action="execute" />
 225           </iq>
 226         """)
 227
 228         self.send("""
 229           <iq id="11" type="result" to="foo@bar">
 230             <command xmlns="http://jabber.org/protocol/commands"
 231                      node="foo"
 232                      status="executing"
 233                      sessionid="_sessionid_">
 234               <actions>
 235                 <next />
 236               </actions>
 237               <x xmlns="jabber:x:data" type="form">
 238                 <field var="foo" label="Foo" type="text-single" />
 239               </x>
 240             </command>
 241           </iq>
 242         """)
 243
 244         self.recv("""
 245           <iq id="12" type="set" to="tester@localhost" from="foo@bar">
 246             <command xmlns="http://jabber.org/protocol/commands"
 247                      node="foo"
 248                      action="next"
 249                      sessionid="_sessionid_">
 250               <x xmlns="jabber:x:data" type="submit">
 251                 <field var="foo" label="Foo" type="text-single">
 252                   <value>blah</value>
 253                 </field>
 254               </x>
 255             </command>
 256           </iq>
 257         """)
 258
 259         self.send("""
 260           <iq id="12" type="result" to="foo@bar">
 261             <command xmlns="http://jabber.org/protocol/commands"
 262                      node="foo"
 263                      status="executing"
 264                      sessionid="_sessionid_">
 265               <actions>
 266                 <complete />
 267               </actions>
 268               <x xmlns="jabber:x:data" type="form">
 269                 <field var="bar" label="Bar" type="text-single" />
 270               </x>
 271             </command>
 272           </iq>
 273         """)
 274
 275         self.recv("""
 276           <iq id="13" type="set" to="tester@localhost" from="foo@bar">
 277             <command xmlns="http://jabber.org/protocol/commands"
 278                      node="foo"
 279                      action="complete"
 280                      sessionid="_sessionid_">
 281               <x xmlns="jabber:x:data" type="submit">
 282                 <field var="bar" label="Bar" type="text-single">
 283                   <value>meh</value>
 284                 </field>
 285               </x>
 286             </command>
 287           </iq>
 288         """)
 289         self.send("""
 290           <iq id="13" type="result" to="foo@bar">
 291             <command xmlns="http://jabber.org/protocol/commands"
 292                      node="foo"
 293                      status="completed"
 294                      sessionid="_sessionid_" />
 295           </iq>
 296         """)
 297
 298         self.assertEqual(results, ['blah', 'meh'],
 299                 "Command handler was not executed: %s" % results)
 300
 301     def testCancelCommand(self):
 302         """Test canceling command."""
 303         results = []
 304
 305         def handle_command(iq, session):
 306
 307             def handle_form(form, session):
 308                 results.append(form['values']['foo'])
 309
 310             def handle_cancel(iq, session):
 311                 results.append('canceled')
 312
 313             form = self.xmpp['xep_0004'].makeForm('form')
 314             form.addField(var='foo', ftype='text-single', label='Foo')
 315
 316             session['payload'] = form
 317             session['next'] = handle_form
 318             session['cancel'] = handle_cancel
 319             session['has_next'] = False
 320
 321             return session
 322
 323         self.xmpp['xep_0050'].add_command('tester@localhost', 'foo',
 324                                           'Do Foo', handle_command)
 325
 326         self.recv("""
 327           <iq id="11" type="set" to="tester@localhost" from="foo@bar">
 328             <command xmlns="http://jabber.org/protocol/commands"
 329                      node="foo"
 330                      action="execute" />
 331           </iq>
 332         """)
 333
 334         self.send("""
 335           <iq id="11" type="result" to="foo@bar">
 336             <command xmlns="http://jabber.org/protocol/commands"
 337                      node="foo"
 338                      status="executing"
 339                      sessionid="_sessionid_">
 340               <actions>
 341                 <complete />
 342               </actions>
 343               <x xmlns="jabber:x:data" type="form">
 344                 <field var="foo" label="Foo" type="text-single" />
 345               </x>
 346             </command>
 347           </iq>
 348         """)
 349
 350         self.recv("""
 351           <iq id="12" type="set" to="tester@localhost" from="foo@bar">
 352             <command xmlns="http://jabber.org/protocol/commands"
 353                      node="foo"
 354                      action="cancel"
 355                      sessionid="_sessionid_">
 356               <x xmlns="jabber:x:data" type="submit">
 357                 <field var="foo" label="Foo" type="text-single">
 358                   <value>blah</value>
 359                 </field>
 360               </x>
 361             </command>
 362           </iq>
 363         """)
 364
 365         self.send("""
 366           <iq id="12" type="result" to="foo@bar">
 367             <command xmlns="http://jabber.org/protocol/commands"
 368                      node="foo"
 369                      status="canceled"
 370                      sessionid="_sessionid_" />
 371           </iq>
 372         """)
 373
 374         self.assertEqual(results, ['canceled'],
 375                 "Cancelation handler not executed: %s" % results)
 376
 377     def testCommandNote(self):
 378         """Test adding notes to commands."""
 379
 380         def handle_command(iq, session):
 381             form = self.xmpp['xep_0004'].makeForm(ftype='result')
 382             form.addField(var='foo', ftype='text-single',
 383                           label='Foo', value='bar')
 384
 385             session['payload'] = form
 386             session['next'] = None
 387             session['has_next'] = False
 388             session['notes'] = [('info', 'testing notes')]
 389
 390             return session
 391
 392         self.xmpp['xep_0050'].add_command('tester@localhost', 'foo',
 393                                           'Do Foo', handle_command)
 394
 395         self.recv("""
 396           <iq id="11" type="set" to="tester@localhost" from="foo@bar">
 397             <command xmlns="http://jabber.org/protocol/commands"
 398                      node="foo"
 399                      action="execute" />
 400           </iq>
 401         """)
 402
 403         self.send("""
 404           <iq id="11" type="result" to="foo@bar">
 405             <command xmlns="http://jabber.org/protocol/commands"
 406                      node="foo"
 407                      status="completed"
 408                      sessionid="_sessionid_">
 409               <note type="info">testing notes</note>
 410               <x xmlns="jabber:x:data" type="result">
 411                 <field var="foo" label="Foo" type="text-single">
 412                   <value>bar</value>
 413                 </field>
 414               </x>
 415             </command>
 416           </iq>
 417         """)
 418
 419
 420
 421     def testMultiPayloads(self):
 422         """Test using commands with multiple payloads."""
 423         results = []
 424
 425         def handle_command(iq, session):
 426
 427             def handle_form(forms, session):
 428                 for form in forms:
 429                     results.append(form['values']['FORM_TYPE'])
 430
 431             form1 = self.xmpp['xep_0004'].makeForm('form')
 432             form1.addField(var='FORM_TYPE', ftype='hidden', value='form_1')
 433             form1.addField(var='foo', ftype='text-single', label='Foo')
 434
 435             form2 = self.xmpp['xep_0004'].makeForm('form')
 436             form2.addField(var='FORM_TYPE', ftype='hidden', value='form_2')
 437             form2.addField(var='foo', ftype='text-single', label='Foo')
 438
 439             session['payload'] = [form1, form2]
 440             session['next'] = handle_form
 441             session['has_next'] = False
 442
 443             return session
 444
 445         self.xmpp['xep_0050'].add_command('tester@localhost', 'foo',
 446                                           'Do Foo', handle_command)
 447
 448         self.recv("""
 449           <iq id="11" type="set" to="tester@localhost" from="foo@bar">
 450             <command xmlns="http://jabber.org/protocol/commands"
 451                      node="foo"
 452                      action="execute" />
 453           </iq>
 454         """)
 455
 456         self.send("""
 457           <iq id="11" type="result" to="foo@bar">
 458             <command xmlns="http://jabber.org/protocol/commands"
 459                      node="foo"
 460                      status="executing"
 461                      sessionid="_sessionid_">
 462               <actions>
 463                 <complete />
 464               </actions>
 465               <x xmlns="jabber:x:data" type="form">
 466                 <field var="FORM_TYPE" type="hidden">
 467                   <value>form_1</value>
 468                 </field>
 469                 <field var="foo" label="Foo" type="text-single" />
 470               </x>
 471               <x xmlns="jabber:x:data" type="form">
 472                 <field var="FORM_TYPE" type="hidden">
 473                   <value>form_2</value>
 474                 </field>
 475                 <field var="foo" label="Foo" type="text-single" />
 476               </x>
 477             </command>
 478           </iq>
 479         """)
 480
 481         self.recv("""
 482           <iq id="12" type="set" to="tester@localhost" from="foo@bar">
 483             <command xmlns="http://jabber.org/protocol/commands"
 484                      node="foo"
 485                      action="complete"
 486                      sessionid="_sessionid_">
 487              <x xmlns="jabber:x:data" type="submit">
 488                 <field var="FORM_TYPE" type="hidden">
 489                   <value>form_1</value>
 490                 </field>
 491                 <field var="foo" type="text-single">
 492                   <value>bar</value>
 493                 </field>
 494               </x>
 495               <x xmlns="jabber:x:data" type="submit">
 496                 <field var="FORM_TYPE" type="hidden">
 497                   <value>form_2</value>
 498                 </field>
 499                 <field var="foo" type="text-single">
 500                   <value>bar</value>
 501                 </field>
 502               </x>
 503             </command>
 504           </iq>
 505         """)
 506
 507         self.send("""
 508           <iq id="12" type="result" to="foo@bar">
 509             <command xmlns="http://jabber.org/protocol/commands"
 510                      node="foo"
 511                      status="completed"
 512                      sessionid="_sessionid_" />
 513           </iq>
 514         """)
 515
 516         self.assertEqual(results, [['form_1'], ['form_2']],
 517                 "Command handler was not executed: %s" % results)
 518
 519     def testClientAPI(self):
 520         """Test using client-side API for commands."""
 521         results = []
 522
 523         def handle_complete(iq, session):
 524             for item in session['custom_data']:
 525                 results.append(item)
 526
 527         def handle_step2(iq, session):
 528             form = self.xmpp['xep_0004'].makeForm(ftype='submit')
 529             form.addField(var='bar', value='123')
 530
 531             session['custom_data'].append('baz')
 532             session['payload'] = form
 533             session['next'] = handle_complete
 534             self.xmpp['xep_0050'].complete_command(session)
 535
 536         def handle_step1(iq, session):
 537             form = self.xmpp['xep_0004'].makeForm(ftype='submit')
 538             form.addField(var='foo', value='42')
 539
 540             session['custom_data'].append('bar')
 541             session['payload'] = form
 542             session['next'] = handle_step2
 543             self.xmpp['xep_0050'].continue_command(session)
 544
 545         session = {'custom_data': ['foo'],
 546                    'next': handle_step1}
 547
 548         self.xmpp['xep_0050'].start_command(
 549                 'foo@example.com',
 550                 'test_client',
 551                 session)
 552
 553         self.send("""
 554           <iq id="1" to="foo@example.com" type="set">
 555             <command xmlns="http://jabber.org/protocol/commands"
 556                      node="test_client"
 557                      action="execute" />
 558           </iq>
 559         """)
 560
 561         self.recv("""
 562           <iq id="1" from="foo@example.com" type="result">
 563             <command xmlns="http://jabber.org/protocol/commands"
 564                      node="test_client"
 565                      sessionid="_sessionid_"
 566                      status="executing">
 567               <x xmlns="jabber:x:data" type="form">
 568                 <field var="foo" type="text-single" />
 569               </x>
 570             </command>
 571           </iq>
 572         """)
 573
 574         self.send("""
 575           <iq id="2" to="foo@example.com" type="set">
 576             <command xmlns="http://jabber.org/protocol/commands"
 577                      node="test_client"
 578                      sessionid="_sessionid_"
 579                      action="next">
 580               <x xmlns="jabber:x:data" type="submit">
 581                 <field var="foo">
 582                   <value>42</value>
 583                 </field>
 584               </x>
 585             </command>
 586           </iq>
 587         """)
 588
 589         self.recv("""
 590           <iq id="2" from="foo@example.com" type="result">
 591             <command xmlns="http://jabber.org/protocol/commands"
 592                      node="test_client"
 593                      sessionid="_sessionid_"
 594                      status="executing">
 595               <x xmlns="jabber:x:data" type="form">
 596                 <field var="bar" type="text-single" />
 597               </x>
 598             </command>
 599           </iq>
 600         """)
 601
 602         self.send("""
 603           <iq id="3" to="foo@example.com" type="set">
 604             <command xmlns="http://jabber.org/protocol/commands"
 605                      node="test_client"
 606                      sessionid="_sessionid_"
 607                      action="complete">
 608               <x xmlns="jabber:x:data" type="submit">
 609                 <field var="bar">
 610                   <value>123</value>
 611                 </field>
 612               </x>
 613             </command>
 614           </iq>
 615         """)
 616
 617         self.recv("""
 618           <iq id="3" from="foo@example.com" type="result">
 619             <command xmlns="http://jabber.org/protocol/commands"
 620                      node="test_client"
 621                      sessionid="_sessionid_"
 622                      status="completed" />
 623           </iq>
 624         """)
 625
 626         # Give the event queue time to process
 627         time.sleep(0.3)
 628
 629         self.failUnless(results == ['foo', 'bar', 'baz'],
 630                 'Incomplete command workflow: %s' % results)
 631
 632     def testClientAPICancel(self):
 633         """Test using client-side cancel API for commands."""
 634         results = []
 635
 636         def handle_canceled(iq, session):
 637             for item in session['custom_data']:
 638                 results.append(item)
 639
 640         def handle_step1(iq, session):
 641             session['custom_data'].append('bar')
 642             session['next'] = handle_canceled
 643             self.xmpp['xep_0050'].cancel_command(session)
 644
 645         session = {'custom_data': ['foo'],
 646                    'next': handle_step1}
 647
 648         self.xmpp['xep_0050'].start_command(
 649                 'foo@example.com',
 650                 'test_client',
 651                 session)
 652
 653         self.send("""
 654           <iq id="1" to="foo@example.com" type="set">
 655             <command xmlns="http://jabber.org/protocol/commands"
 656                      node="test_client"
 657                      action="execute" />
 658           </iq>
 659         """)
 660
 661         self.recv("""
 662           <iq id="1" to="foo@example.com" type="result">
 663             <command xmlns="http://jabber.org/protocol/commands"
 664                      node="test_client"
 665                      sessionid="_sessionid_"
 666                      status="executing">
 667               <x xmlns="jabber:x:data" type="form">
 668                 <field var="foo" type="text-single" />
 669               </x>
 670             </command>
 671           </iq>
 672         """)
 673
 674         self.send("""
 675           <iq id="2" to="foo@example.com" type="set">
 676             <command xmlns="http://jabber.org/protocol/commands"
 677                      node="test_client"
 678                      sessionid="_sessionid_"
 679                      action="cancel" />
 680           </iq>
 681         """)
 682
 683         self.recv("""
 684           <iq id="2" to="foo@example.com" type="result">
 685             <command xmlns="http://jabber.org/protocol/commands"
 686                      node="test_client"
 687                      sessionid="_sessionid_"
 688                      status="canceled" />
 689           </iq>
 690         """)
 691
 692         # Give the event queue time to process
 693         time.sleep(0.3)
 694
 695         self.failUnless(results == ['foo', 'bar'],
 696                 'Incomplete command workflow: %s' % results)
 697
 698     def testClientAPIError(self):
 699         """Test using client-side error API for commands."""
 700         results = []
 701
 702         def handle_error(iq, session):
 703             for item in session['custom_data']:
 704                 results.append(item)
 705
 706         session = {'custom_data': ['foo'],
 707                    'error': handle_error}
 708
 709         self.xmpp['xep_0050'].start_command(
 710                 'foo@example.com',
 711                 'test_client',
 712                 session)
 713
 714         self.send("""
 715           <iq id="1" to="foo@example.com" type="set">
 716             <command xmlns="http://jabber.org/protocol/commands"
 717                      node="test_client"
 718                      action="execute" />
 719           </iq>
 720         """)
 721
 722         self.recv("""
 723           <iq id="1" to="foo@example.com" type="error">
 724             <command xmlns="http://jabber.org/protocol/commands"
 725                      node="test_client"
 726                      action="execute" />
 727             <error type='cancel'>
 728               <item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
 729             </error>
 730           </iq>
 731         """)
 732
 733         # Give the event queue time to process
 734         time.sleep(0.3)
 735
 736         self.failUnless(results == ['foo'],
 737                 'Incomplete command workflow: %s' % results)
 738
 739     def testClientAPIErrorStrippedResponse(self):
 740         """Test errors that don't include the command substanza."""
 741         results = []
 742
 743         def handle_error(iq, session):
 744             for item in session['custom_data']:
 745                 results.append(item)
 746
 747         session = {'custom_data': ['foo'],
 748                    'error': handle_error}
 749
 750         self.xmpp['xep_0050'].start_command(
 751                 'foo@example.com',
 752                 'test_client',
 753                 session)
 754
 755         self.send("""
 756           <iq id="1" to="foo@example.com" type="set">
 757             <command xmlns="http://jabber.org/protocol/commands"
 758                      node="test_client"
 759                      action="execute" />
 760           </iq>
 761         """)
 762
 763         self.recv("""
 764           <iq id="1" to="foo@example.com" type="error">
 765             <error type='cancel'>
 766               <item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas' />
 767             </error>
 768           </iq>
 769         """)
 770
 771         # Give the event queue time to process
 772         time.sleep(0.3)
 773
 774         self.failUnless(results == ['foo'],
 775                 'Incomplete command workflow: %s' % results)
 776
 777
 778
 779
 780
 781 suite = unittest.TestLoader().loadTestsFromTestCase(TestAdHocCommands)