3
3
BaseHTTPRequestHandler,
5
from email.message import Message
6
from email.mime.multipart import MIMEMultipart
7
from email.mime.text import MIMEText
11
7
from signal import SIGKILL
13
9
from StringIO import StringIO
15
10
from unittest import TestCase
16
11
from urlparse import urlparse
12
from urlparse import parse_qs
18
14
from testtools import ExpectedException
20
16
from grackle.client import (
23
UnsupportedDisplayType,
26
from grackle.store import (
32
def make_message(message_id, body='body', headers=None, hidden=False):
35
headers['Message-Id'] = message_id
37
'message_id': message_id,
39
'thread_id': message_id,
40
'date': headers.get('date', '2005-01-01'),
41
'subject': headers.get('subject', 'subject'),
42
'author': headers.get('author', 'author'),
45
'replies': headers.get('in-reply-to', None),
51
def make_mime_message(message_id, body='body', headers=None, hidden=False,
52
attachment_type=None):
55
parts = MIMEMultipart()
56
parts.attach(MIMEText(body))
57
if attachment_type is not None:
58
attachment = Message()
59
attachment.set_payload('attactment data.')
60
attachment['Content-Type'] = attachment_type
61
attachment['Content-Disposition'] = 'attachment; filename="file.ext"'
62
parts.attach(attachment)
64
message.set_payload(parts.as_string())
65
for key, value in headers.items():
67
return make_json_message(message_id, message.as_string())
70
class ForkedFakeService:
71
"""A Grackle service fake, as a ContextManager."""
73
def __init__(self, port, message_archives=None, write_logs=False):
76
:param port: The tcp port to use.
77
:param message_archives: A dict of lists of dicts representing
78
archives of messages. The outer dict represents the archive,
79
the list represents the list of messages for that archive.
80
:param write_logs: If true, log messages will be written to stdout.
22
def threaded_messages(messages):
26
for message in messages:
27
if message.get('in_reply_to') is None:
28
threads[message['message_id']] = [message]
31
pending.append(message)
32
for message in pending:
33
threads[message['in_reply_to']].append(message)
34
return threads.values()
39
def __init__(self, messages):
40
self.messages = messages
42
def get_messages(self, archive_id, query_string):
43
query = parse_qs(query_string)
44
parameters = simplejson.loads(query['parameters'][0])
45
order = parameters.get('order')
46
messages = self.messages[archive_id]
47
if order is not None :
48
if order not in SUPPORTED_ORDERS:
49
raise UnsupportedOrder
50
elif order.startswith('thread_'):
51
threaded = threaded_messages(messages)
53
if order == 'thread_subject':
54
threaded.sort(key=lambda t: t[0]['subject'])
55
if order == 'thread_oldest':
56
threaded.sort(key=lambda t: min(m['date'] for m in t))
57
if order == 'thread_newest':
58
threaded.sort(key=lambda t: max(m['date'] for m in t))
59
for thread in threaded:
60
messages.extend(thread)
62
messages.sort(key=lambda m: m[order])
64
for message in messages:
66
not parameters['include_hidden']
67
and message.get('hidden', False)):
70
if ('message_ids' in parameters and
71
message['message_id'] not in parameters['message_ids']):
73
message = dict(message)
74
if 'headers' in parameters:
76
(k, v) for k, v in message['headers'].iteritems()
77
if k in parameters['headers'])
78
message['headers'] = headers
79
max_body = parameters.get('max_body_length')
80
if max_body is not None:
81
message['body'] = message['body'][:max_body]
82
new_messages.append(message)
83
messages = new_messages
84
limit = parameters.get('limit', 100)
85
memo = parameters.get('memo')
86
message_id_indices = dict(
87
(m['message_id'], idx) for idx, m in enumerate(messages))
91
start = message_id_indices[memo.encode('rot13')]
93
previous_memo = messages[start - 1]['message_id'].encode('rot13')
96
end = min(start + limit, len(messages))
97
if end < len(messages):
98
next_memo = messages[end]['message_id'].encode('rot13')
101
messages = messages[start:end]
104
'messages': messages,
105
'next_memo': next_memo,
106
'previous_memo': previous_memo
114
def __init__(self, port, messages=None):
84
if message_archives is None:
85
self.message_archives = {}
87
self.message_archives = message_archives
120
self.messages = messages
88
121
self.read_end, self.write_end = os.pipe()
89
self.write_logs = write_logs
92
def from_client(client, message_archives=None):
93
"""Instantiate a ForkedFakeService from the client.
95
:param port: The client to provide service for.
96
:param message_archives: A dict of lists of dicts representing
97
archives of messages. The outer dict represents the archive,
98
the list represents the list of messages for that archive.
100
return ForkedFakeService(client.port, message_archives)
124
def from_client(client, messages=None):
125
return ForkedFake(client.port, messages)
102
127
def is_ready(self):
103
"""Tell the parent process that the server is ready for writes."""
104
128
os.write(self.write_end, 'asdf')
106
130
def __enter__(self):
109
Fork and start a server in the child. Return when the server is ready
113
133
self.start_server()
118
138
def start_server(self):
119
"""Start the HTTP server."""
120
139
service = HTTPServer(('', self.port), FakeGrackleRequestHandler)
121
service.store = MemoryStore(self.message_archives)
122
for archive_id, messages in service.store.message_archives.iteritems():
140
service.store = GrackleStore(self.messages)
141
for archive_id, messages in service.store.messages.iteritems():
123
142
for message in messages:
124
143
message.setdefault('headers', {})
128
stream=sys.stderr, level=logging.INFO)
129
145
service.serve_forever()
131
147
def __exit__(self, exc_type, exc_val, traceback):
132
148
os.kill(self.pid, SIGKILL)
151
SUPPORTED_ORDERS = set(
152
['date', 'author', 'subject', 'thread_newest', 'thread_oldest',
135
156
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
136
"""A request handler that forwards to server.store."""
138
def __init__(self, *args, **kwargs):
139
"""Constructor. Sets up logging."""
140
self.logger = logging.getLogger('http')
141
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
143
158
def do_POST(self):
144
"""Create a message on POST."""
145
159
message = self.rfile.read(int(self.headers['content-length']))
146
scheme, netloc, path, params, query_string, fragments = (
148
parts = path.split('/')
149
if parts[1] == 'archive' and len(parts) == 4:
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)
157
self.send_error(httplib.BAD_REQUEST)
160
if message == 'This is a message':
161
self.send_response(httplib.CREATED)
165
self.send_error(httplib.BAD_REQUEST)
159
167
def do_GET(self):
160
"""Retrieve a list of messages on GET."""
161
168
scheme, netloc, path, params, query_string, fragments = (
162
169
urlparse(self.path))
163
170
parts = path.split('/')
168
175
self.send_response(httplib.OK)
169
176
self.end_headers()
170
177
self.wfile.write(simplejson.dumps(response))
171
except Exception, error:
173
httplib.BAD_REQUEST, error.__doc__)
178
except UnsupportedOrder:
179
self.send_response(httplib.BAD_REQUEST)
180
self.wfile.write('Unsupported order')
176
def log_message(self, format, *args):
177
"""Override log_message to use standard Python logging."""
178
message = "%s - - [%s] %s\n" % (
179
self.address_string(), self.log_date_time_string(), format % args)
180
self.logger.info(message)
183
184
class TestPutMessage(TestCase):
185
186
def test_put_message(self):
186
client = GrackleClient('localhost', 8420)
187
message_archives = {'arch1': []}
188
with ForkedFakeService.from_client(client, message_archives):
189
client.put_message('arch1', 'id1', StringIO('This is a message'))
190
response = client.get_messages('arch1')
191
self.assertEqual(1, len(response['messages']))
192
message = response['messages'][0]
193
self.assertEqual('id1', message['message_id'])
195
def test_put_message_without_archive(self):
196
client = GrackleClient('localhost', 8421)
197
message_archives = {'arch1': []}
198
with ForkedFakeService.from_client(client, message_archives):
187
client = GrackleClient('localhost', 8436)
188
with ForkedFake.from_client(client):
189
client.put_message('arch1', 'asdf', StringIO('This is a message'))
199
190
with ExpectedException(Exception, 'wtf'):
200
client.put_message('no-archive', 'id1', StringIO('message'))
191
client.put_message('arch1', 'asdf',
192
StringIO('This is not a message'))
203
195
class TestGetMessages(TestCase):
223
216
def test_get_messages_by_id(self):
224
217
client = GrackleClient('localhost', 8437)
226
'baz': [make_message('foo'), make_message('bar')]}
227
with ForkedFakeService.from_client(client, archive):
218
with ForkedFake.from_client(client,
220
[{'message_id': 'foo'},
221
{'message_id': 'bar'}]}):
228
222
response = client.get_messages('baz', message_ids=['foo'])
229
223
message, = response['messages']
230
224
self.assertEqual('foo', message['message_id'])
232
226
def test_get_messages_batching(self):
233
227
client = GrackleClient('localhost', 8438)
234
archive = {'baz': [make_message('foo'), make_message('bar')]}
235
with ForkedFakeService.from_client(client, archive):
228
with ForkedFake.from_client(client,
230
[{'message_id': 'foo'},
231
{'message_id': 'bar'}]}):
236
232
response = client.get_messages('baz', limit=1)
237
233
self.assertEqual(1, len(response['messages']))
238
234
messages = response['messages']
301
288
def test_get_messages_thread_newest_order(self):
302
289
client = GrackleClient('localhost', 8439)
305
make_message('bar', headers={'date': 'x'}),
306
make_message('qux', headers={'date': 'w'}),
307
make_message('foo', headers={'date': 'y',
308
'in-reply-to': 'bar'}),
309
make_message('baz', headers={'date': 'z',
310
'in-reply-to': 'qux'}),
312
with ForkedFakeService.from_client(client, archive):
290
with ForkedFake.from_client(client, {'baz': [
291
{'message_id': 'bar', 'date': 'x'},
292
{'message_id': 'qux', 'date': 'w'},
293
{'message_id': 'foo', 'date': 'y', 'in_reply_to': 'bar'},
294
{'message_id': 'baz', 'date': 'z', 'in_reply_to': 'qux'},
313
296
response = client.get_messages('baz', order='date')
314
297
self.assertIDOrder(
315
298
['qux', 'bar', 'foo', 'baz'], response['messages'])
320
303
def test_get_messages_unsupported_order(self):
321
304
client = GrackleClient('localhost', 8439)
324
make_message('foo', headers={'date': '2011-03-25'}),
325
make_message('foo', headers={'date': '2011-03-24'}),
327
with ForkedFakeService.from_client(client, archive):
328
with ExpectedException(UnsupportedOrder, ''):
305
with ForkedFake.from_client(client,
306
{'baz': [{'message_id': 'foo', 'date': '2011-03-25'},
307
{'message_id': 'bar', 'date': '2011-03-24'}]}):
308
with ExpectedException(UnsupportedOrder):
329
309
client.get_messages('baz', order='nonsense')
331
311
def test_get_messages_headers_no_headers(self):
332
312
client = GrackleClient('localhost', 8440)
333
archive = {'baz': [make_message('foo')]}
334
with ForkedFakeService.from_client(client, archive):
313
with ForkedFake.from_client(client,
315
{'message_id': 'foo'}
335
317
response = client.get_messages('baz', headers=[
336
318
'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
337
319
first_message = response['messages'][0]
364
347
def test_get_messages_max_body_length(self):
365
348
client = GrackleClient('localhost', 8443)
366
archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
367
with ForkedFakeService.from_client(client, archive):
349
with ForkedFake.from_client(client,
351
{'message_id': 'foo', 'body': u'abcdefghi'}
368
353
response = client.get_messages('baz', max_body_length=3)
369
354
first_message = response['messages'][0]
370
355
self.assertEqual('abc', first_message['body'])
372
357
def test_include_hidden(self):
373
358
client = GrackleClient('localhost', 8444)
376
make_message('foo', hidden=True),
377
make_message('bar', hidden=False),
379
with ForkedFakeService.from_client(client, archive):
359
with ForkedFake.from_client(client,
361
{'message_id': 'foo', 'hidden': True},
362
{'message_id': 'bar', 'hidden': False}
380
364
response = client.get_messages('baz', include_hidden=True)
381
365
self.assertMessageIDs(['bar', 'foo'], response['messages'])
382
366
response = client.get_messages('baz', include_hidden=False)
383
367
self.assertMessageIDs(['bar'], response['messages'])
385
def test_display_type_unknown_value(self):
386
client = GrackleClient('localhost', 8445)
387
archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
388
with ForkedFakeService.from_client(client, archive):
389
with ExpectedException(UnsupportedDisplayType, ''):
390
client.get_messages('baz', display_type='unknown')
392
def test_display_type_headers_only(self):
393
client = GrackleClient('localhost', 8446)
396
make_message('foo', body=u'abcdefghi',
397
headers={'From': 'me', 'To': 'you'})]}
398
with ForkedFakeService.from_client(client, archive):
399
response = client.get_messages('baz', display_type='headers-only')
400
first_message = response['messages'][0]
401
self.assertEqual('foo', first_message['message_id'])
403
{'From': 'me', 'Message-Id': 'foo', 'To': 'you'},
404
first_message['headers'])
405
self.assertNotIn('body', first_message)
407
def test_display_type_text_only(self):
408
client = GrackleClient('localhost', 8446)
413
headers={'From': 'me', 'To': 'you'},
414
attachment_type='text/x-diff')]}
415
with ForkedFakeService.from_client(client, archive):
416
response = client.get_messages('baz', display_type='text-only')
417
first_message = response['messages'][0]
418
self.assertEqual('foo', first_message['message_id'])
419
self.assertEqual('me', first_message['headers']['From'])
420
self.assertEqual('you', first_message['headers']['To'])
421
self.assertEqual(archive['baz'][0]['body'], first_message['body'])
423
def test_display_type_all(self):
424
client = GrackleClient('localhost', 8447)
429
headers={'From': 'me', 'To': 'you'},
430
attachment_type='text/x-diff')]}
431
with ForkedFakeService.from_client(client, archive):
432
response = client.get_messages('baz', display_type='all')
433
first_message = response['messages'][0]
434
self.assertEqual('foo', first_message['message_id'])
435
self.assertEqual('me', first_message['headers']['From'])
436
self.assertEqual('you', first_message['headers']['To'])
437
self.assertEqual(archive['baz'][0]['body'], first_message['body'])
439
def test_date_range(self):
440
client = GrackleClient('localhost', 8448)
444
'foo', 'abcdefghi', headers={'date': '2011-12-31'}),
446
'bar', 'abcdefghi', headers={'date': '2012-01-01'}),
448
'qux', 'abcdefghi', headers={'date': '2012-01-15'}),
450
'naf', 'abcdefghi', headers={'date': '2012-01-31'}),
452
'doh', 'abcdefghi', headers={'date': '2012-02-01'}),
454
with ForkedFakeService.from_client(client, archive):
455
response = client.get_messages(
456
'baz', date_range='2012-01-01..2012-01-31')
457
ids = sorted(m['message_id'] for m in response['messages'])
458
self.assertEqual(['bar', 'naf', 'qux'], ids)
460
def test_date_range_unparsabledaterange(self):
461
client = GrackleClient('localhost', 8449)
462
archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
463
with ForkedFakeService.from_client(client, archive):
464
with ExpectedException(UnparsableDateRange, ''):
465
client.get_messages('baz', date_range='2012-01-01')
467
def test_date_range_unparsabledaterange_missing_part(self):
468
client = GrackleClient('localhost', 8450)
469
archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
470
with ForkedFakeService.from_client(client, archive):
471
with ExpectedException(UnparsableDateRange, ''):
472
client.get_messages('baz', date_range='2012-01-01..')
474
def test_date_range_unparsabledaterange_extra_part(self):
475
client = GrackleClient('localhost', 8451)
476
archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
477
with ForkedFakeService.from_client(client, archive):
478
with ExpectedException(UnparsableDateRange, ''):
479
client.get_messages('baz', date_range='2012-01..12-02..12-03')