test_wsgirequest_charset: Use UTF-8 instead of iso-8859-1test_wsgirequest_charset_use_UTF-8_instead_of_iso-8859-1

because it seems that the defacto standard for encoding URIs is to use UTF-8.

I've been reading about url encoding and it seems like perhaps using an
encoding other than UTF-8 is very non-standard and not well-supported (this
test is trying to use `iso-8859-1`).

From http://en.wikipedia.org/wiki/Percent-encoding

> For a non-ASCII character, it is typically converted to its byte sequence in
> UTF-8, and then each byte value is represented as above.

> The generic URI syntax mandates that new URI schemes that provide for the
> representation of character data in a URI must, in effect, represent
> characters from the unreserved set without translation, and should convert
> all other characters to bytes according to UTF-8, and then percent-encode
> those values. This requirement was introduced in January 2005 with the
> publication of RFC 3986

From http://tools.ietf.org/html/rfc3986:

> Non-ASCII characters must first be encoded according to UTF-8 [STD63], and
> then each octet of the corresponding UTF-8 sequence must be percent-encoded
> to be represented as URI characters.  URI producing applications must not use
> percent-encoding in host unless it is used to represent a UTF-8 character
> sequence.

From http://tools.ietf.org/html/rfc3987:

> Conversions from URIs to IRIs MUST NOT use any character encoding other than
> UTF-8 in steps 3 and 4, even if it might be possible to guess from the
> context that another character encoding than UTF-8 was used in the URI.  For
> example, the URI "http://www.example.org/r%E9sum%E9.html" might with some
> guessing be interpreted to contain two e-acute characters encoded as
> iso-8859-1. It must not be converted to an IRI containing these e-acute
> characters.  Otherwise, in the future the IRI will be mapped to
> "http://www.example.org/r%C3%A9sum%C3%A9.html", which is a different URI from
> "http://www.example.org/r%E9sum%E9.html".

See issue #7, which I think this at least partially fixes.

1 files changed, 97 insertions, 0 deletions

diff --git a/tests/test_exceptions/test_httpexceptions.py b/tests/test_exceptions/test_httpexceptions.py
new file mode 100644
index 0000000..24e00dd
--- /dev/null
+++ b/tests/test_exceptions/test_httpexceptions.py
@@ -0,0 +1,97 @@
+# (c) 2005 Ian Bicking, Clark C. Evans and contributors
+# This module is part of the Python Paste Project and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+"""
+WSGI Exception Middleware
+
+Regression Test Suite
+"""
+from nose.tools import assert_raises
+from paste.httpexceptions import *
+from paste.response import header_value
+import six
+
+
+def test_HTTPMove():
+    """ make sure that location is a mandatory attribute of Redirects """
+    assert_raises(AssertionError, HTTPFound)
+    assert_raises(AssertionError, HTTPTemporaryRedirect,
+                   headers=[('l0cation','/bing')])
+    assert isinstance(HTTPMovedPermanently("This is a message",
+                          headers=[('Location','/bing')])
+                     ,HTTPRedirection)
+    assert isinstance(HTTPUseProxy(headers=[('LOCATION','/bing')])
+                     ,HTTPRedirection)
+    assert isinstance(HTTPFound('/foobar'),HTTPRedirection)
+
+def test_badapp():
+    """ verify that the middleware handles previously-started responses """
+    def badapp(environ, start_response):
+        start_response("200 OK",[])
+        raise HTTPBadRequest("Do not do this at home.")
+    newapp = HTTPExceptionHandler(badapp)
+    assert b'Bad Request' in b''.join(newapp({'HTTP_ACCEPT': 'text/html'},
+                                             (lambda a, b, c=None: None)))
+
+def test_unicode():
+    """ verify unicode output """
+    tstr = u"\0xCAFE"
+    def badapp(environ, start_response):
+        start_response("200 OK",[])
+        raise HTTPBadRequest(tstr)
+    newapp = HTTPExceptionHandler(badapp)
+    assert tstr.encode("utf-8") in b''.join(newapp({'HTTP_ACCEPT':
+                                         'text/html'},
+                                         (lambda a, b, c=None: None)))
+    assert tstr.encode("utf-8") in b''.join(newapp({'HTTP_ACCEPT':
+                                         'text/plain'},
+                                         (lambda a, b, c=None: None)))
+
+def test_template():
+    """ verify that html() and plain() output methods work """
+    e = HTTPInternalServerError()
+    e.template = 'A %(ping)s and <b>%(pong)s</b> message.'
+    assert str(e).startswith("500 Internal Server Error")
+    assert e.plain({'ping': 'fun', 'pong': 'happy'}) == (
+        '500 Internal Server Error\r\n'
+        'A fun and happy message.\r\n')
+    assert '<p>A fun and <b>happy</b> message.</p>' in \
+           e.html({'ping': 'fun', 'pong': 'happy'})
+
+def test_redapp():
+    """ check that redirect returns the correct, expected results """
+    saved = []
+    def saveit(status, headers, exc_info = None):
+        saved.append((status,headers))
+    def redapp(environ, start_response):
+        raise HTTPFound("/bing/foo")
+    app = HTTPExceptionHandler(redapp)
+    result = list(app({'HTTP_ACCEPT': 'text/html'},saveit))
+    assert b'<a href="/bing/foo">' in result[0]
+    assert "302 Found" == saved[0][0]
+    if six.PY3:
+        assert "text/html; charset=utf8" == header_value(saved[0][1], 'content-type')
+    else:
+        assert "text/html" == header_value(saved[0][1], 'content-type')
+    assert "/bing/foo" == header_value(saved[0][1],'location')
+    result = list(app({'HTTP_ACCEPT': 'text/plain'},saveit))
+    assert "text/plain; charset=utf8" == header_value(saved[1][1],'content-type')
+    assert "/bing/foo" == header_value(saved[1][1],'location')
+
+def test_misc():
+    assert get_exception(301) == HTTPMovedPermanently
+    redirect = HTTPFound("/some/path")
+    assert isinstance(redirect,HTTPException)
+    assert isinstance(redirect,HTTPRedirection)
+    assert not isinstance(redirect,HTTPError)
+    notfound = HTTPNotFound()
+    assert isinstance(notfound,HTTPException)
+    assert isinstance(notfound,HTTPError)
+    assert isinstance(notfound,HTTPClientError)
+    assert not isinstance(notfound,HTTPServerError)
+    notimpl = HTTPNotImplemented()
+    assert isinstance(notimpl,HTTPException)
+    assert isinstance(notimpl,HTTPError)
+    assert isinstance(notimpl,HTTPServerError)
+    assert not isinstance(notimpl,HTTPClientError)
+