1
from BaseHTTPServer import (
3
BaseHTTPRequestHandler,
7
from signal import SIGKILL
9
from StringIO import StringIO
10
from unittest import TestCase
11
from urlparse import urlparse
12
from urlparse import parse_qs
14
from testtools import ExpectedException
16
from grackle.client import (
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])
63
messages = [m for m in messages
64
if 'message_ids' not in parameters or
65
m['message_id'] in parameters['message_ids']]
66
limit = parameters.get('limit', 100)
67
memo = parameters.get('memo')
68
message_id_indices = dict(
69
(m['message_id'], idx) for idx, m in enumerate(messages))
73
start = message_id_indices[memo.encode('rot13')]
75
previous_memo = messages[start - 1]['message_id'].encode('rot13')
78
end = min(start + limit, len(messages))
79
if end < len(messages):
80
next_memo = messages[end]['message_id'].encode('rot13')
83
messages = messages[start:end]
85
for message in messages:
86
message = dict(message)
87
if 'headers' in parameters:
89
(k, v) for k, v in message['headers'].iteritems()
90
if k in parameters['headers'])
91
message['headers'] = headers
92
max_body = parameters.get('max_body_length')
93
if max_body is not None:
94
message['body'] = message['body'][:max_body]
95
new_messages.append(message)
97
'messages': new_messages,
98
'next_memo': next_memo,
99
'previous_memo': previous_memo
107
def __init__(self, port, messages=None):
110
self.messages = messages
111
self.read_end, self.write_end = os.pipe()
114
os.write(self.write_end, 'asdf')
121
os.read(self.read_end, 1)
124
def start_server(self):
125
service = HTTPServer(('', self.port), FakeGrackleRequestHandler)
126
service.store = GrackleStore(self.messages)
127
for archive_id, messages in service.store.messages.iteritems():
128
for message in messages:
129
message.setdefault('headers', {})
131
service.serve_forever()
133
def __exit__(self, exc_type, exc_val, traceback):
134
os.kill(self.pid, SIGKILL)
137
SUPPORTED_ORDERS = set(
138
['date', 'author', 'subject', 'thread_newest', 'thread_oldest',
142
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
145
message = self.rfile.read(int(self.headers['content-length']))
146
if message == 'This is a message':
147
self.send_response(httplib.CREATED)
151
self.send_error(httplib.BAD_REQUEST)
154
scheme, netloc, path, params, query_string, fragments = (
156
parts = path.split('/')
157
if parts[1] == 'archive':
159
response = self.server.store.get_messages(
160
parts[2], query_string)
161
self.send_response(httplib.OK)
163
self.wfile.write(simplejson.dumps(response))
164
except UnsupportedOrder:
165
self.send_response(httplib.BAD_REQUEST)
166
self.wfile.write('Unsupported order')
170
def fake_grackle_service(client, messages=None):
173
return ForkedFake(client.port, messages)
176
class TestPutMessage(TestCase):
178
def test_put_message(self):
179
client = GrackleClient('localhost', 8436)
180
with fake_grackle_service(client):
181
client.put_message('arch1', 'asdf', StringIO('This is a message'))
182
with ExpectedException(Exception, 'wtf'):
183
client.put_message('arch1', 'asdf',
184
StringIO('This is not a message'))
187
class TestGetMessages(TestCase):
189
def assertIDOrder(self, ids, messages):
190
self.assertEqual(ids, [m['message_id'] for m in messages])
192
def assertMessageIDs(self, ids, messages):
194
sorted(ids), sorted(messages, key=lambda m:m['message_id']))
196
def test_get_messages(self):
197
client = GrackleClient('localhost', 8435)
198
with fake_grackle_service(client,
200
[{'message_id': 'foo'},
201
{'message_id': 'bar'}]}):
202
response = client.get_messages('baz')
203
self.assertEqual(['bar', 'foo'], sorted(m['message_id'] for m in
204
response['messages']))
205
self.assertIs(None, response['next_memo'])
206
self.assertIs(None, response['previous_memo'])
208
def test_get_messages_by_id(self):
209
client = GrackleClient('localhost', 8437)
210
with fake_grackle_service(client,
212
[{'message_id': 'foo'},
213
{'message_id': 'bar'}]}):
214
response = client.get_messages('baz', message_ids=['foo'])
215
message, = response['messages']
216
self.assertEqual('foo', message['message_id'])
218
def test_get_messages_batching(self):
219
client = GrackleClient('localhost', 8438)
220
with fake_grackle_service(client,
222
[{'message_id': 'foo'},
223
{'message_id': 'bar'}]}):
224
response = client.get_messages('baz', limit=1)
225
self.assertEqual(1, len(response['messages']))
226
messages = response['messages']
227
response = client.get_messages(
228
'baz', limit=1, memo=response['next_memo'])
229
self.assertEqual(1, len(response['messages']))
230
messages.extend(response['messages'])
231
self.assertMessageIDs(['foo', 'bar'], messages)
233
def get_messages_member_order_test(self, key):
234
client = GrackleClient('localhost', 8439)
235
with fake_grackle_service(client,
236
{'baz': [{'message_id': 'foo', key: '2011-03-25'},
237
{'message_id': 'bar', key: '2011-03-24'}]}):
238
response = client.get_messages('baz')
239
self.assertIDOrder(['foo', 'bar'], response['messages'])
240
response = client.get_messages('baz', order=key)
241
self.assertIDOrder(['bar', 'foo'], response['messages'])
243
def test_get_messages_date_order(self):
244
self.get_messages_member_order_test('date')
246
def test_get_messages_author_order(self):
247
self.get_messages_member_order_test('author')
249
def test_get_messages_subject_order(self):
250
self.get_messages_member_order_test('subject')
252
def test_get_messages_thread_subject_order(self):
253
client = GrackleClient('localhost', 8439)
254
with fake_grackle_service(client, {'baz': [
255
{'message_id': 'bar', 'subject': 'y'},
256
{'message_id': 'qux', 'subject': 'z'},
257
{'message_id': 'foo', 'subject': 'x', 'in_reply_to': 'qux'},
259
response = client.get_messages('baz')
260
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
261
response = client.get_messages('baz', order='subject')
262
self.assertIDOrder(['foo', 'bar', 'qux'], response['messages'])
263
response = client.get_messages('baz', order='thread_subject')
264
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
266
def test_get_messages_thread_oldest_order(self):
267
client = GrackleClient('localhost', 8439)
268
with fake_grackle_service(client, {'baz': [
269
{'message_id': 'bar', 'date': 'x'},
270
{'message_id': 'qux', 'date': 'z'},
271
{'message_id': 'foo', 'date': 'y', 'in_reply_to': 'qux'},
273
response = client.get_messages('baz')
274
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
275
response = client.get_messages('baz', order='date')
276
self.assertIDOrder(['bar', 'foo', 'qux'], response['messages'])
277
response = client.get_messages('baz', order='thread_oldest')
278
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
280
def test_get_messages_thread_newest_order(self):
281
client = GrackleClient('localhost', 8439)
282
with fake_grackle_service(client, {'baz': [
283
{'message_id': 'bar', 'date': 'x'},
284
{'message_id': 'qux', 'date': 'w'},
285
{'message_id': 'foo', 'date': 'y', 'in_reply_to': 'bar'},
286
{'message_id': 'baz', 'date': 'z', 'in_reply_to': 'qux'},
288
response = client.get_messages('baz', order='date')
290
['qux', 'bar', 'foo', 'baz'], response['messages'])
291
response = client.get_messages('baz', order='thread_newest')
293
['bar', 'foo', 'qux', 'baz'], response['messages'])
295
def test_get_messages_unsupported_order(self):
296
client = GrackleClient('localhost', 8439)
297
with fake_grackle_service(client,
298
{'baz': [{'message_id': 'foo', 'date': '2011-03-25'},
299
{'message_id': 'bar', 'date': '2011-03-24'}]}):
300
with ExpectedException(UnsupportedOrder):
301
client.get_messages('baz', order='nonsense')
303
def test_get_messages_headers_no_headers(self):
304
client = GrackleClient('localhost', 8440)
305
with fake_grackle_service(client,
307
{'message_id': 'foo'}
309
response = client.get_messages('baz', headers=[
310
'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
311
first_message = response['messages'][0]
312
self.assertEqual('foo', first_message['message_id'])
313
self.assertEqual({}, first_message['headers'])
315
def test_get_messages_headers_exclude_headers(self):
316
client = GrackleClient('localhost', 8440)
317
with fake_grackle_service(client,
319
{'message_id': 'foo', 'headers': {'From': 'me'}}
321
response = client.get_messages('baz', headers=[
322
'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
323
first_message = response['messages'][0]
324
self.assertEqual('foo', first_message['message_id'])
325
self.assertEqual({}, first_message['headers'])
327
def test_get_messages_headers_include_headers(self):
328
client = GrackleClient('localhost', 8440)
329
with fake_grackle_service(client,
331
{'message_id': 'foo', 'headers': {'From': 'me', 'To': 'you'}}
333
response = client.get_messages('baz', headers=[
335
first_message = response['messages'][0]
336
self.assertEqual('foo', first_message['message_id'])
337
self.assertEqual({'From': 'me', 'To': 'you'}, first_message['headers'])
339
def test_get_messages_max_body_length(self):
340
client = GrackleClient('localhost', 8440)
341
with fake_grackle_service(client,
343
{'message_id': 'foo', 'body': u'abcdefghi'}
345
response = client.get_messages('baz', max_body_length=3)
346
first_message = response['messages'][0]
347
self.assertEqual('abc', first_message['body'])