« back to all changes in this revision
Viewing changes to grackle/tests/test_client.py
- browse files at revision 66
- compare with another revision
- download diff
- download tarball
- view history from revision 66
- Committer: Curtis Hovey
- Date: 2012-03-17 21:17:03 UTC
- Revision ID: curtis.hovey@canonical.com-20120317211703-hsmk5h4xux2jgx2p
use send response to ensure a list of strings is returned.
- files added:
- grackle/service.py
- files modified:
- grackle/client.py
added
removed
grackle/tests/test_client.py
1
from BaseHTTPServer import (
2
HTTPServer,
3
BaseHTTPRequestHandler,
4
)
5
1
from email.message import Message
6
2
from email.mime.multipart import MIMEMultipart
7
3
from email.mime.text import MIMEText
8
import httplib
9
import logging
10
import os
11
from signal import SIGKILL
12
import simplejson
13
4
from StringIO import StringIO
14
import sys
15
5
from unittest import TestCase
16
from urlparse import urlparse
17
6
18
7
from testtools import ExpectedException
19
8
20
from grackle.client import (
21
GrackleClient,
9
from grackle.client import GrackleClient
10
from grackle.error import (
11
ArchiveIdExists,
22
12
UnparsableDateRange,
23
13
UnsupportedDisplayType,
24
14
UnsupportedOrder,
25
15
)
16
from grackle.service import ForkedFakeService
26
17
from grackle.store import (
27
18
make_json_message,
28
MemoryStore,
29
19
)
30
20
31
21
32
22
def make_message(message_id, body='body', headers=None, hidden=False):
33
23
if headers is None:
34
24
headers = {}
35
headers['Message-Id'] = message_id
36
message = {
37
'message_id': message_id,
38
'headers': headers,
39
'thread_id': message_id,
40
'date': headers.get('date', '2005-01-01'),
41
'subject': headers.get('subject', 'subject'),
42
'author': headers.get('author', 'author'),
43
'hidden': hidden,
44
'attachments': [],
45
'replies': headers.get('in-reply-to', None),
46
'body': body,
25
message_headers = {
26
'Message-Id': message_id,
27
'date': '2005-01-01',
28
'subject': 'subject',
29
'from': 'author',
30
'replies': '',
47
31
}
48
return message
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)
49
38
50
39
51
40
def make_mime_message(message_id, body='body', headers=None, hidden=False,
52
41
attachment_type=None):
53
if headers is None:
54
headers = {}
55
42
parts = MIMEMultipart()
56
43
parts.attach(MIMEText(body))
57
44
if attachment_type is not None:
60
47
attachment['Content-Type'] = attachment_type
61
48
attachment['Content-Disposition'] = 'attachment; filename="file.ext"'
62
49
parts.attach(attachment)
63
message = Message()
64
message.set_payload(parts.as_string())
65
for key, value in headers.items():
66
message[key] = value
67
return make_json_message(message_id, message.as_string())
68
69
70
class ForkedFakeService:
71
"""A Grackle service fake, as a ContextManager."""
72
73
def __init__(self, port, message_archives=None, write_logs=False):
74
"""Constructor.
75
76
:param port: The tcp port to use.
77
:param message_archives: A dict of lists of dicts representing
78
archives of messages. The outer dict represents the archive,
79
the list represents the list of messages for that archive.
80
:param write_logs: If true, log messages will be written to stdout.
81
"""
82
self.pid = None
83
self.port = port
84
if message_archives is None:
85
self.message_archives = {}
86
else:
87
self.message_archives = message_archives
88
self.read_end, self.write_end = os.pipe()
89
self.write_logs = write_logs
90
91
@staticmethod
92
def from_client(client, message_archives=None):
93
"""Instantiate a ForkedFakeService from the client.
94
95
:param port: The client to provide service for.
96
:param message_archives: A dict of lists of dicts representing
97
archives of messages. The outer dict represents the archive,
98
the list represents the list of messages for that archive.
99
"""
100
return ForkedFakeService(client.port, message_archives)
101
102
def is_ready(self):
103
"""Tell the parent process that the server is ready for writes."""
104
os.write(self.write_end, 'asdf')
105
106
def __enter__(self):
107
"""Run the service.
108
109
Fork and start a server in the child. Return when the server is ready
110
for use."""
111
pid = os.fork()
112
if pid == 0:
113
self.start_server()
114
self.pid = pid
115
os.read(self.read_end, 1)
116
return
117
118
def start_server(self):
119
"""Start the HTTP server."""
120
service = HTTPServer(('', self.port), FakeGrackleRequestHandler)
121
service.store = MemoryStore(self.message_archives)
122
for archive_id, messages in service.store.message_archives.iteritems():
123
for message in messages:
124
message.setdefault('headers', {})
125
self.is_ready()
126
if self.write_logs:
127
logging.basicConfig(
128
stream=sys.stderr, level=logging.INFO)
129
service.serve_forever()
130
131
def __exit__(self, exc_type, exc_val, traceback):
132
os.kill(self.pid, SIGKILL)
133
134
135
class FakeGrackleRequestHandler(BaseHTTPRequestHandler):
136
"""A request handler that forwards to server.store."""
137
138
def __init__(self, *args, **kwargs):
139
"""Constructor. Sets up logging."""
140
self.logger = logging.getLogger('http')
141
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
142
143
def do_POST(self):
144
"""Create a message on POST."""
145
message = self.rfile.read(int(self.headers['content-length']))
146
scheme, netloc, path, params, query_string, fragments = (
147
urlparse(self.path))
148
parts = path.split('/')
149
if parts[1] == 'archive' and len(parts) == 4:
150
try:
151
# This expected path is /archive/archive_id/message_id.
152
self.server.store.put_message(parts[2], parts[3], message)
153
self.send_response(httplib.CREATED)
154
self.end_headers()
155
self.wfile.close()
156
except:
157
self.send_error(httplib.BAD_REQUEST)
158
159
def do_GET(self):
160
"""Retrieve a list of messages on GET."""
161
scheme, netloc, path, params, query_string, fragments = (
162
urlparse(self.path))
163
parts = path.split('/')
164
if parts[1] == 'archive':
165
try:
166
response = self.server.store.get_messages(
167
parts[2], query_string)
168
self.send_response(httplib.OK)
169
self.end_headers()
170
self.wfile.write(simplejson.dumps(response))
171
except Exception, error:
172
self.send_response(
173
httplib.BAD_REQUEST, error.__doc__)
174
return
175
176
def log_message(self, format, *args):
177
"""Override log_message to use standard Python logging."""
178
message = "%s - - [%s] %s\n" % (
179
self.address_string(), self.log_date_time_string(), format % args)
180
self.logger.info(message)
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')
181
69
182
70
183
71
class TestPutMessage(TestCase):
244
132
245
133
def get_messages_member_order_test(self, key):
246
134
client = GrackleClient('localhost', 8439)
135
if key == 'author':
136
header_name = 'from'
137
else:
138
header_name = key
247
139
archive = {
248
140
'baz': [
249
make_message('foo', headers={key: '2011-03-25'}),
250
make_message('bar', headers={key: '2011-03-24'}),
141
make_message('foo', headers={header_name: '2011-03-25'}),
142
make_message('bar', headers={header_name: '2011-03-24'}),
251
143
]}
252
144
with ForkedFakeService.from_client(client, archive):
253
145
response = client.get_messages('baz')
400
292
first_message = response['messages'][0]
401
293
self.assertEqual('foo', first_message['message_id'])
402
294
self.assertEqual(
403
{'From': 'me', 'Message-Id': 'foo', 'To': 'you'},
404
first_message['headers'])
295
archive['baz'][0]['headers'], first_message['headers'])
405
296
self.assertNotIn('body', first_message)
406
297
407
298
def test_display_type_text_only(self):
477
368
with ForkedFakeService.from_client(client, archive):
478
369
with ExpectedException(UnparsableDateRange, ''):
479
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