← 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 05:24:10 UTC
  • mfrom: (35.1.19 client-get-messages-0)
  • Revision ID: curtis.hovey@canonical.com-20120131052410-4n5iva4ujik6nhp8
Added support for display_type.
Introduced make_message and make_mime_message to make test data consistent for
InMemoryStore.

Show diffs side-by-side

added added

removed removed

Lines of Context:
grackle/tests/test_client.py
14
14
import sys
15
15
from unittest import TestCase
16
16
from urlparse import urlparse
 
17
from urlparse import parse_qs
17
18
 
18
19
from testtools import ExpectedException
19
20
 
20
21
from grackle.client import (
21
22
    GrackleClient,
22
 
    UnparsableDateRange,
23
23
    UnsupportedDisplayType,
24
24
    UnsupportedOrder,
25
25
    )
26
 
from grackle.store import (
27
 
    make_json_message,
28
 
    MemoryStore,
29
 
    )
30
26
 
31
27
 
32
28
def make_message(message_id, body='body', headers=None, hidden=False):
33
29
    if headers is None:
34
30
        headers = {}
35
 
    message_headers = {
36
 
        'Message-Id': message_id,
37
 
        'date': '2005-01-01',
38
 
        'subject': 'subject',
39
 
        'from': 'author',
40
 
        'replies': '',
 
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
        'author': headers.get('author', 'author'),
 
39
        'hidden': hidden,
 
40
        'attachments': [],
 
41
        'replies': headers.get('in-reply-to', None),
 
42
        'body': body,
41
43
        }
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)
 
44
    return message
48
45
 
49
46
 
50
47
def make_mime_message(message_id, body='body', headers=None, hidden=False,
51
48
                      attachment_type=None):
52
 
    parts = MIMEMultipart()
53
 
    parts.attach(MIMEText(body))
 
49
    message = MIMEMultipart()
 
50
    message.attach(MIMEText(body))
54
51
    if attachment_type is not None:
55
52
        attachment = Message()
56
53
        attachment.set_payload('attactment data.')
57
54
        attachment['Content-Type'] = attachment_type
58
55
        attachment['Content-Disposition'] = 'attachment; filename="file.ext"'
59
 
        parts.attach(attachment)
60
 
    return make_message(message_id, parts.as_string(), headers, hidden)
 
56
        message.attach(attachment)
 
57
    return make_message(message_id, message.get_payload(), headers, hidden)
 
58
 
 
59
 
 
60
def threaded_messages(messages):
 
61
    threads = {}
 
62
    count = 0
 
63
    pending = []
 
64
    for message in messages:
 
65
        if message.get('replies') is None:
 
66
            threads[message['message_id']] = [message]
 
67
            count += 1
 
68
        else:
 
69
            pending.append(message)
 
70
    for message in pending:
 
71
        threads[message['replies']].append(message)
 
72
    return threads.values()
 
73
 
 
74
 
 
75
class GrackleStore:
 
76
    """A memory-backed message store."""
 
77
 
 
78
    def __init__(self, messages):
 
79
        """Constructor."""
 
80
        self.messages = messages
 
81
 
 
82
    @staticmethod
 
83
    def is_multipart(message):
 
84
        return isinstance(message['body'], list)
 
85
 
 
86
    def get_messages(self, archive_id, query_string):
 
87
        """Return matching messages.
 
88
 
 
89
        :param archive_id: The archive to retrieve from.
 
90
        :param query_string: Contains 'parameters', which is a JSON-format
 
91
            string describing parameters.
 
92
        """
 
93
        query = parse_qs(query_string)
 
94
        parameters = simplejson.loads(query['parameters'][0])
 
95
        order = parameters.get('order')
 
96
        messages = self.messages[archive_id]
 
97
        if order is not None:
 
98
            if order not in SUPPORTED_ORDERS:
 
99
                raise UnsupportedOrder
 
100
            elif order.startswith('thread_'):
 
101
                threaded = threaded_messages(messages)
 
102
                messages = []
 
103
                if order == 'thread_subject':
 
104
                    threaded.sort(key=lambda t: t[0]['subject'])
 
105
                if order == 'thread_oldest':
 
106
                    threaded.sort(key=lambda t: min(m['date'] for m in t))
 
107
                if order == 'thread_newest':
 
108
                    threaded.sort(key=lambda t: max(m['date'] for m in t))
 
109
                for thread in threaded:
 
110
                    messages.extend(thread)
 
111
            else:
 
