« back to all changes in this revision
Viewing changes to grackle/tests/test_client.py
- browse files at revision 31
- compare with another revision
- download diff
- download tarball
- view history from revision 31
- Committer: Aaron Bentley
- Date: 2012-01-16 15:23:42 UTC
- Revision ID: aaron@canonical.com-20120116152342-a501e23hpygeyjai
Switch fake_grackle_service to ForkedFake.from_client.
- files removed:
- grackle/error.py
- files modified:
- grackle-put-message
added
removed
grackle/tests/test_client.py
1
__metaclass__ = type
2
3
from email.message import Message
4
from email.mime.multipart import MIMEMultipart
5
from email.mime.text import MIMEText
1
from BaseHTTPServer import (
2
HTTPServer,
3
BaseHTTPRequestHandler,
4
)
5
import httplib
6
import os
7
from signal import SIGKILL
8
import simplejson
6
9
from StringIO import StringIO
7
10
from unittest import TestCase
11
from urlparse import urlparse
12
from urlparse import parse_qs
8
13
9
14
from testtools import ExpectedException
10
15
11
from grackle.client import GrackleClient
12
from grackle.error import (
13
ArchiveIdExists,
14
UnparsableDateRange,
15
UnsupportedDisplayType,
16
from grackle.client import (
17
GrackleClient,
16
18
UnsupportedOrder,
17
19
)
18
from grackle.service import ForkedFakeService
19
from grackle.store import make_json_message
20
21
22
def make_message(message_id, body='body', headers=None, hidden=False):
23
if headers is None:
24
headers = {}
25
message_headers = {
26
'Message-Id': message_id,
27
'date': '2005-01-01',
28
'subject': 'subject',
29
'from': 'author',
30
'replies': '',
31
}
32
message_headers.update(headers.items())
33
message = Message()
34
message.set_payload(body)
35
for key, value in message_headers.items():
36
message[key] = value
37
return make_json_message(message_id, message.as_string(), hidden)
38
39
40
def make_mime_message(message_id, body='body', headers=None, hidden=False,
41
attachment_type=None):
42
parts = MIMEMultipart()
43
parts.attach(MIMEText(body))
44
if attachment_type is not None:
45
attachment = Message()
46
attachment.set_payload('attactment data.')
47
attachment['Content-Type'] = attachment_type
48
attachment['Content-Disposition'] = 'attachment; filename="file.ext"'
49
parts.attach(attachment)
50
return make_message(message_id, parts.as_string(), headers, hidden)
51
52
53
class TestPutArchive(TestCase):
54
55
def test_put_archive(self):
56
client = GrackleClient('localhost', 8410)
57
message_archives = {}
58
with ForkedFakeService.from_client(client, message_archives):
59
client.put_archive('arch1')
60
response = client.get_messages('arch1')
61
self.assertEqual(0, len(response['messages']))
62
63
def test_put_archive_existing_archive(self):
64
client = GrackleClient('localhost', 8411)
65
message_archives = {'arch1': []}
66
with ForkedFakeService.from_client(client, message_archives):
67
with ExpectedException(ArchiveIdExists, ''):
68
client.put_archive('arch1')
20
21
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
class ForkedFake:
113
114
def __init__(self, port, messages=None):
115
self.pid = None
116
self.port = port
117
if messages is None:
118
self.messages = {}
119
else:
120
self.messages = messages
121
self.read_end, self.write_end = os.pipe()
122
123
@staticmethod
124
def from_client(client, messages=None):
125
return ForkedFake(client.port, messages)
126
127
def is_ready(self):
128
os.write(self.write_end, 'asdf')
129
130
def __enter__(self):
131
pid = os.fork()
132
if pid == 0:
133
self.start_server()
134
self.pid = pid
135
os.read(self.read_end, 1)
136
return
137
138
def start_server(self):
139
service = HTTPServer(('', self.port), FakeGrackleRequestHandler)
140
service.store = GrackleStore(self.messages)
141
for archive_id, messages in service.store.messages.iteritems():
142
for message in messages:
143
message.setdefault('headers', {})
144
self.is_ready()
145
service.serve_forever()
146
147
def __exit__(self, exc_type, exc_val, traceback):
148
os.kill(self.pid, SIGKILL)
149
150
151
SUPPORTED_ORDERS = set(
152
['date', 'author', 'subject', 'thread_newest', 'thread_oldest',
153
'thread_subject'])
154
155
156
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
157
158
def do_POST(self):
159
message = self.rfile.read(int(self.headers['content-length']))
160
if message == 'This is a message':
161
self.send_response(httplib.CREATED)
162
self.end_headers()
163
self.wfile.close()
164
else:
165
self.send_error(httplib.BAD_REQUEST)
166
167
def do_GET(self):
168
scheme, netloc, path, params, query_string, fragments = (
169
urlparse(self.path))
170
parts = path.split('/')
171
if parts[1] == 'archive':
172
try:
173
response = self.server.store.get_messages(
174
parts[2], query_string)
175
self.send_response(httplib.OK)
176
self.end_headers()
177
self.wfile.write(simplejson.dumps(response))
178
except UnsupportedOrder:
179
self.send_response(httplib.BAD_REQUEST)
180
self.wfile.write('Unsupported order')
181
return
69
182
70
183
71
184
class TestPutMessage(TestCase):
72
185
73
186
def test_put_message(self):
74
client = GrackleClient('localhost', 8420)
75
message_archives = {'arch1': []}
76
with ForkedFakeService.from_client(client, message_archives):
77
client.put_message('arch1', 'id1', StringIO('This is a message'))
78
response = client.get_messages('arch1')
79
self.assertEqual(1, len(response['messages']))
80
message = response['messages'][0]
81
self.assertEqual('id1', message['message_id'])
82
83
def test_put_message_without_archive(self):
84
client = GrackleClient('localhost', 8421)
85
message_archives = {'arch1': []}
86
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'))
87
190
with ExpectedException(Exception, 'wtf'):
88
client.put_message('no-archive', 'id1', StringIO('message'))
191
client.put_message('arch1', 'asdf',
192
StringIO('This is not a message'))
89
193
90
194
91
195
class TestGetMessages(TestCase):
95
199
96
200
def assertMessageIDs(self, ids, messages):
97
201
self.assertIDOrder(
98
sorted(ids), sorted(messages, key=lambda m: m['message_id']))
202
sorted(ids), sorted(messages, key=lambda m:m['message_id']))
99
203
100
204
def test_get_messages(self):
101
client = GrackleClient('localhost', 8430)
102
archive = {
103
'baz': [make_message('foo'), make_message('bar')]}
104
with ForkedFakeService.from_client(client, archive):
205
client = GrackleClient('localhost', 8435)
206
with ForkedFake.from_client(client,
207
{'baz':
208
[{'message_id': 'foo'},
209
{'message_id': 'bar'}]}):
105
210
response = client.get_messages('baz')
106
211
self.assertEqual(['bar', 'foo'], sorted(m['message_id'] for m in
107
212
response['messages']))
110
215
111
216
def test_get_messages_by_id(self):
112
217
client = GrackleClient('localhost', 8437)
113
archive = {
114
'baz': [make_message('foo'), make_message('bar')]}
115
with ForkedFakeService.from_client(client, archive):
218
with ForkedFake.from_client(client,
219
{'baz':
220
[{'message_id': 'foo'},
221
{'message_id': 'bar'}]}):
116
222
response = client.get_messages('baz', message_ids=['foo'])
117
223
message, = response['messages']
118
224
self.assertEqual('foo', message['message_id'])
119
225
120
226
def test_get_messages_batching(self):
121
227
client = GrackleClient('localhost', 8438)
122
archive = {'baz': [make_message('foo'), make_message('bar')]}
123
with ForkedFakeService.from_client(client, archive):
228
with ForkedFake.from_client(client,
229
{'baz':
230
[{'message_id': 'foo'},
231
{'message_id': 'bar'}]}):
124
232
response = client.get_messages('baz', limit=1)
125
233
self.assertEqual(1, len(response['messages']))
126
234
messages = response['messages']
132
240
133
241
def get_messages_member_order_test(self, key):
134
242
client = GrackleClient('localhost', 8439)
135
if key == 'author':
136
header_name = 'from'
137
else:
138
header_name = key
139
archive = {
140
'baz': [
141
make_message('foo', headers={header_name: '2011-03-25'}),
142
make_message('bar', headers={header_name: '2011-03-24'}),
143
]}
144
with ForkedFakeService.from_client(client, archive):
243
with ForkedFake.from_client(client,
244
{'baz': [{'message_id': 'foo', key: '2011-03-25'},
245
{'message_id': 'bar', key: '2011-03-24'}]}):
145
246
response = client.get_messages('baz')
146
247
self.assertIDOrder(['foo', 'bar'], response['messages'])
147
248
response = client.get_messages('baz', order=key)
157
258
self.get_messages_member_order_test('subject')
158
259
159
260
def test_get_messages_thread_subject_order(self):
160
archive = {
161
'baz': [
162
make_message('bar', headers={'subject': 'y'}),
163
make_message('qux', headers={'subject': 'z'}),
164
make_message('foo', headers={'subject': 'x',
165
'in-reply-to': 'qux'}),
166
]}
167
261
client = GrackleClient('localhost', 8439)
168
with ForkedFakeService.from_client(client, archive):
262
with ForkedFake.from_client(client, {'baz': [
263
{'message_id': 'bar', 'subject': 'y'},
264
{'message_id': 'qux', 'subject': 'z'},
265
{'message_id': 'foo', 'subject': 'x', 'in_reply_to': 'qux'},
266
]}):
169
267
response = client.get_messages('baz')
170
268
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
171
269
response = client.get_messages('baz', order='subject')
175
273
176
274
def test_get_messages_thread_oldest_order(self):
177
275
client = GrackleClient('localhost', 8439)
178
archive = {
179
'baz': [
180
make_message('bar', headers={'date': 'x'}),
181
make_message('qux', headers={'date': 'z'}),
182
make_message('foo', headers={'date': 'y',
183
'in-reply-to': 'qux'}),
184
]}
185
with ForkedFakeService.from_client(client, archive):
276
with ForkedFake.from_client(client, {'baz': [
277
{'message_id': 'bar', 'date': 'x'},
278
{'message_id': 'qux', 'date': 'z'},
279
{'message_id': 'foo', 'date': 'y', 'in_reply_to': 'qux'},
280
]}):
186
281
response = client.get_messages('baz')
187
282
self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
188
283
response = client.get_messages('baz', order='date')
192
287
193
288
def test_get_messages_thread_newest_order(self):
194
289
client = GrackleClient('localhost', 8439)
195
archive = {
196
'baz': [
197
make_message('bar', headers={'date': 'x'}),
198
make_message('qux', headers={'date': 'w'}),
199
make_message('foo', headers={'date': 'y',
200
'in-reply-to': 'bar'}),
201
make_message('baz', headers={'date': 'z',
202
'in-reply-to': 'qux'}),
203
]}
204
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'},
295
]}):
205
296
response = client.get_messages('baz', order='date')
206
297
self.assertIDOrder(
207
298
['qux', 'bar', 'foo', 'baz'], response['messages'])
211
302
212
303
def test_get_messages_unsupported_order(self):
213
304
client = GrackleClient('localhost', 8439)
214
archive = {
215
'baz': [
216
make_message('foo', headers={'date': '2011-03-25'}),
217
make_message('foo', headers={'date': '2011-03-24'}),
218
]}
219
with ForkedFakeService.from_client(client, archive):
220
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):
221
309
client.get_messages('baz', order='nonsense')
222
310
223
311
def test_get_messages_headers_no_headers(self):
224
312
client = GrackleClient('localhost', 8440)
225
archive = {'baz': [make_message('foo')]}
226
with ForkedFakeService.from_client(client, archive):
313
with ForkedFake.from_client(client,
314
{'baz': [
315
{'message_id': 'foo'}
316
]}):
227
317
response = client.get_messages('baz', headers=[
228
318
'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
229
319
first_message = response['messages'][0]
232
322
233
323
def test_get_messages_headers_exclude_headers(self):
234
324
client = GrackleClient('localhost', 8441)
235
archive = {
236
'baz': [make_message('foo', headers={'From': 'me'})]}
237
with ForkedFakeService.from_client(client, archive):
325
with ForkedFake.from_client(client,
326
{'baz': [
327
{'message_id': 'foo', 'headers': {'From': 'me'}}
328
]}):
238
329
response = client.get_messages('baz', headers=[
239
330
'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
240
331
first_message = response['messages'][0]
243
334
244
335
def test_get_messages_headers_include_headers(self):
245
336
client = GrackleClient('localhost', 8442)
246
archive = {
247
'baz': [
248
make_message('foo', headers={'From': 'me', 'To': 'you'})]}
249
with ForkedFakeService.from_client(client, archive):
337
with ForkedFake.from_client(client,
338
{'baz': [
339
{'message_id': 'foo', 'headers': {'From': 'me', 'To': 'you'}}
340
]}):
250
341
response = client.get_messages('baz', headers=[
251
342
'From', 'To'])
252
343
first_message = response['messages'][0]
255
346
256
347
def test_get_messages_max_body_length(self):
257
348
client = GrackleClient('localhost', 8443)
258
archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
259
with ForkedFakeService.from_client(client, archive):
349
with ForkedFake.from_client(client,
350
{'baz': [
351
{'message_id': 'foo', 'body': u'abcdefghi'}
352
]}):
260
353
response = client.get_messages('baz', max_body_length=3)
261
354
first_message = response['messages'][0]
262
355
self.assertEqual('abc', first_message['body'])
263
356
264
357
def test_include_hidden(self):
265
358
client = GrackleClient('localhost', 8444)
266
archive = {
267
'baz': [
268
make_message('foo', hidden=True),
269
make_message('bar', hidden=False),
270
]}
271
with ForkedFakeService.from_client(client, archive):
359
with ForkedFake.from_client(client,
360
{'baz': [
361
{'message_id': 'foo', 'hidden': True},
362
{'message_id': 'bar', 'hidden': False}
363
]}):
272
364
response = client.get_messages('baz', include_hidden=True)
273
365
self.assertMessageIDs(['bar', 'foo'], response['messages'])
274
366
response = client.get_messages('baz', include_hidden=False)
275
367
self.assertMessageIDs(['bar'], response['messages'])
276
368
277
def test_display_type_unknown_value(self):
278
client = GrackleClient('localhost', 8445)
279
archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
280
with ForkedFakeService.from_client(client, archive):
281
with ExpectedException(UnsupportedDisplayType, ''):
282
client.get_messages('baz', display_type='unknown')
283
284
def test_display_type_headers_only(self):
285
client = GrackleClient('localhost', 8446)
286
archive = {
287
'baz': [
288
make_message('foo', body=u'abcdefghi',
289
headers={'From': 'me', 'To': 'you'})]}
290
with ForkedFakeService.from_client(client, archive):
291
response = client.get_messages('baz', display_type='headers-only')
292
first_message = response['messages'][0]
293
self.assertEqual('foo', first_message['message_id'])
294
self.assertEqual(
295
archive['baz'][0]['headers'], first_message['headers'])
296
self.assertNotIn('body', first_message)
297
298
def test_display_type_text_only(self):
299
client = GrackleClient('localhost', 8446)
300
archive = {
301
'baz': [
302
make_mime_message(
303
'foo', 'abcdefghi',
304
headers={'From': 'me', 'To': 'you'},
305
attachment_type='text/x-diff')]}
306
with ForkedFakeService.from_client(client, archive):
307
response = client.get_messages('baz', display_type='text-only')
308
first_message = response['messages'][0]
309
self.assertEqual('foo', first_message['message_id'])
310
self.assertEqual('me', first_message['headers']['From'])
311
self.assertEqual('you', first_message['headers']['To'])
312
self.assertEqual(archive['baz'][0]['body'], first_message['body'])
313
314
def test_display_type_all(self):
315
client = GrackleClient('localhost', 8447)
316
archive = {
317
'baz': [
318
make_mime_message(
319
'foo', 'abcdefghi',
320
headers={'From': 'me', 'To': 'you'},
321
attachment_type='text/x-diff')]}
322
with ForkedFakeService.from_client(client, archive):
323
response = client.get_messages('baz', display_type='all')
324
first_message = response['messages'][0]
325
self.assertEqual('foo', first_message['message_id'])
326
self.assertEqual('me', first_message['headers']['From'])
327
self.assertEqual('you', first_message['headers']['To'])
328
self.assertEqual(archive['baz'][0]['body'], first_message['body'])
329
330
def test_date_range(self):
331
client = GrackleClient('localhost', 8448)
332
archive = {
333
'baz': [
334
make_mime_message(
335
'foo', 'abcdefghi', headers={'date': '2011-12-31'}),
336
make_mime_message(
337
'bar', 'abcdefghi', headers={'date': '2012-01-01'}),
338
make_mime_message(
339
'qux', 'abcdefghi', headers={'date': '2012-01-15'}),
340
make_mime_message(
341
'naf', 'abcdefghi', headers={'date': '2012-01-31'}),
342
make_mime_message(
343
'doh', 'abcdefghi', headers={'date': '2012-02-01'}),
344
]}
345
with ForkedFakeService.from_client(client, archive):
346
response = client.get_messages(
347
'baz', date_range='2012-01-01..2012-01-31')
348
ids = sorted(m['message_id'] for m in response['messages'])
349
self.assertEqual(['bar', 'naf', 'qux'], ids)
350
351
def test_date_range_unparsabledaterange(self):
352
client = GrackleClient('localhost', 8449)
353
archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
354
with ForkedFakeService.from_client(client, archive):
355
with ExpectedException(UnparsableDateRange, ''):
356
client.get_messages('baz', date_range='2012-01-01')
357
358
def test_date_range_unparsabledaterange_missing_part(self):
359
client = GrackleClient('localhost', 8450)
360
archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
361
with ForkedFakeService.from_client(client, archive):
362
with ExpectedException(UnparsableDateRange, ''):
363
client.get_messages('baz', date_range='2012-01-01..')
364
365
def test_date_range_unparsabledaterange_extra_part(self):
366
client = GrackleClient('localhost', 8451)
367
archive = {'baz': [make_message('foo', body=u'abcdefghi')]}
368
with ForkedFakeService.from_client(client, archive):
369
with ExpectedException(UnparsableDateRange, ''):
370
client.get_messages('baz', date_range='2012-01..12-02..12-03')
371
372
373
class TestHideMessages(TestCase):
374
375
def test_hide_message_true(self):
376
client = GrackleClient('localhost', 8470)
377
archive = {
378
'baz': [
379
make_message('foo', hidden=False),
380
]}
381
with ForkedFakeService.from_client(client, archive):
382
response = client.hide_message('baz', 'foo', hidden=True)
383
self.assertEqual('foo', response['message_id'])
384
self.assertIs(True, response['hidden'])
385
386
def test_hide_message_false(self):
387
client = GrackleClient('localhost', 8470)
388
archive = {
389
'baz': [
390
make_message('foo', hidden=True),
391
]}
392
with ForkedFakeService.from_client(client, archive):
393
response = client.hide_message('baz', 'foo', hidden=False)
394
self.assertEqual('foo', response['message_id'])
395
self.assertIs(False, response['hidden'])
Loggerhead is a web-based interface for Breezy
Version: 2.0.1