← 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 16:29:12 UTC
  • Revision ID: aaron@canonical.com-20120116162912-cc760p6gn7q5qdwr
Switch test HTTP server to standard Python logging.

Show diffs side-by-side

added added

removed removed

Lines of Context:
grackle/tests/test_client.py
3
3
    BaseHTTPRequestHandler,
4
4
    )
5
5
import httplib
 
6
import logging
6
7
import os
7
8
from signal import SIGKILL
8
9
import simplejson
9
10
from StringIO import StringIO
 
11
import sys
10
12
from unittest import TestCase
11
13
from urlparse import urlparse
12
14
from urlparse import parse_qs
19
21
    )
20
22
 
21
23
 
 
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
 
22
114
class ForkedFake:
23
115
 
24
116
    def __init__(self, port, messages=None):
25
117
        self.pid = None
26
118
        self.port = port
27
 
        self.messages = messages
 
119
        if messages is None:
 
120
            self.messages = {}
 
121
        else:
 
122
            self.messages = messages
28
123
        self.read_end, self.write_end = os.pipe()
29
124
 
 
125
    @staticmethod
 
126
    def from_client(client, messages=None):
 
127
        return ForkedFake(client.port, messages)
 
128
 
30
129
    def is_ready(self):
31
130
        os.write(self.write_end, 'asdf')
32
131
 
40
139
 
41
140
    def start_server(self):
42
141
        service = HTTPServer(('', self.port), FakeGrackleRequestHandler)
43
 
        service.messages = self.messages
 
142
        service.store = GrackleStore(self.messages)
 
143
        for archive_id, messages in service.store.messages.iteritems():
 
144
            for message in messages:
 
145
                message.setdefault('headers', {})
44
146
        self.is_ready()
 
147
#        logging.basicConfig(
 
148
#            stream=sys.stderr, level=logging.INFO)
45
149
        service.serve_forever()
46
150
 
47
151
    def __exit__(self, exc_type, exc_val, traceback):
48
152
        os.kill(self.pid, SIGKILL)
49
153
 
50
154
 
51
 
SUPPORTED_ORDERS = set(['date'])
 
155
SUPPORTED_ORDERS = set(
 
156
    ['date', 'author', 'subject', 'thread_newest', 'thread_oldest',
 
157
     'thread_subject'])
52
158
 
53
159
 
54
160
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
55
161
 
 
162
    def __init__(self, *args, **kwargs):
 
163
        self.logger = logging.getLogger('http')
 
164
        BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
 
165
 
56
166
    def do_POST(self):
57
167
        message = self.rfile.read(int(self.headers['content-length']))
58
168
        if message == 'This is a message':
65
175
    def do_GET(self):
66
176
        scheme, netloc, path, params, query_string, fragments = (
67
177
            urlparse(self.path))
68
 
        archive = os.path.split(path)[1]
69
 
        query = parse_qs(query_string)
70
 
        parameters = simplejson.loads(query['parameters'][0])
71
 
        messages = [m for m in self.server.messages[archive] if 'message_ids'
72
 
                    not in parameters or m['message_id'] in
73
 
                    parameters['message_ids']]
74
 
        if 'order' in parameters:
75
 
            if parameters['order'] not in SUPPORTED_ORDERS:
 
178
        parts = path.split('/')
 
179
        if parts[1] == 'archive':
 
180
            try:
 
181
                response = self.server.store.get_messages(
 
182
                    parts[2], query_string)
 
183
                self.send_response(httplib.OK)
 
184
                self.end_headers()
 
185
                self.wfile.write(simplejson.dumps(response))
 
186
            except UnsupportedOrder:
76
187
                self.send_response(httplib.BAD_REQUEST)
77
188
                self.wfile.write('Unsupported order')
78
189
                return
79
 
            messages.sort(key=lambda m: m[parameters['order']])
80
 
        self.send_response(httplib.OK)
81
 
        self.end_headers()
82
 
        limit = parameters.get('limit', 100)
83
 
        memo = parameters.get('memo')
84
 
        message_id_indices = dict(
85
 
            (m['message_id'], idx) for idx, m in enumerate(messages))
86
 
        if memo is None:
87
 
            start = 0
88
 
        else:
89
 
            start = message_id_indices[memo.encode('rot13')]
90
 
        if start > 0:
91
 
            previous_memo = messages[start - 1]['message_id'].encode('rot13')
92
 
        else:
93
 
            previous_memo = None
94
 
        end = min(start + limit, len(messages))
95
 
        if end < len(messages):
96
 
            next_memo = messages[end]['message_id'].encode('rot13')
