← 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-03-01 01:08:15 UTC
  • Revision ID: curtis.hovey@canonical.com-20120301010815-hz0al69e3j0c9e6n
Raise ArchiveIdNotFound if the client puts a message into an unknown archive.

Show diffs side-by-side

added added

removed removed

Lines of Context:
grackle/tests/test_client.py
24
24
    UnsupportedOrder,
25
25
    )
26
26
from grackle.store import (
27
 
    make_json_message,
28
27
    MemoryStore,
29
28
    )
30
29
 
32
31
def make_message(message_id, body='body', headers=None, hidden=False):
33
32
    if headers is None:
34
33
        headers = {}
35
 
    message_headers = {
36
 
        'Message-Id': message_id,
37
 
        'date': '2005-01-01',
38
 
        'subject': 'subject',
39
 
        'from': 'author',
40
 
        'replies': '',
 
34
    headers['Message-Id'] = message_id
 
35
    message = {
 
36
        'message_id': message_id,
 
37
        'headers': headers,
 
38
        'thread_id': message_id,
 
39
        'date': headers.get('date', '2005-01-01'),
 
40
        'subject': headers.get('subject', 'subject'),
 
41
        'author': headers.get('author', 'author'),
 
42
        'hidden': hidden,
 
43
        'attachments': [],
 
44
        'replies': headers.get('in-reply-to', None),
 
45
        'body': body,
41
46
        }
42
 
    message_headers.update(headers.items())
43
 
    message = Message()
44
 
    message.set_payload(body)
45
 
    for key, value in message_headers.items():
46
 
        message[key] = value
47
 
    return make_json_message(message_id, message.as_string(), hidden)
 
47
    return message
48
48
 
49
49
 
50
50
def make_mime_message(message_id, body='body', headers=None, hidden=False,
51
51
                      attachment_type=None):
52
 
    parts = MIMEMultipart()
53
 
    parts.attach(MIMEText(body))
 
52
    message = MIMEMultipart()
 
53
    message.attach(MIMEText(body))
54
54
    if attachment_type is not None:
55
55
        attachment = Message()
56
56
        attachment.set_payload('attactment data.')
57
57
        attachment['Content-Type'] = attachment_type
58
58
        attachment['Content-Disposition'] = 'attachment; filename="file.ext"'
59
 
        parts.attach(attachment)
60
 
    return make_message(message_id, parts.as_string(), headers, hidden)
 
59
        message.attach(attachment)
 
60
    return make_message(message_id, message.get_payload(), headers, hidden)
61
61
 
62
62
 
63
63
class ForkedFakeService:
135
135
 
136
136
    def do_POST(self):
137
137
        """Create a message on POST."""
 
138
        message = self.rfile.read(int(self.headers['content-length']))
138
139
        scheme, netloc, path, params, query_string, fragments = (
139
140
            urlparse(self.path))
140
141
        parts = path.split('/')
141
 
        if parts[1] != 'archive':
142
 
            # This is an unknonwn operation?
143
 
            return
144
 
        if 'content-length' in self.headers:
145
 
            operation = 'put_message'
146
 
        else:
147
 
            operation = 'hide_message'
148
 
        if operation == 'put_message':
149
 
            message = self.rfile.read(int(self.headers['content-length']))
 
142
        if parts[1] == 'archive' and len(parts) == 4:
150
143
            try:
151
144
                # This expected path is /archive/archive_id/message_id.
152
145
                self.server.store.put_message(parts[2], parts[3], message)
155
148
                self.wfile.close()
156
149
            except:
157
150
                self.send_error(httplib.BAD_REQUEST)
158
 
        elif operation == 'hide_message':
159
 
            try:
160
 
                # This expected path is /archive/archive_id/message_id.
161
 
                response = self.server.store.hide_message(
162
 
                    parts[2], parts[3], query_string)
163
 
                self.send_response(httplib.OK)
164
 
                self.end_headers()
165
 
                self.wfile.write(simplejson.dumps(response))
166
 
            except:
167
 
                self.send_error(httplib.BAD_REQUEST)
168
151
 
169
152
    def do_GET(self):
170
153
        """Retrieve a list of messages on GET."""
254
237
 
255
238
    def get_messages_member_order_test(self, key):
256
239
        client = GrackleClient('localhost', 8439)
257
 
        if key == 'author':
258
 
            header_name = 'from'
259
 
        else:
260
 
            header_name = key
261
240
        archive = {
262
241
            'baz': [
263
 
                make_message('foo', headers={header_name: '2011-03-25'}),
264
 
                make_message('bar', headers={header_name: '2011-03-24'}),
 
242
                make_message('foo', headers={key: '2011-03-25'}),
 
243
                make_message('bar', headers={key: '2011-03-24'}),
265
244
             ]}
266
245
        with ForkedFakeService.from_client(client, archive):
267
246
            response = client.get_messages('baz')
414
393
        first_message = response['messages'][0]
415
394
        self.assertEqual('foo', first_message['message_id'])
416
395
        self.assertEqual(
417
 
            archive['baz'][0]['headers'], first_message['headers'])
 
396
            {'From': 'me', 'Message-Id': 'foo', 'To': 'you'},
 
397
            first_message['headers'])
418
398
        self.assertNotIn('body', first_message)
419
399
 
420
400
    def test_display_type_text_only(self):
431
411
        self.assertEqual('foo', first_message['message_id'])
432
412
        self.assertEqual('me', first_message['headers']['From'])
433
413
        self.assertEqual('you', first_message['headers']['To'])
434
 
        self.assertEqual(archive['baz'][0]['body'], first_message['body'])
 
414
        self.assertEqual('abcdefghi', first_message['body'])
435
415
 
436
416
    def test_display_type_all(self):
437
417
        client = GrackleClient('localhost', 8447)
447
427
        self.assertEqual('foo', first_message['message_id'])
448
428
        self.assertEqual('me', first_message['headers']['From'])
449
429
        self.assertEqual('you', first_message['headers']['To'])
450
 
        self.assertEqual(archive['baz'][0]['body'], first_message['body'])
 
430
        self.assertEqual(
 
431
            'abcdefghi\n\nattactment data.', first_message['body'])
451
432
 
452
433
    def test_date_range(self):
453
434
        client = GrackleClient('localhost', 8448)
490
471
        with ForkedFakeService.from_client(client, archive):
491
472
            with ExpectedException(UnparsableDateRange, ''):
492
473
                client.get_messages('baz', date_range='2012-01..12-02..12-03')
493
 
 
494
 
 
495
 
class TestHideMessages(TestCase):
496
 
 
497
 
    def test_hide_message_true(self):
498
 
        client = GrackleClient('localhost', 8470)
499
 
        archive = {
500
 
            'baz': [
501
 
                make_message('foo', hidden=False),
502
 
            ]}
503
 
        with ForkedFakeService.from_client(client, archive):
504
 
            response = client.hide_message('baz', 'foo', hidden=True)
505
 
        self.assertEqual('foo', response['message_id'])
506
 
        self.assertIs(True, response['hidden'])
507
 
 
508
 
    def test_hide_message_false(self):
509
 
        client = GrackleClient('localhost', 8470)
510
 
        archive = {
511
 
            'baz': [
512
 
                make_message('foo', hidden=True),
513
 
            ]}
514
 
        with ForkedFakeService.from_client(client, archive):
515
 
            response = client.hide_message('baz', 'foo', hidden=False)
516
 
        self.assertEqual('foo', response['message_id'])
517
 
        self.assertIs(False, response['hidden'])