def testParsedAndRaw(self):
def parse(raw):
return parsedvalue(raw)
def generate(parsed):
return parsed.raw
rawvalue = ("value1", "value2")
rawvalue2 = ("value3", "value4")
handler = HeaderHandler(parsers={'test': (parse, )},
generators={'test': (generate, )})
h = http_headers.Headers(handler=handler)
h.setRawHeaders("test", rawvalue)
self.assertEquals(h.getHeader("test"), parsedvalue(rawvalue))
h.setHeader("test", parsedvalue(rawvalue2))
self.assertEquals(h.getRawHeaders("test"), rawvalue2)
# Check the initializers
h = http_headers.Headers(rawHeaders={"test": rawvalue},
handler=handler)
self.assertEquals(h.getHeader("test"), parsedvalue(rawvalue))
h = http_headers.Headers({"test": parsedvalue(rawvalue2)},
handler=handler)
self.assertEquals(h.getRawHeaders("test"), rawvalue2)
def __init__(self, code=None, headers=None, stream=None):
"""
@param code: The HTTP status code for this Response
@type code: C{int}
@param headers: Headers to be sent to the client.
@type headers: C{dict}, L{twisted.web2.http_headers.Headers}, or
C{None}
@param stream: Content body to send to the HTTP client
@type stream: L{twisted.web2.stream.IByteStream}
"""
if code is not None:
self.code = int(code)
if headers is not None:
if isinstance(headers, dict):
headers = http_headers.Headers(headers)
self.headers=headers
else:
self.headers = http_headers.Headers()
if stream is not None:
self.stream = IByteStream(stream)
def testIfMatch(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
# Behavior with no ETag set, should be same as with an ETag
request.headers.setRawHeaders("If-Match", ('*', ))
self.checkPreconditions(request, response, True, responsecode.OK)
self.checkPreconditions(request,
response,
False,
responsecode.PRECONDITION_FAILED,
entityExists=False)
# Ask for tag, but no etag set.
request.headers.setRawHeaders("If-Match", ('"frob"', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
## Actually set the ETag header
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
# behavior of entityExists
request.headers.setRawHeaders("If-Match", ('*', ))
self.checkPreconditions(request, response, True, responsecode.OK)
self.checkPreconditions(request,
response,
False,
responsecode.PRECONDITION_FAILED,
entityExists=False)
# tag matches
request.headers.setRawHeaders("If-Match", ('"frob", "foo"', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# none match
request.headers.setRawHeaders("If-Match", ('"baz", "bob"', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# Must only compare strong tags
out_headers.setHeader("ETag", http_headers.ETag('foo', weak=True))
request.headers.setRawHeaders("If-Match", ('W/"foo"', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
def testIfModifiedSince(self):
if time.time() < 946771200:
self.fail(
RuntimeError("Your computer's clock is way wrong, "
"this test will be invalid."))
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
# No Last-Modified => always succeed
request.headers.setRawHeaders("If-Modified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# Set output headers
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
request.headers.setRawHeaders("If-Modified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
# With a non-GET method
request.method = "PUT"
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
request.method = "GET"
request.headers.setRawHeaders("If-Modified-Since",
('Sat, 01 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# invalid date => header ignored
request.headers.setRawHeaders("If-Modified-Since",
('alalalalalalalalalala', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# date in the future => assume modified
request.headers.setHeader("If-Modified-Since", time.time() + 500)
self.checkPreconditions(request, response, True, responsecode.OK)
def getResponseFor(self,
root,
uri,
headers={},
method=None,
version=None,
prepath='',
content=None,
length=_unset):
if not isinstance(headers, http_headers.Headers):
headers = http_headers.Headers(headers)
if length is _unset:
if content is not None:
length = len(content)
else:
length = 0
if method is None:
method = self.method
if version is None:
version = self.version
cr = self.chanrequest(root, uri, length, headers, method, version,
prepath, content)
cr.request.process()
return cr.deferredFinish
def test_multipart(self):
"""
Test parsing data in multipart format: it should fill the C{files}
attribute.
"""
ctype = http_headers.MimeType('multipart', 'form-data',
(('boundary', '---weeboundary'),))
content="""-----weeboundary\r
Content-Disposition: form-data; name="FileNameOne"; filename="myfilename"\r
Content-Type: text/html\r
\r
my great content wooo\r
-----weeboundary--\r
"""
root = resource.Resource()
request = SimpleRequest(server.Site(root), "GET", "/",
http_headers.Headers({'content-type': ctype}), content)
def cb(ign):
self.assertEquals(request.args, {})
self.assertEquals(request.files.keys(), ['FileNameOne'])
self.assertEquals(request.files.values()[0][0][:2],
('myfilename', http_headers.MimeType('text', 'html', {})))
f = request.files.values()[0][0][2]
self.assertEquals(f.read(), "my great content wooo")
return server.parsePOSTData(request).addCallback(cb)
def test_maxFields(self):
"""
Check that the C{maxSize} parameter makes the parsing raise an
exception if the data contains too many fields.
"""
ctype = http_headers.MimeType('multipart', 'form-data',
(('boundary', '---xyz'),))
content = """-----xyz\r
Content-Disposition: form-data; name="foo"\r
\r
Foo Bar\r
-----xyz\r
Content-Disposition: form-data; name="foo"\r
\r
Baz\r
-----xyz\r
Content-Disposition: form-data; name="file"; filename="filename"\r
Content-Type: text/html\r
\r
blah\r
-----xyz\r
Content-Disposition: form-data; name="file"; filename="filename"\r
Content-Type: text/plain\r
\r
bleh\r
-----xyz--\r
"""
root = resource.Resource()
request = SimpleRequest(server.Site(root), "GET", "/",
http_headers.Headers({'content-type': ctype}), content)
def cb(res):
self.assertEquals(res.response.description,
"Maximum number of fields 3 exceeded")
return self.assertFailure(server.parsePOSTData(request, maxFields=3),
http.HTTPError).addCallback(cb)
def __init__(self, site, method, prepath, uri, length=None,
headers=None, version=(1,1), content=None):
self.site = site
self.method = method
self.prepath = prepath
self.uri = uri
if headers is None:
headers = http_headers.Headers()
self.headers = headers
self.http_version = version
# Anything below here we do not pass as arguments
self.request = server.Request(self,
self.method,
self.uri,
self.http_version,
length,
self.headers,
site=self.site,
prepathuri=self.prepath)
if content is not None:
self.request.handleContentChunk(content)
self.request.handleContentComplete()
self.code = None
self.responseHeaders = None
self.data = ''
self.deferredFinish = defer.Deferred()
def testImmutable(self):
h = http_headers.Headers(handler=HeaderHandler(parsers={}, generators={}))
h.makeImmutable()
self.assertRaises(AttributeError, h.setRawHeaders, "test", [1])
self.assertRaises(AttributeError, h.setHeader, "test", 1)
self.assertRaises(AttributeError, h.removeHeader, "test")
def __init__(self, method, uri, headers, stream):
"""
@param method: The HTTP method to for this request, ex: 'GET', 'HEAD',
'POST', etc.
@type method: C{str}
@param uri: The URI of the resource to request, this may be absolute or
relative, however the interpretation of this URI is left up to the
remote server.
@type uri: C{str}
@param headers: Headers to be sent to the server. It is important to
note that this object does not create any implicit headers. So it
is up to the HTTP Client to add required headers such as 'Host'.
@type headers: C{dict}, L{twisted.web2.http_headers.Headers}, or
C{None}
@param stream: Content body to send to the remote HTTP server.
@type stream: L{twisted.web2.stream.IByteStream}
"""
self.method = method
self.uri = uri
if isinstance(headers, http_headers.Headers):
self.headers = headers
else:
self.headers = http_headers.Headers(headers or {})
if stream is not None:
self.stream = stream_mod.IByteStream(stream)
else:
self.stream = None
def setCommonHeaders(self):
"""Get the common HTTP headers for all requests."""
headers = http_headers.Headers()
headers.setHeader('Host', self.host)
headers.setHeader('User-Agent', 'apt-p2p/%s (twisted/%s twisted.web2/%s)' %
(version.short(), twisted_version.short(), web2_version.short()))
return headers
def testWithoutHeaders(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.setHeader("ETag", http_headers.ETag('foo'))
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.removeHeader("ETag")
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.setHeader("ETag", http_headers.ETag('foo'))
self.checkPreconditions(request, response, True, responsecode.OK)
def testParsed(self):
parsed = parsedvalue(("value1", "value2"))
h = http_headers.Headers(handler=HeaderHandler(parsers={}, generators={}))
h.setHeader("test", parsed)
self.assertEquals(h.hasHeader("test"), True)
self.assertEquals(h.getHeader("test"), parsed)
self.assertEquals(h.getHeader("foobar"), None)
h.removeHeader("test")
self.assertEquals(h.getHeader("test"), None)
def testRaw(self):
rawvalue = ("value1", "value2")
h = http_headers.Headers(handler=HeaderHandler(parsers={}, generators={}))
h.setRawHeaders("test", rawvalue)
self.assertEquals(h.hasHeader("test"), True)
self.assertEquals(h.getRawHeaders("test"), rawvalue)
self.assertEquals(list(h.getAllRawHeaders()), [('Test', rawvalue)])
self.assertEquals(h.getRawHeaders("foobar"), None)
h.removeHeader("test")
self.assertEquals(h.getRawHeaders("test"), None)
def _abortWithError(self, errorcode, text=''):
"""Handle low level protocol errors."""
headers = http_headers.Headers()
headers.setHeader('content-length', len(text)+1)
self.abortConnection(closeWrite=False)
self.writeHeaders(errorcode, headers)
self.write(text)
self.write("\n")
self.finish()
raise AbortedException
def test_wrongContentType(self):
"""
Check that a content-type not handled raise a C{http.HTTPError}.
"""
ctype = http_headers.MimeType('application', 'foobar')
content = "key=value&multiple=two+words&multiple=more%20words"
root = resource.Resource()
request = SimpleRequest(server.Site(root), "GET", "/",
http_headers.Headers({'content-type': ctype}), content)
return self.assertFailure(server.parsePOSTData(request),
http.HTTPError)
def create_request(self, host, path):
req = server.Request(None, 'GET', path, (1, 1), 0,
http_headers.Headers())
class addr:
host = ''
port = 0
req.remoteAddr = addr()
req.remoteAddr.host = host
req.remoteAddr.port = 23456
server.Request._parseURL(req)
return req
def testIfRange(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
response = TestResponse()
self.assertEquals(http.checkIfRange(request, response), True)
request.headers.setRawHeaders("If-Range", ('"foo"', ))
self.assertEquals(http.checkIfRange(request, response), False)
response.headers.setHeader("ETag", http_headers.ETag('foo'))
self.assertEquals(http.checkIfRange(request, response), True)
request.headers.setRawHeaders("If-Range", ('"bar"', ))
response.headers.setHeader("ETag", http_headers.ETag('foo'))
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range", ('W/"foo"', ))
response.headers.setHeader("ETag", http_headers.ETag('foo', weak=True))
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range", ('"foo"', ))
response.headers.removeHeader("ETag")
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range",
('Sun, 02 Jan 2000 00:00:00 GMT', ))
response.headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
self.assertEquals(http.checkIfRange(request, response), True)
request.headers.setRawHeaders("If-Range",
('Sun, 02 Jan 2000 00:00:01 GMT', ))
response.headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range",
('Sun, 01 Jan 2000 23:59:59 GMT', ))
response.headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range",
('Sun, 01 Jan 2000 23:59:59 GMT', ))
response.headers.removeHeader("Last-Modified")
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range", ('jwerlqjL#$Y*KJAN', ))
self.assertEquals(http.checkIfRange(request, response), False)
def processLockRequest(resource, request):
"""
Respond to a LOCK request. (RFC 2518, section 8.10)
Relevant notes:
"""
requestStream = request.stream
depth = getDepth(request.headers)
#log.error(request.headers.getRawHeaders("X-Litmus")[0])
# generate DAVDocument from request body
lockInfo = waitForDeferred(
deferredGenerator(parseLockRequest)(requestStream))
yield lockInfo
lockInfo = lockInfo.getResult()
assertExclusiveLock(lockInfo)
assertWriteLock(lockInfo)
# we currently only allow lock depths of "0"
assertZeroLockDepth(depth)
# build the corresponding activelock element
# e.g. http://www.webdav.org/specs/rfc2518.html#rfc.section.8.10.8
activeLock = buildActiveLock(lockInfo, depth)
# extract the lock token
lt = activeLock.childOfType(davxml.LockToken).childOfType(davxml.HRef)
# make headers with lock token header
lth = http_headers.Headers(rawHeaders={"Lock-Token": [lt]})
ld = davxml.LockDiscovery(activeLock)
ignored = waitForDeferred(
deferredGenerator(resource._setLock)(ld, request))
yield ignored
ignored = ignored.getResult()
# debug
ignored = waitForDeferred(deferredGenerator(resource._getLock)())
yield ignored
ignored = ignored.getResult()
pp = davxml.PropertyContainer(ld)
yield Response(code=responsecode.OK,
headers=lth,
stream=stream.MemoryStream(pp.toxml()))
def test_urlencoded(self):
"""
Test parsing data in urlencoded format: it should end in the C{args}
attribute.
"""
ctype = http_headers.MimeType('application', 'x-www-form-urlencoded')
content = "key=value&multiple=two+words&multiple=more%20words"
root = resource.Resource()
request = SimpleRequest(server.Site(root), "GET", "/",
http_headers.Headers({'content-type': ctype}), content)
def cb(ign):
self.assertEquals(request.files, {})
self.assertEquals(request.args,
{'multiple': ['two words', 'more words'], 'key': ['value']})
return server.parsePOSTData(request).addCallback(cb)
def testIfUnmodifiedSince(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
# No Last-Modified => always fail.
request.headers.setRawHeaders("If-Unmodified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
# Set output headers
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
request.headers.setRawHeaders("If-Unmodified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
request.headers.setRawHeaders("If-Unmodified-Since",
('Sat, 01 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# invalid date => header ignored
request.headers.setRawHeaders("If-Unmodified-Since",
('alalalalalalalalalala', ))
self.checkPreconditions(request, response, True, responsecode.OK)
def NotModifiedResponse(oldResponse=None):
if oldResponse is not None:
headers=http_headers.Headers()
for header in (
# Required from sec 10.3.5:
'date', 'etag', 'content-location', 'expires',
'cache-control', 'vary',
# Others:
'server', 'proxy-authenticate', 'www-authenticate', 'warning'):
value = oldResponse.headers.getRawHeaders(header)
if value is not None:
headers.setRawHeaders(header, value)
else:
headers = None
return Response(code=responsecode.NOT_MODIFIED, headers=headers)
def makeRequest(self, vars):
headers = http_headers.Headers()
http_vers = http.parseVersion(vars['SERVER_PROTOCOL'])
if http_vers[0] != 'http' or http_vers[1] > 1:
_abortWithError(
responsecode.INTERNAL_SERVER_ERROR,
"Twisted.web CGITransport: Unknown HTTP version: " %
vars['SERVER_PROTOCOL'])
secure = vars.get("HTTPS") in ("1", "on") # apache extension?
port = vars.get('SERVER_PORT') or 80
server_host = vars.get('SERVER_NAME') or vars.get(
'SERVER_ADDR') or 'localhost'
self.hostinfo = address.IPv4Address('TCP', server_host,
port), bool(secure)
self.remoteinfo = address.IPv4Address('TCP',
vars.get('REMOTE_ADDR', ''),
vars.get('REMOTE_PORT', 0))
uri = vars.get('REQUEST_URI') # apache extension?
if not uri:
qstr = vars.get('QUERY_STRING', '')
if qstr:
qstr = "?" + urllib.quote(qstr, safe="")
uri = urllib.quote(vars['SCRIPT_NAME']) + urllib.quote(
vars.get('PATH_INFO', '')) + qstr
for name, val in vars.iteritems():
if name.startswith('HTTP_'):
name = name[5:].replace('_', '-')
elif name == 'CONTENT_TYPE':
name = 'content-type'
else:
continue
headers.setRawHeaders(name, (val, ))
self._dataRemaining = int(vars.get('CONTENT_LENGTH', '0'))
self.request = self.requestFactory(self,
vars['REQUEST_METHOD'],
uri,
http_vers[1:3],
self._dataRemaining,
headers,
prepathuri=vars['SCRIPT_NAME'])
def test_otherErrors(self):
"""
Test that errors durign parsing other than C{MimeFormatError} are
propagated.
"""
ctype = http_headers.MimeType('multipart', 'form-data',
(('boundary', '---weeboundary'),))
# XXX: maybe this is not a good example
# parseContentDispositionFormData could handle this problem
content="""-----weeboundary\r
Content-Disposition: form-data; name="FileNameOne"; filename="myfilename and invalid data \r
-----weeboundary--\r
"""
root = resource.Resource()
request = SimpleRequest(server.Site(root), "GET", "/",
http_headers.Headers({'content-type': ctype}), content)
return self.assertFailure(server.parsePOSTData(request),
ValueError)
def __init__(self, site, method, uri, headers=None, content=None):
if not headers:
headers = http_headers.Headers(headers)
super(SimpleRequest, self).__init__(site=site,
chanRequest=None,
command=method,
path=uri,
version=self.clientproto,
contentLength=len(content or ''),
headers=headers)
self.stream = stream.MemoryStream(content or '')
self.remoteAddr = address.IPv4Address('TCP', '127.0.0.1', 0)
self._parseURL()
self.host = 'localhost'
self.port = 8080
def test_multipartWithNoBoundary(self):
"""
If the boundary type is not specified, parsing should fail with a
C{http.HTTPError}.
"""
ctype = http_headers.MimeType('multipart', 'form-data')
content="""-----weeboundary\r
Content-Disposition: form-data; name="FileNameOne"; filename="myfilename"\r
Content-Type: text/html\r
\r
my great content wooo\r
-----weeboundary--\r
"""
root = resource.Resource()
request = SimpleRequest(server.Site(root), "GET", "/",
http_headers.Headers({'content-type': ctype}), content)
return self.assertFailure(server.parsePOSTData(request),
http.HTTPError)
def test_mimeParsingError(self):
"""
A malformed content should result in a C{http.HTTPError}.
The tested content has an invalid closing boundary.
"""
ctype = http_headers.MimeType('multipart', 'form-data',
(('boundary', '---weeboundary'),))
content="""-----weeboundary\r
Content-Disposition: form-data; name="FileNameOne"; filename="myfilename"\r
Content-Type: text/html\r
\r
my great content wooo\r
-----weeoundary--\r
"""
root = resource.Resource()
request = SimpleRequest(server.Site(root), "GET", "/",
http_headers.Headers({'content-type': ctype}), content)
return self.assertFailure(server.parsePOSTData(request),
http.HTTPError)
def testNoResponse(self):
# Ensure that passing etag/lastModified arguments instead of response works.
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
request.method = "PUT"
request.headers.setRawHeaders("If-None-Match", ('"foo"', ))
self.checkPreconditions(request, None, True, responsecode.OK)
self.checkPreconditions(request,
None,
False,
responsecode.PRECONDITION_FAILED,
etag=http_headers.ETag('foo'),
lastModified=946771200)
# Make sure that, while you shoudn't do this, that it doesn't cause an error
request.method = "GET"
self.checkPreconditions(request,
None,
False,
responsecode.NOT_MODIFIED,
etag=http_headers.ETag('foo'))
def submitNext(_):
headers = http_headers.Headers(
headers={'Accept-Language': {
'en': 1.0
}},
rawHeaders={'X-My-Other-Header': ['socks']})
req = http.ClientRequest('GET', '/', headers, None)
cxn.server.data = ''
d = cxn.client.submitRequest(req, closeAfter=True)
self.assertReceived(cxn, 'GET / HTTP/1.1', [
'Connection: close', 'X-My-Other-Header: socks',
'Accept-Language: en'
])
self.writeLines(cxn, ('HTTP/1.1 200 OK', 'Content-Length: 0',
'Connection: close', '\r\n'))
return d
def test_multipartMaxSize(self):
"""
Check that the C{maxSize} parameter makes the parsing raise an
exception if the data is too big.
"""
ctype = http_headers.MimeType('multipart', 'form-data',
(('boundary', '---weeboundary'),))
content="""-----weeboundary\r
Content-Disposition: form-data; name="FileNameOne"; filename="myfilename"\r
Content-Type: text/html\r
\r
my great content wooo
and even more and more\r
-----weeboundary--\r
"""
root = resource.Resource()
request = SimpleRequest(server.Site(root), "GET", "/",
http_headers.Headers({'content-type': ctype}), content)
def cb(res):
self.assertEquals(res.response.description,
"Maximum length of 10 bytes exceeded.")
return self.assertFailure(server.parsePOSTData(request, maxSize=10),
http.HTTPError).addCallback(cb)
