« back to all changes in this revision
Viewing changes to grackle/tests/test_client.py
- browse files at revision 9
- compare with another revision
- download diff
- download tarball
- view history from revision 9
- Committer: Aaron Bentley
- Date: 2012-01-10 15:36:31 UTC
- Revision ID: aaron@canonical.com-20120110153631-vvqlfg122u08wsrt
Accept arbitrary permalink urls.
- files modified:
- Makefile
added
removed
grackle/tests/test_client.py
3
3
BaseHTTPRequestHandler,
4
4
)
5
5
import httplib
6
import logging
7
6
import os
8
7
from signal import SIGKILL
9
import simplejson
10
8
from StringIO import StringIO
11
import sys
12
9
from unittest import TestCase
13
from urlparse import urlparse
14
from urlparse import parse_qs
15
10
16
11
from testtools import ExpectedException
17
12
18
13
from grackle.client import (
19
14
GrackleClient,
20
UnsupportedOrder,
21
15
)
22
16
23
17
24
def threaded_messages(messages):
25
threads = {}
26
count = 0
27
pending = []
28
for message in messages:
29
if message.get('in_reply_to') is None:
30
threads[message['message_id']] = [message]
31
count += 1
32
else:
33
pending.append(message)
34
for message in pending:
35
threads[message['in_reply_to']].append(message)
36
return threads.values()
37
38
39
class GrackleStore:
40
41
def __init__(self, messages):
42
self.messages = messages
43
44
def get_messages(self, archive_id, query_string):
45
query = parse_qs(query_string)
46
parameters = simplejson.loads(query['parameters'][0])
47
order = parameters.get('order')
48
messages = self.messages[archive_id]
49
if order is not None :
50
if order not in SUPPORTED_ORDERS:
51
raise UnsupportedOrder
52
elif order.startswith('thread_'):
53
threaded = threaded_messages(messages)
54
messages = []
55
if order == 'thread_subject':
56
threaded.sort(key=lambda t: t[0]['subject'])
57
if order == 'thread_oldest':
58
threaded.sort(key=lambda t: min(m['date'] for m in t))
59
if order == 'thread_newest':
60
threaded.sort(key=lambda t: max(m['date'] for m in t))
61
for thread in threaded:
62
messages.extend(thread)
63
else:
64
messages.sort(key=lambda m: m[order])
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
class ForkedFake:
115
116
def __init__(self, port, messages=None, write_logs=False):
18
class Forked:
19
20
def __init__(self, func_or_method, *args):
21
self.func_or_method = func_or_method
117
22
self.pid = None
118
self.port = port
119
if messages is None:
120
self.messages = {}
121
else:
122
self.messages = messages
123
self.read_end, self.write_end = os.pipe()
124
self.write_logs = write_logs
125
126
@staticmethod
127
def from_client(client, messages=None):
128
return ForkedFake(client.port, messages)
129
130
def is_ready(self):
131
os.write(self.write_end, 'asdf')
23
self.args = args
132
24
133
25
def __enter__(self):
134
26
pid = os.fork()
135
if pid == 0:
136
self.start_server()
137
self.pid = pid
138
os.read(self.read_end, 1)
139
return
27
if pid != 0:
28
self.pid = pid
29
return
30
self.func_or_method(*self.args)
140
31
141
def start_server(self):
142
service = HTTPServer(('', self.port), FakeGrackleRequestHandler)
143
service.store = GrackleStore(self.messages)
144
for archive_id, messages in service.store.messages.iteritems():
145
for message in messages:
146
message.setdefault('headers', {})
147
self.is_ready()
148
if self.write_logs:
149
logging.basicConfig(
150
stream=sys.stderr, level=logging.INFO)
151
service.serve_forever()
152
32
153
33
def __exit__(self, exc_type, exc_val, traceback):
154
34
os.kill(self.pid, SIGKILL)
155
35
156
36
157
SUPPORTED_ORDERS = set(
158
['date', 'author', 'subject', 'thread_newest', 'thread_oldest',
159
'thread_subject'])
160
161
162
37
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
163
38
164
def __init__(self, *args, **kwargs):
165
self.logger = logging.getLogger('http')
166
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
167
168
def do_POST(self):
39
def do_PUT(self):
169
40
message = self.rfile.read(int(self.headers['content-length']))
170
41
if message == 'This is a message':
171
42
self.send_response(httplib.CREATED)
174
45
else:
175
46
self.send_error(httplib.BAD_REQUEST)
176
47
177
def do_GET(self):
178
scheme, netloc, path, params, query_string, fragments = (
179
urlparse(self.path))
180
parts = path.split('/')
181
if parts[1] == 'archive':
182
try:
183
response = self.server.store.get_messages(
184
parts[2], query_string)
185
self.send_response(httplib.OK)
186
self.end_headers()
187
self.wfile.write(simplejson.dumps(response))
188
except UnsupportedOrder:
189
self.send_response(httplib.BAD_REQUEST)
190
self.wfile.write('Unsupported order')
191
return
192
193
def log_message(self, format, *args):
194
message = "%s - - [%s] %s\n" % (
195
self.address_string(), self.log_date_time_string(), format%args)
196
self.logger.info(message)
48
49
def run_service(port):
50
service = HTTPServer(('', port), FakeGrackleRequestHandler)
51
service.serve_forever()
52
197
53
198
54
199
55
class TestPutMessage(TestCase):
200
56
201
57
def test_put_message(self):
202
client = GrackleClient('localhost', 8436)
203
with ForkedFake.from_client(client):
58
client = GrackleClient('localhost', 8435)
59
with Forked(run_service, client.port):
204
60
client.put_message('arch1', 'asdf', StringIO('This is a message'))
205
61
with ExpectedException(Exception, 'wtf'):
206
62
client.put_message('arch1', 'asdf',
207
63
StringIO('This is not a message'))
208
209
210
class TestGetMessages(TestCase):
211
212
def assertIDOrder(self, ids, messages):
213
self.assertEqual(ids, [m['message_id'] for m in messages])
214
215
def assertMessageIDs(self, ids, messages):
216
self.assertIDOrder(
217
sorted(ids), sorted(messages, key=lambda m:m['message_id']))
218
219
def test_get_messages(self):
220
client = GrackleClient('localhost', 8435)
221
with ForkedFake.from_client(client,
222
{'baz':
223
[{'message_id': 'foo'},
224
{'message_id': 'bar'}]}):
225
response = client.get_messages('baz')
226
self.assertEqual(['bar', 'foo'], sorted(m['message_id'] for m in
227
response['messages']))
228
self.assertIs(None, response['next_memo'])
229
self.assertIs(None, response['previous_memo'])
230
231
def test_get_messages_by_id(self):
232
client = GrackleClient('localhost', 8437)
233
with ForkedFake.from_client(client,
234
{'baz':
235
[{'message_id': 'foo'},
236
{'message_id': 'bar'}]}):
237
response = client.get_messages('baz', message_ids=['foo'])
238
message, = response['messages']
239
self.assertEqual('foo', message['message_id'])
240
241
def test_get_messages_batching(self):
242
client = GrackleClient('localhost', 8438)
243
with ForkedFake.from_client(client,
244
{'baz':
245
[{'message_id': 'foo'},
246
{'message_id': 'bar'}]}):
247
response = client.get_messages('baz', limit=1)
248
self.assertEqual(1, len(response['messages']))
249
messages = response['messages']
250
response = client.get_messages(
251
'baz', limit=1, memo=response['next_memo'])
252
self.assertEqual(1, len(response['messages']))
253
messages.extend(response['messages'])
254
self.assertMessageIDs(['foo', 'bar'], messages)
255
256
def get_messages_member_order_test(self, key):
257
client = GrackleClient('localhost', 8439)
258
with ForkedFake.from_client(client,
259
{'baz': [{'message_id': 'foo', key: '2011-03-25'},
260
{'message_id': 'bar', key: '2011-03-24'}]}):
261
response = client.get_messages('baz')
262
self.assertIDOrder(['foo', 'bar'], response['messages'])
263
response = client.get_messages('baz', order=key)
264
self.assertIDOrder(['bar', 'foo'], response['messages'])
265
266
def test_get_messages_date_order(self):
267
self.get_messages_member_order_test('date')
268
269
def test_get_messages_author_order(self):
270
self.get_messages_member_order_test('author')
271
272
def test_get_messages_subject_order(self):
273
self.get_messages_member_order_test('subject')
274
275
def test_get_messages_thread_subject_order(self):
276
client = GrackleClient('localhost', 8439)
277
with ForkedFake.from_client(client, {'baz': [
278
{'message_id': 'bar', 'subject': 'y'},
279
{'message_id': 'qux', 'subject': 'z'},
280
{'message_id': 'foo', 'subject': 'x', '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='subject')
285
self.assertIDOrder(['foo', 'bar', 'qux'], response['messages'])
286
response = client.get_messages('baz', order='thread_subject')
287
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
288
289
def test_get_messages_thread_oldest_order(self):
290
client = GrackleClient('localhost', 8439)
291
with ForkedFake.from_client(client, {'baz': [
292
{'message_id': 'bar', 'date': 'x'},
293
{'message_id': 'qux', 'date': 'z'},
294
{'message_id': 'foo', 'date': 'y', 'in_reply_to': 'qux'},
295
]}):
296
response = client.get_messages('baz')
297
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
298
response = client.get_messages('baz', order='date')
299
self.assertIDOrder(['bar', 'foo', 'qux'], response['messages'])
300
response = client.get_messages('baz', order='thread_oldest')
301
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
302
303
def test_get_messages_thread_newest_order(self):
304
client = GrackleClient('localhost', 8439)
305
with ForkedFake.from_client(client, {'baz': [
306
{'message_id': 'bar', 'date': 'x'},
307
{'message_id': 'qux', 'date': 'w'},
308
{'message_id': 'foo', 'date': 'y', 'in_reply_to': 'bar'},
309
{'message_id': 'baz', 'date': 'z', 'in_reply_to': 'qux'},
310
]}):
311
response = client.get_messages('baz', order='date')
312
self.assertIDOrder(
313
['qux', 'bar', 'foo', 'baz'], response['messages'])
314
response = client.get_messages('baz', order='thread_newest')
315
self.assertIDOrder(
316
['bar', 'foo', 'qux', 'baz'], response['messages'])
317
318
def test_get_messages_unsupported_order(self):
319
client = GrackleClient('localhost', 8439)
320
with ForkedFake.from_client(client,
321
{'baz': [{'message_id': 'foo', 'date': '2011-03-25'},
322
{'message_id': 'bar', 'date': '2011-03-24'}]}):
323
with ExpectedException(UnsupportedOrder):
324
client.get_messages('baz', order='nonsense')
325
326
def test_get_messages_headers_no_headers(self):
327
client = GrackleClient('localhost', 8440)
328
with ForkedFake.from_client(client,
329
{'baz': [
330
{'message_id': 'foo'}
331
]}):
332
response = client.get_messages('baz', headers=[
333
'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
334
first_message = response['messages'][0]
335
self.assertEqual('foo', first_message['message_id'])
336
self.assertEqual({}, first_message['headers'])
337
338
def test_get_messages_headers_exclude_headers(self):
339
client = GrackleClient('localhost', 8441)
340
with ForkedFake.from_client(client,
341
{'baz': [
342
{'message_id': 'foo', 'headers': {'From': 'me'}}
343
]}):
344
response = client.get_messages('baz', headers=[
345
'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
346
first_message = response['messages'][0]
347
self.assertEqual('foo', first_message['message_id'])
348
self.assertEqual({}, first_message['headers'])
349
350
def test_get_messages_headers_include_headers(self):
351
client = GrackleClient('localhost', 8442)
352
with ForkedFake.from_client(client,
353
{'baz': [
354
{'message_id': 'foo', 'headers': {'From': 'me', 'To': 'you'}}
355
]}):
356
response = client.get_messages('baz', headers=[
357
'From', 'To'])
358
first_message = response['messages'][0]
359
self.assertEqual('foo', first_message['message_id'])
360
self.assertEqual({'From': 'me', 'To': 'you'}, first_message['headers'])
361
362
def test_get_messages_max_body_length(self):
363
client = GrackleClient('localhost', 8443)
364
with ForkedFake.from_client(client,
365
{'baz': [
366
{'message_id': 'foo', 'body': u'abcdefghi'}
367
]}):
368
response = client.get_messages('baz', max_body_length=3)
369
first_message = response['messages'][0]
370
self.assertEqual('abc', first_message['body'])
371
372
def test_include_hidden(self):
373
client = GrackleClient('localhost', 8444)
374
with ForkedFake.from_client(client,
375
{'baz': [
376
{'message_id': 'foo', 'hidden': True},
377
{'message_id': 'bar', 'hidden': False}
378
]}):
379
response = client.get_messages('baz', include_hidden=True)
380
self.assertMessageIDs(['bar', 'foo'], response['messages'])
381
response = client.get_messages('baz', include_hidden=False)
382
self.assertMessageIDs(['bar'], response['messages'])
383
Loggerhead is a web-based interface for Breezy
Version: 2.0.1