← Back to branch summary

~didrocks/unity/altf10

« back to all changes in this revision

Viewing changes to grackle/tests/test_client.py

  • Committer: Curtis Hovey
  • Date: 2012-01-31 04:27:13 UTC
  • mto: This revision was merged to the branch mainline in revision 37.
  • Revision ID: curtis.hovey@canonical.com-20120131042713-tsjq1nx6jtwiyw5p
Use make_message() to make test data consistent.

Show diffs side-by-side

added added

removed removed

Lines of Context:
grackle/tests/test_client.py
25
25
    )
26
26
 
27
27
 
28
 
def make_mime_message(message_id, text, headers=None, attachment_type=None):
 
28
def make_message(message_id, body='body text', headers=None, hidden=False):
 
29
    if headers is None:
 
30
        headers = {}
 
31
    headers['Message-Id'] = message_id
 
32
    message = {
 
33
        'message_id': message_id,
 
34
        'headers': headers,
 
35
        'thread_id': message_id,
 
36
        'date': headers.get('date', '2005-01-01'),
 
37
        'subject': headers.get('subject', 'subject'),
 
38
        'hidden': hidden,
 
39
        'attachments': [],
 
40
        'body': body,
 
41
        'replies': [],
 
42
        }
 
43
    if 'in-reply-to' in headers:
 
44
        message['in_reply_to'] = headers['in-reply-to']
 
45
    return message
 
46
 
 
47
 
 
48
def make_mime_message(message_id, text, headers=None, hidden=False,
 
49
                      attachment_type=None):
29
50
    message = MIMEMultipart()
30
51
    message.attach(MIMEText(text))
31
52
    message['Message-Id'] = message_id
302
323
        client = GrackleClient('localhost', 8435)
303
324
        with ForkedFakeService.from_client(client,
304
325
            {'baz':
305
 
            [{'message_id': 'foo'},
306
 
             {'message_id': 'bar'}]}):
 
326
                [make_message('foo'),
 
327
                 make_message('bar')]}):
307
328
            response = client.get_messages('baz')
308
329
        self.assertEqual(['bar', 'foo'], sorted(m['message_id'] for m in
309
330
            response['messages']))
314
335
        client = GrackleClient('localhost', 8437)
315
336
        with ForkedFakeService.from_client(client,
316
337
            {'baz':
317
 
            [{'message_id': 'foo'},
318
 
             {'message_id': 'bar'}]}):
 
338
                [make_message('foo'),
 
339
                 make_message('bar')]}):
319
340
            response = client.get_messages('baz', message_ids=['foo'])
320
341
        message, = response['messages']
321
342
        self.assertEqual('foo', message['message_id'])
324
345
        client = GrackleClient('localhost', 8438)
325
346
        with ForkedFakeService.from_client(client,
326
347
            {'baz':
327
 
            [{'message_id': 'foo'},
328
 
             {'message_id': 'bar'}]}):
 
348
                [make_message('foo'),
 
349
                 make_message('bar')]}):
329
350
            response = client.get_messages('baz', limit=1)
330
351
            self.assertEqual(1, len(response['messages']))
331
352
            messages = response['messages']
338
359
    def get_messages_member_order_test(self, key):
339
360
        client = GrackleClient('localhost', 8439)