112
                messages.sort(key=lambda m: m[order])
 
113
        display_type = parameters.get('display_type', 'all')
 
114
        if display_type not in SUPPORTED_DISPLAY_TYPES:
 
115
            raise UnsupportedDisplayType
 
116
        new_messages = []
 
117
        for message in messages:
 
118
            if (not parameters['include_hidden'] and message['hidden']):
 
119
                continue
 
120
            if ('message_ids' in parameters
 
121
                and message['message_id'] not in parameters['message_ids']):
 
122
                continue
 
123
            message = dict(message)
 
124
            if 'headers' in parameters:
 
125
                headers = dict(
 
126
                    (k, v) for k, v in message['headers'].iteritems()
 
127
                    if k in parameters['headers'])
 
128
                message['headers'] = headers
 
129
            if display_type == 'headers-only':
 
130
                del message['body']
 
131
            elif display_type == 'text-only' and self.is_multipart(message):
 
132
                text_parts = [
 
133
                    part.get_payload() for part in message['body']
 
134
                    if part.get_content_type() == 'text/plain']
 
135
                message['body'] = '\n\n'.join(text_parts)
 
136
            elif display_type == 'all' and self.is_multipart(message):
 
137
                parts = [str(part.get_payload()) for part in message['body']]
 
138
                message['body'] = '\n\n'.join(parts)
 
139
            max_body = parameters.get('max_body_length')
 
140
            if max_body is not None and display_type != 'headers-only':
 
141
                message['body'] = message['body'][:max_body]
 
142
            new_messages.append(message)
 
143
        messages = new_messages
 
144
        limit = parameters.get('limit', 100)
 
145
        memo = parameters.get('memo')
 
146
        message_id_indices = dict(
 
147
            (m['message_id'], idx) for idx, m in enumerate(messages))
 
148
        if memo is None:
 
149
            start = 0
 
150
        else:
 
151
            start = message_id_indices[memo.encode('rot13')]
 
152
        if start > 0:
 
153
            previous_memo = messages[start - 1]['message_id'].encode('rot13')
 
154
        else:
 
155
            previous_memo = None
 
156
        end = min(start + limit, len(messages))
 
157
        if end < len(messages):
 
158
            next_memo = messages[end]['message_id'].encode('rot13')
 
159
        else:
 
160
            next_memo = None
 
161
        messages = messages[start:end]
 
162
 
 
163
        response = {
 
164
            'messages': messages,
 
165
            'next_memo': next_memo,
 
166
            'previous_memo': previous_memo
 
167
            }
 
168
        return response
61
169
 
62
170
 
63
171
class ForkedFakeService:
64
172
    """A Grackle service fake, as a ContextManager."""
65
173
 
66
 
    def __init__(self, port, message_archives=None, write_logs=False):
 
174
    def __init__(self, port, messages=None, write_logs=False):
67
175
        """Constructor.
68
176
 
69
177
        :param port: The tcp port to use.
70
 
        :param message_archives: A dict of lists of dicts representing
71
 
            archives of messages. The outer dict represents the archive,
72
 
            the list represents the list of messages for that archive.
 
178
        :param messages: A dict of lists of dicts representing messages.  The
 
179
            outer dict represents the archive, the list represents the list of
 
180
            messages for that archive.
73
181
        :param write_logs: If true, log messages will be written to stdout.
74
182
        """
75
183
        self.pid = None
76
184
        self.port = port
77
 
        if message_archives is None:
78
 
            self.message_archives = {}
 
185
        if messages is None:
 
186
            self.messages = {}
79
187
        else:
80
 
            self.message_archives = message_archives
 
188
            self.messages = messages
81
189
        self.read_end, self.write_end = os.pipe()
82
190
        self.write_logs = write_logs
83
191
 
84
192
    @staticmethod
85
 
    def from_client(client, message_archives=None):
 
193
    def from_client(client, messages=None):
86
194
        """Instantiate a ForkedFakeService from the client.
87
195
 
88
196
        :param port: The client to provide service for.
89
 
        :param message_archives: A dict of lists of dicts representing
90
 
            archives of messages. The outer dict represents the archive,
91
 
            the list represents the list of messages for that archive.
 
197
        :param messages: A dict of lists of dicts representing messages.  The
 
198
            outer dict represents the archive, the list represents the list of
 
199
            messages for that archive.
92
200
        """
93
 
        return ForkedFakeService(client.port, message_archives)
 
201
        return ForkedFakeService(client.port, messages)