97
 
        else:
98
 
            next_memo = None
99
 
        messages = messages[start:end]
100
 
        response = {
101
 
            'messages': messages,
102
 
            'next_memo': next_memo,
103
 
            'previous_memo': previous_memo
104
 
            }
105
 
        self.wfile.write(simplejson.dumps(response))
106
 
 
107
 
 
108
 
def fake_grackle_service(client, messages=None):
109
 
    if messages is None:
110
 
        messages = {}
111
 
    return ForkedFake(client.port, messages)
 
190
 
 
191
    def log_message(self, format, *args):
 
192
        message = "%s - - [%s] %s\n" % (
 
193
            self.address_string(), self.log_date_time_string(), format%args)
 
194
        self.logger.info(message)
112
195
 
113
196
 
114
197
class TestPutMessage(TestCase):
115
198
 
116
199
    def test_put_message(self):
117
200
        client = GrackleClient('localhost', 8436)
118
 
        with fake_grackle_service(client):
 
201
        with ForkedFake.from_client(client):
119
202
            client.put_message('arch1', 'asdf', StringIO('This is a message'))
120
203
            with ExpectedException(Exception, 'wtf'):
121
204
                client.put_message('arch1', 'asdf',
133
216
 
134
217
    def test_get_messages(self):
135
218
        client = GrackleClient('localhost', 8435)
136
 
        with fake_grackle_service(client,
 
219
        with ForkedFake.from_client(client,
137
220
            {'baz':
138
221
            [{'message_id': 'foo'},
139
222
             {'message_id': 'bar'}]}):
145
228
 
146
229
    def test_get_messages_by_id(self):
147
230
        client = GrackleClient('localhost', 8437)
148
 
        with fake_grackle_service(client,
 
231
        with ForkedFake.from_client(client,
149
232
            {'baz':
150
233
            [{'message_id': 'foo'},
151
234
             {'message_id': 'bar'}]}):
155
238
 
156
239
    def test_get_messages_batching(self):
157
240
        client = GrackleClient('localhost', 8438)
158
 
        with fake_grackle_service(client,
 
241
        with ForkedFake.from_client(client,
159
242
            {'baz':
160
243
            [{'message_id': 'foo'},
161
244
             {'message_id': 'bar'}]}):
168
251
            messages.extend(response['messages'])
169
252
            self.assertMessageIDs(['foo', 'bar'], messages)
170
253
 
171
 
    def test_get_messages_date_order(self):
 
254
    def get_messages_member_order_test(self, key):
172
255
        client = GrackleClient('localhost', 8439)
173
 
        with fake_grackle_service(client,
174
 
                {'baz': [{'message_id': 'foo', 'date': '2011-03-25'},
175
 
                 {'message_id': 'bar', 'date': '2011-03-24'}]}):
 
256
        with ForkedFake.from_client(client,
 
257
                {'baz': [{'message_id': 'foo', key: '2011-03-25'},
 
258
                 {'message_id': 'bar', key: '2011-03-24'}]}):
176
259
            response = client.get_messages('baz')
177
260
            self.assertIDOrder(['foo', 'bar'], response['messages'])
178
 
            response = client.get_messages('baz', order='date')
 
261
            response = client.get_messages('baz', order=key)
179
262
            self.assertIDOrder(['bar', 'foo'], response['messages'])
180
263
 
 
264
    def test_get_messages_date_order(self):
 
265
        self.get_messages_member_order_test('date')
 
266
 
 
267
    def test_get_messages_author_order(self):
 
268
        self.get_messages_member_order_test('author')
 
269
 
 
270
    def test_get_messages_subject_order(self):
 
271
        self.get_messages_member_order_test('subject')
 
272
 
 
273
    def test_get_messages_thread_subject_order(self):
 
274
        client = GrackleClient('localhost', 8439)
 
275
        with ForkedFake.from_client(client, {'baz': [
 
276
            {'message_id': 'bar', 'subject': 'y'},
 
277
            {'message_id': 'qux', 'subject': 'z'},
 
278
            {'message_id': 'foo', 'subject': 'x', '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='subject')
 
283
            self.assertIDOrder(['foo', 'bar', 'qux'], response['messages'])
 
284
            response = client.get_messages('baz', order='thread_subject')
 
285
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
 
286
 
 
287
    def test_get_messages_thread_oldest_order(self):
 
288
        client = GrackleClient('localhost', 8439)
 
289
        with ForkedFake.from_client(client, {'baz': [
 
290
            {'message_id': 'bar', 'date': 'x'},
 
291
            {'message_id': 'qux', 'date': 'z'},
 
292
            {'message_id': 'foo', 'date': 'y', 'in_reply_to': 'qux'},
 
293
            ]}):
 
294
            response = client.get_messages('baz')
 
295
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
 
296
            response = client.get_messages('baz', order='date')
 
297
            self.assertIDOrder(['bar', 'foo', 'qux'], response['messages'])
 
298
            response = client.get_messages('baz', order='thread_oldest')
 
299
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
 
300
 
 
301
    def test_get_messages_thread_newest_order(self):
 
302
        client = GrackleClient('localhost', 8439)
 
303
        with ForkedFake.from_client(client, {'baz': [
 
304
            {'message_id': 'bar', 'date': 'x'},
 
305
            {'message_id': 'qux', 'date': 'w'},
 
306
            {'message_id': 'foo', 'date': 'y', 'in_reply_to': 'bar'},
 
307
            {'message_id': 'baz', 'date': 'z', 'in_reply_to': 'qux'},
 
308
            ]}):
 
309
            response = client.get_messages('baz', order='date')
 
310
            self.assertIDOrder(
 
311
                ['qux', 'bar', 'foo', 'baz'], response['messages'])
 
312
            response = client.get_messages('baz', order='thread_newest')
 
313
            self.assertIDOrder(
 
314
                ['bar', 'foo', 'qux', 'baz'], response['messages'])
 
315
 
181
316
    def test_get_messages_unsupported_order(self):
182
317
        client = GrackleClient('localhost', 8439)
183
 
        with fake_grackle_service(client,
 
318
        with ForkedFake.from_client(client,
184
319
                {'baz': [{'message_id': 'foo', 'date': '2011-03-25'},
185
320
                 {'message_id': 'bar', 'date': '2011-03-24'}]}):
186
321
            with ExpectedException(UnsupportedOrder):
187
322
                client.get_messages('baz', order='nonsense')
 
323
 
 
324
    def test_get_messages_headers_no_headers(self):
 
325
        client = GrackleClient('localhost', 8440)
 
326
        with ForkedFake.from_client(client,
 
327
            {'baz': [
 
328
                {'message_id': 'foo'}
 
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_exclude_headers(self):
 
337
        client = GrackleClient('localhost', 8441)
 
338
        with ForkedFake.from_client(client,
 
339
            {'baz': [
 
340
                {'message_id': 'foo', 'headers': {'From': 'me'}}
 
341
            ]}):
 
342
            response = client.get_messages('baz', headers=[
 
343
                'Subject', 'Date', 'X-Launchpad-Message-Rationale'])
 
344
        first_message = response['messages'][0]
 
345
        self.assertEqual('foo', first_message['message_id'])
 
346
        self.assertEqual({}, first_message['headers'])
 
347
 
 
348
    def test_get_messages_headers_include_headers(self):
 
349
        client = GrackleClient('localhost', 8442)
 
350
        with ForkedFake.from_client(client,
 
351
            {'baz': [
 
352
                {'message_id': 'foo', 'headers': {'From': 'me', 'To': 'you'}}
 
353
            ]}):
 
354
            response = client.get_messages('baz', headers=[
 
355
                'From', 'To'])
 
356
        first_message = response['messages'][0]
 
357
        self.assertEqual('foo', first_message['message_id'])
 
358
        self.assertEqual({'From': 'me', 'To': 'you'}, first_message['headers'])
 
359
 
 
360
    def test_get_messages_max_body_length(self):
 
361
        client = GrackleClient('localhost', 8443)
 
362
        with ForkedFake.from_client(client,
 
363
            {'baz': [
 
364
                {'message_id': 'foo', 'body': u'abcdefghi'}
 
365
            ]}):
 
366
            response = client.get_messages('baz', max_body_length=3)
 
367
        first_message = response['messages'][0]
 
368
        self.assertEqual('abc', first_message['body'])
 
369
 
 
370
    def test_include_hidden(self):
 
371
        client = GrackleClient('localhost', 8444)
 
372
        with ForkedFake.from_client(client,
 
373
            {'baz': [
 
374
                {'message_id': 'foo', 'hidden': True},
 
375
                {'message_id': 'bar', 'hidden': False}
 
376
            ]}):
 
377
            response = client.get_messages('baz', include_hidden=True)
 
378
            self.assertMessageIDs(['bar', 'foo'], response['messages'])
 
379
            response = client.get_messages('baz', include_hidden=False)
 
380
            self.assertMessageIDs(['bar'], response['messages'])
 
381