Mercurial > libervia-pubsub

comparison sat_pubsub/test/test_backend.py @ 414:ccb2a22ea0fc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Python 3 port: /!\ Python 3.6+ is now needed to use SàT Pubsub /!\ instability may occur and features may not be working anymore, this will improve with time The same procedure as in backend has been applied (check backend commit ab2696e34d29 logs for details). Python minimal version has been updated in setup.py
author Goffi <goffi@goffi.org>
date Fri, 16 Aug 2019 12:53:33 +0200
parents c56a728412f1
children 074037832daf
comparison
equal deleted inserted replaced
413:a5edf5e1dd74 414:ccb2a22ea0fc
103 self.assertFalse(self.storage.deleteCalled) 103 self.assertFalse(self.storage.deleteCalled)
104 preDeleteCalled.append(data) 104 preDeleteCalled.append(data)
105 return defer.succeed(None) 105 return defer.succeed(None)
106 106
107 def cb(result): 107 def cb(result):
108 self.assertEquals(1, len(preDeleteCalled)) 108 self.assertEqual(1, len(preDeleteCalled))
109 data = preDeleteCalled[-1] 109 data = preDeleteCalled[-1]
110 self.assertEquals('to-be-deleted', data['node'].nodeIdentifier) 110 self.assertEqual('to-be-deleted', data['node'].nodeIdentifier)
111 self.assertTrue(self.storage.deleteCalled) 111 self.assertTrue(self.storage.deleteCalled)
112 112
113 self.storage = TestStorage() 113 self.storage = TestStorage()
114 self.backend = backend.BackendService(self.storage) 114 self.backend = backend.BackendService(self.storage)
115 115
148 self.assertFalse(self.storage.deleteCalled) 148 self.assertFalse(self.storage.deleteCalled)
149 preDeleteCalled.append(data) 149 preDeleteCalled.append(data)
150 return defer.succeed(None) 150 return defer.succeed(None)
151 151
152 def cb(result): 152 def cb(result):
153 self.assertEquals(1, len(preDeleteCalled)) 153 self.assertEqual(1, len(preDeleteCalled))
154 data = preDeleteCalled[-1] 154 data = preDeleteCalled[-1]
155 self.assertEquals('to-be-deleted', data['node'].nodeIdentifier) 155 self.assertEqual('to-be-deleted', data['node'].nodeIdentifier)
156 self.assertEquals(uri, data['redirectURI']) 156 self.assertEqual(uri, data['redirectURI'])
157 self.assertTrue(self.storage.deleteCalled) 157 self.assertTrue(self.storage.deleteCalled)
158 158
159 self.storage = TestStorage() 159 self.storage = TestStorage()
160 self.backend = backend.BackendService(self.storage) 160 self.backend = backend.BackendService(self.storage)
161 161
215 class TestNode: 215 class TestNode:
216 def getSubscriptions(self, state=None): 216 def getSubscriptions(self, state=None):
217 return [sub] 217 return [sub]
218 218
219 def cb(result): 219 def cb(result):
220 self.assertEquals(1, len(result)) 220 self.assertEqual(1, len(result))
221 subscriber, subscriptions, items = result[-1] 221 subscriber, subscriptions, items = result[-1]
222 222
223 self.assertEquals(OWNER, subscriber) 223 self.assertEqual(OWNER, subscriber)
224 self.assertEquals({sub}, subscriptions) 224 self.assertEqual({sub}, subscriptions)
225 self.assertEquals([item], items) 225 self.assertEqual([item], items)
226 226
227 self.storage = self.NodeStore({'test': TestNode()}) 227 self.storage = self.NodeStore({'test': TestNode()})
228 self.backend = backend.BackendService(self.storage) 228 self.backend = backend.BackendService(self.storage)
229 d = self.backend.getNotifications('test', [item]) 229 d = self.backend.getNotifications('test', [item])
230 d.addCallback(cb) 230 d.addCallback(cb)
249 class TestRootNode: 249 class TestRootNode:
250 def getSubscriptions(self, state=None): 250 def getSubscriptions(self, state=None):
251 return [subRoot] 251 return [subRoot]
252 252
253 def cb(result): 253 def cb(result):
254 self.assertEquals(1, len(result)) 254 self.assertEqual(1, len(result))
255 subscriber, subscriptions, items = result[-1] 255 subscriber, subscriptions, items = result[-1]
256 self.assertEquals(OWNER, subscriber) 256 self.assertEqual(OWNER, subscriber)
257 self.assertEquals({subRoot}, subscriptions) 257 self.assertEqual({subRoot}, subscriptions)
258 self.assertEquals([item], items) 258 self.assertEqual([item], items)
259 259
260 self.storage = self.NodeStore({'test': TestNode(), 260 self.storage = self.NodeStore({'test': TestNode(),
261 '': TestRootNode()}) 261 '': TestRootNode()})
262 self.backend = backend.BackendService(self.storage) 262 self.backend = backend.BackendService(self.storage)
263 d = self.backend.getNotifications('test', [item]) 263 d = self.backend.getNotifications('test', [item])
281 class TestRootNode: 281 class TestRootNode:
282 def getSubscriptions(self, state=None): 282 def getSubscriptions(self, state=None):
283 return [subRoot] 283 return [subRoot]
284 284
285 def cb(result): 285 def cb(result):
286 self.assertEquals(1, len(result)) 286 self.assertEqual(1, len(result))
287 subscriber, subscriptions, items = result[-1] 287 subscriber, subscriptions, items = result[-1]
288 288
289 self.assertEquals(OWNER, subscriber) 289 self.assertEqual(OWNER, subscriber)
290 self.assertEquals({sub, subRoot}, subscriptions) 290 self.assertEqual({sub, subRoot}, subscriptions)
291 self.assertEquals([item], items) 291 self.assertEqual([item], items)
292 292
293 self.storage = self.NodeStore({'test': TestNode(), 293 self.storage = self.NodeStore({'test': TestNode(),
294 '': TestRootNode()}) 294 '': TestRootNode()})
295 self.backend = backend.BackendService(self.storage) 295 self.backend = backend.BackendService(self.storage)
296 d = self.backend.getNotifications('test', [item]) 296 d = self.backend.getNotifications('test', [item])
450 class TestStorage: 450 class TestStorage:
451 def getNode(self, nodeIdentifier): 451 def getNode(self, nodeIdentifier):
452 return defer.succeed(TestNode()) 452 return defer.succeed(TestNode())
453 453
454 def cb(data): 454 def cb(data):
455 self.assertEquals('node', data['node'].nodeIdentifier) 455 self.assertEqual('node', data['node'].nodeIdentifier)
456 self.assertEquals([ITEM], data['items']) 456 self.assertEqual([ITEM], data['items'])
457 self.assertEquals(OWNER, data['subscription'].subscriber) 457 self.assertEqual(OWNER, data['subscription'].subscriber)
458 458
459 self.storage = TestStorage() 459 self.storage = TestStorage()
460 self.backend = backend.BackendService(self.storage) 460 self.backend = backend.BackendService(self.storage)
461 self.storage.backend = self.backend 461 self.storage.backend = self.backend
462 462
614 class TestBackend(BaseTestBackend): 614 class TestBackend(BaseTestBackend):
615 def unsubscribe(self, nodeIdentifier, subscriber, requestor): 615 def unsubscribe(self, nodeIdentifier, subscriber, requestor):
616 return defer.fail(error.NotSubscribed()) 616 return defer.fail(error.NotSubscribed())
617 617
618 def cb(e): 618 def cb(e):
619 self.assertEquals('unexpected-request', e.condition) 619 self.assertEqual('unexpected-request', e.condition)
620 620
621 resource = backend.PubSubResourceFromBackend(TestBackend()) 621 resource = backend.PubSubResourceFromBackend(TestBackend())
622 request = pubsub.PubSubRequest() 622 request = pubsub.PubSubRequest()
623 request.sender = OWNER 623 request.sender = OWNER
624 request.recipient = SERVICE 624 request.recipient = SERVICE
642 def getNodeMetaData(self, nodeIdentifier): 642 def getNodeMetaData(self, nodeIdentifier):
643 return defer.succeed({'pubsub#persist_items': True}) 643 return defer.succeed({'pubsub#persist_items': True})
644 644
645 def cb(info): 645 def cb(info):
646 self.assertIn('type', info) 646 self.assertIn('type', info)
647 self.assertEquals('leaf', info['type']) 647 self.assertEqual('leaf', info['type'])
648 self.assertIn('meta-data', info) 648 self.assertIn('meta-data', info)
649 self.assertEquals({'pubsub#persist_items': True}, info['meta-data']) 649 self.assertEqual({'pubsub#persist_items': True}, info['meta-data'])
650 650
651 resource = backend.PubSubResourceFromBackend(TestBackend()) 651 resource = backend.PubSubResourceFromBackend(TestBackend())
652 d = resource.getInfo(OWNER, SERVICE, 'test') 652 d = resource.getInfo(OWNER, SERVICE, 'test')
653 d.addCallback(cb) 653 d.addCallback(cb)
654 return d 654 return d
678 "pubsub#send_last_published_item": 'on_sub', 678 "pubsub#send_last_published_item": 'on_sub',
679 } 679 }
680 return defer.succeed(options) 680 return defer.succeed(options)
681 681
682 def cb(options): 682 def cb(options):
683 self.assertEquals(True, options["pubsub#persist_items"]) 683 self.assertEqual(True, options["pubsub#persist_items"])
684 684
685 resource = backend.PubSubResourceFromBackend(TestBackend()) 685 resource = backend.PubSubResourceFromBackend(TestBackend())
686 request = pubsub.PubSubRequest() 686 request = pubsub.PubSubRequest()
687 request.sender = OWNER 687 request.sender = OWNER
688 request.recipient = SERVICE 688 request.recipient = SERVICE