diff options
author | Marc Abramowitz <marc@marc-abramowitz.com> | 2015-04-30 17:39:24 -0700 |
---|---|---|
committer | Marc Abramowitz <marc@marc-abramowitz.com> | 2015-04-30 17:39:24 -0700 |
commit | fa100c92c06d3a8a61a0dda1a2e06018437b09c6 (patch) | |
tree | a1cc50f93fbf257685c3849e03496c5e33949281 /tests/test_exceptions/test_formatter.py | |
download | paste-git-test_wsgirequest_charset_use_UTF-8_instead_of_iso-8859-1.tar.gz |
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.
Diffstat (limited to 'tests/test_exceptions/test_formatter.py')
-rw-r--r-- | tests/test_exceptions/test_formatter.py | 183 |
1 files changed, 183 insertions, 0 deletions
diff --git a/tests/test_exceptions/test_formatter.py b/tests/test_exceptions/test_formatter.py new file mode 100644 index 0000000..9c53a9a --- /dev/null +++ b/tests/test_exceptions/test_formatter.py @@ -0,0 +1,183 @@ +from paste.exceptions import formatter +from paste.exceptions import collector +import sys +import os +import difflib + +class Mock(object): + def __init__(self, **kw): + for name, value in kw.items(): + setattr(self, name, value) + +class Supplement(Mock): + + object = 'test_object' + source_url = 'http://whatever.com' + info = 'This is some supplemental information' + args = () + def getInfo(self): + return self.info + + def __call__(self, *args): + self.args = args + return self + +class BadSupplement(Supplement): + + def getInfo(self): + raise ValueError("This supplemental info is buggy") + +def call_error(sup): + 1 + 2 + __traceback_supplement__ = (sup, ()) + assert 0, "I am an error" + +def raise_error(sup='default'): + if sup == 'default': + sup = Supplement() + for i in range(10): + __traceback_info__ = i + if i == 5: + call_error(sup=sup) + +def hide(t, inner, *args, **kw): + __traceback_hide__ = t + return inner(*args, **kw) + +def pass_through(info, inner, *args, **kw): + """ + To add another frame to the call; detectable because + __tracback_info__ is set to `info` + """ + __traceback_info__ = info + return inner(*args, **kw) + +def format(type='html', **ops): + data = collector.collect_exception(*sys.exc_info()) + report = getattr(formatter, 'format_' + type)(data, **ops) + return report + +formats = ('text', 'html') + +def test_excersize(): + for f in formats: + try: + raise_error() + except: + format(f) + +def test_content(): + for f in formats: + try: + raise_error() + except: + result = format(f) + print(result) + assert 'test_object' in result + assert 'http://whatever.com' in result + assert 'This is some supplemental information' in result + assert 'raise_error' in result + assert 'call_error' in result + assert '5' in result + assert 'test_content' in result + else: + assert 0 + +def test_trim(): + current = os.path.abspath(os.getcwd()) + for f in formats: + try: + raise_error() + except: + result = format(f, trim_source_paths=[(current, '.')]) + assert current not in result + assert ('%stest_formatter.py' % os.sep) in result, ValueError(repr(result)) + else: + assert 0 + +def test_hide(): + for f in formats: + try: + hide(True, raise_error) + except: + result = format(f) + print(result) + assert 'in hide_inner' not in result + assert 'inner(*args, **kw)' not in result + else: + assert 0 + +def print_diff(s1, s2): + differ = difflib.Differ() + result = list(differ.compare(s1.splitlines(), s2.splitlines())) + print('\n'.join(result)) + +def test_hide_supppressed(): + """ + When an error occurs and __traceback_stop__ is true for the + erroneous frame, then that setting should be ignored. + """ + for f in ['html']: #formats: + results = [] + for hide_value in (False, 'after'): + try: + pass_through( + 'a', + hide, + hide_value, + pass_through, + 'b', + raise_error) + except: + results.append(format(f)) + else: + assert 0 + if results[0] != results[1]: + print_diff(results[0], results[1]) + assert 0 + +def test_hide_after(): + for f in formats: + try: + pass_through( + 'AABB', + hide, 'after', + pass_through, 'CCDD', + # A little whitespace to keep this line out of the + # content part of the report + + + hide, 'reset', + raise_error) + except: + result = format(f) + assert 'AABB' in result + assert 'CCDD' not in result + assert 'raise_error' in result + else: + assert 0 + +def test_hide_before(): + for f in formats: + try: + pass_through( + 'AABB', + hide, 'before', + raise_error) + except: + result = format(f) + print(result) + assert 'AABB' not in result + assert 'raise_error' in result + else: + assert 0 + +def test_make_wrappable(): + assert '<wbr>' in formatter.make_wrappable('x'*1000) + # I'm just going to test that this doesn't excede the stack limit: + formatter.make_wrappable(';'*2000) + assert (formatter.make_wrappable('this that the other') + == 'this that the other') + assert (formatter.make_wrappable('this that ' + ('x'*50) + ';' + ('y'*50) + ' and the other') + == 'this that '+('x'*50) + ';<wbr>' + ('y'*50) + ' and the other') + |