← 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-02-24 21:43:12 UTC
  • Revision ID: curtis.hovey@canonical.com-20120224214312-zlji369uv0l9v75m
Move errors to their own module.
Remove duplicate definiton of SUPPORTED_DISPLAY_TYPES.

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
18
17
 
19
18
from testtools import ExpectedException
20
19
 
21
20
from grackle.client import (
22
21
    GrackleClient,
 
22
    UnparsableDateRange,
23
23
    UnsupportedDisplayType,
24
24
    UnsupportedOrder,
25
25
    )
 
26
from grackle.store import (
 
27
    MemoryStore,
 
28
    )
26
29
 
27
30
 
28
31
def make_message(message_id, body='body', headers=None, hidden=False):
57
60
    return make_message(message_id, message.get_payload(), headers, hidden)
58
61
 
59
62
 
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
169
 
 
170
 
 
171
63
class ForkedFakeService:
172
64
    """A Grackle service fake, as a ContextManager."""
173
65
 
219
111
    def start_server(self):
220
112
        """Start the HTTP server."""
221
113
        service = HTTPServer(('', self.port), FakeGrackleRequestHandler)
222
 
        service.store = GrackleStore(self.messages)
 
114
        service.store = MemoryStore(self.messages)
223
115
        for archive_id, messages in service.store.messages.iteritems():
224
116
            for message in messages:
225
117
                message.setdefault('headers', {})
233
125
        os.kill(self.pid, SIGKILL)
234
126
 
235
127
 
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
 
 
244
128
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
245
129
    """A request handler that forwards to server.store."""
246
130
 
271
155
                self.send_response(httplib.OK)
272
156
                self.end_headers()
273
157
                self.wfile.write(simplejson.dumps(response))
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__)
 
158
            except Exception, error:
 
159
                self.send_response(
 
160
                    httplib.BAD_REQUEST, error.__doc__)
281
161
                return
282
162
 
283
163
    def log_message(self, format, *args):
290
170
class TestPutMessage(TestCase):
291
171
 
292
172
    def test_put_message(self):
293
 
        client = GrackleClient('localhost', 8436)
 
173
        client = GrackleClient('localhost', 8420)
294
174
        with ForkedFakeService.from_client(client):
295
175
            client.put_message('arch1', 'asdf', StringIO('This is a message'))
296
176
            with ExpectedException(Exception, 'wtf'):
308
188
            sorted(ids), sorted(messages, key=lambda m: m['message_id']))
309
189
 
310
190
    def test_get_messages(self):
311
 
        client = GrackleClient('localhost', 8435)
 
191
        client = GrackleClient('localhost', 8430)
312
192
        archive = {
313
193
            'baz': [make_message('foo'), make_message('bar')]}
314
194
        with ForkedFakeService.from_client(client, archive):
534
414
        self.assertEqual('you', first_message['headers']['To'])
535
415
        self.assertEqual(
536
416
            'abcdefghi\n\nattactment data.', first_message['body'])
 
417
 
 
418
    def test_date_range(self):
 
419
        client = GrackleClient('localhost', 8448)
 
420
        archive = {
 
421
            'baz': [
 
422
                make_mime_message(
 
423
                    'foo', 'abcdefghi', headers={'date': '2011-12-31'}),
 
424
                make_mime_message(
 
425
                    'bar', 'abcdefghi', headers={'date': '2012-01-01'}),
 
426
                make_mime_message(
 
427
                    'qux', 'abcdefghi', headers={'date': '2012-01-15'}),
 
428
                make_mime_message(
 
429
                    'naf', 'abcdefghi', headers={'date': '2012-01-31'}),
 
430
                make_mime_message(
 
431
                    'doh', 'abcdefghi', headers={'date': '2012-02-01'}),
 
432
                    ]}
 
433
        with ForkedFakeService.from_client(client, archive):
 
434
            response = client.get_messages(
 
435
                'baz', date_range='2012-01-01..2012-01-31')
 
436
        ids = sorted(m['message_id'] for m in response['messages'])
 
437
        self.assertEqual(['bar', 'naf', 'qux'], ids)
 
438
 
 
439
    def test_date_range_unparsabledaterange(self):
 
440
        client = GrackleClient('localhost', 8449)
 
441
        archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
 
442
        with ForkedFakeService.from_client(client, archive):
 
443
            with ExpectedException(UnparsableDateRange, ''):
 
444
                client.get_messages('baz', date_range='2012-01-01')
 
445
 
 
446
    def test_date_range_unparsabledaterange_missing_part(self):
 
447
        client = GrackleClient('localhost', 8450)
 
448
        archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
 
449
        with ForkedFakeService.from_client(client, archive):
 
450
            with ExpectedException(UnparsableDateRange, ''):
 
451
                client.get_messages('baz', date_range='2012-01-01..')
 
452
 
 
453
    def test_date_range_unparsabledaterange_extra_part(self):
 
454
        client = GrackleClient('localhost', 8451)
 
455
        archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
 
456
        with ForkedFakeService.from_client(client, archive):
 
457
            with ExpectedException(UnparsableDateRange, ''):
 
458
                client.get_messages('baz', date_range='2012-01..12-02..12-03')