94
202
 
95
203
    def is_ready(self):
96
204
        """Tell the parent process that the server is ready for writes."""
111
219
    def start_server(self):
112
220
        """Start the HTTP server."""
113
221
        service = HTTPServer(('', self.port), FakeGrackleRequestHandler)
114
 
        service.store = MemoryStore(self.message_archives)
115
 
        for archive_id, messages in service.store.message_archives.iteritems():
 
222
        service.store = GrackleStore(self.messages)
 
223
        for archive_id, messages in service.store.messages.iteritems():
116
224
            for message in messages:
117
225
                message.setdefault('headers', {})
118
226
        self.is_ready()
125
233
        os.kill(self.pid, SIGKILL)
126
234
 
127
235
 
 
236
SUPPORTED_DISPLAY_TYPES = set(['all', 'text-only', 'headers-only'])
 
237
 
 
238
 
 
239
SUPPORTED_ORDERS = set(
 
240
    ['date', 'author', 'subject', 'thread_newest', 'thread_oldest',
 
241
     'thread_subject'])
 
242
 
 
243
 
128
244
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
129
245
    """A request handler that forwards to server.store."""
130
246
 
135
251
 
136
252
    def do_POST(self):
137
253
        """Create a message on POST."""
138
 
        scheme, netloc, path, params, query_string, fragments = (
139
 
            urlparse(self.path))
140
 
        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'
 
254
        message = self.rfile.read(int(self.headers['content-length']))
 
255
        if message == 'This is a message':
 
256
            self.send_response(httplib.CREATED)
 
257
            self.end_headers()
 
258
            self.wfile.close()
146
259
        else:
147
 
            operation = 'hide_message'
148
 
        if operation == 'put_message':
149
 
            message = self.rfile.read(int(self.headers['content-length']))
150
 
            try:
151
 
                # This expected path is /archive/archive_id/message_id.
152
 
                self.server.store.put_message(parts[2], parts[3], message)
153
 
                self.send_response(httplib.CREATED)
154
 
                self.end_headers()
155
 
                self.wfile.close()
156
 
            except:
157
 
                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)
 
260
            self.send_error(httplib.BAD_REQUEST)
168
261
 
169
262
    def do_GET(self):
170
263
        """Retrieve a list of messages on GET."""
178
271
                self.send_response(httplib.OK)
179
272
                self.end_headers()
180
273
                self.wfile.write(simplejson.dumps(response))
181
 
            except Exception, error:
182
 
                self.send_response(
183
 
                    httplib.BAD_REQUEST, error.__doc__)
 
274
            except UnsupportedOrder:
 
275
                self.send_response(
 
276
                    httplib.BAD_REQUEST, UnsupportedOrder.__doc__)
 
277
                return
 
278
            except UnsupportedDisplayType:
 
279
                self.send_response(
 
280
                    httplib.BAD_REQUEST, UnsupportedDisplayType.__doc__)
184
281
                return
185
282
 
186
283
    def log_message(self, format, *args):
193
290
class TestPutMessage(TestCase):
194
291
 
195
292
    def test_put_message(self):
196
 
        client = GrackleClient('localhost', 8420)
197
 
        message_archives = {'arch1': []}
198
 
        with ForkedFakeService.from_client(client, message_archives):
199
 
            client.put_message('arch1', 'id1', StringIO('This is a message'))
200
 
            response = client.get_messages('arch1')
201
 
        self.assertEqual(1, len(response['messages']))
202
 
        message = response['messages'][0]
203
 
        self.assertEqual('id1', message['message_id'])
204
 
 
205
 
    def test_put_message_without_archive(self):
206
 
        client = GrackleClient('localhost', 8421)
207
 
        message_archives = {'arch1': []}
208
 
        with ForkedFakeService.from_client(client, message_archives):
 
293
        client = GrackleClient('localhost', 8436)
 
294
        with ForkedFakeService.from_client(client):
 
295
            client.put_message('arch1', 'asdf', StringIO('This is a message'))
209
296
            with ExpectedException(Exception, 'wtf'):
210
 
                client.put_message('no-archive', 'id1', StringIO('message'))
 
297
                client.put_message('arch1', 'asdf',
 
298
                    StringIO('This is not a message'))
211
299
 
212
300
 
213
301
class TestGetMessages(TestCase):
220
308
            sorted(ids), sorted(messages, key=lambda m: m['message_id']))
221
309
 
222
310
    def test_get_messages(self):
223
 
        client = GrackleClient('localhost', 8430)
 
