Mercurial > libervia-pubsub
comparison idavoll/test/test_backend.py @ 209:7f3ffb7a1a9e
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 |