Mercurial > libervia-pubsub

comparison idavoll/test/test_storage.py @ 206:274a45d2a5ab

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Implement root collection that includes all leaf nodes.
author Ralph Meijer <ralphm@ik.nu>
date Mon, 04 Aug 2008 13:47:10 +0000
parents b4bf0a5ce50d
children bb7103da9879
comparison
equal deleted inserted replaced
205:e6b710bf2b24 206:274a45d2a5ab
3 3
4 """ 4 """
5 Tests for L{idavoll.memory_storage} and L{idavoll.pgsql_storage}. 5 Tests for L{idavoll.memory_storage} and L{idavoll.pgsql_storage}.
6 """ 6 """
7 7
8 from zope.interface.verify import verifyObject
8 from twisted.trial import unittest 9 from twisted.trial import unittest
9 from twisted.words.protocols.jabber import jid 10 from twisted.words.protocols.jabber import jid
10 from twisted.internet import defer 11 from twisted.internet import defer
11 from twisted.words.xish import domish 12 from twisted.words.xish import domish
12 13
13 from wokkel import pubsub 14 from wokkel import pubsub
14 15
15 from idavoll import error 16 from idavoll import error, iidavoll
16 17
17 OWNER = jid.JID('owner@example.com') 18 OWNER = jid.JID('owner@example.com')
18 SUBSCRIBER = jid.JID('subscriber@example.com/Home') 19 SUBSCRIBER = jid.JID('subscriber@example.com/Home')
19 SUBSCRIBER_NEW = jid.JID('new@example.com/Home') 20 SUBSCRIBER_NEW = jid.JID('new@example.com/Home')
20 SUBSCRIBER_TO_BE_DELETED = jid.JID('to_be_deleted@example.com/Home') 21 SUBSCRIBER_TO_BE_DELETED = jid.JID('to_be_deleted@example.com/Home')
21 SUBSCRIBER_PENDING = jid.JID('pending@example.com/Home') 22 SUBSCRIBER_PENDING = jid.JID('pending@example.com/Home')
22 PUBLISHER = jid.JID('publisher@example.com') 23 PUBLISHER = jid.JID('publisher@example.com')
23 ITEM = domish.Element((pubsub.NS_PUBSUB, 'item'), pubsub.NS_PUBSUB) 24 ITEM = domish.Element((None, 'item'))
24 ITEM['id'] = 'current' 25 ITEM['id'] = 'current'
25 ITEM.addElement(('testns', 'test'), content=u'Test \u2083 item') 26 ITEM.addElement(('testns', 'test'), content=u'Test \u2083 item')
26 ITEM_NEW = domish.Element((pubsub.NS_PUBSUB, 'item'), pubsub.NS_PUBSUB) 27 ITEM_NEW = domish.Element((None, 'item'))
27 ITEM_NEW['id'] = 'new' 28 ITEM_NEW['id'] = 'new'
28 ITEM_NEW.addElement(('testns', 'test'), content=u'Test \u2083 item') 29 ITEM_NEW.addElement(('testns', 'test'), content=u'Test \u2083 item')
29 ITEM_UPDATED = domish.Element((pubsub.NS_PUBSUB, 'item'), pubsub.NS_PUBSUB) 30 ITEM_UPDATED = domish.Element((None, 'item'))
30 ITEM_UPDATED['id'] = 'current' 31 ITEM_UPDATED['id'] = 'current'
31 ITEM_UPDATED.addElement(('testns', 'test'), content=u'Test \u2084 item') 32 ITEM_UPDATED.addElement(('testns', 'test'), content=u'Test \u2084 item')
32 ITEM_TO_BE_DELETED = domish.Element((pubsub.NS_PUBSUB, 'item'), 33 ITEM_TO_BE_DELETED = domish.Element((None, 'item'))
33 pubsub.NS_PUBSUB)
34 ITEM_TO_BE_DELETED['id'] = 'to-be-deleted' 34 ITEM_TO_BE_DELETED['id'] = 'to-be-deleted'
35 ITEM_TO_BE_DELETED.addElement(('testns', 'test'), content=u'Test \u2083 item') 35 ITEM_TO_BE_DELETED.addElement(('testns', 'test'), content=u'Test \u2083 item')
36 36
37 def decode(object): 37 def decode(object):
38 if isinstance(object, str): 38 if isinstance(object, str):
51 d = self.s.getNode('pre-existing') 51 d = self.s.getNode('pre-existing')
52 d.addCallback(self._assignTestNode) 52 d.addCallback(self._assignTestNode)
53 return d 53 return d
54 54
55 55
56 def test_interfaceIStorage(self):
57 self.assertTrue(verifyObject(iidavoll.IStorage, self.s))
58
59
60 def test_interfaceINode(self):
61 self.assertTrue(verifyObject(iidavoll.INode, self.node))
62
63
64 def test_interfaceILeafNode(self):
65 self.assertTrue(verifyObject(iidavoll.ILeafNode, self.node))
66
67
56 def test_getNode(self): 68 def test_getNode(self):
57 return self.s.getNode('pre-existing') 69 return self.s.getNode('pre-existing')
58 70
59 71
60 def test_getNonExistingNode(self): 72 def test_getNonExistingNode(self):
70 82
71 return self.s.getNodeIds().addCallback(cb) 83 return self.s.getNodeIds().addCallback(cb)
72 84
73 85
74 def test_createExistingNode(self): 86 def test_createExistingNode(self):
75 d = self.s.createNode('pre-existing', OWNER) 87 config = self.s.getDefaultConfiguration('leaf')
88 config['pubsub#node_type'] = 'leaf'
89 d = self.s.createNode('pre-existing', OWNER, config)
76 self.assertFailure(d, error.NodeExists) 90 self.assertFailure(d, error.NodeExists)
77 return d 91 return d
78 92
79 93
80 def test_createNode(self): 94 def test_createNode(self):
81 def cb(void): 95 def cb(void):
82 d = self.s.getNode('new 1') 96 d = self.s.getNode('new 1')
83 return d 97 return d
84 98
85 d = self.s.createNode('new 1', OWNER) 99 config = self.s.getDefaultConfiguration('leaf')
100 config['pubsub#node_type'] = 'leaf'
101 d = self.s.createNode('new 1', OWNER, config)
86 d.addCallback(cb) 102 d.addCallback(cb)
87 return d 103 return d
88 104
89 105
90 def test_deleteNonExistingNode(self): 106 def test_deleteNonExistingNode(self):
113 return d 129 return d
114 130
115 131
116 def test_getSubscriptions(self): 132 def test_getSubscriptions(self):
117 def cb(subscriptions): 133 def cb(subscriptions):
118 self.assertIn(('pre-existing', SUBSCRIBER, 'subscribed'), subscriptions) 134 found = False
135 for subscription in subscriptions:
136 if (subscription.nodeIdentifier == 'pre-existing' and
137 subscription.subscriber == SUBSCRIBER and
138 subscription.state == 'subscribed'):
139 found = True
140 self.assertTrue(found)
119 141
120 d = self.s.getSubscriptions(SUBSCRIBER) 142 d = self.s.getSubscriptions(SUBSCRIBER)
121 d.addCallback(cb) 143 d.addCallback(cb)
122 return d 144 return d
123 145
190 212
191 def test_addSubscription(self): 213 def test_addSubscription(self):
192 def cb1(void): 214 def cb1(void):
193 return self.node.getSubscription(SUBSCRIBER_NEW) 215 return self.node.getSubscription(SUBSCRIBER_NEW)
194 216
195 def cb2(state): 217 def cb2(subscription):
196 self.assertEqual(state, 'pending') 218 self.assertEqual(subscription.state, 'pending')
197 219
198 d = self.node.addSubscription(SUBSCRIBER_NEW, 'pending') 220 d = self.node.addSubscription(SUBSCRIBER_NEW, 'pending', {})
199 d.addCallback(cb1) 221 d.addCallback(cb1)
200 d.addCallback(cb2) 222 d.addCallback(cb2)
201 return d 223 return d
202 224
203 225
204 def test_addExistingSubscription(self): 226 def test_addExistingSubscription(self):
205 d = self.node.addSubscription(SUBSCRIBER, 'pending') 227 d = self.node.addSubscription(SUBSCRIBER, 'pending', {})
206 self.assertFailure(d, error.SubscriptionExists) 228 self.assertFailure(d, error.SubscriptionExists)
207 return d 229 return d
208 230
209 231
210 def test_getSubscription(self): 232 def test_getSubscription(self):
211 def cb(subscriptions): 233 def cb(subscriptions):
212 self.assertEquals(subscriptions[0][1], 'subscribed') 234 self.assertEquals(subscriptions[0].state, 'subscribed')
213 self.assertEquals(subscriptions[1][1], 'pending') 235 self.assertEquals(subscriptions[1].state, 'pending')
214 self.assertEquals(subscriptions[2][1], None) 236 self.assertEquals(subscriptions[2], None)
215 237
216 d = defer.DeferredList([self.node.getSubscription(SUBSCRIBER), 238 d = defer.gatherResults([self.node.getSubscription(SUBSCRIBER),
217 self.node.getSubscription(SUBSCRIBER_PENDING), 239 self.node.getSubscription(SUBSCRIBER_PENDING),
218 self.node.getSubscription(OWNER)]) 240 self.node.getSubscription(OWNER)])
219 d.addCallback(cb) 241 d.addCallback(cb)
220 return d 242 return d
221 243
222 244
223 def test_removeSubscription(self): 245 def test_removeSubscription(self):
228 d = self.node.removeSubscription(OWNER) 250 d = self.node.removeSubscription(OWNER)
229 self.assertFailure(d, error.NotSubscribed) 251 self.assertFailure(d, error.NotSubscribed)
230 return d 252 return d
231 253
232 254
233 def test_getSubscribers(self): 255 def test_getNodeSubscriptions(self):
256 def extractSubscribers(subscriptions):
257 return [subscription.subscriber for subscription in subscriptions]
258
234 def cb(subscribers): 259 def cb(subscribers):
235 self.assertIn(SUBSCRIBER, subscribers) 260 self.assertIn(SUBSCRIBER, subscribers)
236 self.assertNotIn(SUBSCRIBER_PENDING, subscribers) 261 self.assertNotIn(SUBSCRIBER_PENDING, subscribers)
237 self.assertNotIn(OWNER, subscribers) 262 self.assertNotIn(OWNER, subscribers)
238 263
239 d = self.node.getSubscribers() 264 d = self.node.getSubscriptions('subscribed')
265 d.addCallback(extractSubscribers)
240 d.addCallback(cb) 266 d.addCallback(cb)
241 return d 267 return d
242 268
243 269
244 def test_isSubscriber(self): 270 def test_isSubscriber(self):
379 405
380 class MemoryStorageStorageTestCase(unittest.TestCase, StorageTests): 406 class MemoryStorageStorageTestCase(unittest.TestCase, StorageTests):
381 407
382 def setUp(self): 408 def setUp(self):
383 from idavoll.memory_storage import Storage, PublishedItem, LeafNode 409 from idavoll.memory_storage import Storage, PublishedItem, LeafNode
384 from idavoll.memory_storage import Subscription, defaultConfig 410 from idavoll.memory_storage import Subscription
411
412 defaultConfig = Storage.defaultConfig['leaf']
385 413
386 self.s = Storage() 414 self.s = Storage()
387 self.s._nodes['pre-existing'] = \ 415 self.s._nodes['pre-existing'] = \
388 LeafNode('pre-existing', OWNER, defaultConfig) 416 LeafNode('pre-existing', OWNER, defaultConfig)
389 self.s._nodes['to-be-deleted'] = \ 417 self.s._nodes['to-be-deleted'] = \
392 LeafNode('to-be-reconfigured', OWNER, defaultConfig) 420 LeafNode('to-be-reconfigured', OWNER, defaultConfig)
393 self.s._nodes['to-be-purged'] = \ 421 self.s._nodes['to-be-purged'] = \
394 LeafNode('to-be-purged', OWNER, None) 422 LeafNode('to-be-purged', OWNER, None)
395 423
396 subscriptions = self.s._nodes['pre-existing']._subscriptions 424 subscriptions = self.s._nodes['pre-existing']._subscriptions
397 subscriptions[SUBSCRIBER.full()] = Subscription('subscribed') 425 subscriptions[SUBSCRIBER.full()] = Subscription('pre-existing',
426 SUBSCRIBER,
427 'subscribed')
398 subscriptions[SUBSCRIBER_TO_BE_DELETED.full()] = \ 428 subscriptions[SUBSCRIBER_TO_BE_DELETED.full()] = \
399 Subscription('subscribed') 429 Subscription('pre-existing', SUBSCRIBER_TO_BE_DELETED,
430 'subscribed')
400 subscriptions[SUBSCRIBER_PENDING.full()] = \ 431 subscriptions[SUBSCRIBER_PENDING.full()] = \
401 Subscription('pending') 432 Subscription('pre-existing', SUBSCRIBER_PENDING,
433 'pending')
402 434
403 item = PublishedItem(ITEM_TO_BE_DELETED, PUBLISHER) 435 item = PublishedItem(ITEM_TO_BE_DELETED, PUBLISHER)
404 self.s._nodes['pre-existing']._items['to-be-deleted'] = item 436 self.s._nodes['pre-existing']._items['to-be-deleted'] = item
405 self.s._nodes['pre-existing']._itemlist.append(item) 437 self.s._nodes['pre-existing']._itemlist.append(item)
406 self.s._nodes['to-be-purged']._items['to-be-deleted'] = item 438 self.s._nodes['to-be-purged']._items['to-be-deleted'] = item
434 return self.dbpool.runInteraction(self.cleandb) 466 return self.dbpool.runInteraction(self.cleandb)
435 467
436 468
437 def init(self, cursor): 469 def init(self, cursor):
438 self.cleandb(cursor) 470 self.cleandb(cursor)
439 cursor.execute("""INSERT INTO nodes (node) VALUES ('pre-existing')""") 471 cursor.execute("""INSERT INTO nodes
472 (node, node_type, persist_items)
473 VALUES ('pre-existing', 'leaf', TRUE)""")
440 cursor.execute("""INSERT INTO nodes (node) VALUES ('to-be-deleted')""") 474 cursor.execute("""INSERT INTO nodes (node) VALUES ('to-be-deleted')""")
441 cursor.execute("""INSERT INTO nodes (node) VALUES ('to-be-reconfigured')""") 475 cursor.execute("""INSERT INTO nodes (node) VALUES ('to-be-reconfigured')""")
442 cursor.execute("""INSERT INTO nodes (node) VALUES ('to-be-purged')""") 476 cursor.execute("""INSERT INTO nodes (node) VALUES ('to-be-purged')""")
443 cursor.execute("""INSERT INTO entities (jid) VALUES (%s)""", 477 cursor.execute("""INSERT INTO entities (jid) VALUES (%s)""",
444 OWNER.userhost()) 478 OWNER.userhost())
445 cursor.execute("""INSERT INTO affiliations 479 cursor.execute("""INSERT INTO affiliations
446 (node_id, entity_id, affiliation) 480 (node_id, entity_id, affiliation)
447 SELECT nodes.id, entities.id, 'owner' 481 SELECT node_id, entity_id, 'owner'
448 FROM nodes, entities 482 FROM nodes, entities
449 WHERE node='pre-existing' AND jid=%s""", 483 WHERE node='pre-existing' AND jid=%s""",
450 OWNER.userhost()) 484 OWNER.userhost())
451 cursor.execute("""INSERT INTO entities (jid) VALUES (%s)""", 485 cursor.execute("""INSERT INTO entities (jid) VALUES (%s)""",
452 SUBSCRIBER.userhost()) 486 SUBSCRIBER.userhost())
453 cursor.execute("""INSERT INTO subscriptions 487 cursor.execute("""INSERT INTO subscriptions
454 (node_id, entity_id, resource, subscription) 488 (node_id, entity_id, resource, state)
455 SELECT nodes.id, entities.id, %s, 'subscribed' 489 SELECT node_id, entity_id, %s, 'subscribed'
456 FROM nodes, entities 490 FROM nodes, entities
457 WHERE node='pre-existing' AND jid=%s""", 491 WHERE node='pre-existing' AND jid=%s""",
458 (SUBSCRIBER.resource, 492 (SUBSCRIBER.resource,
459 SUBSCRIBER.userhost())) 493 SUBSCRIBER.userhost()))
460 cursor.execute("""INSERT INTO entities (jid) VALUES (%s)""", 494 cursor.execute("""INSERT INTO entities (jid) VALUES (%s)""",
461 SUBSCRIBER_TO_BE_DELETED.userhost()) 495 SUBSCRIBER_TO_BE_DELETED.userhost())
462 cursor.execute("""INSERT INTO subscriptions 496 cursor.execute("""INSERT INTO subscriptions
463 (node_id, entity_id, resource, subscription) 497 (node_id, entity_id, resource, state)
464 SELECT nodes.id, entities.id, %s, 'subscribed' 498 SELECT node_id, entity_id, %s, 'subscribed'
465 FROM nodes, entities 499 FROM nodes, entities
466 WHERE node='pre-existing' AND jid=%s""", 500 WHERE node='pre-existing' AND jid=%s""",
467 (SUBSCRIBER_TO_BE_DELETED.resource, 501 (SUBSCRIBER_TO_BE_DELETED.resource,
468 SUBSCRIBER_TO_BE_DELETED.userhost())) 502 SUBSCRIBER_TO_BE_DELETED.userhost()))
469 cursor.execute("""INSERT INTO entities (jid) VALUES (%s)""", 503 cursor.execute("""INSERT INTO entities (jid) VALUES (%s)""",
470 SUBSCRIBER_PENDING.userhost()) 504 SUBSCRIBER_PENDING.userhost())
471 cursor.execute("""INSERT INTO subscriptions 505 cursor.execute("""INSERT INTO subscriptions
472 (node_id, entity_id, resource, subscription) 506 (node_id, entity_id, resource, state)
473 SELECT nodes.id, entities.id, %s, 'pending' 507 SELECT node_id, entity_id, %s, 'pending'
474 FROM nodes, entities 508 FROM nodes, entities
475 WHERE node='pre-existing' AND jid=%s""", 509 WHERE node='pre-existing' AND jid=%s""",
476 (SUBSCRIBER_PENDING.resource, 510 (SUBSCRIBER_PENDING.resource,
477 SUBSCRIBER_PENDING.userhost())) 511 SUBSCRIBER_PENDING.userhost()))
478 cursor.execute("""INSERT INTO entities (jid) VALUES (%s)""", 512 cursor.execute("""INSERT INTO entities (jid) VALUES (%s)""",
479 PUBLISHER.userhost()) 513 PUBLISHER.userhost())
480 cursor.execute("""INSERT INTO items 514 cursor.execute("""INSERT INTO items
481 (node_id, publisher, item, data, date) 515 (node_id, publisher, item, data, date)
482 SELECT nodes.id, %s, 'to-be-deleted', %s, 516 SELECT node_id, %s, 'to-be-deleted', %s,
483 now() - interval '1 day' 517 now() - interval '1 day'
484 FROM nodes 518 FROM nodes
485 WHERE node='pre-existing'""", 519 WHERE node='pre-existing'""",
486 (PUBLISHER.userhost(), 520 (PUBLISHER.userhost(),
487 ITEM_TO_BE_DELETED.toXml())) 521 ITEM_TO_BE_DELETED.toXml()))
488 cursor.execute("""INSERT INTO items (node_id, publisher, item, data) 522 cursor.execute("""INSERT INTO items (node_id, publisher, item, data)
489 SELECT nodes.id, %s, 'to-be-deleted', %s 523 SELECT node_id, %s, 'to-be-deleted', %s
490 FROM nodes 524 FROM nodes
491 WHERE node='to-be-purged'""", 525 WHERE node='to-be-purged'""",
492 (PUBLISHER.userhost(), 526 (PUBLISHER.userhost(),
493 ITEM_TO_BE_DELETED.toXml())) 527 ITEM_TO_BE_DELETED.toXml()))
494 cursor.execute("""INSERT INTO items (node_id, publisher, item, data) 528 cursor.execute("""INSERT INTO items (node_id, publisher, item, data)
495 SELECT nodes.id, %s, 'current', %s 529 SELECT node_id, %s, 'current', %s
496 FROM nodes 530 FROM nodes
497 WHERE node='pre-existing'""", 531 WHERE node='pre-existing'""",
498 (PUBLISHER.userhost(), 532 (PUBLISHER.userhost(),
499 ITEM.toXml())) 533 ITEM.toXml()))
500 534