← 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-12 09:54:51 UTC
  • Revision ID: aaron@canonical.com-20120112095451-6hwsm1c1demeokl5
Support order by date

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
21
class ForkedFake:
38
22
 
39
23
    def __init__(self, port, messages=None):
63
47
        os.kill(self.pid, SIGKILL)
64
48
 
65
49
 
66
 
SUPPORTED_ORDERS = set(
67
 
    ['date', 'author', 'subject', 'thread_newest', 'thread_oldest',
68
 
     'thread_subject'])
69
 
 
70
 
 
71
50
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
72
51
 
73
52
    def do_POST(self):
85
64
        archive = os.path.split(path)[1]
86
65
        query = parse_qs(query_string)
87
66
        parameters = simplejson.loads(query['parameters'][0])
88
 
        order = parameters.get('order')
89
 
        messages = self.server.messages[archive]
90
 
        if order is not None :
91
 
            if order not in SUPPORTED_ORDERS:
92
 
                self.send_response(httplib.BAD_REQUEST)
93
 
                self.wfile.write('Unsupported order')
94
 
                return
95
 
            elif order.startswith('thread_'):
96
 
                threaded = threaded_messages(messages)
97
 
                messages = []
98
 
                if order == 'thread_subject':
99
 
                    threaded.sort(key=lambda t: t[0]['subject'])
100
 
                if order == 'thread_oldest':
101
 
                    threaded.sort(key=lambda t: min(m['date'] for m in t))
102
 
                if order == 'thread_newest':
103
 
                    threaded.sort(key=lambda t: max(m['date'] for m in t))
104
 
                for thread in threaded:
105
 
                    messages.extend(thread)
106
 
            else:
107
 
                messages.sort(key=lambda m: m[order])
108
 
        messages = [m for m in messages
109
 
                    if 'message_ids' not in parameters or
110
 
                    m['message_id'] in parameters['message_ids']]
111
67
        self.send_response(httplib.OK)
112
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
        if 'order' in parameters:
 
73
            messages.sort(key=lambda m: m[parameters['order']])
113
74
        limit = parameters.get('limit', 100)
114
75
        memo = parameters.get('memo')
115
76
        message_id_indices = dict(
199
160
            messages.extend(response['messages'])
200
161
            self.assertMessageIDs(['foo', 'bar'], messages)
201
162
 
202
 
    def get_messages_member_order_test(self, key):
203
 
        client = GrackleClient('localhost', 8439)
204
 
        with fake_grackle_service(client,
205
 
                {'baz': [{'message_id': 'foo', key: '2011-03-25'},
206
 
                 {'message_id': 'bar', key: '2011-03-24'}]}):
207
 
            response = client.get_messages('baz')
208
 
            self.assertIDOrder(['foo', 'bar'], response['messages'])
209
 
            response = client.get_messages('baz', order=key)
210
 
            self.assertIDOrder(['bar', 'foo'], response['messages'])
211
 
 
212
163
    def test_get_messages_date_order(self):
213
 
        self.get_messages_member_order_test('date')
214
 
 
215
 
    def test_get_messages_author_order(self):
216
 
        self.get_messages_member_order_test('author')
217
 
 
218
 
    def test_get_messages_subject_order(self):
219
 
        self.get_messages_member_order_test('subject')
220
 
 
221
 
    def test_get_messages_thread_subject_order(self):
222
 
        client = GrackleClient('localhost', 8439)
223
 
        with fake_grackle_service(client, {'baz': [
224
 
            {'message_id': 'bar', 'subject': 'y'},
225
 
            {'message_id': 'qux', 'subject': 'z'},
226
 
            {'message_id': 'foo', 'subject': 'x', 'in_reply_to': 'qux'},
227
 
            ]}):
228
 
            response = client.get_messages('baz')
229
 
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
230
 
            response = client.get_messages('baz', order='subject')
231
 
            self.assertIDOrder(['foo', 'bar', 'qux'], response['messages'])
232
 
            response = client.get_messages('baz', order='thread_subject')
233
 
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
234
 
 
235
 
    def test_get_messages_thread_oldest_order(self):
236
 
        client = GrackleClient('localhost', 8439)
237
 
        with fake_grackle_service(client, {'baz': [
238
 
            {'message_id': 'bar', 'date': 'x'},
239
 
            {'message_id': 'qux', 'date': 'z'},
240
 
            {'message_id': 'foo', 'date': 'y', 'in_reply_to': 'qux'},
241
 
            ]}):
242
 
            response = client.get_messages('baz')
243
 
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
244
 
            response = client.get_messages('baz', order='date')
245
 
            self.assertIDOrder(['bar', 'foo', 'qux'], response['messages'])
246
 
            response = client.get_messages('baz', order='thread_oldest')
247
 
            self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])
248
 
 
249
 
    def test_get_messages_thread_newest_order(self):
250
 
        client = GrackleClient('localhost', 8439)
251
 
        with fake_grackle_service(client, {'baz': [
252
 
            {'message_id': 'bar', 'date': 'x'},
253
 
            {'message_id': 'qux', 'date': 'w'},
254
 
            {'message_id': 'foo', 'date': 'y', 'in_reply_to': 'bar'},
255
 
            {'message_id': 'baz', 'date': 'z', 'in_reply_to': 'qux'},
256
 
            ]}):
257
 
            response = client.get_messages('baz', order='date')
258
 
            self.assertIDOrder(
259
 
                ['qux', 'bar', 'foo', 'baz'], response['messages'])
260
 
            response = client.get_messages('baz', order='thread_newest')
261
 
            self.assertIDOrder(
262
 
                ['bar', 'foo', 'qux', 'baz'], response['messages'])
263
 
 
264
 
    def test_get_messages_unsupported_order(self):
265
164
        client = GrackleClient('localhost', 8439)
266
165
        with fake_grackle_service(client,
267
166
                {'baz': [{'message_id': 'foo', 'date': '2011-03-25'},
268
167
                 {'message_id': 'bar', 'date': '2011-03-24'}]}):
269
 
            with ExpectedException(UnsupportedOrder):
270
 
                client.get_messages('baz', order='nonsense')
 
168
            response = client.get_messages('baz')
 
169
            self.assertIDOrder(['foo', 'bar'], response['messages'])
 
170
            response = client.get_messages('baz', order='date')
 
171
            self.assertIDOrder(['bar', 'foo'], response['messages'])