← 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
9
9
from StringIO import StringIO
10
10
from unittest import TestCase
11
11
from urlparse import urlparse
 
12
from urlparse import parse_qs
12
13
 
13
14
from testtools import ExpectedException
14
15
 
58
59
            self.send_error(httplib.BAD_REQUEST)
59
60
 
60
61
    def do_GET(self):
61
 
        scheme, netloc, path, params, query, fragments = urlparse(self.path)
 
62
        scheme, netloc, path, params, query_string, fragments = (
 
63
            urlparse(self.path))
62
64
        archive = os.path.split(path)[1]
 
65
        query = parse_qs(query_string)
 
66
        parameters = simplejson.loads(query['parameters'][0])
63
67
        self.send_response(httplib.OK)
64
68
        self.end_headers()
65
 
        print "path: %s" % self.path
66
 
        self.wfile.write(simplejson.dumps(self.server.messages[archive]))
 
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']])
 
74
        limit = parameters.get('limit', 100)
 
75
        memo = parameters.get('memo')
 
76
        message_id_indices = dict(
 
77
            (m['message_id'], idx) for idx, m in enumerate(messages))
 
78
        if memo is None:
 
79
            start = 0
 
80
        else:
 
81
            start = message_id_indices[memo.encode('rot13')]
 
82
        if start > 0:
 
83
            previous_memo = messages[start - 1]['message_id'].encode('rot13')
 
84
        else:
 
85
            previous_memo = None
 
86
        end = min(start + limit, len(messages))
 
87
        if end < len(messages):
 
88
            next_memo = messages[end]['message_id'].encode('rot13')
 
89
        else:
 
90
            next_memo = None
 
91
        messages = messages[start:end]
 
92
        response = {
 
93
            'messages': messages,
 
94
            'next_memo': next_memo,
 
95
            'previous_memo': previous_memo
 
96
            }
 
97
        self.wfile.write(simplejson.dumps(response))
67
98
 
68
99
 
69
100
def fake_grackle_service(client, messages=None):
85
116
 
86
117
class TestGetMessages(TestCase):
87
118
 
 
119
    def assertIDOrder(self, ids, messages):
 
120
        self.assertEqual(ids, [m['message_id'] for m in messages])
 
121
 
 
122
    def assertMessageIDs(self, ids, messages):
 
123
        self.assertIDOrder(
 
124
            sorted(ids), sorted(messages, key=lambda m:m['message_id']))
 
125
 
88
126
    def test_get_messages(self):
89
127
        client = GrackleClient('localhost', 8435)
90
128
        with fake_grackle_service(client,
91
129
            {'baz':
92
 
            [{'message-id': 'foo'},
93
 
             {'message-id': 'bar'}]}):
94
 
            response = client.get_messages('baz', message_ids=['a'])
95
 
        self.assertEqual(['bar', 'foo'], sorted(m['message-id'] for m in
96
 
            response))
 
130
            [{'message_id': 'foo'},
 
131
             {'message_id': 'bar'}]}):
 
132
            response = client.get_messages('baz')
 
133
        self.assertEqual(['bar', 'foo'], sorted(m['message_id'] for m in
 
134
            response['messages']))
 
135
        self.assertIs(None, response['next_memo'])
 
136
        self.assertIs(None, response['previous_memo'])
 
137
 
 
138
    def test_get_messages_by_id(self):
 
139
        client = GrackleClient('localhost', 8437)
 
140
        with fake_grackle_service(client,
 
141
            {'baz':
 
142
            [{'message_id': 'foo'},
 
143
             {'message_id': 'bar'}]}):
 
144
            response = client.get_messages('baz', message_ids=['foo'])
 
145
        message, = response['messages']
 
146
        self.assertEqual('foo', message['message_id'])
 
147
 
 
148
    def test_get_messages_batching(self):
 
149
        client = GrackleClient('localhost', 8438)
 
150
        with fake_grackle_service(client,
 
151
            {'baz':
 
152
            [{'message_id': 'foo'},
 
153
             {'message_id': 'bar'}]}):
 
154
            response = client.get_messages('baz', limit=1)
 
155
            self.assertEqual(1, len(response['messages']))
 
156
            messages = response['messages']
 
157
            response = client.get_messages(
 
158
                'baz', limit=1, memo=response['next_memo'])
 
159
            self.assertEqual(1, len(response['messages']))
 
160
            messages.extend(response['messages'])
 
161
            self.assertMessageIDs(['foo', 'bar'], messages)
 
162
 
 
163
    def test_get_messages_date_order(self):
 
164
        client = GrackleClient('localhost', 8439)
 
165
        with fake_grackle_service(client,
 
166
                {'baz': [{'message_id': 'foo', 'date': '2011-03-25'},
 
167
                 {'message_id': 'bar', 'date': '2011-03-24'}]}):
 
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'])