← Back to branch summary

~didrocks/unity/altf10

« back to all changes in this revision

Viewing changes to grackle/tests/test_client.py

  • 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.

Show diffs side-by-side

added added

removed removed

Lines of Context:
grackle/tests/test_client.py
5
5
import httplib
6
6
import os
7
7
from signal import SIGKILL
 
8
import simplejson
8
9
from StringIO import StringIO
9
10
from unittest import TestCase
 
11
from urlparse import urlparse
 
12
from urlparse import parse_qs
10
13
 
11
14
from testtools import ExpectedException
12
15
 
13
16
from grackle.client import (
14
17
    GrackleClient,
 
18
    UnsupportedOrder,
15
19
    )
16
20
 
17
21
 
18
 
class Forked:
19
 
 
20
 
    def __init__(self, func_or_method, *args):
21
 
        self.func_or_method = func_or_method
 
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):
22
115
        self.pid = None
23
 
        self.args = args
 
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')
24
129
 
25
130
    def __enter__(self):
26
131
        pid = os.fork()
27
 
        if pid != 0:
28
 
            self.pid = pid
29
 
            return
30
 
        self.func_or_method(*self.args)
 
132
        if pid == 0:
 
133
            self.start_server()
 
134
        self.pid = pid
 
135
        os.read(self.read_end, 1)
 
136
        return
31
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()
32
146
 
33
147
    def __exit__(self, exc_type, exc_val, traceback):
34
148
        os.kill(self.pid, SIGKILL)
35
149
 
36
150
 
 
151
SUPPORTED_ORDERS = set(
 
152
    ['date', 'author', 'subject', 'thread_newest', 'thread_oldest',
 
153
     'thread_subject'])
 
154
 
 
155
 
37
156
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
38
157
 
39
 
    def do_PUT(self):
 
158
    def do_POST(self):
40
159
        message = self.rfile.read(int(self.headers['content-length']))
41
160
        if message == 'This is a message':
42
161
            self.send_response(httplib.CREATED)
45
164
        else:
46
165
            self.send_error(httplib.BAD_REQUEST)
47
166
 
48
 
 
49
 
def run_service(port):
50
 
    service = HTTPServer(('', port), FakeGrackleRequestHandler)
51
 
    service.serve_forever()
52
 
 
 
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
53
182
 
54
183
 
55
184
class TestPutMessage(TestCase):
56
185
 
57
186
    def test_put_message(self):
58
 
        client = GrackleClient('localhost', 8435)
59
 
        with Forked(run_service, client.port):
 
187
        client = GrackleClient('localhost', 8436)
 
188
        with ForkedFake.from_client(client):
60
189
            client.put_message('arch1', 'asdf', StringIO('This is a message'))
61
190
            with ExpectedException(Exception, 'wtf'):
62
191
                client.put_message('arch1', 'asdf',
63
192
                    StringIO('This is not a message'))
 
193
 
 
194
 
 
195
class TestGetMessages(TestCase):
 
196
 
 
197
    def assertIDOrder(self, ids, messages):
 
198
        self.assertEqual(ids, [m['message_id'] for m in messages])
 
199
 
 
200
    def assertMessageIDs(self, ids, messages):
 
201
        self.assertIDOrder(
 
202
            sorted(ids), sorted(messages, key=lambda m:m['message_id']))
 
203
 
 
204
    def test_get_messages(self):
 
205
        client = GrackleClient('localhost', 8435)
 
206
        with ForkedFake.from_client(client,
 
207
            {'baz':
 
208
            [{'message_id': 'foo'},
 
209
             {'message_id': 'bar'}]}):
 
210
            response = client.get_messages('baz')
 
211
        self.assertEqual(['bar', 'foo'], sorted(m['message_id'] for m in
 
212
            response['messages']))
 
213
        self.assertIs(None, response['next_memo'])
 
214
        self.assertIs(None, response['previous_memo'])
 
215
 
 
216
    def test_get_messages_by_id(self):
 
217
        client = GrackleClient('localhost', 8437)
 
218
        with ForkedFake.from_client(client,
 
219
            {'baz':
 
220
            [{'message_id': 'foo'},
 
221
             {'message_id': 'bar'}]}):
 
222
            response = client.get_messages('baz', message_ids=['foo'])
 
223
        message, = response['messages']
 
224
        self.assertEqual('foo', message['message_id'])
 
225
 
 
226
    def test_get_messages_batching(self):
 
227
        client = GrackleClient('localhost', 8438)
 
228
        with ForkedFake.from_client(client,
 
229
            {'baz':
 
230
            [{'message_id': 'foo'},
 
231
             {'message_id': 'bar'}]}):
 
232
            response = client.get_messages('baz', limit=1)
 
233
            self.assertEqual(1, len(response['messages']))
 
234
            messages = response['messages']
 
235
            response = client.get_messages(
 
236
                'baz', limit=1, memo=response['next_memo'])
 
237
            self.assertEqual(1, len(response['messages']))
 
238
            messages.extend(response['messages'])
 
239
            self.assertMessageIDs(['foo', 'bar'], messages)
 
240
 
 
241
    def get_messages_member_order_test(self, key):
 
242
        client = GrackleClient('localhost', 8439)
 