311
        client = GrackleClient('localhost', 8435)
224
312
        archive = {
225
313
            'baz': [make_message('foo'), make_message('bar')]}
226
314
        with ForkedFakeService.from_client(client, archive):
254
342
 
255
343
    def get_messages_member_order_test(self, key):
256
344
        client = GrackleClient('localhost', 8439)
257
 
        if key == 'author':
258
 
            header_name = 'from'
259
 
        else:
260
 
            header_name = key
261
345
        archive = {
262
346
            'baz': [
263
 
                make_message('foo', headers={header_name: '2011-03-25'}),
264
 
                make_message('bar', headers={header_name: '2011-03-24'}),
 
347
                make_message('foo', headers={key: '2011-03-25'}),
 
348
                make_message('bar', headers={key: '2011-03-24'}),
265
349
             ]}
266
350
        with ForkedFakeService.from_client(client, archive):
267
351
            response = client.get_messages('baz')
414
498
        first_message = response['messages'][0]
415
499
        self.assertEqual('foo', first_message['message_id'])
416
500
        self.assertEqual(
417
 
            archive['baz'][0]['headers'], first_message['headers'])
 
501
            {'From': 'me', 'Message-Id': 'foo', 'To': 'you'},
 
502
            first_message['headers'])
418
503
        self.assertNotIn('body', first_message)
419
504
 
420
505
    def test_display_type_text_only(self):
431
516
        self.assertEqual('foo', first_message['message_id'])
432
517
        self.assertEqual('me', first_message['headers']['From'])
433
518
        self.assertEqual('you', first_message['headers']['To'])
434
 
        self.assertEqual(archive['baz'][0]['body'], first_message['body'])
 
519
        self.assertEqual('abcdefghi', first_message['body'])
435
520
 
436
521
    def test_display_type_all(self):
437
522
        client = GrackleClient('localhost', 8447)
447
532
        self.assertEqual('foo', first_message['message_id'])
448
533
        self.assertEqual('me', first_message['headers']['From'])
449
534
        self.assertEqual('you', first_message['headers']['To'])
450
 
        self.assertEqual(archive['baz'][0]['body'], first_message['body'])
451
 
 
452
 
    def test_date_range(self):
453
 
        client = GrackleClient('localhost', 8448)
454
 
        archive = {
455
 
            'baz': [
456
 
                make_mime_message(
457
 
                    'foo', 'abcdefghi', headers={'date': '2011-12-31'}),
458
 
                make_mime_message(
459
 
                    'bar', 'abcdefghi', headers={'date': '2012-01-01'}),
460
 
                make_mime_message(
461
 
                    'qux', 'abcdefghi', headers={'date': '2012-01-15'}),
462
 
                make_mime_message(
463
 
                    'naf', 'abcdefghi', headers={'date': '2012-01-31'}),
464
 
                make_mime_message(
465
 
                    'doh', 'abcdefghi', headers={'date': '2012-02-01'}),
466
 
                    ]}
467
 
        with ForkedFakeService.from_client(client, archive):
468
 
            response = client.get_messages(
469
 
                'baz', date_range='2012-01-01..2012-01-31')
470
 
        ids = sorted(m['message_id'] for m in response['messages'])
471
 
        self.assertEqual(['bar', 'naf', 'qux'], ids)
472
 
 
473
 
    def test_date_range_unparsabledaterange(self):
474
 
        client = GrackleClient('localhost', 8449)
475
 
        archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
476
 
        with ForkedFakeService.from_client(client, archive):
477
 
            with ExpectedException(UnparsableDateRange, ''):
478
 
                client.get_messages('baz', date_range='2012-01-01')
479
 
 
480
 
    def test_date_range_unparsabledaterange_missing_part(self):
481
 
        client = GrackleClient('localhost', 8450)
482
 
        archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
483
 
        with ForkedFakeService.from_client(client, archive):
484
 
            with ExpectedException(UnparsableDateRange, ''):
485
 
                client.get_messages('baz', date_range='2012-01-01..')
486
 
 
487
 
    def test_date_range_unparsabledaterange_extra_part(self):
488
 
        client = GrackleClient('localhost', 8451)
489
 
        archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
490
 
        with ForkedFakeService.from_client(client, archive):
491
 
            with ExpectedException(UnparsableDateRange, ''):
492
 
                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'])
 
535
        self.assertEqual(
 
536
            'abcdefghi\n\nattactment data.', first_message['body'])