Mercurial > libervia-pubsub

comparison idavoll/test/test_backend.py @ 209:7f3ffb7a1a9e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add support for node deletion with redirect.
author Ralph Meijer <ralphm@ik.nu>
date Fri, 30 Jan 2009 14:35:05 +0000
parents 274a45d2a5ab
children bfc198af5d27
comparison
equal deleted inserted replaced
208:cc4f45ef793e 209:7f3ffb7a1a9e
11 from twisted.internet import defer 11 from twisted.internet import defer
12 from twisted.trial import unittest 12 from twisted.trial import unittest
13 from twisted.words.protocols.jabber import jid 13 from twisted.words.protocols.jabber import jid
14 from twisted.words.protocols.jabber.error import StanzaError 14 from twisted.words.protocols.jabber.error import StanzaError
15 15
16 from wokkel import pubsub 16 from wokkel import iwokkel, pubsub
17 17
18 from idavoll import backend, error, iidavoll 18 from idavoll import backend, error, iidavoll
19 19
20 OWNER = jid.JID('owner@example.com') 20 OWNER = jid.JID('owner@example.com')
21 SERVICE = jid.JID('test.example.org')
21 NS_PUBSUB = 'http://jabber.org/protocol/pubsub' 22 NS_PUBSUB = 'http://jabber.org/protocol/pubsub'
22 23
23 class BackendTest(unittest.TestCase): 24 class BackendTest(unittest.TestCase):
24 25
25 def test_interfaceIBackend(self): 26 def test_interfaceIBackend(self):
33 def getAffiliation(self, entity): 34 def getAffiliation(self, entity):
34 if entity is OWNER: 35 if entity is OWNER:
35 return defer.succeed('owner') 36 return defer.succeed('owner')
36 37
37 class TestStorage: 38 class TestStorage:
39 def __init__(self):
40 self.deleteCalled = []
41
38 def getNode(self, nodeIdentifier): 42 def getNode(self, nodeIdentifier):
39 return defer.succeed(TestNode()) 43 return defer.succeed(TestNode())
40 44
41 def deleteNode(self, nodeIdentifier): 45 def deleteNode(self, nodeIdentifier):
42 if nodeIdentifier in ['to-be-deleted']: 46 if nodeIdentifier in ['to-be-deleted']:
43 self.deleteCalled = True 47 self.deleteCalled.append(nodeIdentifier)
44 return defer.succeed(None) 48 return defer.succeed(None)
45 else: 49 else:
46 return defer.fail(error.NodeNotFound()) 50 return defer.fail(error.NodeNotFound())
47 51
48 def preDelete(nodeIdentifier): 52 def preDelete(data):
49 self.preDeleteCalled = True 53 self.assertFalse(self.storage.deleteCalled)
54 preDeleteCalled.append(data)
50 return defer.succeed(None) 55 return defer.succeed(None)
51 56
52 def cb(result): 57 def cb(result):
53 self.assertTrue(self.preDeleteCalled) 58 self.assertEquals(1, len(preDeleteCalled))
59 data = preDeleteCalled[-1]
60 self.assertEquals('to-be-deleted', data['nodeIdentifier'])
54 self.assertTrue(self.storage.deleteCalled) 61 self.assertTrue(self.storage.deleteCalled)
55 62
56 self.storage = TestStorage() 63 self.storage = TestStorage()
57 self.backend = backend.BackendService(self.storage) 64 self.backend = backend.BackendService(self.storage)
58 self.storage.backend = self.backend 65
59 66 preDeleteCalled = []
60 self.preDeleteCalled = False
61 self.deleteCalled = False
62 67
63 self.backend.registerPreDelete(preDelete) 68 self.backend.registerPreDelete(preDelete)
64 d = self.backend.deleteNode('to-be-deleted', OWNER) 69 d = self.backend.deleteNode('to-be-deleted', OWNER)
70 d.addCallback(cb)
71 return d
72
73
74 def test_deleteNodeRedirect(self):
75 uri = 'xmpp:%s?;node=test2' % (SERVICE.full(),)
76
77 class TestNode:
78 nodeIdentifier = 'to-be-deleted'
79 def getAffiliation(self, entity):
80 if entity is OWNER:
81 return defer.succeed('owner')
82
83 class TestStorage:
84 def __init__(self):
85 self.deleteCalled = []
86
87 def getNode(self, nodeIdentifier):
88 return defer.succeed(TestNode())
89
90 def deleteNode(self, nodeIdentifier):
91 if nodeIdentifier in ['to-be-deleted']:
92 self.deleteCalled.append(nodeIdentifier)
93 return defer.succeed(None)
94 else:
95 return defer.fail(error.NodeNotFound())
96
97 def preDelete(data):
98 self.assertFalse(self.storage.deleteCalled)
99 preDeleteCalled.append(data)
100 return defer.succeed(None)
101
102 def cb(result):
103 self.assertEquals(1, len(preDeleteCalled))
104 data = preDeleteCalled[-1]
105 self.assertEquals('to-be-deleted', data['nodeIdentifier'])
106 self.assertEquals(uri, data['redirectURI'])
107 self.assertTrue(self.storage.deleteCalled)
108
109 self.storage = TestStorage()
110 self.backend = backend.BackendService(self.storage)
111
112 preDeleteCalled = []
113
114 self.backend.registerPreDelete(preDelete)
115 d = self.backend.deleteNode('to-be-deleted', OWNER, redirectURI=uri)
65 d.addCallback(cb) 116 d.addCallback(cb)
66 return d 117 return d
67 118
68 119
69 def test_createNodeNoID(self): 120 def test_createNodeNoID(self):
395 446
396 447
397 448
398 class PubSubServiceFromBackendTest(unittest.TestCase): 449 class PubSubServiceFromBackendTest(unittest.TestCase):
399 450
451 def test_interfaceIBackend(self):
452 s = backend.PubSubServiceFromBackend(BaseTestBackend())
453 self.assertTrue(verifyObject(iwokkel.IPubSubService, s))
454
455
456 def test_preDelete(self):
457 """
458 Test pre-delete sending out notifications to subscribers.
459 """
460
461 class TestBackend(BaseTestBackend):
462 preDeleteFn = None
463
464 def registerPreDelete(self, preDeleteFn):
465 self.preDeleteFn = preDeleteFn
466
467 def getSubscribers(self, nodeIdentifier):
468 return defer.succeed([OWNER])
469
470 def notifyDelete(service, nodeIdentifier, subscribers,
471 redirectURI=None):
472 self.assertEqual(SERVICE, service)
473 self.assertEqual('test', nodeIdentifier)
474 self.assertEqual([OWNER], subscribers)
475 self.assertIdentical(None, redirectURI)
476 d1.callback(None)
477
478 d1 = defer.Deferred()
479 s = backend.PubSubServiceFromBackend(TestBackend())
480 s.serviceJID = SERVICE
481 s.notifyDelete = notifyDelete
482 self.assertTrue(verifyObject(iwokkel.IPubSubService, s))
483 self.assertNotIdentical(None, s.backend.preDeleteFn)
484 data = {'nodeIdentifier': 'test'}
485 d2 = s.backend.preDeleteFn(data)
486 return defer.DeferredList([d1, d2], fireOnOneErrback=1)
487
488
489 def test_preDeleteRedirect(self):
490 """
491 Test pre-delete sending out notifications to subscribers.
492 """
493
494 uri = 'xmpp:%s?;node=test2' % (SERVICE.full(),)
495
496 class TestBackend(BaseTestBackend):
497 preDeleteFn = None
498
499 def registerPreDelete(self, preDeleteFn):
500 self.preDeleteFn = preDeleteFn
501
502 def getSubscribers(self, nodeIdentifier):
503 return defer.succeed([OWNER])
504
505 def notifyDelete(service, nodeIdentifier, subscribers,
506 redirectURI=None):
507 self.assertEqual(SERVICE, service)
508 self.assertEqual('test', nodeIdentifier)
509 self.assertEqual([OWNER], subscribers)
510 self.assertEqual(uri, redirectURI)
511 d1.callback(None)
512
513 d1 = defer.Deferred()
514 s = backend.PubSubServiceFromBackend(TestBackend())
515 s.serviceJID = SERVICE
516 s.notifyDelete = notifyDelete
517 self.assertTrue(verifyObject(iwokkel.IPubSubService, s))
518 self.assertNotIdentical(None, s.backend.preDeleteFn)
519 data = {'nodeIdentifier': 'test',
520 'redirectURI': uri}
521 d2 = s.backend.preDeleteFn(data)
522 return defer.DeferredList([d1, d2], fireOnOneErrback=1)
523
524
400 def test_unsubscribeNotSubscribed(self): 525 def test_unsubscribeNotSubscribed(self):
401 """ 526 """
402 Test unsubscription request when not subscribed. 527 Test unsubscription request when not subscribed.
403 """ 528 """
404 529
408 533
409 def cb(e): 534 def cb(e):
410 self.assertEquals('unexpected-request', e.condition) 535 self.assertEquals('unexpected-request', e.condition)
411 536
412 s = backend.PubSubServiceFromBackend(TestBackend()) 537 s = backend.PubSubServiceFromBackend(TestBackend())
413 d = s.unsubscribe(OWNER, 'test.example.org', 'test', OWNER) 538 d = s.unsubscribe(OWNER, SERVICE, 'test', OWNER)
414 self.assertFailure(d, StanzaError) 539 self.assertFailure(d, StanzaError)
415 d.addCallback(cb) 540 d.addCallback(cb)
416 return d 541 return d
417 542
418 543
433 self.assertEquals('leaf', info['type']) 558 self.assertEquals('leaf', info['type'])
434 self.assertIn('meta-data', info) 559 self.assertIn('meta-data', info)
435 self.assertEquals({'pubsub#persist_items': True}, info['meta-data']) 560 self.assertEquals({'pubsub#persist_items': True}, info['meta-data'])
436 561
437 s = backend.PubSubServiceFromBackend(TestBackend()) 562 s = backend.PubSubServiceFromBackend(TestBackend())
438 d = s.getNodeInfo(OWNER, 'test.example.org', 'test') 563 d = s.getNodeInfo(OWNER, SERVICE, 'test')
439 d.addCallback(cb) 564 d.addCallback(cb)
440 return d 565 return d
441 566
442 567
443 def test_getConfigurationOptions(self): 568 def test_getConfigurationOptions(self):
467 592
468 def cb(options): 593 def cb(options):
469 self.assertEquals(True, options["pubsub#persist_items"]) 594 self.assertEquals(True, options["pubsub#persist_items"])
470 595
471 s = backend.PubSubServiceFromBackend(TestBackend()) 596 s = backend.PubSubServiceFromBackend(TestBackend())
472 d = s.getDefaultConfiguration(OWNER, 'test.example.org', 'leaf') 597 d = s.getDefaultConfiguration(OWNER, SERVICE, 'leaf')
473 d.addCallback(cb) 598 d.addCallback(cb)
474 return d 599 return d