« back to all changes in this revision
Viewing changes to grackle/tests/test_client.py
- browse files at revision 15
- compare with another revision
- download diff
- download tarball
- view history from revision 15
- Committer: Aaron Bentley
- Date: 2012-01-11 14:04:41 UTC
- Revision ID: aaron@canonical.com-20120111140441-l4sanxq1en07oblx
Test filtering by message-id.
- files modified:
- grackle-put-message
added
removed
grackle/tests/test_client.py
15
15
16
16
from grackle.client import (
17
17
GrackleClient,
18
UnsupportedOrder,
19
18
)
20
19
21
20
22
def threaded_messages(messages):
23
threads = {}
24
count = 0
25
pending = []
26
for message in messages:
27
if message.get('in_reply_to') is None:
28
threads[message['message_id']] = [message]
29
count += 1
30
else:
31
pending.append(message)
32
for message in pending:
33
threads[message['in_reply_to']].append(message)
34
return threads.values()
35
36
37
class GrackleStore:
38
39
def __init__(self, messages):
40
self.messages = messages
41
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)
52
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)
61
else:
62
messages.sort(key=lambda m: m[order])
63
messages = [m for m in messages
64
]
65
new_messages = []
66
for message in messages:
67
if (
68
not parameters['include_hidden']
69
and message.get('hidden', False)):
70
continue
71
72
if ('message_ids' in parameters and
73
message['message_id'] not in parameters['message_ids']):
74
continue
75
message = dict(message)
76
if 'headers' in parameters:
77
headers = dict(
78
(k, v) for k, v in message['headers'].iteritems()
79
if k in parameters['headers'])
80
message['headers'] = headers
81
max_body = parameters.get('max_body_length')
82
if max_body is not None:
83
message['body'] = message['body'][:max_body]
84
new_messages.append(message)
85
messages = new_messages
86
limit = parameters.get('limit', 100)
87
memo = parameters.get('memo')
88
message_id_indices = dict(
89
(m['message_id'], idx) for idx, m in enumerate(messages))
90
if memo is None:
91
start = 0
92
else:
93
start = message_id_indices[memo.encode('rot13')]
94
if start > 0:
95
previous_memo = messages[start - 1]['message_id'].encode('rot13')
96
else:
97
previous_memo = None
98
end = min(start + limit, len(messages))
99
if end < len(messages):
100
next_memo = messages[end]['message_id'].encode('rot13')
101
else:
102
next_memo = None
103
messages = messages[start:end]
104
105
response = {
106
'messages': messages,
107
'next_memo': next_memo,
108
'previous_memo': previous_memo
109
}
110
return response
111
112
113
114
21
class ForkedFake:
115
22
116
23
def __init__(self, port, messages=None):
132
39
133
40
def start_server(self):
134
41
service = HTTPServer(('', self.port), FakeGrackleRequestHandler)
135
service.store = GrackleStore(self.messages)
136
for archive_id, messages in service.store.messages.iteritems():
137
for message in messages:
138
message.setdefault('headers', {})
42
service.messages = self.messages
139
43
self.is_ready()
140
44
service.serve_forever()
141
45
143
47
os.kill(self.pid, SIGKILL)
144
48
145
49
146
SUPPORTED_ORDERS = set(
147
['date', 'author', 'subject', 'thread_newest', 'thread_oldest',
148
'thread_subject'])
149
150
151
50
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
152
51
153
52
def do_POST(self):
162
61
def do_GET(self):
163
62
scheme, netloc, path, params, query_string, fragments = (
164
63
urlparse(self.path))
165
parts = path.split('/')
166
if parts[1] == 'archive':
167
try:
168
response = self.server.store.get_messages(
169
parts[2], query_string)
170
self.send_response(httplib.OK)
171
self.end_headers()
172
self.wfile.write(simplejson.dumps(response))
173
except UnsupportedOrder:
174
self.send_response(httplib.BAD_REQUEST)
175
self.wfile.write('Unsupported order')
176
return
64
archive = os.path.split(path)[1]
65
query = parse_qs(query_string)
66
parameters = simplejson.loads(query['parameters'][0])
67
self.send_response(httplib.OK)
68
self.end_headers()
69
messages = [m for m in self.server.messages[archive] if 'message_ids'
70
not in parameters or m['message-id'] in
71
parameters['message_ids']]
72
self.wfile.write(simplejson.dumps(messages))
177
73
178
74
179
75
def fake_grackle_service(client, messages=None):
195
91
196
92
class TestGetMessages(TestCase):
197
93
198
def assertIDOrder(self, ids, messages):
199
self.assertEqual(ids, [m['message_id'] for m in messages])
200
201
def assertMessageIDs(self, ids, messages):
202
self.assertIDOrder(
203
sorted(ids), sorted(messages, key=lambda m:m['message_id']))
204
205
94
def test_get_messages(self):
206
95
client = GrackleClient('localhost', 8435)
207
96
with fake_grackle_service(client,
208
97
{'baz':
209
[{'message_id': 'foo'},
210
{'message_id': 'bar'}]}):
98
[{'message-id': 'foo'},
99
{'message-id': 'bar'}]}):
211
100
response = client.get_messages('baz')
212
self.assertEqual(['bar', 'foo'], sorted(m['message_id'] for m in
213
response['messages']))
214
self.assertIs(None, response['next_memo'])
215
self.assertIs(None, response['previous_memo'])
101
self.assertEqual(['bar', 'foo'], sorted(m['message-id'] for m in
102
response))
216
103
217
104
def test_get_messages_by_id(self):
218
105
client = GrackleClient('localhost', 8437)
219
106
with fake_grackle_service(client,
220
107
{'baz':
221
[{'message_id': 'foo'},
222
{'message_id': 'bar'}]}):
223
response = client.get_messages('baz', message_ids=['foo'])
224
message, = response['messages']
225
self.assertEqual('foo', message['message_id'])
226
227
def test_get_messages_batching(self):
228
client = GrackleClient('localhost', 8438)
229
with fake_grackle_service(client,
230
{'baz':
231
[{'message_id': 'foo'},
232
{'message_id': 'bar'}]}):
233
response = client.get_messages('baz', limit=1)
234
self.assertEqual(1, len(response['messages']))
235
messages = response['messages']
236
response = client.get_messages(
237
'baz', limit=1, memo=response['next_memo'])
238
self.assertEqual(1, len(response['messages']))
239
messages.extend(response['messages'])
240
self.assertMessageIDs(['foo', 'bar'], messages)
241
242
def get_messages_member_order_test(self, key):
243
client = GrackleClient('localhost', 8439)
244
with fake_grackle_service(client,
245
{'baz': [{'message_id': 'foo', key: '2011-03-25'},
246
{'message_id': 'bar', key: '2011-03-24'}]}):
247
response = client.get_messages('baz')
248
self.assertIDOrder(['foo', 'bar'], response['messages'])
249
response = client.get_messages('baz', order=key)
250
self.assertIDOrder(['bar', 'foo'], response['messages'])
251
252
def test_get_messages_date_order(self):
253
self.get_messages_member_order_test('date')
254
255
def test_get_messages_author_order(self):
256
self.get_messages_member_order_test('author')
257
258
def test_get_messages_subject_order(self):
259
self.get_messages_member_order_test('subject')
260
261
def test_get_messages_thread_subject_order(self):
262
client = GrackleClient('localhost', 8439)
263
with fake_grackle_service(client, {'baz': [
264
{'message_id': 'bar', 'subject': 'y'},
265
{'message_id': 'qux', 'subject': 'z'},
266
{'message_id': 'foo', 'subject': 'x', 'in_reply_to': 'qux'},
267
]}):
268
response = client.get_messages('baz')
269
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
270
response = client.get_messages('baz', order='subject')
271
self.assertIDOrder(['foo', 'bar', 'qux'], response['messages'])
272
response = client.get_messages('baz', order='thread_subject')
273
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
274
275
def test_get_messages_thread_oldest_order(self):
276
client = GrackleClient('localhost', 8439)
277
with fake_grackle_service(client, {'baz': [
278
{'message_id': 'bar', 'date': 'x'},
279
{'message_id': 'qux', 'date': 'z'},
280
{'message_id': 'foo', 'date': 'y', 'in_reply_to': 'qux'},
281
]}):
282
response = client.get_messages('baz')
283
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
284
response = client.get_messages('baz', order='date')
285
self.assertIDOrder(['bar', 'foo', 'qux'], response['messages'])
286
response = client.get_messages('baz', order='thread_oldest')
287
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
288
289
def test_get_messages_thread_newest_order(self):
290
client = GrackleClient('localhost', 8439)
291
with fake_grackle_service(client, {'baz': [
292
{'message_id': 'bar', 'date': 'x'},
293
{'message_id': 'qux', 'date': 'w'},
294
{'message_id': 'foo', 'date': 'y', 'in_reply_to': 'bar'},
295
{'message_id': 'baz', 'date': 'z', 'in_reply_to': 'qux'},
296
]}):
297
response = client.get_messages('baz', order='date')
298
self.assertIDOrder(
299
['qux', 'bar', 'foo', 'baz'], response['messages'])
300
response = client.get_messages('baz', order='thread_newest')
301
self.assertIDOrder(
302
['bar', 'foo', 'qux', 'baz'], response['messages'])
303
304
def test_get_messages_unsupported_order(self):
305
client = GrackleClient('localhost', 8439)
306
with fake_grackle_service(client,
307
{'baz': [{'message_id': 'foo', 'date': '2011-03-25'},
308
{'message_id': 'bar', 'date': '2011-03-24'}]}):
309
with ExpectedException(UnsupportedOrder):
310
client.get_messages('baz', order='nonsense')
311
312
def test_get_messages_headers_no_headers(self):
313
client = GrackleClient('localhost', 8440)
314
with fake_grackle_service(client,
315
{'baz': [
316
{'message_id': 'foo'}
317
]}):
318
response = client.get_messages('baz', headers=[
319
'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
320
first_message = response['messages'][0]
321
self.assertEqual('foo', first_message['message_id'])
322
self.assertEqual({}, first_message['headers'])
323
324
def test_get_messages_headers_exclude_headers(self):
325
client = GrackleClient('localhost', 8441)
326
with fake_grackle_service(client,
327
{'baz': [
328
{'message_id': 'foo', 'headers': {'From': 'me'}}
329
]}):
330
response = client.get_messages('baz', headers=[
331
'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
332
first_message = response['messages'][0]
333
self.assertEqual('foo', first_message['message_id'])
334
self.assertEqual({}, first_message['headers'])
335
336
def test_get_messages_headers_include_headers(self):
337
client = GrackleClient('localhost', 8442)
338
with fake_grackle_service(client,
339
{'baz': [
340
{'message_id': 'foo', 'headers': {'From': 'me', 'To': 'you'}}
341
]}):
342
response = client.get_messages('baz', headers=[
343
'From', 'To'])
344
first_message = response['messages'][0]
345
self.assertEqual('foo', first_message['message_id'])
346
self.assertEqual({'From': 'me', 'To': 'you'}, first_message['headers'])
347
348
def test_get_messages_max_body_length(self):
349
client = GrackleClient('localhost', 8443)
350
with fake_grackle_service(client,
351
{'baz': [
352
{'message_id': 'foo', 'body': u'abcdefghi'}
353
]}):
354
response = client.get_messages('baz', max_body_length=3)
355
first_message = response['messages'][0]
356
self.assertEqual('abc', first_message['body'])
357
358
def test_include_hidden(self):
359
client = GrackleClient('localhost', 8444)
360
with fake_grackle_service(client,
361
{'baz': [
362
{'message_id': 'foo', 'hidden': True},
363
{'message_id': 'bar', 'hidden': False}
364
]}):
365
response = client.get_messages('baz', include_hidden=True)
366
self.assertMessageIDs(['bar', 'foo'], response['messages'])
367
response = client.get_messages('baz', include_hidden=False)
368
self.assertMessageIDs(['bar'], response['messages'])
369
108
[{'message-id': 'foo'},
109
{'message-id': 'bar'}]}):
110
message, = client.get_messages('baz', message_ids=['foo'])
111
self.assertEqual('foo', message['message-id'])
Loggerhead is a web-based interface for Breezy
Version: 2.0.1