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