243
        with ForkedFake.from_client(client,
 
244
                {'baz': [{'message_id': 'foo', key: '2011-03-25'},
 
245
                 {'message_id': 'bar', key: '2011-03-24'}]}):
 
246
            response = client.get_messages('baz')
 
247
            self.assertIDOrder(['foo', 'bar'], response['messages'])
 
248
            response = client.get_messages('baz', order=key)
 
249
            self.assertIDOrder(['bar', 'foo'], response['messages'])
 
250
 
 
251
    def test_get_messages_date_order(self):
 
252
        self.get_messages_member_order_test('date')
 
253
 
 
254
    def test_get_messages_author_order(self):
 
255
        self.get_messages_member_order_test('author')
 
256
 
 
257
    def test_get_messages_subject_order(self):
 
258
        self.get_messages_member_order_test('subject')
 
259
 
 
260
    def test_get_messages_thread_subject_order(self):
 
261
        client = GrackleClient('localhost', 8439)
 
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
            ]}):
 
267
            response = client.get_messages('baz')
 
268
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
 
269
            response = client.get_messages('baz', order='subject')
 
270
            self.assertIDOrder(['foo', 'bar', 'qux'], response['messages'])
 
271
            response = client.get_messages('baz', order='thread_subject')
 
272
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
 
273
 
 
274
    def test_get_messages_thread_oldest_order(self):
 
275
        client = GrackleClient('localhost', 8439)
 
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
            ]}):
 
281
            response = client.get_messages('baz')
 
282
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
 
283
            response = client.get_messages('baz', order='date')
 
284
            self.assertIDOrder(['bar', 'foo', 'qux'], response['messages'])
 
285
            response = client.get_messages('baz', order='thread_oldest')
 
286
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
 
287
 
 
288
    def test_get_messages_thread_newest_order(self):
 
289
        client = GrackleClient('localhost', 8439)
 
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
            ]}):
 
296
            response = client.get_messages('baz', order='date')
 
297
            self.assertIDOrder(
 
298
                ['qux', 'bar', 'foo', 'baz'], response['messages'])
 
299
            response = client.get_messages('baz', order='thread_newest')
 
300
            self.assertIDOrder(
 
301
                ['bar', 'foo', 'qux', 'baz'], response['messages'])
 
302
 
 
303
    def test_get_messages_unsupported_order(self):
 
304
        client = GrackleClient('localhost', 8439)
 
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):
 
309
                client.get_messages('baz', order='nonsense')
 
310
 
 
311
    def test_get_messages_headers_no_headers(self):
 
312
        client = GrackleClient('localhost', 8440)
 
313
        with ForkedFake.from_client(client,
 
314
            {'baz': [
 
315
                {'message_id': 'foo'}
 
316
            ]}):
 
317
            response = client.get_messages('baz', headers=[
 
318
                'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
 
319
        first_message = response['messages'][0]
 
320
        self.assertEqual('foo', first_message['message_id'])
 
321
        self.assertEqual({}, first_message['headers'])
 
322
 
 
323
    def test_get_messages_headers_exclude_headers(self):
 
324
        client = GrackleClient('localhost', 8441)
 
325
        with ForkedFake.from_client(client,
 
326
            {'baz': [
 
327
                {'message_id': 'foo', 'headers': {'From': 'me'}}
 
328
            ]}):
 
329
            response = client.get_messages('baz', headers=[
 
330
                'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
 
331
        first_message = response['messages'][0]
 
332
        self.assertEqual('foo', first_message['message_id'])
 
333
        self.assertEqual({}, first_message['headers'])
 
334
 
 
335
    def test_get_messages_headers_include_headers(self):
 
336
        client = GrackleClient('localhost', 8442)
 
337
        with ForkedFake.from_client(client,
 
338
            {'baz': [
 
339
                {'message_id': 'foo', 'headers': {'From': 'me', 'To': 'you'}}
 
340
            ]}):
 
341
            response = client.get_messages('baz', headers=[
 
342
                'From', 'To'])
 
343
        first_message = response['messages'][0]
 
344
        self.assertEqual('foo', first_message['message_id'])
 
345
        self.assertEqual({'From': 'me', 'To': 'you'}, first_message['headers'])
 
346
 
 
347
    def test_get_messages_max_body_length(self):
 
348
        client = GrackleClient('localhost', 8443)
 
349
        with ForkedFake.from_client(client,
 
350
            {'baz': [
 
351
                {'message_id': 'foo', 'body': u'abcdefghi'}
 
352
            ]}):
 
353
            response = client.get_messages('baz', max_body_length=3)
 
354
        first_message = response['messages'][0]
 
355
        self.assertEqual('abc', first_message['body'])
 
356
 
 
357
    def test_include_hidden(self):
 
358
        client = GrackleClient('localhost', 8444)
 
359
        with ForkedFake.from_client(client,
 
360
            {'baz': [
 
361
                {'message_id': 'foo', 'hidden': True},
 
362
                {'message_id': 'bar', 'hidden': False}
 
363
            ]}):
 
364
            response = client.get_messages('baz', include_hidden=True)
 
365
            self.assertMessageIDs(['bar', 'foo'], response['messages'])
 
366
            response = client.get_messages('baz', include_hidden=False)
 
367
            self.assertMessageIDs(['bar'], response['messages'])
 
368