17
17
from cStringIO import StringIO
20
from SimpleHTTPServer import SimpleHTTPRequestHandler
28
from bzrlib.smart import protocol
29
from bzrlib.tests import TestCaseWithTransport
30
from bzrlib.tests.HttpServer import (
32
TestingHTTPRequestHandler,
32
from bzrlib.smart import medium, protocol
33
from bzrlib.tests import http_server
34
34
from bzrlib.transport import (
40
class HTTPServerWithSmarts(http_server.HttpServer):
39
class WallRequestHandler(TestingHTTPRequestHandler):
40
"""Whatever request comes in, close the connection"""
42
def handle_one_request(self):
43
"""Handle a single HTTP request, by abruptly closing the connection"""
44
self.close_connection = 1
47
class BadStatusRequestHandler(TestingHTTPRequestHandler):
48
"""Whatever request comes in, returns a bad status"""
50
def parse_request(self):
51
"""Fakes handling a single HTTP request, returns a bad status"""
52
ignored = TestingHTTPRequestHandler.parse_request(self)
54
self.send_response(0, "Bad status")
56
except socket.error, e:
57
# We don't want to pollute the test results with
58
# spurious server errors while test succeed. In our
59
# case, it may occur that the test has already read
60
# the 'Bad Status' and closed the socket while we are
61
# still trying to send some headers... So the test is
62
# ok, but if we raise the exception, the output is
63
# dirty. So we don't raise, but we close the
64
# connection, just to be safe :)
65
spurious = [errno.EPIPE,
69
if (len(e.args) > 0) and (e.args[0] in spurious):
70
self.close_connection = 1
77
class InvalidStatusRequestHandler(TestingHTTPRequestHandler):
78
"""Whatever request comes in, returns am invalid status"""
80
def parse_request(self):
81
"""Fakes handling a single HTTP request, returns a bad status"""
82
ignored = TestingHTTPRequestHandler.parse_request(self)
83
self.wfile.write("Invalid status line\r\n")
87
class BadProtocolRequestHandler(TestingHTTPRequestHandler):
88
"""Whatever request comes in, returns a bad protocol version"""
90
def parse_request(self):
91
"""Fakes handling a single HTTP request, returns a bad status"""
92
ignored = TestingHTTPRequestHandler.parse_request(self)
93
# Returns an invalid protocol version, but curl just
94
# ignores it and those cannot be tested.
95
self.wfile.write("%s %d %s\r\n" % ('HTTP/0.0',
97
'Look at my protocol version'))
101
class ForbiddenRequestHandler(TestingHTTPRequestHandler):
102
"""Whatever request comes in, returns a 403 code"""
104
def parse_request(self):
105
"""Handle a single HTTP request, by replying we cannot handle it"""
106
ignored = TestingHTTPRequestHandler.parse_request(self)
111
class HTTPServerWithSmarts(HttpServer):
41
112
"""HTTPServerWithSmarts extends the HttpServer with POST methods that will
42
113
trigger a smart server to execute with a transport rooted at the rootdir of
46
def __init__(self, protocol_version=None):
47
http_server.HttpServer.__init__(self, SmartRequestHandler,
48
protocol_version=protocol_version)
51
class SmartRequestHandler(http_server.TestingHTTPRequestHandler):
52
"""Extend TestingHTTPRequestHandler to support smart client POSTs.
54
XXX: This duplicates a fair bit of the logic in bzrlib.transport.http.wsgi.
118
HttpServer.__init__(self, SmartRequestHandler)
121
class SmartRequestHandler(TestingHTTPRequestHandler):
122
"""Extend TestingHTTPRequestHandler to support smart client POSTs."""
57
124
def do_POST(self):
58
125
"""Hand the request off to a smart server instance."""
59
backing = get_transport(self.server.test_case_server._home_dir)
60
chroot_server = chroot.ChrootServer(backing)
63
t = get_transport(chroot_server.get_url())
66
chroot_server.tearDown()
68
def do_POST_inner(self, chrooted_transport):
69
126
self.send_response(200)
70
127
self.send_header("Content-type", "application/octet-stream")
71
if not self.path.endswith('.bzr/smart'):
73
'POST to path not ending in .bzr/smart: %r' % (self.path,))
74
t = chrooted_transport.clone(self.path[:-len('.bzr/smart')])
75
# if this fails, we should return 400 bad request, but failure is
76
# failure for now - RBC 20060919
77
data_length = int(self.headers['Content-Length'])
128
transport = get_transport(self.server.test_case_server._home_dir)
78
129
# TODO: We might like to support streaming responses. 1.0 allows no
79
130
# Content-length in this case, so for integrity we should perform our
80
131
# own chunking within the stream.
82
133
# the HTTP chunking as this will allow HTTP persistence safely, even if
83
134
# we have to stop early due to error, but we would also have to use the
84
135
# HTTP trailer facility which may not be widely available.
85
request_bytes = self.rfile.read(data_length)
86
protocol_factory, unused_bytes = medium._get_protocol_factory_for_bytes(
88
136
out_buffer = StringIO()
89
smart_protocol_request = protocol_factory(t, out_buffer.write, '/')
137
smart_protocol_request = protocol.SmartServerRequestProtocolOne(
138
transport, out_buffer.write)
139
# if this fails, we should return 400 bad request, but failure is
140
# failure for now - RBC 20060919
141
data_length = int(self.headers['Content-Length'])
90
142
# Perhaps there should be a SmartServerHTTPMedium that takes care of
91
143
# feeding the bytes in the http request to the smart_protocol_request,
92
144
# but for now it's simpler to just feed the bytes directly.
93
smart_protocol_request.accept_bytes(unused_bytes)
94
if not (smart_protocol_request.next_read_size() == 0):
95
raise errors.SmartProtocolError(
96
"not finished reading, but all data sent to protocol.")
145
smart_protocol_request.accept_bytes(self.rfile.read(data_length))
146
assert smart_protocol_request.next_read_size() == 0, (
147
"not finished reading, but all data sent to protocol.")
97
148
self.send_header("Content-Length", str(len(out_buffer.getvalue())))
98
149
self.end_headers()
99
150
self.wfile.write(out_buffer.getvalue())
102
class TestCaseWithWebserver(tests.TestCaseWithTransport):
153
class LimitedRangeRequestHandler(TestingHTTPRequestHandler):
154
"""Errors out when range specifiers exceed the limit"""
156
def get_multiple_ranges(self, file, file_size, ranges):
157
"""Refuses the multiple ranges request"""
158
tcs = self.server.test_case_server
159
if tcs.range_limit is not None and len(ranges) > tcs.range_limit:
161
# Emulate apache behavior
162
self.send_error(400, "Bad Request")
164
return TestingHTTPRequestHandler.get_multiple_ranges(self, file,
168
class LimitedRangeHTTPServer(HttpServer):
169
"""An HttpServer erroring out on requests with too much range specifiers"""
171
def __init__(self, request_handler=LimitedRangeRequestHandler,
173
HttpServer.__init__(self, request_handler)
174
self.range_limit = range_limit
177
class SingleRangeRequestHandler(TestingHTTPRequestHandler):
178
"""Always reply to range request as if they were single.
180
Don't be explicit about it, just to annoy the clients.
183
def get_multiple_ranges(self, file, file_size, ranges):
184
"""Answer as if it was a single range request and ignores the rest"""
185
(start, end) = ranges[0]
186
return self.get_single_range(file, file_size, start, end)
189
class SingleOnlyRangeRequestHandler(TestingHTTPRequestHandler):
190
"""Only reply to simple range requests, errors out on multiple"""
192
def get_multiple_ranges(self, file, file_size, ranges):
193
"""Refuses the multiple ranges request"""
196
self.send_error(416, "Requested range not satisfiable")
198
(start, end) = ranges[0]
199
return self.get_single_range(file, file_size, start, end)
202
class NoRangeRequestHandler(TestingHTTPRequestHandler):
203
"""Ignore range requests without notice"""
206
# Update the statistics
207
self.server.test_case_server.GET_request_nb += 1
208
# Just bypass the range handling done by TestingHTTPRequestHandler
209
return SimpleHTTPRequestHandler.do_GET(self)
212
class TestCaseWithWebserver(TestCaseWithTransport):
103
213
"""A support class that provides readonly urls that are http://.
105
215
This is done by forcing the readonly server to be an http
432
532
class HTTPBasicAuthServer(HTTPAuthServer):
433
533
"""An HTTP server requiring basic authentication"""
435
def __init__(self, protocol_version=None):
436
HTTPAuthServer.__init__(self, BasicAuthRequestHandler, 'basic',
437
protocol_version=protocol_version)
536
HTTPAuthServer.__init__(self, BasicAuthRequestHandler, 'basic')
438
537
self.init_http_auth()
441
540
class HTTPDigestAuthServer(DigestAuthServer, HTTPAuthServer):
442
541
"""An HTTP server requiring digest authentication"""
444
def __init__(self, protocol_version=None):
445
DigestAuthServer.__init__(self, DigestAuthRequestHandler, 'digest',
446
protocol_version=protocol_version)
544
DigestAuthServer.__init__(self, DigestAuthRequestHandler, 'digest')
447
545
self.init_http_auth()
450
548
class ProxyBasicAuthServer(ProxyAuthServer):
451
549
"""A proxy server requiring basic authentication"""
453
def __init__(self, protocol_version=None):
454
ProxyAuthServer.__init__(self, BasicAuthRequestHandler, 'basic',
455
protocol_version=protocol_version)
552
ProxyAuthServer.__init__(self, BasicAuthRequestHandler, 'basic')
456
553
self.init_proxy_auth()
459
556
class ProxyDigestAuthServer(DigestAuthServer, ProxyAuthServer):
460
557
"""A proxy server requiring basic authentication"""
462
def __init__(self, protocol_version=None):
463
ProxyAuthServer.__init__(self, DigestAuthRequestHandler, 'digest',
464
protocol_version=protocol_version)
560
ProxyAuthServer.__init__(self, DigestAuthRequestHandler, 'digest')
465
561
self.init_proxy_auth()
added
removed
bzrlib/tests/HTTPTestUtil.py