340
361
        with ForkedFakeService.from_client(client,
341
 
                {'baz': [{'message_id': 'foo', key: '2011-03-25'},
 
362
            {'baz': [
 
363
                 {'message_id': 'foo', key: '2011-03-25'},
342
364
                 {'message_id': 'bar', key: '2011-03-24'}]}):
343
365
            response = client.get_messages('baz')
344
366
            self.assertIDOrder(['foo', 'bar'], response['messages'])
355
377
        self.get_messages_member_order_test('subject')
356
378
 
357
379
    def test_get_messages_thread_subject_order(self):
 
380
        archive = {'baz': [
 
381
            make_message('bar', headers={'subject': 'y'}),
 
382
            make_message('qux', headers={'subject': 'z'}),
 
383
            make_message('foo', headers={'subject': 'x',
 
384
                                         'in-reply-to': 'qux'})]}
358
385
        client = GrackleClient('localhost', 8439)
359
 
        with ForkedFakeService.from_client(client, {'baz': [
360
 
            {'message_id': 'bar', 'subject': 'y'},
361
 
            {'message_id': 'qux', 'subject': 'z'},
362
 
            {'message_id': 'foo', 'subject': 'x', 'in_reply_to': 'qux'},
363
 
            ]}):
 
386
        with ForkedFakeService.from_client(client, archive):
364
387
            response = client.get_messages('baz')
365
388
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
366
389
            response = client.get_messages('baz', order='subject')
370
393
 
371
394
    def test_get_messages_thread_oldest_order(self):
372
395
        client = GrackleClient('localhost', 8439)
373
 
        with ForkedFakeService.from_client(client, {'baz': [
374
 
            {'message_id': 'bar', 'date': 'x'},
375
 
            {'message_id': 'qux', 'date': 'z'},
376
 
            {'message_id': 'foo', 'date': 'y', 'in_reply_to': 'qux'},
377
 
            ]}):
 
396
        archive = {'baz': [
 
397
            make_message('bar', headers={'date': 'x'}),
 
398
            make_message('qux', headers={'date': 'z'}),
 
399
            make_message('foo', headers={'date': 'y', 'in-reply-to': 'qux'}),
 
400
            ]}
 
401
        with ForkedFakeService.from_client(client, archive):
378
402
            response = client.get_messages('baz')
379
403
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
380
404
            response = client.get_messages('baz', order='date')
385
409
    def test_get_messages_thread_newest_order(self):
386
410
        client = GrackleClient('localhost', 8439)
387
411
        with ForkedFakeService.from_client(client, {'baz': [
388
 
            {'message_id': 'bar', 'date': 'x'},
389
 
            {'message_id': 'qux', 'date': 'w'},
390
 
            {'message_id': 'foo', 'date': 'y', 'in_reply_to': 'bar'},
391
 
            {'message_id': 'baz', 'date': 'z', 'in_reply_to': 'qux'},
 
412
            make_message('bar', headers={'date': 'x'}),
 
413
            make_message('qux', headers={'date': 'w'}),
 
414
            make_message('foo', headers={'date': 'y', 'in-reply-to': 'bar'}),
 
415
            make_message('baz', headers={'date': 'z', 'in-reply-to': 'qux'}),
392
416
            ]}):
393
417
            response = client.get_messages('baz', order='date')
394
418
            self.assertIDOrder(
400
424
    def test_get_messages_unsupported_order(self):
401
425
        client = GrackleClient('localhost', 8439)
402
426
        with ForkedFakeService.from_client(client,
403
 
                {'baz': [{'message_id': 'foo', 'date': '2011-03-25'},
404
 
                 {'message_id': 'bar', 'date': '2011-03-24'}]}):
 
427
            {'baz': [
 
428
                make_message('foo', headers={'date': '2011-03-25'}),
 
429
                make_message('foo', headers={'date': '2011-03-24'})]}):
405
430
            with ExpectedException(UnsupportedOrder, ''):
406
431
                client.get_messages('baz', order='nonsense')
407
432
 
408
433
    def test_get_messages_headers_no_headers(self):
409
434
        client = GrackleClient('localhost', 8440)
410
435
        with ForkedFakeService.from_client(client,
411
 
            {'baz': [
412
 
                {'message_id': 'foo'}
413
 
            ]}):
 
436
            {'baz':
 
437
                [make_message('foo')]}):
414
438
            response = client.get_messages('baz', headers=[
415
439
                'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
416
440
        first_message = response['messages'][0]
421
445
        client = GrackleClient('localhost', 8441)
422
446
        with ForkedFakeService.from_client(client,
423
447
            {'baz': [
424
 
                {'message_id': 'foo', 'headers': {'From': 'me'}}
425
 
            ]}):
 
448
                make_message('foo', headers={'From': 'me'})]}):
426
449
            response = client.get_messages('baz', headers=[
427
450
                'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
428
451
        first_message = response['messages'][0]
433
456
        client = GrackleClient('localhost', 8442)
434
457
        with ForkedFakeService.from_client(client,
435
458
            {'baz': [
436
 
                {'message_id': 'foo', 'headers': {'From': 'me', 'To': 'you'}}
437
 
            ]}):
 
459
                make_message('foo', headers={'From': 'me', 'To': 'you'})]}):
438
460
            response = client.get_messages('baz', headers=[
439
461
                'From', 'To'])
440
462
        first_message = response['messages'][0]
445
467
        client = GrackleClient('localhost', 8443)
446
468
        with ForkedFakeService.from_client(client,
447
469
            {'baz': [
448
 
                {'message_id': 'foo', 'body': u'abcdefghi'}
449
 
            ]}):
 
470
                make_message('foo', body=u'abcdefghi')]}):
450
471
            response = client.get_messages('baz', max_body_length=3)
451
472
        first_message = response['messages'][0]
452
473
        self.assertEqual('abc', first_message['body'])
455
476
        client = GrackleClient('localhost', 8444)
456
477
        with ForkedFakeService.from_client(client,
457
478
            {'baz': [
458
 
                {'message_id': 'foo', 'hidden': True},
459
 
                {'message_id': 'bar', 'hidden': False}
460
 
            ]}):
 
479
                make_message('foo', hidden=True),
 
480
                make_message('bar', hidden=False)]}):
461
481
            response = client.get_messages('baz', include_hidden=True)
462
482
            self.assertMessageIDs(['bar', 'foo'], response['messages'])
463
483
            response = client.get_messages('baz', include_hidden=False)
467
487
        client = GrackleClient('localhost', 8445)
468
488
        with ForkedFakeService.from_client(client,
469
489
            {'baz': [
470
 
                {'message_id': 'foo', 'body': u'abcdefghi'}
471
 
            ]}):
 
490
                make_message('foo', body=u'abcdefghi')]}):
472
491
            with ExpectedException(UnsupportedDisplayType, ''):
473
492
                client.get_messages('baz', display_type='unknown')
474
493
 
476
495
        client = GrackleClient('localhost', 8446)
477
496
        with ForkedFakeService.from_client(client,
478
497
            {'baz': [
479
 
                {'message_id': 'foo',
480
 
                 'headers': {'From': 'me', 'To': 'you'},
481
 
                 'body': 'abcdefghi'}
482
 
            ]}):
 
498
                make_message('foo', body=u'abcdefghi',
 
499
                              headers={'From': 'me', 'To': 'you'})]}):
483
500
            response = client.get_messages('baz', display_type='headers-only')
484
501
        first_message = response['messages'][0]
485
502
        self.assertEqual('foo', first_message['message_id'])
486
 
        self.assertEqual({'From': 'me', 'To': 'you'}, first_message['headers'])
 
503
        self.assertEqual(
 
504
            {'From': 'me', 'Message-Id': 'foo', 'To': 'you'},
 
505
            first_message['headers'])
487
506
        self.assertNotIn('body', first_message)
488
507
 
489
508
    def test_display_type_text_only(self):