← 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
 
136
252
    def do_POST(self):
137
253
        """Create a message on POST."""
138
254
        message = self.rfile.read(int(self.headers['content-length']))
139
 
        scheme, netloc, path, params, query_string, fragments = (
140
 
            urlparse(self.path))
141
 
        parts = path.split('/')
142
 
        if parts[1] == 'archive' and len(parts) == 4:
143
 
            try:
144
 
                # This expected path is /archive/archive_id/message_id.
145
 
                self.server.store.put_message(parts[2], parts[3], message)
146
 
                self.send_response(httplib.CREATED)
147
 
                self.end_headers()
148
 
                self.wfile.close()
149
 
            except:
150
 
                self.send_error(httplib.BAD_REQUEST)
 
255
        if message == 'This is a message':
 
256
            self.send_response(httplib.CREATED)
 
257
            self.end_headers()
 
258
            self.wfile.close()
 
259
        else:
 
260
            self.send_error(httplib.BAD_REQUEST)
151
261
 
152
262
    def do_GET(self):
153
263
        """Retrieve a list of messages on GET."""
161
271
                self.send_response(httplib.OK)
162
272
                self.end_headers()
163
273
                self.wfile.write(simplejson.dumps(response))
164
 
            except Exception, error:
165
 
                self.send_response(
166
 
                    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__)
167
281
                return
168
282
 
169
283
    def log_message(self, format, *args):
176
290
class TestPutMessage(TestCase):
177
291
 
178
292
    def test_put_message(self):
179
 
        client = GrackleClient('localhost', 8420)
180
 
        message_archives = {'arch1': []}
181
 
        with ForkedFakeService.from_client(client, message_archives):
182
 
            client.put_message('arch1', 'id1', StringIO('This is a message'))
183
 
            response = client.get_messages('arch1')
184
 
        self.assertEqual(1, len(response['messages']))
185
 
        message = response['messages'][0]
186
 
        self.assertEqual('id1', message['message_id'])
187
 
 
188
 
    def test_put_message_without_archive(self):
189
 
        client = GrackleClient('localhost', 8421)
190
 
        message_archives = {'arch1': []}
191
 
        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'))
192
296
            with ExpectedException(Exception, 'wtf'):
193
 
                client.put_message('no-archive', 'id1', StringIO('message'))
 
297
                client.put_message('arch1', 'asdf',
 
298
                    StringIO('This is not a message'))
194
299
 
195
300
 
196
301
class TestGetMessages(TestCase):
203
308
            sorted(ids), sorted(messages, key=lambda m: m['message_id']))
204
309
 
205
310
    def test_get_messages(self):
206
 
        client = GrackleClient('localhost', 8430)
 
311
        client = GrackleClient('localhost', 8435)
207
312
        archive = {
208
313
            'baz': [make_message('foo'), make_message('bar')]}
209
314
        with ForkedFakeService.from_client(client, archive):
237
342
 
238
343
    def get_messages_member_order_test(self, key):
239
344
        client = GrackleClient('localhost', 8439)
240
 
        if key == 'author':
241
 
            header_name = 'from'
242
 
        else:
243
 
            header_name = key
244
345
        archive = {
245
346
            'baz': [
246
 
                make_message('foo', headers={header_name: '2011-03-25'}),
247
 
                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'}),
248
349
             ]}
249
350
        with ForkedFakeService.from_client(client, archive):
250
351
            response = client.get_messages('baz')
397
498
        first_message = response['messages'][0]
398
499
        self.assertEqual('foo', first_message['message_id'])
399
500
        self.assertEqual(
400
 
            archive['baz'][0]['headers'], first_message['headers'])
 
501
            {'From': 'me', 'Message-Id': 'foo', 'To': 'you'},
 
502
            first_message['headers'])
401
503
        self.assertNotIn('body', first_message)
402
504
 
403
505
    def test_display_type_text_only(self):
414
516
        self.assertEqual('foo', first_message['message_id'])
415
517
        self.assertEqual('me', first_message['headers']['From'])
416
518
        self.assertEqual('you', first_message['headers']['To'])
417
 
        self.assertEqual(archive['baz'][0]['body'], first_message['body'])
 
519
        self.assertEqual('abcdefghi', first_message['body'])
418
520
 
419
521
    def test_display_type_all(self):
420
522
        client = GrackleClient('localhost', 8447)
430
532
        self.assertEqual('foo', first_message['message_id'])
431
533
        self.assertEqual('me', first_message['headers']['From'])
432
534
        self.assertEqual('you', first_message['headers']['To'])
433
 
        self.assertEqual(archive['baz'][0]['body'], first_message['body'])
434
 
 
435
 
    def test_date_range(self):
436
 
        client = GrackleClient('localhost', 8448)
437
 
        archive = {
438
 
            'baz': [
439
 
                make_mime_message(
440
 
                    'foo', 'abcdefghi', headers={'date': '2011-12-31'}),
441
 
                make_mime_message(
442
 
                    'bar', 'abcdefghi', headers={'date': '2012-01-01'}),
443
 
                make_mime_message(
444
 
                    'qux', 'abcdefghi', headers={'date': '2012-01-15'}),
445
 
                make_mime_message(
446
 
                    'naf', 'abcdefghi', headers={'date': '2012-01-31'}),
447
 
                make_mime_message(
448
 
                    'doh', 'abcdefghi', headers={'date': '2012-02-01'}),
449
 
                    ]}
450
 
        with ForkedFakeService.from_client(client, archive):
451
 
            response = client.get_messages(
452
 
                'baz', date_range='2012-01-01..2012-01-31')
453
 
        ids = sorted(m['message_id'] for m in response['messages'])
454
 
        self.assertEqual(['bar', 'naf', 'qux'], ids)
455
 
 
456
 
    def test_date_range_unparsabledaterange(self):
457
 
        client = GrackleClient('localhost', 8449)
458
 
        archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
459
 
        with ForkedFakeService.from_client(client, archive):
460
 
            with ExpectedException(UnparsableDateRange, ''):
461
 
                client.get_messages('baz', date_range='2012-01-01')
462
 
 
463
 
    def test_date_range_unparsabledaterange_missing_part(self):
464
 
        client = GrackleClient('localhost', 8450)
465
 
        archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
466
 
        with ForkedFakeService.from_client(client, archive):
467
 
            with ExpectedException(UnparsableDateRange, ''):
468
 
                client.get_messages('baz', date_range='2012-01-01..')
469
 
 
470
 
    def test_date_range_unparsabledaterange_extra_part(self):
471
 
        client = GrackleClient('localhost', 8451)
472
 
        archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
473
 
        with ForkedFakeService.from_client(client, archive):
474
 
            with ExpectedException(UnparsableDateRange, ''):
475
 
                client.get_messages('baz', date_range='2012-01..12-02..12-03')
 
535
        self.assertEqual(
 
536
            'abcdefghi\n\nattactment data.', first_message['body'])