def testQueryStringIgnoredForPOST(self):
request = self._createRequest(
{"REQUEST_METHOD": "POST",
'PATH_INFO': '/folder/item3'}, body=b'c=5&d:int=6')
publish(request)
self.assertEqual(request.form, {_u("c"): _u("5"), _u("d"): 6})
self.assertEqual(request.get('QUERY_STRING'), 'a=5&b:int=6')
def testFormTextTypes(self):
extra = {'QUERY_STRING': 'a:text=a%0a%0db%0d%0ac%0dd%0ae&b:text='}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {
_u("a"): _u("a\nb\nc\nd\ne"),
_u("b"): _u("")
})
def testFormFieldValue(self):
extra = {
'QUERY_STRING': 'a=b+%2B%2F%3D%26b%3Aint',
'PATH_INFO': '/folder/item3/'
}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): _u("b +/=&b:int")})
def testIssue559(self):
extra = {'QUERY_STRING': 'HTTP_REFERER=peter',
'HTTP_REFERER':'http://localhost/',
'PATH_INFO': '/folder/item3/'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.headers.get('HTTP_REFERER'), 'http://localhost/')
self.assertEqual(request.form, {_u("HTTP_REFERER"): _u("peter")})
def testFormListTypes2(self):
extra = {'QUERY_STRING': 'a=5&a=6&b=1'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {
_u("a"): [_u("5"), _u("6")],
_u("b"): _u("1")
})
def testFormTupleTypes(self):
extra = {'QUERY_STRING': 'a:tuple=5&a:tuple=6&b=1'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {
_u("a"): (_u("5"), _u("6")),
_u("b"): _u("1")
})
def testFormBooleanTypes(self):
extra = {'QUERY_STRING': 'a:boolean=&b:boolean=1&c:boolean=%20'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {
_u("a"): False,
_u("b"): True,
_u("c"): True
})
def testQueryStringIgnoredForPOST(self):
request = self._createRequest(
{
"REQUEST_METHOD": "POST",
'PATH_INFO': '/folder/item3'
},
body=b'c=5&d:int=6')
publish(request)
self.assertEqual(request.form, {_u("c"): _u("5"), _u("d"): 6})
self.assertEqual(request.get('QUERY_STRING'), 'a=5&b:int=6')
def testIssue559(self):
extra = {
'QUERY_STRING': 'HTTP_REFERER=peter',
'HTTP_REFERER': 'http://localhost/',
'PATH_INFO': '/folder/item3/'
}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.headers.get('HTTP_REFERER'),
'http://localhost/')
self.assertEqual(request.form, {_u("HTTP_REFERER"): _u("peter")})
def testFormLongTypes(self):
extra = {'QUERY_STRING':'a:long=99999999999999&b:long=0L'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): 99999999999999, _u("b"): 0})
extra = {'QUERY_STRING':'a:long='}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
extra = {'QUERY_STRING':'a:long=abc'}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
def testFormFloatTypes(self):
extra = {'QUERY_STRING':'a:float=5&b:float=-5.01&c:float=0'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): 5.0, _u("b"): -5.01, _u("c"): 0.0})
extra = {'QUERY_STRING':'a:float='}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
extra = {'QUERY_STRING':'a:float=abc'}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
def testFormIntTypes(self):
extra = {'QUERY_STRING':'a:int=5&b:int=-5&c:int=0&d:int=-0'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): 5, _u("b"): -5, _u("c"): 0, _u("d"): 0})
extra = {'QUERY_STRING':'a:int='}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
extra = {'QUERY_STRING':'a:int=abc'}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
def testFormLongTypes(self):
extra = {'QUERY_STRING': 'a:long=99999999999999&b:long=0L'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): 99999999999999, _u("b"): 0})
extra = {'QUERY_STRING': 'a:long='}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
extra = {'QUERY_STRING': 'a:long=abc'}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
def testFormNoEncodingUsesUTF8(self):
encoded = 'K\xc3\xb6hlerstra\xc3\x9fe'
extra = {
# if nothing else is specified, form data should be
# interpreted as UTF-8, as this stub query string is
'QUERY_STRING': 'a=5&b:int=6&street=' + encoded
}
request = self._createRequest(extra)
# many mainstream browsers do not send HTTP_ACCEPT_CHARSET
del request._environ['HTTP_ACCEPT_CHARSET']
publish(request)
self.assertTrue(isinstance(request.form[_u("street")], unicode))
self.assertEqual(_u("K\xf6hlerstra\xdfe"), request.form['street'])
def testFormNoEncodingUsesUTF8(self):
encoded = 'K\xc3\xb6hlerstra\xc3\x9fe'
extra = {
# if nothing else is specified, form data should be
# interpreted as UTF-8, as this stub query string is
'QUERY_STRING': 'a=5&b:int=6&street=' + encoded
}
request = self._createRequest(extra)
# many mainstream browsers do not send HTTP_ACCEPT_CHARSET
del request._environ['HTTP_ACCEPT_CHARSET']
publish(request)
self.assertTrue(isinstance(request.form[_u("street")], unicode))
self.assertEqual(_u("K\xf6hlerstra\xdfe"), request.form['street'])
def testLargePostValue(self):
extra = {'REQUEST_METHOD':'POST',
'PATH_INFO': _u("/"),
'CONTENT_TYPE': 'multipart/form-data;\
boundary=---------------------------1'}
request = self._createRequest(extra, body=LARGE_POSTED_VALUE)
request.processInputs()
def testFormFieldName(self):
extra = {
'QUERY_STRING': 'c+%2B%2F%3D%26c%3Aint=6',
'PATH_INFO': '/folder/item3/'
}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("c +/=&c"): 6})
def testFormFloatTypes(self):
extra = {'QUERY_STRING': 'a:float=5&b:float=-5.01&c:float=0'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {
_u("a"): 5.0,
_u("b"): -5.01,
_u("c"): 0.0
})
extra = {'QUERY_STRING': 'a:float='}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
extra = {'QUERY_STRING': 'a:float=abc'}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
def _html(self, title, content):
t = escape(title)
return (
_u("<html><head><title>%s</title></head>\n"
"<body><h2>%s</h2>\n"
"%s\n"
"</body></html>\n") %
(t, t, content)
)
def testFormIntTypes(self):
extra = {'QUERY_STRING': 'a:int=5&b:int=-5&c:int=0&d:int=-0'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {
_u("a"): 5,
_u("b"): -5,
_u("c"): 0,
_u("d"): 0
})
extra = {'QUERY_STRING': 'a:int='}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
extra = {'QUERY_STRING': 'a:int=abc'}
request = self._createRequest(extra)
self.assertRaises(ValueError, publish, request)
def _parseCookies(self, text, result=None):
"""Parse 'text' and return found cookies as 'result' dictionary."""
if result is None:
result = {}
# ignore cookies on a CookieError
try:
c = cookies.SimpleCookie(text)
except cookies.CookieError as e:
eventlog.warning(e)
return result
for k, v in c.items():
# recode cookie value to ENCODING (UTF-8)
rk = _u(k if type(k) == bytes else k.encode('latin1'), ENCODING)
rv = _u(
v.value if type(v.value) == bytes else
v.value.encode('latin1'), ENCODING)
result[rk] = rv
return result
def _parseCookies(self, text, result=None):
"""Parse 'text' and return found cookies as 'result' dictionary."""
if result is None:
result = {}
# ignore cookies on a CookieError
try:
c = cookies.SimpleCookie(text)
except cookies.CookieError as e:
eventlog.warning(e)
return result
for k,v in c.items():
# recode cookie value to ENCODING (UTF-8)
rk = _u(k if type(k) == bytes
else k.encode('latin1'), ENCODING)
rv = _u(v.value if type(v.value) == bytes
else v.value.encode('latin1'), ENCODING)
result[rk] = rv
return result
def testLargePostValue(self):
extra = {
'REQUEST_METHOD':
'POST',
'PATH_INFO':
_u("/"),
'CONTENT_TYPE':
'multipart/form-data;\
boundary=---------------------------1'
}
request = self._createRequest(extra, body=LARGE_POSTED_VALUE)
request.processInputs()
def testFormTokensTypes(self):
extra = {'QUERY_STRING': 'a:tokens=a%20b%20c%20d&b:tokens='}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {
_u("a"): [_u("a"), _u("b"), _u("c"),
_u("d")],
_u("b"): []
})
def testFormLinesTypes(self):
extra = {'QUERY_STRING': 'a:lines=a%0ab%0ac%0ad&b:lines='}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {
_u("a"): [_u("a"), _u("b"), _u("c"),
_u("d")],
_u("b"): []
})
def testNoneFieldNamePost(self):
"""Produce a Fieldstorage with a name wich is None, this
should be catched"""
extra = {'REQUEST_METHOD':'POST',
'PATH_INFO': _u("/"),
'CONTENT_TYPE': 'multipart/form-data;\
boundary=---------------------------1'}
body = b"""-----------------------------1
Content-Disposition: form-data; name="field.contentType"
...
application/octet-stream
-----------------------------1--
"""
request = self._createRequest(extra,body=body)
request.processInputs()
def testFileUploadPost(self):
"""Produce a Fieldstorage with a file handle that exposes
its filename."""
extra = {'REQUEST_METHOD':'POST',
'PATH_INFO': _u("/"),
'CONTENT_TYPE': 'multipart/form-data;\
boundary=---------------------------1'}
request = self._createRequest(extra, body=LARGE_FILE_BODY)
request.processInputs()
self.assertTrue(request.form['upload'].name)
request = self._createRequest(extra, body=IE_FILE_BODY)
request.processInputs()
self.assertEqual(request.form['upload'].filename, 'notepad.exe')
# Test that we can actually read the file data
self.assertEqual(request.form['upload'].read(), b'Some data')
def _decode(self, text):
"""Try to decode the text using one of the available charsets."""
# According to PEP-3333, in python-3, QUERY_STRING is a string,
# representing 'latin-1' encoded byte array. So, if we are in python-3
# context, encode text as 'latin-1' first, to try to decode
# resulting byte array using user-supplied charset.
if not isinstance(text, bytes):
text = text.encode('latin-1')
if self.charsets is None:
envadapter = IUserPreferredCharsets(self)
self.charsets = envadapter.getPreferredCharsets() or ['utf-8']
self.charsets = [c for c in self.charsets if c != '*']
for charset in self.charsets:
try:
text = _u(text, charset)
break
except UnicodeError:
pass
return text
def handleException(self, exc_info):
"""
Calls self.setBody() with an error response.
"""
t, v = exc_info[:2]
if isinstance(t, CLASS_TYPES):
if issubclass(t, Redirect):
self.redirect(v.getLocation())
return
title = tname = t.__name__
else:
title = tname = _u(t)
# Throwing non-protocol-specific exceptions is a good way
# for apps to control the status code.
self.setStatus(tname)
body = self._html(title, "A server error occurred.")
self.setHeader("Content-Type", "text/html")
self.setResult(body)
def handleException(self, exc_info):
"""
Calls self.setBody() with an error response.
"""
t, v = exc_info[:2]
if isinstance(t, CLASS_TYPES):
if issubclass(t, Redirect):
self.redirect(v.getLocation(), trusted=v.getTrusted())
return
title = tname = t.__name__
else:
title = tname = _u(t)
# Throwing non-protocol-specific exceptions is a good way
# for apps to control the status code.
self.setStatus(tname)
body = self._html(title, "A server error occurred." )
self.setHeader("Content-Type", "text/html")
self.setResult(body)
def testNoneFieldNamePost(self):
"""Produce a Fieldstorage with a name wich is None, this
should be catched"""
extra = {
'REQUEST_METHOD':
'POST',
'PATH_INFO':
_u("/"),
'CONTENT_TYPE':
'multipart/form-data;\
boundary=---------------------------1'
}
body = b"""-----------------------------1
Content-Disposition: form-data; name="field.contentType"
...
application/octet-stream
-----------------------------1--
"""
request = self._createRequest(extra, body=body)
request.processInputs()
def __init__(self, aFieldStorage):
file = aFieldStorage.file
if hasattr(file, '__methods__'):
methods = file.__methods__
else:
methods = ['close', 'fileno', 'flush', 'isatty',
'read', 'readline', 'readlines', 'seek',
'tell', 'truncate', 'write', 'writelines',
'name']
d = self.__dict__
for m in methods:
if hasattr(file,m):
d[m] = getattr(file,m)
self.headers = aFieldStorage.headers
filename = aFieldStorage.filename
if isinstance(aFieldStorage.filename, bytes):
filename = _u(aFieldStorage.filename, 'UTF-8')
# fix for IE full paths
filename = filename[filename.rfind('\\')+1:].strip()
self.filename = filename
def testFileUploadPost(self):
"""Produce a Fieldstorage with a file handle that exposes
its filename."""
extra = {
'REQUEST_METHOD':
'POST',
'PATH_INFO':
_u("/"),
'CONTENT_TYPE':
'multipart/form-data;\
boundary=---------------------------1'
}
request = self._createRequest(extra, body=LARGE_FILE_BODY)
request.processInputs()
self.assertTrue(request.form['upload'].name)
request = self._createRequest(extra, body=IE_FILE_BODY)
request.processInputs()
self.assertEqual(request.form['upload'].filename, 'notepad.exe')
# Test that we can actually read the file data
self.assertEqual(request.form['upload'].read(), b'Some data')
def testFormStringTypes(self):
extra = {'QUERY_STRING':'a:string=test&b:string='}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): _u("test"), _u("b"): _u("")})
def testFormLinesTypes(self):
extra = {'QUERY_STRING':'a:lines=a%0ab%0ac%0ad&b:lines='}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): [_u("a"), _u("b"), _u("c"), _u("d")],
_u("b"): []})
def internalError(self):
'See IPublisherResponse'
self.setStatus(500, _u("The engines can't take any more, Jim!"))
def testForm(self):
request = self._createRequest()
publish(request)
self.assertEqual(request.form,
{_u("a"):_u("5"), _u("b"):6})
def testFormListTypes2(self):
extra = {'QUERY_STRING':'a=5&a=6&b=1'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"):[_u("5"),_u("6")], _u("b"):_u("1")})
def testFormMultipleRecordsTypes(self):
extra = {'QUERY_STRING':'a.x:records:int=5&a.y:records:int=51'
'&a.x:records:int=6&a.y:records:int=61&b=1'}
request = self._createRequest(extra)
publish(request)
keys = sorted(request.form.keys())
self.assertEqual(keys, [_u("a"),_u("b")])
self.assertEqual(request.form[_u("b")], _u("1"))
self.assertEqual(len(request.form[_u("a")]), 2)
self.assertEqual(request.form[_u("a")][0][_u("x")], 5)
self.assertEqual(request.form[_u("a")][0].x, 5)
self.assertEqual(request.form[_u("a")][0][_u("y")], 51)
self.assertEqual(request.form[_u("a")][0].y, 51)
self.assertEqual(request.form[_u("a")][1][_u("x")], 6)
self.assertEqual(request.form[_u("a")][1].x, 6)
self.assertEqual(request.form[_u("a")][1][_u("y")], 61)
self.assertEqual(request.form[_u("a")][1].y, 61)
self.assertEqual(str(request.form[_u("a")]),
"[{x: 5, y: 51}, {x: 6, y: 61}]")
self.assertEqual(repr(request.form[_u("a")]),
"[{x: 5, y: 51}, {x: 6, y: 61}]")
def __call__(self, a, b):
return _u("%s, %s") % (repr(a).lstrip('u'),
repr(b).lstrip('u'))
def testFormFieldValue(self):
extra = {'QUERY_STRING':'a=b+%2B%2F%3D%26b%3Aint',
'PATH_INFO': '/folder/item3/'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"):_u("b +/=&b:int")})
def testFormMultipleRecordsTypes(self):
extra = {
'QUERY_STRING':
'a.x:records:int=5&a.y:records:int=51'
'&a.x:records:int=6&a.y:records:int=61&b=1'
}
request = self._createRequest(extra)
publish(request)
keys = sorted(request.form.keys())
self.assertEqual(keys, [_u("a"), _u("b")])
self.assertEqual(request.form[_u("b")], _u("1"))
self.assertEqual(len(request.form[_u("a")]), 2)
self.assertEqual(request.form[_u("a")][0][_u("x")], 5)
self.assertEqual(request.form[_u("a")][0].x, 5)
self.assertEqual(request.form[_u("a")][0][_u("y")], 51)
self.assertEqual(request.form[_u("a")][0].y, 51)
self.assertEqual(request.form[_u("a")][1][_u("x")], 6)
self.assertEqual(request.form[_u("a")][1].x, 6)
self.assertEqual(request.form[_u("a")][1][_u("y")], 61)
self.assertEqual(request.form[_u("a")][1].y, 61)
self.assertEqual(str(request.form[_u("a")]),
"[{x: 5, y: 51}, {x: 6, y: 61}]")
self.assertEqual(repr(request.form[_u("a")]),
"[{x: 5, y: 51}, {x: 6, y: 61}]")
def testFormListRecordTypes(self):
extra = {'QUERY_STRING': 'a.x:list:record=5&a.x:list:record=6&b=1'}
request = self._createRequest(extra)
publish(request)
keys = sorted(request.form.keys())
self.assertEqual(keys, [_u("a"), _u("b")])
self.assertEqual(request.form[_u("b")], _u("1"))
self.assertEqual(list(request.form[_u("a")].keys()), [_u("x")])
self.assertEqual(request.form[_u("a")][_u("x")], [_u("5"), _u("6")])
self.assertEqual(request.form[_u("a")].x, [_u("5"), _u("6")])
self.assertEqual(
str(request.form[_u("a")]).replace("u'", "'"), "{x: ['5', '6']}")
self.assertEqual(
repr(request.form[_u("a")]).replace("u'", "'"), "{x: ['5', '6']}")
def testFormRecordsTypes(self):
extra = {'QUERY_STRING': 'a.x:records=5&a.x:records=6&b=1'}
request = self._createRequest(extra)
publish(request)
keys = sorted(request.form.keys())
self.assertEqual(keys, [_u("a"), _u("b")])
self.assertEqual(request.form[_u("b")], _u("1"))
self.assertEqual(len(request.form[_u("a")]), 2)
self.assertEqual(request.form[_u("a")][0][_u("x")], _u("5"))
self.assertEqual(request.form[_u("a")][0].x, _u("5"))
self.assertEqual(request.form[_u("a")][1][_u("x")], _u("6"))
self.assertEqual(request.form[_u("a")][1].x, _u("6"))
self.assertEqual(
str(request.form[_u("a")]).replace("u'", "'"),
"[{x: '5'}, {x: '6'}]")
self.assertEqual(
repr(request.form[_u("a")]).replace("u'", "'"),
"[{x: '5'}, {x: '6'}]")
def __call__(self, *args):
return _u("...")
def index(self, a, b):
"""Required docstring for the publisher."""
return _u("%s, %s") % (repr(a).lstrip('u'),
repr(b).lstrip('u'))
def testFormDefaults2(self):
extra = {'QUERY_STRING': 'a:default=10&b=1'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): _u("10"), _u("b"): _u("1")})
def testFormFieldName(self):
extra = {'QUERY_STRING':'c+%2B%2F%3D%26c%3Aint=6',
'PATH_INFO': '/folder/item3/'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("c +/=&c"): 6})
def testFormTokensTypes(self):
extra = {'QUERY_STRING':'a:tokens=a%20b%20c%20d&b:tokens='}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): [_u("a"), _u("b"), _u("c"), _u("d")],
_u("b"): []})
def testFormDefaults2(self):
extra = {'QUERY_STRING':'a:default=10&b=1'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"):_u("10"), _u("b"):_u("1")})
def testFormListRecordTypes(self):
extra = {'QUERY_STRING':'a.x:list:record=5&a.x:list:record=6&b=1'}
request = self._createRequest(extra)
publish(request)
keys = sorted(request.form.keys())
self.assertEqual(keys, [_u("a"),_u("b")])
self.assertEqual(request.form[_u("b")], _u("1"))
self.assertEqual(list(request.form[_u("a")].keys()), [_u("x")])
self.assertEqual(request.form[_u("a")][_u("x")], [_u("5"),_u("6")])
self.assertEqual(request.form[_u("a")].x, [_u("5"),_u("6")])
self.assertEqual(str(request.form[_u("a")]).replace("u'", "'"),
"{x: ['5', '6']}")
self.assertEqual(repr(request.form[_u("a")]).replace("u'", "'"),
"{x: ['5', '6']}")
def testFormBooleanTypes(self):
extra = {'QUERY_STRING':'a:boolean=&b:boolean=1&c:boolean=%20'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): False, _u("b"): True, _u("c"): True})
def testFormRecordsTypes(self):
extra = {'QUERY_STRING':'a.x:records=5&a.x:records=6&b=1'}
request = self._createRequest(extra)
publish(request)
keys = sorted(request.form.keys())
self.assertEqual(keys, [_u("a"),_u("b")])
self.assertEqual(request.form[_u("b")], _u("1"))
self.assertEqual(len(request.form[_u("a")]), 2)
self.assertEqual(request.form[_u("a")][0][_u("x")], _u("5"))
self.assertEqual(request.form[_u("a")][0].x, _u("5"))
self.assertEqual(request.form[_u("a")][1][_u("x")], _u("6"))
self.assertEqual(request.form[_u("a")][1].x, _u("6"))
self.assertEqual(str(request.form[_u("a")]).replace("u'", "'"),
"[{x: '5'}, {x: '6'}]")
self.assertEqual(repr(request.form[_u("a")]).replace("u'", "'"),
"[{x: '5'}, {x: '6'}]")
def testFormStringTypes(self):
extra = {'QUERY_STRING': 'a:string=test&b:string='}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): _u("test"), _u("b"): _u("")})
def testFormTupleTypes(self):
extra = {'QUERY_STRING':'a:tuple=5&a:tuple=6&b=1'}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"):(_u("5"),_u("6")), _u("b"):_u("1")})
def testFormTextTypes(self):
extra = {'QUERY_STRING':'a:text=a%0a%0db%0d%0ac%0dd%0ae&b:text='}
request = self._createRequest(extra)
publish(request)
self.assertEqual(request.form, {_u("a"): _u("a\nb\nc\nd\ne"), _u("b"): _u("")})
def index(self, a, b):
"""Required docstring for the publisher."""
return _u("%s, %s") % (repr(a).lstrip('u'), repr(b).lstrip('u'))
def testForm(self):
request = self._createRequest()
publish(request)
self.assertEqual(request.form, {_u("a"): _u("5"), _u("b"): 6})
