Mercurial > libervia-backend

comparison src/tmp/wokkel/test/test_rsm.py @ 1438:0fb5785b4c63

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add tests for sat.tmp.wokkel
author souliane <souliane@mailoo.org>
date Tue, 14 Jul 2015 15:22:02 +0200
parents
children ec764bfb146d
comparison
equal deleted inserted replaced
1437:a568fc14ab46 1438:0fb5785b4c63
1 # Copyright (c) Adrien Cossa.
2 # See LICENSE for details.
3
4 """
5 Tests for L{wokkel.rsm}.
6 """
7
8 from zope.interface import verify
9
10 from twisted.trial import unittest
11 from twisted.words.xish import domish
12 from twisted.words.protocols.jabber.jid import JID
13 from twisted.words.protocols.jabber.xmlstream import toResponse
14 from twisted.internet import defer
15
16 from wokkel.generic import parseXml
17 from wokkel import iwokkel
18 from wokkel.test.helpers import XmlStreamStub, TestableRequestHandlerMixin
19
20 from sat.tmp.wokkel import pubsub
21 from sat.tmp.wokkel.rsm import NS_RSM, RSMRequest, RSMResponse, PubSubClient, PubSubService
22
23 import uuid
24
25
26 class RSMRequestTest(unittest.TestCase):
27 """
28 Tests for L{rsm.RSMRequest}.
29 """
30
31 def test___init__(self):
32 """
33 Fail to initialize a RSMRequest with wrong attribute values.
34 """
35 self.assertRaises(AssertionError, RSMRequest, index=371, after=u'test')
36 self.assertRaises(AssertionError, RSMRequest, index=371, before=u'test')
37 self.assertRaises(AssertionError, RSMRequest, before=117)
38 self.assertRaises(AssertionError, RSMRequest, after=312)
39 self.assertRaises(AssertionError, RSMRequest, after=u'117', before=u'312')
40
41 def test_parse(self):
42 """
43 Parse a request element asking for the first page.
44 """
45 xml = """
46 <query xmlns='jabber:iq:search'>
47 <nick>Pete</nick>
48 <set xmlns='http://jabber.org/protocol/rsm'>
49 <max>1</max>
50 </set>
51 </query>
52 """
53 request = RSMRequest.parse(parseXml(xml))
54 self.assertEqual(1, request.max)
55 self.assertIdentical(None, request.index)
56 self.assertIdentical(None, request.after)
57 self.assertIdentical(None, request.before)
58
59 def test_parseSecondPage(self):
60 """
61 Parse a request element asking for a next page.
62 """
63 xml = """
64 <query xmlns='jabber:iq:search'>
65 <nick>Pete</nick>
66 <set xmlns='http://jabber.org/protocol/rsm'>
67 <max>3</max>
68 <after>peterpan@neverland.lit</after>
69 </set>
70 </query>
71 """
72 request = RSMRequest.parse(parseXml(xml))
73 self.assertEqual(3, request.max)
74 self.assertIdentical(None, request.index)
75 self.assertEqual(u'peterpan@neverland.lit', request.after)
76 self.assertIdentical(None, request.before)
77
78 def test_parsePreviousPage(self):
79 """
80 Parse a request element asking for a previous page.
81 """
82 xml = """
83 <query xmlns='jabber:iq:search'>
84 <nick>Pete</nick>
85 <set xmlns='http://jabber.org/protocol/rsm'>
86 <max>5</max>
87 <before>peterpan@pixyland.org</before>
88 </set>
89 </query>
90 """
91 request = RSMRequest.parse(parseXml(xml))
92 self.assertEqual(5, request.max)
93 self.assertIdentical(None, request.index)
94 self.assertIdentical(None, request.after)
95 self.assertEqual(u'peterpan@pixyland.org', request.before)
96
97 def test_parseLastPage(self):
98 """
99 Parse a request element asking for the last page.
100 """
101 xml = """
102 <query xmlns='jabber:iq:search'>
103 <nick>Pete</nick>
104 <set xmlns='http://jabber.org/protocol/rsm'>
105 <max>7</max>
106 <before/>
107 </set>
108 </query>
109 """
110 request = RSMRequest.parse(parseXml(xml))
111 self.assertEqual(7, request.max)
112 self.assertIdentical(None, request.index)
113 self.assertIdentical(None, request.after)
114 self.assertEqual('', request.before)
115
116 def test_parseOutOfOrderPage(self):
117 """
118 Parse a request element asking for a page out of order.
119 """
120 xml = """
121 <query xmlns='jabber:iq:search'>
122 <nick>Pete</nick>
123 <set xmlns='http://jabber.org/protocol/rsm'>
124 <max>9</max>
125 <index>371</index>
126 </set>
127 </query>
128 """
129 request = RSMRequest.parse(parseXml(xml))
130 self.assertEqual(9, request.max)
131 self.assertEqual(371, request.index)
132 self.assertIdentical(None, request.after)
133 self.assertIdentical(None, request.before)
134
135 def test_parseItemCount(self):
136 """
137 Parse a request element asking for the items count.
138 """
139 xml = """
140 <query xmlns='jabber:iq:search'>
141 <nick>Pete</nick>
142 <set xmlns='http://jabber.org/protocol/rsm'>
143 <max>0</max>
144 </set>
145 </query>
146 """
147 request = RSMRequest.parse(parseXml(xml))
148 self.assertEqual(0, request.max)
149 self.assertIdentical(None, request.index)
150 self.assertIdentical(None, request.after)
151 self.assertIdentical(None, request.before)
152
153 def test_render(self):
154 """
155 Embed a page request in the element.
156 """
157 element = domish.Element(('jabber:iq:search', 'query'))
158 element.addElement('items')['max_items'] = u'10'
159 RSMRequest(1).render(element)
160
161 self.assertEqual(u'10', element.items['max_items']) # not changed
162
163 self.assertEqual(NS_RSM, element.set.uri)
164 self.assertEqual(u'1', ''.join(element.set.max.children))
165 self.assertIdentical(None, element.set.after)
166 self.assertIdentical(None, element.set.before)
167 self.assertIdentical(None, element.set.index)
168
169 def test_renderPubSub(self):
170 """
171 Embed a page request in the pubsub element.
172 """
173 element = domish.Element((pubsub.NS_PUBSUB, 'pubsub'))
174 element.addElement('items')['max_items'] = u'10'
175 RSMRequest(3).render(element)
176
177 self.assertEqual(u'3', element.items['max_items']) # changed
178
179 self.assertEqual(NS_RSM, element.set.uri)
180 self.assertEqual(u'3', ''.join(element.set.max.children))
181 self.assertIdentical(None, element.set.after)
182 self.assertIdentical(None, element.set.before)
183 self.assertIdentical(None, element.set.index)
184
185 def test_renderItems(self):
186 """
187 Embed a page request in the element, specify items.
188 """
189 element = domish.Element(('jabber:iq:search', 'query'))
190 RSMRequest(5, 127).render(element)
191 self.assertEqual(NS_RSM, element.set.uri)
192 self.assertEqual(u'5', ''.join(element.set.max.children))
193 self.assertIdentical(None, element.set.after)
194 self.assertIdentical(None, element.set.before)
195 self.assertEqual(u'127', ''.join(element.set.index.children))
196
197 def test_renderAfter(self):
198 """
199 Embed a page request in the element, specify after.
200 """
201 element = domish.Element(('jabber:iq:search', 'query'))
202 RSMRequest(5, after=u'test').render(element)
203 self.assertEqual(NS_RSM, element.set.uri)
204 self.assertEqual(u'5', ''.join(element.set.max.children))
205 self.assertEqual(u'test', ''.join(element.set.after.children))
206 self.assertIdentical(None, element.set.before)
207 self.assertIdentical(None, element.set.index)
208
209 def test_renderBefore(self):
210 """
211 Embed a page request in the element, specify before.
212 """
213 element = domish.Element(('jabber:iq:search', 'query'))
214 RSMRequest(5, before=u'test').render(element)
215 self.assertEqual(NS_RSM, element.set.uri)
216 self.assertEqual(u'5', ''.join(element.set.max.children))
217 self.assertIdentical(None, element.set.after)
218 self.assertEqual(u'test', ''.join(element.set.before.children))
219 self.assertIdentical(None, element.set.index)
220
221
222 class RSMResponseTest(unittest.TestCase):
223 """
224 Tests for L{rsm.RSMResponse}.
225 """
226
227 def test___init__(self):
228 """
229 Fail to initialize a RSMResponse with wrong attribute values.
230 """
231 self.assertRaises(AssertionError, RSMResponse, count=u'1')
232 self.assertRaises(AssertionError, RSMResponse, index=127, first=u'127')
233 self.assertRaises(AssertionError, RSMResponse, index=127, last=u'351')
234 self.assertRaises(AssertionError, RSMResponse, first=u'127', last=u'351')
235 self.assertRaises(AssertionError, RSMResponse, index=u'127',
236 first=u'127', last=u'351')
237 self.assertRaises(AssertionError, RSMResponse, index=127,
238 first=127, last=u'351')
239 self.assertRaises(AssertionError, RSMResponse, index=127,
240 first=u'127', last=351)
241
242 def test_parse(self):
243 """
244 Parse a response element returning a page.
245 """
246 xml = """
247 <query xmlns='jabber:iq:search'>
248 <set xmlns='http://jabber.org/protocol/rsm'>
249 <first index='20'>stpeter@jabber.org</first>
250 <last>peterpan@neverland.lit</last>
251 <count>800</count>
252 </set>
253 </query>
254 """
255 response = RSMResponse.parse(parseXml(xml))
256 self.assertEqual(800, response.count)
257 self.assertEqual(20, response.index)
258 self.assertEqual(u'stpeter@jabber.org', response.first)
259 self.assertEqual(u'peterpan@neverland.lit', response.last)
260
261 def test_parseEmptySet(self):
262 """
263 Parse a response element returning an empty set.
264 """
265 xml = """
266 <query xmlns='jabber:iq:search'>
267 <set xmlns='http://jabber.org/protocol/rsm'>
268 <count>800</count>
269 </set>
270 </query>
271 """
272 response = RSMResponse.parse(parseXml(xml))
273 self.assertEqual(800, response.count)
274 self.assertIdentical(None, response.first)
275 self.assertIdentical(None, response.last)
276 self.assertIdentical(None, response.index)
277
278 def test_render(self):
279 """
280 Embed a page response in the element.
281 """
282 element = domish.Element(('jabber:iq:search', 'query'))
283 RSMResponse(800, 20, u'stpeter@jabber.org',
284 u'peterpan@neverland.lit').render(element)
285
286 self.assertEqual(NS_RSM, element.set.uri)
287 self.assertEqual(u'800', ''.join(element.set.count.children))
288 self.assertEqual(u'stpeter@jabber.org',
289 ''.join(element.set.first.children))
290 self.assertEqual(u'peterpan@neverland.lit',
291 ''.join(element.set.last.children))
292 self.assertEqual(u'20', element.set.first['index'])
293
294 def test_renderEmptySet(self):
295 """
296 Embed a page response in the element, for empty set.
297 """
298 element = domish.Element(('jabber:iq:search', 'query'))
299 RSMResponse(800).render(element)
300
301 self.assertEqual(NS_RSM, element.set.uri)
302 self.assertEqual(u'800', ''.join(element.set.count.children))
303 self.assertIdentical(None, element.set.first)
304 self.assertIdentical(None, element.set.last)
305
306
307 class PubSubClientTest(unittest.TestCase):
308 """
309 Tests for L{rsm.PubSubClient}.
310 """
311 timeout = 2
312
313 def setUp(self):
314 self.stub = XmlStreamStub()
315 self.protocol = PubSubClient()
316 self.protocol.xmlstream = self.stub.xmlstream
317 self.protocol.connectionInitialized()
318
319 def test_items(self):
320 """
321 Test sending items request to get the first page.
322 """
323 def cb(items):
324 self.assertEquals(2, len(items))
325 self.assertEquals([item1, item2], items)
326 rsm = self.protocol.getRSMResponse(ext_data['id'])
327 self.assertDictEqual(rsm, {'count': '800', 'index': '0',
328 'first': 'item1', 'last': 'item2'})
329
330 ext_data = {'id': unicode(uuid.uuid4()), 'rsm': RSMRequest(2)}
331 d = self.protocol.items(JID('pubsub.example.org'), 'test',
332 ext_data=ext_data)
333 d.addCallback(cb)
334
335 iq = self.stub.output[-1]
336 self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
337 self.assertEquals('get', iq.getAttribute('type'))
338 self.assertEquals('pubsub', iq.pubsub.name)
339 self.assertEquals(pubsub.NS_PUBSUB, iq.pubsub.uri)
340 children = list(domish.generateElementsQNamed(iq.pubsub.children,
341 'items', pubsub.NS_PUBSUB))
342 self.assertEquals(1, len(children))
343 child = children[0]
344 self.assertEquals('test', child['node'])
345
346 set_elts = list(domish.generateElementsQNamed(iq.pubsub.children,
347 'set', NS_RSM))
348 self.assertEquals(1, len(set_elts))
349 set_elt = set_elts[0]
350 self.assertEquals(u'2', ''.join(set_elt.max.children))
351
352 response = toResponse(iq, 'result')
353 items = response.addElement((pubsub.NS_PUBSUB,
354 'pubsub')).addElement('items')
355 items['node'] = 'test'
356 item1 = items.addElement('item')
357 item1['id'] = 'item1'
358 item2 = items.addElement('item')
359 item2['id'] = 'item2'
360 RSMResponse(800, 0, u'item1', u'item2').render(response.pubsub)
361 self.stub.send(response)
362
363 return d
364
365 def test_itemsAfter(self):
366 """
367 Test sending items request to get the next page.
368 """
369 def cb(items):
370 self.assertEquals(2, len(items))
371 self.assertEquals([item1, item2], items)
372 rsm = self.protocol.getRSMResponse(ext_data['id'])
373 self.assertDictEqual(rsm, {'count': '800', 'index': '2',
374 'first': 'item3', 'last': 'item4'})
375
376 ext_data = {'id': unicode(uuid.uuid4()),
377 'rsm': RSMRequest(2, after=u'item2')}
378 d = self.protocol.items(JID('pubsub.example.org'), 'test',
379 ext_data=ext_data)
380 d.addCallback(cb)
381
382 iq = self.stub.output[-1]
383 self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
384 self.assertEquals('get', iq.getAttribute('type'))
385 self.assertEquals('pubsub', iq.pubsub.name)
386 self.assertEquals(pubsub.NS_PUBSUB, iq.pubsub.uri)
387 children = list(domish.generateElementsQNamed(iq.pubsub.children,
388 'items', pubsub.NS_PUBSUB))
389 self.assertEquals(1, len(children))
390 child = children[0]
391 self.assertEquals('test', child['node'])
392
393 set_elts = list(domish.generateElementsQNamed(iq.pubsub.children,
394 'set', NS_RSM))
395 self.assertEquals(1, len(set_elts))
396 set_elt = set_elts[0]
397 self.assertEquals(u'2', ''.join(set_elt.max.children))
398 self.assertEquals(u'item2', ''.join(set_elt.after.children))
399
400 response = toResponse(iq, 'result')
401 items = response.addElement((pubsub.NS_PUBSUB,
402 'pubsub')).addElement('items')
403 items['node'] = 'test'
404 item1 = items.addElement('item')
405 item1['id'] = 'item3'
406 item2 = items.addElement('item')
407 item2['id'] = 'item4'
408 RSMResponse(800, 2, u'item3', u'item4').render(response.pubsub)
409 self.stub.send(response)
410
411 return d
412
413 def test_itemsBefore(self):
414 """
415 Test sending items request to get the previous page.
416 """
417 def cb(items):
418 self.assertEquals(2, len(items))
419 self.assertEquals([item1, item2], items)
420 rsm = self.protocol.getRSMResponse(ext_data['id'])
421 self.assertDictEqual(rsm, {'count': '800', 'index': '0',
422 'first': 'item1', 'last': 'item2'})
423
424 ext_data = {'id': unicode(uuid.uuid4()),
425 'rsm': RSMRequest(2, before=u'item3')}
426 d = self.protocol.items(JID('pubsub.example.org'), 'test',
427 ext_data=ext_data)
428 d.addCallback(cb)
429
430 iq = self.stub.output[-1]
431 self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
432 self.assertEquals('get', iq.getAttribute('type'))
433 self.assertEquals('pubsub', iq.pubsub.name)
434 self.assertEquals(pubsub.NS_PUBSUB, iq.pubsub.uri)
435 children = list(domish.generateElementsQNamed(iq.pubsub.children,
436 'items', pubsub.NS_PUBSUB))
437 self.assertEquals(1, len(children))
438 child = children[0]
439 self.assertEquals('test', child['node'])
440
441 set_elts = list(domish.generateElementsQNamed(iq.pubsub.children,
442 'set', NS_RSM))
443 self.assertEquals(1, len(set_elts))
444 set_elt = set_elts[0]
445 self.assertEquals(u'2', ''.join(set_elt.max.children))
446 self.assertEquals(u'item3', ''.join(set_elt.before.children))
447
448 response = toResponse(iq, 'result')
449 items = response.addElement((pubsub.NS_PUBSUB,
450 'pubsub')).addElement('items')
451 items['node'] = 'test'
452 item1 = items.addElement('item')
453 item1['id'] = 'item1'
454 item2 = items.addElement('item')
455 item2['id'] = 'item2'
456 RSMResponse(800, 0, u'item1', u'item2').render(response.pubsub)
457 self.stub.send(response)
458
459 return d
460
461 def test_itemsIndex(self):
462 """
463 Test sending items request to get a page out of order.
464 """
465 def cb(items):
466 self.assertEquals(3, len(items))
467 self.assertEquals([item1, item2, item3], items)
468 rsm = self.protocol.getRSMResponse(ext_data['id'])
469 self.assertDictEqual(rsm, {'count': '800', 'index': '3',
470 'first': 'item4', 'last': 'item6'})
471
472 ext_data = {'id': unicode(uuid.uuid4()), 'rsm': RSMRequest(3, 3)}
473 d = self.protocol.items(JID('pubsub.example.org'), 'test',
474 ext_data=ext_data)
475 d.addCallback(cb)
476
477 iq = self.stub.output[-1]
478 self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
479 self.assertEquals('get', iq.getAttribute('type'))
480 self.assertEquals('pubsub', iq.pubsub.name)
481 self.assertEquals(pubsub.NS_PUBSUB, iq.pubsub.uri)
482 children = list(domish.generateElementsQNamed(iq.pubsub.children,
483 'items', pubsub.NS_PUBSUB))
484 self.assertEquals(1, len(children))
485 child = children[0]
486 self.assertEquals('test', child['node'])
487
488 set_elts = list(domish.generateElementsQNamed(iq.pubsub.children,
489 'set', NS_RSM))
490 self.assertEquals(1, len(set_elts))
491 set_elt = set_elts[0]
492 self.assertEquals(u'3', ''.join(set_elt.max.children))
493 self.assertEquals(u'3', ''.join(set_elt.index.children))
494
495 response = toResponse(iq, 'result')
496 items = response.addElement((pubsub.NS_PUBSUB,
497 'pubsub')).addElement('items')
498 items['node'] = 'test'
499 item1 = items.addElement('item')
500 item1['id'] = 'item4'
501 item2 = items.addElement('item')
502 item2['id'] = 'item5'
503 item3 = items.addElement('item')
504 item3['id'] = 'item6'
505 RSMResponse(800, 3, u'item4', u'item6').render(response.pubsub)
506 self.stub.send(response)
507
508 return d
509
510 def test_itemsCount(self):
511 """
512 Test sending items request to count them.
513 """
514 def cb(items):
515 self.assertEquals(0, len(items))
516 rsm = self.protocol.getRSMResponse(ext_data['id'])
517 self.assertDictEqual(rsm, {'count': '800'})
518
519 ext_data = {'id': unicode(uuid.uuid4()), 'rsm': RSMRequest(0)}
520 d = self.protocol.items(JID('pubsub.example.org'), 'test',
521 ext_data=ext_data)
522 d.addCallback(cb)
523
524 iq = self.stub.output[-1]
525 self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
526 self.assertEquals('get', iq.getAttribute('type'))
527 self.assertEquals('pubsub', iq.pubsub.name)
528 self.assertEquals(pubsub.NS_PUBSUB, iq.pubsub.uri)
529 children = list(domish.generateElementsQNamed(iq.pubsub.children,
530 'items', pubsub.NS_PUBSUB))
531 self.assertEquals(1, len(children))
532 child = children[0]
533 self.assertEquals('test', child['node'])
534
535 set_elts = list(domish.generateElementsQNamed(iq.pubsub.children,
536 'set', NS_RSM))
537 self.assertEquals(1, len(set_elts))
538 set_elt = set_elts[0]
539 self.assertEquals(u'0', ''.join(set_elt.max.children))
540
541 response = toResponse(iq, 'result')
542 response.addElement((pubsub.NS_PUBSUB, 'pubsub'))
543 RSMResponse(800).render(response.pubsub)
544 self.stub.send(response)
545
546 return d
547
548
549 class PubSubServiceTest(unittest.TestCase, TestableRequestHandlerMixin):
550
551 def setUp(self):
552 self.stub = XmlStreamStub()
553 self.resource = pubsub.PubSubResource()
554 self.service = PubSubService(self.resource)
555 self.service.send = self.stub.xmlstream.send
556
557 def test_on_items(self):
558 """
559 On a items request, return the first item for the given node.
560 """
561 xml = """
562 <iq type='get' to='pubsub.example.org'
563 from='user@example.org'>
564 <pubsub xmlns='http://jabber.org/protocol/pubsub'>
565 <items node='test'/>
566 </pubsub>
567 <set xmlns='http://jabber.org/protocol/rsm'>
568 <max>1</max>
569 </set>
570 </iq>
571 """
572
573 def items(request):
574 rsm = RSMResponse(800, 0, u'item', u'item').toElement()
575 return defer.succeed([pubsub.Item('current'), rsm])
576
577 def cb(element):
578 self.assertEqual(pubsub.NS_PUBSUB, element.uri)
579 self.assertEqual(pubsub.NS_PUBSUB, element.items.uri)
580 self.assertEqual(1, len(element.items.children))
581 item = element.items.children[-1]
582 self.assertTrue(domish.IElement.providedBy(item))
583 self.assertEqual('item', item.name)
584 self.assertEqual(pubsub.NS_PUBSUB, item.uri)
585 self.assertEqual('current', item['id'])
586 self.assertEqual(NS_RSM, element.set.uri)
587 self.assertEqual('800', ''.join(element.set.count.children))
588 self.assertEqual('0', element.set.first['index'])
589 self.assertEqual('item', ''.join(element.set.first.children))
590 self.assertEqual('item', ''.join(element.set.last.children))
591
592 self.resource.items = items
593 verify.verifyObject(iwokkel.IPubSubResource, self.resource)
594 d = self.handleRequest(xml)
595 d.addCallback(cb)
596 return d
597
598 def test_on_itemsIndex(self):
599 """
600 On a items request, return some items out of order for the given node.
601 """
602 xml = """
603 <iq type='get' to='pubsub.example.org'
604 from='user@example.org'>
605 <pubsub xmlns='http://jabber.org/protocol/pubsub'>
606 <items node='test'/>
607 </pubsub>
608 <set xmlns='http://jabber.org/protocol/rsm'>
609 <max>2</max>
610 <index>3</index>
611 </set>
612 </iq>
613 """
614
615 def items(request):
616 rsm = RSMResponse(800, 3, u'i1', u'i2').toElement()
617 return defer.succeed([pubsub.Item('i1'), pubsub.Item('i2'), rsm])
618
619 def cb(element):
620 self.assertEqual(pubsub.NS_PUBSUB, element.uri)
621 self.assertEqual(pubsub.NS_PUBSUB, element.items.uri)
622 self.assertEqual(2, len(element.items.children))
623 item = element.items.children[0]
624 self.assertTrue(domish.IElement.providedBy(item))
625 self.assertEqual('item', item.name)
626 self.assertEqual(pubsub.NS_PUBSUB, item.uri)
627 self.assertEqual('i1', item['id'])
628 item = element.items.children[1]
629 self.assertTrue(domish.IElement.providedBy(item))
630 self.assertEqual('item', item.name)
631 self.assertEqual(pubsub.NS_PUBSUB, item.uri)
632 self.assertEqual('i2', item['id'])
633 self.assertEqual(NS_RSM, element.set.uri)
634 self.assertEqual('800', ''.join(element.set.count.children))
635 self.assertEqual('3', element.set.first['index'])
636 self.assertEqual('i1', ''.join(element.set.first.children))
637 self.assertEqual('i2', ''.join(element.set.last.children))
638
639 self.resource.items = items
640 verify.verifyObject(iwokkel.IPubSubResource, self.resource)
641 d = self.handleRequest(xml)
642 d.addCallback(cb)
643 return d
644
645 def test_on_itemsCount(self):
646 """
647 On a items request, return the items count.
648 """
649 xml = """
650 <iq type='get' to='pubsub.example.org'
651 from='user@example.org'>
652 <pubsub xmlns='http://jabber.org/protocol/pubsub'>
653 <items node='test'/>
654 </pubsub>
655 <set xmlns='http://jabber.org/protocol/rsm'>
656 <max>0</max>
657 </set>
658 </iq>
659 """
660
661 def items(request):
662 rsm = RSMResponse(800).toElement()
663 return defer.succeed([rsm])
664
665 def cb(element):
666 self.assertEqual(pubsub.NS_PUBSUB, element.uri)
667 self.assertEqual(pubsub.NS_PUBSUB, element.items.uri)
668 self.assertEqual(0, len(element.items.children))
669 self.assertEqual(NS_RSM, element.set.uri)
670 self.assertEqual('800', ''.join(element.set.count.children))
671 self.assertEqual(None, element.set.first)
672 self.assertEqual(None, element.set.last)
673
674 self.resource.items = items
675 verify.verifyObject(iwokkel.IPubSubResource, self.resource)
676 d = self.handleRequest(xml)
677 d.addCallback(cb)
678 return d