Commits

Panayiotis Lipiridis committed 01244e8

Removed tests and compiled files from repository

Comments (0)

Files changed (79)

 *.pyo
 main/index.yaml
 main/node_modules
-
-#Include these lines if you don't want the compiled *.css, *.js, *.zip in the repo
-#main/static/dst
-#main/static/min
-#main/lib.zip
+main/static/dst
+main/static/min
+main/lib.zip

main/lib.zip

Binary file removed.

main/lib/flask/testsuite/__init__.py

-# -*- coding: utf-8 -*-
-"""
-    flask.testsuite
-    ~~~~~~~~~~~~~~~
-
-    Tests Flask itself.  The majority of Flask is already tested
-    as part of Werkzeug.
-
-    :copyright: (c) 2011 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from __future__ import with_statement
-
-import os
-import sys
-import flask
-import warnings
-import unittest
-from StringIO import StringIO
-from functools import update_wrapper
-from contextlib import contextmanager
-from werkzeug.utils import import_string, find_modules
-
-
-def add_to_path(path):
-    """Adds an entry to sys.path if it's not already there.  This does
-    not append it but moves it to the front so that we can be sure it
-    is loaded.
-    """
-    if not os.path.isdir(path):
-        raise RuntimeError('Tried to add nonexisting path')
-
-    def _samefile(x, y):
-        try:
-            return os.path.samefile(x, y)
-        except (IOError, OSError):
-            return False
-    sys.path[:] = [x for x in sys.path if not _samefile(path, x)]
-    sys.path.insert(0, path)
-
-
-def iter_suites():
-    """Yields all testsuites."""
-    for module in find_modules(__name__):
-        mod = import_string(module)
-        if hasattr(mod, 'suite'):
-            yield mod.suite()
-
-
-def find_all_tests(suite):
-    """Yields all the tests and their names from a given suite."""
-    suites = [suite]
-    while suites:
-        s = suites.pop()
-        try:
-            suites.extend(s)
-        except TypeError:
-            yield s, '%s.%s.%s' % (
-                s.__class__.__module__,
-                s.__class__.__name__,
-                s._testMethodName
-            )
-
-
-@contextmanager
-def catch_warnings():
-    """Catch warnings in a with block in a list"""
-    # make sure deprecation warnings are active in tests
-    warnings.simplefilter('default', category=DeprecationWarning)
-
-    filters = warnings.filters
-    warnings.filters = filters[:]
-    old_showwarning = warnings.showwarning
-    log = []
-    def showwarning(message, category, filename, lineno, file=None, line=None):
-        log.append(locals())
-    try:
-        warnings.showwarning = showwarning
-        yield log
-    finally:
-        warnings.filters = filters
-        warnings.showwarning = old_showwarning
-
-
-@contextmanager
-def catch_stderr():
-    """Catch stderr in a StringIO"""
-    old_stderr = sys.stderr
-    sys.stderr = rv = StringIO()
-    try:
-        yield rv
-    finally:
-        sys.stderr = old_stderr
-
-
-def emits_module_deprecation_warning(f):
-    def new_f(self, *args, **kwargs):
-        with catch_warnings() as log:
-            f(self, *args, **kwargs)
-            self.assert_(log, 'expected deprecation warning')
-            for entry in log:
-                self.assert_('Modules are deprecated' in str(entry['message']))
-    return update_wrapper(new_f, f)
-
-
-class FlaskTestCase(unittest.TestCase):
-    """Baseclass for all the tests that Flask uses.  Use these methods
-    for testing instead of the camelcased ones in the baseclass for
-    consistency.
-    """
-
-    def ensure_clean_request_context(self):
-        # make sure we're not leaking a request context since we are
-        # testing flask internally in debug mode in a few cases
-        self.assert_equal(flask._request_ctx_stack.top, None)
-
-    def setup(self):
-        pass
-
-    def teardown(self):
-        pass
-
-    def setUp(self):
-        self.setup()
-
-    def tearDown(self):
-        unittest.TestCase.tearDown(self)
-        self.ensure_clean_request_context()
-        self.teardown()
-
-    def assert_equal(self, x, y):
-        return self.assertEqual(x, y)
-
-    def assert_raises(self, exc_type, callable=None, *args, **kwargs):
-        catcher = _ExceptionCatcher(self, exc_type)
-        if callable is None:
-            return catcher
-        with catcher:
-            callable(*args, **kwargs)
-
-
-class _ExceptionCatcher(object):
-
-    def __init__(self, test_case, exc_type):
-        self.test_case = test_case
-        self.exc_type = exc_type
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        exception_name = self.exc_type.__name__
-        if exc_type is None:
-            self.test_case.fail('Expected exception of type %r' %
-                                exception_name)
-        elif not issubclass(exc_type, self.exc_type):
-            raise exc_type, exc_value, tb
-        return True
-
-
-class BetterLoader(unittest.TestLoader):
-    """A nicer loader that solves two problems.  First of all we are setting
-    up tests from different sources and we're doing this programmatically
-    which breaks the default loading logic so this is required anyways.
-    Secondly this loader has a nicer interpolation for test names than the
-    default one so you can just do ``run-tests.py ViewTestCase`` and it
-    will work.
-    """
-
-    def getRootSuite(self):
-        return suite()
-
-    def loadTestsFromName(self, name, module=None):
-        root = self.getRootSuite()
-        if name == 'suite':
-            return root
-
-        all_tests = []
-        for testcase, testname in find_all_tests(root):
-            if testname == name or \
-               testname.endswith('.' + name) or \
-               ('.' + name + '.') in testname or \
-               testname.startswith(name + '.'):
-                all_tests.append(testcase)
-
-        if not all_tests:
-            raise LookupError('could not find test case for "%s"' % name)
-
-        if len(all_tests) == 1:
-            return all_tests[0]
-        rv = unittest.TestSuite()
-        for test in all_tests:
-            rv.addTest(test)
-        return rv
-
-
-def setup_path():
-    add_to_path(os.path.abspath(os.path.join(
-        os.path.dirname(__file__), 'test_apps')))
-
-
-def suite():
-    """A testsuite that has all the Flask tests.  You can use this
-    function to integrate the Flask tests into your own testsuite
-    in case you want to test that monkeypatches to Flask do not
-    break it.
-    """
-    setup_path()
-    suite = unittest.TestSuite()
-    for other_suite in iter_suites():
-        suite.addTest(other_suite)
-    return suite
-
-
-def main():
-    """Runs the testsuite as command line application."""
-    try:
-        unittest.main(testLoader=BetterLoader(), defaultTest='suite')
-    except Exception, e:
-        print 'Error: %s' % e

main/lib/flask/testsuite/appctx.py

-# -*- coding: utf-8 -*-
-"""
-    flask.testsuite.appctx
-    ~~~~~~~~~~~~~~~~~~~~~~
-
-    Tests the application context.
-
-    :copyright: (c) 2012 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from __future__ import with_statement
-
-import flask
-import unittest
-from flask.testsuite import FlaskTestCase
-
-
-class AppContextTestCase(FlaskTestCase):
-
-    def test_basic_url_generation(self):
-        app = flask.Flask(__name__)
-        app.config['SERVER_NAME'] = 'localhost'
-        app.config['PREFERRED_URL_SCHEME'] = 'https'
-
-        @app.route('/')
-        def index():
-            pass
-
-        with app.app_context():
-            rv = flask.url_for('index')
-            self.assert_equal(rv, 'https://localhost/')
-
-    def test_url_generation_requires_server_name(self):
-        app = flask.Flask(__name__)
-        with app.app_context():
-            with self.assert_raises(RuntimeError):
-                flask.url_for('index')
-
-    def test_url_generation_without_context_fails(self):
-        with self.assert_raises(RuntimeError):
-            flask.url_for('index')
-
-    def test_request_context_means_app_context(self):
-        app = flask.Flask(__name__)
-        with app.test_request_context():
-            self.assert_equal(flask.current_app._get_current_object(), app)
-        self.assert_equal(flask._app_ctx_stack.top, None)
-
-    def test_app_context_provides_current_app(self):
-        app = flask.Flask(__name__)
-        with app.app_context():
-            self.assert_equal(flask.current_app._get_current_object(), app)
-        self.assert_equal(flask._app_ctx_stack.top, None)
-
-    def test_app_tearing_down(self):
-        cleanup_stuff = []
-        app = flask.Flask(__name__)
-        @app.teardown_appcontext
-        def cleanup(exception):
-            cleanup_stuff.append(exception)
-
-        with app.app_context():
-            pass
-
-        self.assert_equal(cleanup_stuff, [None])
-
-    def test_custom_request_globals_class(self):
-        class CustomRequestGlobals(object):
-            def __init__(self):
-                self.spam = 'eggs'
-        app = flask.Flask(__name__)
-        app.request_globals_class = CustomRequestGlobals
-        with app.test_request_context():
-            self.assert_equal(
-                flask.render_template_string('{{ g.spam }}'), 'eggs')
-
-    def test_context_refcounts(self):
-        called = []
-        app = flask.Flask(__name__)
-        @app.teardown_request
-        def teardown_req(error=None):
-            called.append('request')
-        @app.teardown_appcontext
-        def teardown_app(error=None):
-            called.append('app')
-        @app.route('/')
-        def index():
-            with flask._app_ctx_stack.top:
-                with flask._request_ctx_stack.top:
-                    pass
-            self.assert_(flask._request_ctx_stack.request.environ
-                ['werkzeug.request'] is not None)
-        c = app.test_client()
-        c.get('/')
-        self.assertEqual(called, ['request', 'app'])
-
-
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(unittest.makeSuite(AppContextTestCase))
-    return suite

main/lib/flask/testsuite/basic.py

-# -*- coding: utf-8 -*-
-"""
-    flask.testsuite.basic
-    ~~~~~~~~~~~~~~~~~~~~~
-
-    The basic functionality.
-
-    :copyright: (c) 2011 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from __future__ import with_statement
-
-import re
-import flask
-import unittest
-from datetime import datetime
-from threading import Thread
-from flask.testsuite import FlaskTestCase, emits_module_deprecation_warning
-from werkzeug.exceptions import BadRequest, NotFound
-from werkzeug.http import parse_date
-from werkzeug.routing import BuildError
-
-
-class BasicFunctionalityTestCase(FlaskTestCase):
-
-    def test_options_work(self):
-        app = flask.Flask(__name__)
-        @app.route('/', methods=['GET', 'POST'])
-        def index():
-            return 'Hello World'
-        rv = app.test_client().open('/', method='OPTIONS')
-        self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS', 'POST'])
-        self.assert_equal(rv.data, '')
-
-    def test_options_on_multiple_rules(self):
-        app = flask.Flask(__name__)
-        @app.route('/', methods=['GET', 'POST'])
-        def index():
-            return 'Hello World'
-        @app.route('/', methods=['PUT'])
-        def index_put():
-            return 'Aha!'
-        rv = app.test_client().open('/', method='OPTIONS')
-        self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'])
-
-    def test_options_handling_disabled(self):
-        app = flask.Flask(__name__)
-        def index():
-            return 'Hello World!'
-        index.provide_automatic_options = False
-        app.route('/')(index)
-        rv = app.test_client().open('/', method='OPTIONS')
-        self.assert_equal(rv.status_code, 405)
-
-        app = flask.Flask(__name__)
-        def index2():
-            return 'Hello World!'
-        index2.provide_automatic_options = True
-        app.route('/', methods=['OPTIONS'])(index2)
-        rv = app.test_client().open('/', method='OPTIONS')
-        self.assert_equal(sorted(rv.allow), ['OPTIONS'])
-
-    def test_request_dispatching(self):
-        app = flask.Flask(__name__)
-        @app.route('/')
-        def index():
-            return flask.request.method
-        @app.route('/more', methods=['GET', 'POST'])
-        def more():
-            return flask.request.method
-
-        c = app.test_client()
-        self.assert_equal(c.get('/').data, 'GET')
-        rv = c.post('/')
-        self.assert_equal(rv.status_code, 405)
-        self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS'])
-        rv = c.head('/')
-        self.assert_equal(rv.status_code, 200)
-        self.assert_(not rv.data) # head truncates
-        self.assert_equal(c.post('/more').data, 'POST')
-        self.assert_equal(c.get('/more').data, 'GET')
-        rv = c.delete('/more')
-        self.assert_equal(rv.status_code, 405)
-        self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS', 'POST'])
-
-    def test_url_mapping(self):
-        app = flask.Flask(__name__)
-        def index():
-            return flask.request.method
-        def more():
-            return flask.request.method
-
-        app.add_url_rule('/', 'index', index)
-        app.add_url_rule('/more', 'more', more, methods=['GET', 'POST'])
-
-        c = app.test_client()
-        self.assert_equal(c.get('/').data, 'GET')
-        rv = c.post('/')
-        self.assert_equal(rv.status_code, 405)
-        self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS'])
-        rv = c.head('/')
-        self.assert_equal(rv.status_code, 200)
-        self.assert_(not rv.data) # head truncates
-        self.assert_equal(c.post('/more').data, 'POST')
-        self.assert_equal(c.get('/more').data, 'GET')
-        rv = c.delete('/more')
-        self.assert_equal(rv.status_code, 405)
-        self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS', 'POST'])
-
-    def test_werkzeug_routing(self):
-        from werkzeug.routing import Submount, Rule
-        app = flask.Flask(__name__)
-        app.url_map.add(Submount('/foo', [
-            Rule('/bar', endpoint='bar'),
-            Rule('/', endpoint='index')
-        ]))
-        def bar():
-            return 'bar'
-        def index():
-            return 'index'
-        app.view_functions['bar'] = bar
-        app.view_functions['index'] = index
-
-        c = app.test_client()
-        self.assert_equal(c.get('/foo/').data, 'index')
-        self.assert_equal(c.get('/foo/bar').data, 'bar')
-
-    def test_endpoint_decorator(self):
-        from werkzeug.routing import Submount, Rule
-        app = flask.Flask(__name__)
-        app.url_map.add(Submount('/foo', [
-            Rule('/bar', endpoint='bar'),
-            Rule('/', endpoint='index')
-        ]))
-
-        @app.endpoint('bar')
-        def bar():
-            return 'bar'
-
-        @app.endpoint('index')
-        def index():
-            return 'index'
-
-        c = app.test_client()
-        self.assert_equal(c.get('/foo/').data, 'index')
-        self.assert_equal(c.get('/foo/bar').data, 'bar')
-
-    def test_session(self):
-        app = flask.Flask(__name__)
-        app.secret_key = 'testkey'
-        @app.route('/set', methods=['POST'])
-        def set():
-            flask.session['value'] = flask.request.form['value']
-            return 'value set'
-        @app.route('/get')
-        def get():
-            return flask.session['value']
-
-        c = app.test_client()
-        self.assert_equal(c.post('/set', data={'value': '42'}).data, 'value set')
-        self.assert_equal(c.get('/get').data, '42')
-
-    def test_session_using_server_name(self):
-        app = flask.Flask(__name__)
-        app.config.update(
-            SECRET_KEY='foo',
-            SERVER_NAME='example.com'
-        )
-        @app.route('/')
-        def index():
-            flask.session['testing'] = 42
-            return 'Hello World'
-        rv = app.test_client().get('/', 'http://example.com/')
-        self.assert_('domain=.example.com' in rv.headers['set-cookie'].lower())
-        self.assert_('httponly' in rv.headers['set-cookie'].lower())
-
-    def test_session_using_server_name_and_port(self):
-        app = flask.Flask(__name__)
-        app.config.update(
-            SECRET_KEY='foo',
-            SERVER_NAME='example.com:8080'
-        )
-        @app.route('/')
-        def index():
-            flask.session['testing'] = 42
-            return 'Hello World'
-        rv = app.test_client().get('/', 'http://example.com:8080/')
-        self.assert_('domain=.example.com' in rv.headers['set-cookie'].lower())
-        self.assert_('httponly' in rv.headers['set-cookie'].lower())
-
-    def test_session_using_application_root(self):
-        class PrefixPathMiddleware(object):
-            def __init__(self, app, prefix):
-                self.app = app
-                self.prefix = prefix
-            def __call__(self, environ, start_response):
-                environ['SCRIPT_NAME'] = self.prefix
-                return self.app(environ, start_response)
-
-        app = flask.Flask(__name__)
-        app.wsgi_app = PrefixPathMiddleware(app.wsgi_app, '/bar')
-        app.config.update(
-            SECRET_KEY='foo',
-            APPLICATION_ROOT='/bar'
-        )
-        @app.route('/')
-        def index():
-            flask.session['testing'] = 42
-            return 'Hello World'
-        rv = app.test_client().get('/', 'http://example.com:8080/')
-        self.assert_('path=/bar' in rv.headers['set-cookie'].lower())
-
-    def test_session_using_session_settings(self):
-        app = flask.Flask(__name__)
-        app.config.update(
-            SECRET_KEY='foo',
-            SERVER_NAME='www.example.com:8080',
-            APPLICATION_ROOT='/test',
-            SESSION_COOKIE_DOMAIN='.example.com',
-            SESSION_COOKIE_HTTPONLY=False,
-            SESSION_COOKIE_SECURE=True,
-            SESSION_COOKIE_PATH='/'
-        )
-        @app.route('/')
-        def index():
-            flask.session['testing'] = 42
-            return 'Hello World'
-        rv = app.test_client().get('/', 'http://www.example.com:8080/test/')
-        cookie = rv.headers['set-cookie'].lower()
-        self.assert_('domain=.example.com' in cookie)
-        self.assert_('path=/;' in cookie)
-        self.assert_('secure' in cookie)
-        self.assert_('httponly' not in cookie)
-
-    def test_missing_session(self):
-        app = flask.Flask(__name__)
-        def expect_exception(f, *args, **kwargs):
-            try:
-                f(*args, **kwargs)
-            except RuntimeError, e:
-                self.assert_(e.args and 'session is unavailable' in e.args[0])
-            else:
-                self.assert_(False, 'expected exception')
-        with app.test_request_context():
-            self.assert_(flask.session.get('missing_key') is None)
-            expect_exception(flask.session.__setitem__, 'foo', 42)
-            expect_exception(flask.session.pop, 'foo')
-
-    def test_session_expiration(self):
-        permanent = True
-        app = flask.Flask(__name__)
-        app.secret_key = 'testkey'
-        @app.route('/')
-        def index():
-            flask.session['test'] = 42
-            flask.session.permanent = permanent
-            return ''
-
-        @app.route('/test')
-        def test():
-            return unicode(flask.session.permanent)
-
-        client = app.test_client()
-        rv = client.get('/')
-        self.assert_('set-cookie' in rv.headers)
-        match = re.search(r'\bexpires=([^;]+)', rv.headers['set-cookie'])
-        expires = parse_date(match.group())
-        expected = datetime.utcnow() + app.permanent_session_lifetime
-        self.assert_equal(expires.year, expected.year)
-        self.assert_equal(expires.month, expected.month)
-        self.assert_equal(expires.day, expected.day)
-
-        rv = client.get('/test')
-        self.assert_equal(rv.data, 'True')
-
-        permanent = False
-        rv = app.test_client().get('/')
-        self.assert_('set-cookie' in rv.headers)
-        match = re.search(r'\bexpires=([^;]+)', rv.headers['set-cookie'])
-        self.assert_(match is None)
-
-    def test_session_stored_last(self):
-        app = flask.Flask(__name__)
-        app.secret_key = 'development-key'
-        app.testing = True
-
-        @app.after_request
-        def modify_session(response):
-            flask.session['foo'] = 42
-            return response
-        @app.route('/')
-        def dump_session_contents():
-            return repr(flask.session.get('foo'))
-
-        c = app.test_client()
-        self.assert_equal(c.get('/').data, 'None')
-        self.assert_equal(c.get('/').data, '42')
-
-    def test_flashes(self):
-        app = flask.Flask(__name__)
-        app.secret_key = 'testkey'
-
-        with app.test_request_context():
-            self.assert_(not flask.session.modified)
-            flask.flash('Zap')
-            flask.session.modified = False
-            flask.flash('Zip')
-            self.assert_(flask.session.modified)
-            self.assert_equal(list(flask.get_flashed_messages()), ['Zap', 'Zip'])
-
-    def test_extended_flashing(self):
-        # Be sure app.testing=True below, else tests can fail silently.
-        #
-        # Specifically, if app.testing is not set to True, the AssertionErrors
-        # in the view functions will cause a 500 response to the test client
-        # instead of propagating exceptions.
-
-        app = flask.Flask(__name__)
-        app.secret_key = 'testkey'
-        app.testing = True
-
-        @app.route('/')
-        def index():
-            flask.flash(u'Hello World')
-            flask.flash(u'Hello World', 'error')
-            flask.flash(flask.Markup(u'<em>Testing</em>'), 'warning')
-            return ''
-
-        @app.route('/test/')
-        def test():
-            messages = flask.get_flashed_messages()
-            self.assert_equal(len(messages), 3)
-            self.assert_equal(messages[0], u'Hello World')
-            self.assert_equal(messages[1], u'Hello World')
-            self.assert_equal(messages[2], flask.Markup(u'<em>Testing</em>'))
-            return ''
-
-        @app.route('/test_with_categories/')
-        def test_with_categories():
-            messages = flask.get_flashed_messages(with_categories=True)
-            self.assert_equal(len(messages), 3)
-            self.assert_equal(messages[0], ('message', u'Hello World'))
-            self.assert_equal(messages[1], ('error', u'Hello World'))
-            self.assert_equal(messages[2], ('warning', flask.Markup(u'<em>Testing</em>')))
-            return ''
-
-        @app.route('/test_filter/')
-        def test_filter():
-            messages = flask.get_flashed_messages(category_filter=['message'], with_categories=True)
-            self.assert_equal(len(messages), 1)
-            self.assert_equal(messages[0], ('message', u'Hello World'))
-            return ''
-
-        @app.route('/test_filters/')
-        def test_filters():
-            messages = flask.get_flashed_messages(category_filter=['message', 'warning'], with_categories=True)
-            self.assert_equal(len(messages), 2)
-            self.assert_equal(messages[0], ('message', u'Hello World'))
-            self.assert_equal(messages[1], ('warning', flask.Markup(u'<em>Testing</em>')))
-            return ''
-
-        @app.route('/test_filters_without_returning_categories/')
-        def test_filters():
-            messages = flask.get_flashed_messages(category_filter=['message', 'warning'])
-            self.assert_equal(len(messages), 2)
-            self.assert_equal(messages[0], u'Hello World')
-            self.assert_equal(messages[1], flask.Markup(u'<em>Testing</em>'))
-            return ''
-
-        # Create new test client on each test to clean flashed messages.
-
-        c = app.test_client()
-        c.get('/')
-        c.get('/test/')
-
-        c = app.test_client()
-        c.get('/')
-        c.get('/test_with_categories/')
-
-        c = app.test_client()
-        c.get('/')
-        c.get('/test_filter/')
-
-        c = app.test_client()
-        c.get('/')
-        c.get('/test_filters/')
-
-        c = app.test_client()
-        c.get('/')
-        c.get('/test_filters_without_returning_categories/')
-
-    def test_request_processing(self):
-        app = flask.Flask(__name__)
-        evts = []
-        @app.before_request
-        def before_request():
-            evts.append('before')
-        @app.after_request
-        def after_request(response):
-            response.data += '|after'
-            evts.append('after')
-            return response
-        @app.route('/')
-        def index():
-            self.assert_('before' in evts)
-            self.assert_('after' not in evts)
-            return 'request'
-        self.assert_('after' not in evts)
-        rv = app.test_client().get('/').data
-        self.assert_('after' in evts)
-        self.assert_equal(rv, 'request|after')
-
-    def test_after_request_processing(self):
-        app = flask.Flask(__name__)
-        app.testing = True
-        @app.route('/')
-        def index():
-            @flask.after_this_request
-            def foo(response):
-                response.headers['X-Foo'] = 'a header'
-                return response
-            return 'Test'
-        c = app.test_client()
-        resp = c.get('/')
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(resp.headers['X-Foo'], 'a header')
-
-    def test_teardown_request_handler(self):
-        called = []
-        app = flask.Flask(__name__)
-        @app.teardown_request
-        def teardown_request(exc):
-            called.append(True)
-            return "Ignored"
-        @app.route('/')
-        def root():
-            return "Response"
-        rv = app.test_client().get('/')
-        self.assert_equal(rv.status_code, 200)
-        self.assert_('Response' in rv.data)
-        self.assert_equal(len(called), 1)
-
-    def test_teardown_request_handler_debug_mode(self):
-        called = []
-        app = flask.Flask(__name__)
-        app.testing = True
-        @app.teardown_request
-        def teardown_request(exc):
-            called.append(True)
-            return "Ignored"
-        @app.route('/')
-        def root():
-            return "Response"
-        rv = app.test_client().get('/')
-        self.assert_equal(rv.status_code, 200)
-        self.assert_('Response' in rv.data)
-        self.assert_equal(len(called), 1)
-
-    def test_teardown_request_handler_error(self):
-        called = []
-        app = flask.Flask(__name__)
-        @app.teardown_request
-        def teardown_request1(exc):
-            self.assert_equal(type(exc), ZeroDivisionError)
-            called.append(True)
-            # This raises a new error and blows away sys.exc_info(), so we can
-            # test that all teardown_requests get passed the same original
-            # exception.
-            try:
-                raise TypeError
-            except:
-                pass
-        @app.teardown_request
-        def teardown_request2(exc):
-            self.assert_equal(type(exc), ZeroDivisionError)
-            called.append(True)
-            # This raises a new error and blows away sys.exc_info(), so we can
-            # test that all teardown_requests get passed the same original
-            # exception.
-            try:
-                raise TypeError
-            except:
-                pass
-        @app.route('/')
-        def fails():
-            1/0
-        rv = app.test_client().get('/')
-        self.assert_equal(rv.status_code, 500)
-        self.assert_('Internal Server Error' in rv.data)
-        self.assert_equal(len(called), 2)
-
-    def test_before_after_request_order(self):
-        called = []
-        app = flask.Flask(__name__)
-        @app.before_request
-        def before1():
-            called.append(1)
-        @app.before_request
-        def before2():
-            called.append(2)
-        @app.after_request
-        def after1(response):
-            called.append(4)
-            return response
-        @app.after_request
-        def after2(response):
-            called.append(3)
-            return response
-        @app.teardown_request
-        def finish1(exc):
-            called.append(6)
-        @app.teardown_request
-        def finish2(exc):
-            called.append(5)
-        @app.route('/')
-        def index():
-            return '42'
-        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, '42')
-        self.assert_equal(called, [1, 2, 3, 4, 5, 6])
-
-    def test_error_handling(self):
-        app = flask.Flask(__name__)
-        @app.errorhandler(404)
-        def not_found(e):
-            return 'not found', 404
-        @app.errorhandler(500)
-        def internal_server_error(e):
-            return 'internal server error', 500
-        @app.route('/')
-        def index():
-            flask.abort(404)
-        @app.route('/error')
-        def error():
-            1 // 0
-        c = app.test_client()
-        rv = c.get('/')
-        self.assert_equal(rv.status_code, 404)
-        self.assert_equal(rv.data, 'not found')
-        rv = c.get('/error')
-        self.assert_equal(rv.status_code, 500)
-        self.assert_equal('internal server error', rv.data)
-
-    def test_before_request_and_routing_errors(self):
-        app = flask.Flask(__name__)
-        @app.before_request
-        def attach_something():
-            flask.g.something = 'value'
-        @app.errorhandler(404)
-        def return_something(error):
-            return flask.g.something, 404
-        rv = app.test_client().get('/')
-        self.assert_equal(rv.status_code, 404)
-        self.assert_equal(rv.data, 'value')
-
-    def test_user_error_handling(self):
-        class MyException(Exception):
-            pass
-
-        app = flask.Flask(__name__)
-        @app.errorhandler(MyException)
-        def handle_my_exception(e):
-            self.assert_(isinstance(e, MyException))
-            return '42'
-        @app.route('/')
-        def index():
-            raise MyException()
-
-        c = app.test_client()
-        self.assert_equal(c.get('/').data, '42')
-
-    def test_trapping_of_bad_request_key_errors(self):
-        app = flask.Flask(__name__)
-        app.testing = True
-        @app.route('/fail')
-        def fail():
-            flask.request.form['missing_key']
-        c = app.test_client()
-        self.assert_equal(c.get('/fail').status_code, 400)
-
-        app.config['TRAP_BAD_REQUEST_ERRORS'] = True
-        c = app.test_client()
-        try:
-            c.get('/fail')
-        except KeyError, e:
-            self.assert_(isinstance(e, BadRequest))
-        else:
-            self.fail('Expected exception')
-
-    def test_trapping_of_all_http_exceptions(self):
-        app = flask.Flask(__name__)
-        app.testing = True
-        app.config['TRAP_HTTP_EXCEPTIONS'] = True
-        @app.route('/fail')
-        def fail():
-            flask.abort(404)
-
-        c = app.test_client()
-        try:
-            c.get('/fail')
-        except NotFound, e:
-            pass
-        else:
-            self.fail('Expected exception')
-
-    def test_enctype_debug_helper(self):
-        from flask.debughelpers import DebugFilesKeyError
-        app = flask.Flask(__name__)
-        app.debug = True
-        @app.route('/fail', methods=['POST'])
-        def index():
-            return flask.request.files['foo'].filename
-
-        # with statement is important because we leave an exception on the
-        # stack otherwise and we want to ensure that this is not the case
-        # to not negatively affect other tests.
-        with app.test_client() as c:
-            try:
-                c.post('/fail', data={'foo': 'index.txt'})
-            except DebugFilesKeyError, e:
-                self.assert_('no file contents were transmitted' in str(e))
-                self.assert_('This was submitted: "index.txt"' in str(e))
-            else:
-                self.fail('Expected exception')
-
-    def test_teardown_on_pop(self):
-        buffer = []
-        app = flask.Flask(__name__)
-        @app.teardown_request
-        def end_of_request(exception):
-            buffer.append(exception)
-
-        ctx = app.test_request_context()
-        ctx.push()
-        self.assert_equal(buffer, [])
-        ctx.pop()
-        self.assert_equal(buffer, [None])
-
-    def test_response_creation(self):
-        app = flask.Flask(__name__)
-        @app.route('/unicode')
-        def from_unicode():
-            return u'Hällo Wörld'
-        @app.route('/string')
-        def from_string():
-            return u'Hällo Wörld'.encode('utf-8')
-        @app.route('/args')
-        def from_tuple():
-            return 'Meh', 400, {
-                'X-Foo': 'Testing',
-                'Content-Type': 'text/plain; charset=utf-8'
-            }
-        c = app.test_client()
-        self.assert_equal(c.get('/unicode').data, u'Hällo Wörld'.encode('utf-8'))
-        self.assert_equal(c.get('/string').data, u'Hällo Wörld'.encode('utf-8'))
-        rv = c.get('/args')
-        self.assert_equal(rv.data, 'Meh')
-        self.assert_equal(rv.headers['X-Foo'], 'Testing')
-        self.assert_equal(rv.status_code, 400)
-        self.assert_equal(rv.mimetype, 'text/plain')
-
-    def test_make_response(self):
-        app = flask.Flask(__name__)
-        with app.test_request_context():
-            rv = flask.make_response()
-            self.assert_equal(rv.status_code, 200)
-            self.assert_equal(rv.data, '')
-            self.assert_equal(rv.mimetype, 'text/html')
-
-            rv = flask.make_response('Awesome')
-            self.assert_equal(rv.status_code, 200)
-            self.assert_equal(rv.data, 'Awesome')
-            self.assert_equal(rv.mimetype, 'text/html')
-
-            rv = flask.make_response('W00t', 404)
-            self.assert_equal(rv.status_code, 404)
-            self.assert_equal(rv.data, 'W00t')
-            self.assert_equal(rv.mimetype, 'text/html')
-
-    def test_make_response_with_response_instance(self):
-        app = flask.Flask(__name__)
-        with app.test_request_context():
-            rv = flask.make_response(
-                flask.jsonify({'msg': 'W00t'}), 400)
-            self.assertEqual(rv.status_code, 400)
-            self.assertEqual(rv.data,
-                             '{\n  "msg": "W00t"\n}')
-            self.assertEqual(rv.mimetype, 'application/json')
-
-            rv = flask.make_response(
-                flask.Response(''), 400)
-            self.assertEqual(rv.status_code, 400)
-            self.assertEqual(rv.data, '')
-            self.assertEqual(rv.mimetype, 'text/html')
-
-            rv = flask.make_response(
-                flask.Response('', headers={'Content-Type': 'text/html'}),
-                400, [('X-Foo', 'bar')])
-            self.assertEqual(rv.status_code, 400)
-            self.assertEqual(rv.headers['Content-Type'], 'text/html')
-            self.assertEqual(rv.headers['X-Foo'], 'bar')
-
-    def test_url_generation(self):
-        app = flask.Flask(__name__)
-        @app.route('/hello/<name>', methods=['POST'])
-        def hello():
-            pass
-        with app.test_request_context():
-            self.assert_equal(flask.url_for('hello', name='test x'), '/hello/test%20x')
-            self.assert_equal(flask.url_for('hello', name='test x', _external=True),
-                              'http://localhost/hello/test%20x')
-
-    def test_build_error_handler(self):
-        app = flask.Flask(__name__)
-
-        # Test base case, a URL which results in a BuildError.
-        with app.test_request_context():
-            self.assertRaises(BuildError, flask.url_for, 'spam')
-
-        # Verify the error is re-raised if not the current exception.
-        try:
-            with app.test_request_context():
-                flask.url_for('spam')
-        except BuildError, error:
-            pass
-        try:
-            raise RuntimeError('Test case where BuildError is not current.')
-        except RuntimeError:
-            self.assertRaises(BuildError, app.handle_url_build_error, error, 'spam', {})
-
-        # Test a custom handler.
-        def handler(error, endpoint, values):
-            # Just a test.
-            return '/test_handler/'
-        app.url_build_error_handlers.append(handler)
-        with app.test_request_context():
-            self.assert_equal(flask.url_for('spam'), '/test_handler/')
-
-    def test_custom_converters(self):
-        from werkzeug.routing import BaseConverter
-        class ListConverter(BaseConverter):
-            def to_python(self, value):
-                return value.split(',')
-            def to_url(self, value):
-                base_to_url = super(ListConverter, self).to_url
-                return ','.join(base_to_url(x) for x in value)
-        app = flask.Flask(__name__)
-        app.url_map.converters['list'] = ListConverter
-        @app.route('/<list:args>')
-        def index(args):
-            return '|'.join(args)
-        c = app.test_client()
-        self.assert_equal(c.get('/1,2,3').data, '1|2|3')
-
-    def test_static_files(self):
-        app = flask.Flask(__name__)
-        rv = app.test_client().get('/static/index.html')
-        self.assert_equal(rv.status_code, 200)
-        self.assert_equal(rv.data.strip(), '<h1>Hello World!</h1>')
-        with app.test_request_context():
-            self.assert_equal(flask.url_for('static', filename='index.html'),
-                              '/static/index.html')
-
-    def test_none_response(self):
-        app = flask.Flask(__name__)
-        @app.route('/')
-        def test():
-            return None
-        try:
-            app.test_client().get('/')
-        except ValueError, e:
-            self.assert_equal(str(e), 'View function did not return a response')
-            pass
-        else:
-            self.assert_("Expected ValueError")
-
-    def test_request_locals(self):
-        self.assert_equal(repr(flask.g), '<LocalProxy unbound>')
-        self.assertFalse(flask.g)
-
-    def test_proper_test_request_context(self):
-        app = flask.Flask(__name__)
-        app.config.update(
-            SERVER_NAME='localhost.localdomain:5000'
-        )
-
-        @app.route('/')
-        def index():
-            return None
-
-        @app.route('/', subdomain='foo')
-        def sub():
-            return None
-
-        with app.test_request_context('/'):
-            self.assert_equal(flask.url_for('index', _external=True), 'http://localhost.localdomain:5000/')
-
-        with app.test_request_context('/'):
-            self.assert_equal(flask.url_for('sub', _external=True), 'http://foo.localhost.localdomain:5000/')
-
-        try:
-            with app.test_request_context('/', environ_overrides={'HTTP_HOST': 'localhost'}):
-                pass
-        except Exception, e:
-            self.assert_(isinstance(e, ValueError))
-            self.assert_equal(str(e), "the server name provided " +
-                    "('localhost.localdomain:5000') does not match the " + \
-                    "server name from the WSGI environment ('localhost')")
-
-        try:
-            app.config.update(SERVER_NAME='localhost')
-            with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost'}):
-                pass
-        except ValueError, e:
-            raise ValueError(
-                "No ValueError exception should have been raised \"%s\"" % e
-            )
-
-        try:
-            app.config.update(SERVER_NAME='localhost:80')
-            with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost:80'}):
-                pass
-        except ValueError, e:
-            raise ValueError(
-                "No ValueError exception should have been raised \"%s\"" % e
-            )
-
-    def test_test_app_proper_environ(self):
-        app = flask.Flask(__name__)
-        app.config.update(
-            SERVER_NAME='localhost.localdomain:5000'
-        )
-        @app.route('/')
-        def index():
-            return 'Foo'
-
-        @app.route('/', subdomain='foo')
-        def subdomain():
-            return 'Foo SubDomain'
-
-        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, 'Foo')
-
-        rv = app.test_client().get('/', 'http://localhost.localdomain:5000')
-        self.assert_equal(rv.data, 'Foo')
-
-        rv = app.test_client().get('/', 'https://localhost.localdomain:5000')
-        self.assert_equal(rv.data, 'Foo')
-
-        app.config.update(SERVER_NAME='localhost.localdomain')
-        rv = app.test_client().get('/', 'https://localhost.localdomain')
-        self.assert_equal(rv.data, 'Foo')
-
-        try:
-            app.config.update(SERVER_NAME='localhost.localdomain:443')
-            rv = app.test_client().get('/', 'https://localhost.localdomain')
-            # Werkzeug 0.8
-            self.assert_equal(rv.status_code, 404)
-        except ValueError, e:
-            # Werkzeug 0.7
-            self.assert_equal(str(e), "the server name provided " +
-                    "('localhost.localdomain:443') does not match the " + \
-                    "server name from the WSGI environment ('localhost.localdomain')")
-
-        try:
-            app.config.update(SERVER_NAME='localhost.localdomain')
-            rv = app.test_client().get('/', 'http://foo.localhost')
-            # Werkzeug 0.8
-            self.assert_equal(rv.status_code, 404)
-        except ValueError, e:
-            # Werkzeug 0.7
-            self.assert_equal(str(e), "the server name provided " + \
-                    "('localhost.localdomain') does not match the " + \
-                    "server name from the WSGI environment ('foo.localhost')")
-
-        rv = app.test_client().get('/', 'http://foo.localhost.localdomain')
-        self.assert_equal(rv.data, 'Foo SubDomain')
-
-    def test_exception_propagation(self):
-        def apprunner(configkey):
-            app = flask.Flask(__name__)
-            @app.route('/')
-            def index():
-                1/0
-            c = app.test_client()
-            if config_key is not None:
-                app.config[config_key] = True
-                try:
-                    resp = c.get('/')
-                except Exception:
-                    pass
-                else:
-                    self.fail('expected exception')
-            else:
-                self.assert_equal(c.get('/').status_code, 500)
-
-        # we have to run this test in an isolated thread because if the
-        # debug flag is set to true and an exception happens the context is
-        # not torn down.  This causes other tests that run after this fail
-        # when they expect no exception on the stack.
-        for config_key in 'TESTING', 'PROPAGATE_EXCEPTIONS', 'DEBUG', None:
-            t = Thread(target=apprunner, args=(config_key,))
-            t.start()
-            t.join()
-
-    def test_max_content_length(self):
-        app = flask.Flask(__name__)
-        app.config['MAX_CONTENT_LENGTH'] = 64
-        @app.before_request
-        def always_first():
-            flask.request.form['myfile']
-            self.assert_(False)
-        @app.route('/accept', methods=['POST'])
-        def accept_file():
-            flask.request.form['myfile']
-            self.assert_(False)
-        @app.errorhandler(413)
-        def catcher(error):
-            return '42'
-
-        c = app.test_client()
-        rv = c.post('/accept', data={'myfile': 'foo' * 100})
-        self.assert_equal(rv.data, '42')
-
-    def test_url_processors(self):
-        app = flask.Flask(__name__)
-
-        @app.url_defaults
-        def add_language_code(endpoint, values):
-            if flask.g.lang_code is not None and \
-               app.url_map.is_endpoint_expecting(endpoint, 'lang_code'):
-                values.setdefault('lang_code', flask.g.lang_code)
-
-        @app.url_value_preprocessor
-        def pull_lang_code(endpoint, values):
-            flask.g.lang_code = values.pop('lang_code', None)
-
-        @app.route('/<lang_code>/')
-        def index():
-            return flask.url_for('about')
-
-        @app.route('/<lang_code>/about')
-        def about():
-            return flask.url_for('something_else')
-
-        @app.route('/foo')
-        def something_else():
-            return flask.url_for('about', lang_code='en')
-
-        c = app.test_client()
-
-        self.assert_equal(c.get('/de/').data, '/de/about')
-        self.assert_equal(c.get('/de/about').data, '/foo')
-        self.assert_equal(c.get('/foo').data, '/en/about')
-        
-    def test_inject_blueprint_url_defaults(self):
-        app = flask.Flask(__name__)
-        bp = flask.Blueprint('foo.bar.baz', __name__, 
-                       template_folder='template')
-
-        @bp.url_defaults
-        def bp_defaults(endpoint, values):
-            values['page'] = 'login'
-        @bp.route('/<page>')
-        def view(page): pass
-
-        app.register_blueprint(bp)
-
-        values = dict()
-        app.inject_url_defaults('foo.bar.baz.view', values)
-        expected = dict(page='login')
-        self.assert_equal(values, expected) 
-
-        with app.test_request_context('/somepage'):
-            url = flask.url_for('foo.bar.baz.view')
-        expected = '/login'
-        self.assert_equal(url, expected)
-
-    def test_debug_mode_complains_after_first_request(self):
-        app = flask.Flask(__name__)
-        app.debug = True
-        @app.route('/')
-        def index():
-            return 'Awesome'
-        self.assert_(not app.got_first_request)
-        self.assert_equal(app.test_client().get('/').data, 'Awesome')
-        try:
-            @app.route('/foo')
-            def broken():
-                return 'Meh'
-        except AssertionError, e:
-            self.assert_('A setup function was called' in str(e))
-        else:
-            self.fail('Expected exception')
-
-        app.debug = False
-        @app.route('/foo')
-        def working():
-            return 'Meh'
-        self.assert_equal(app.test_client().get('/foo').data, 'Meh')
-        self.assert_(app.got_first_request)
-
-    def test_before_first_request_functions(self):
-        got = []
-        app = flask.Flask(__name__)
-        @app.before_first_request
-        def foo():
-            got.append(42)
-        c = app.test_client()
-        c.get('/')
-        self.assert_equal(got, [42])
-        c.get('/')
-        self.assert_equal(got, [42])
-        self.assert_(app.got_first_request)
-
-    def test_routing_redirect_debugging(self):
-        app = flask.Flask(__name__)
-        app.debug = True
-        @app.route('/foo/', methods=['GET', 'POST'])
-        def foo():
-            return 'success'
-        with app.test_client() as c:
-            try:
-                c.post('/foo', data={})
-            except AssertionError, e:
-                self.assert_('http://localhost/foo/' in str(e))
-                self.assert_('Make sure to directly send your POST-request '
-                             'to this URL' in str(e))
-            else:
-                self.fail('Expected exception')
-
-            rv = c.get('/foo', data={}, follow_redirects=True)
-            self.assert_equal(rv.data, 'success')
-
-        app.debug = False
-        with app.test_client() as c:
-            rv = c.post('/foo', data={}, follow_redirects=True)
-            self.assert_equal(rv.data, 'success')
-
-    def test_route_decorator_custom_endpoint(self):
-        app = flask.Flask(__name__)
-        app.debug = True
-
-        @app.route('/foo/')
-        def foo():
-            return flask.request.endpoint
-
-        @app.route('/bar/', endpoint='bar')
-        def for_bar():
-            return flask.request.endpoint
-
-        @app.route('/bar/123', endpoint='123')
-        def for_bar_foo():
-            return flask.request.endpoint
-
-        with app.test_request_context():
-            assert flask.url_for('foo') == '/foo/'
-            assert flask.url_for('bar') == '/bar/'
-            assert flask.url_for('123') == '/bar/123'
-
-        c = app.test_client()
-        self.assertEqual(c.get('/foo/').data, 'foo')
-        self.assertEqual(c.get('/bar/').data, 'bar')
-        self.assertEqual(c.get('/bar/123').data, '123')
-
-    def test_preserve_only_once(self):
-        app = flask.Flask(__name__)
-        app.debug = True
-
-        @app.route('/fail')
-        def fail_func():
-            1/0
-
-        c = app.test_client()
-        for x in xrange(3):
-            with self.assert_raises(ZeroDivisionError):
-                c.get('/fail')
-
-        self.assert_(flask._request_ctx_stack.top is not None)
-        flask._request_ctx_stack.pop()
-        self.assert_(flask._request_ctx_stack.top is None)
-
-
-class ContextTestCase(FlaskTestCase):
-
-    def test_context_binding(self):
-        app = flask.Flask(__name__)
-        @app.route('/')
-        def index():
-            return 'Hello %s!' % flask.request.args['name']
-        @app.route('/meh')
-        def meh():
-            return flask.request.url
-
-        with app.test_request_context('/?name=World'):
-            self.assert_equal(index(), 'Hello World!')
-        with app.test_request_context('/meh'):
-            self.assert_equal(meh(), 'http://localhost/meh')
-        self.assert_(flask._request_ctx_stack.top is None)
-
-    def test_context_test(self):
-        app = flask.Flask(__name__)
-        self.assert_(not flask.request)
-        self.assert_(not flask.has_request_context())
-        ctx = app.test_request_context()
-        ctx.push()
-        try:
-            self.assert_(flask.request)
-            self.assert_(flask.has_request_context())
-        finally:
-            ctx.pop()
-
-    def test_manual_context_binding(self):
-        app = flask.Flask(__name__)
-        @app.route('/')
-        def index():
-            return 'Hello %s!' % flask.request.args['name']
-
-        ctx = app.test_request_context('/?name=World')
-        ctx.push()
-        self.assert_equal(index(), 'Hello World!')
-        ctx.pop()
-        try:
-            index()
-        except RuntimeError:
-            pass
-        else:
-            self.assert_(0, 'expected runtime error')
-
-
-class SubdomainTestCase(FlaskTestCase):
-
-    def test_basic_support(self):
-        app = flask.Flask(__name__)
-        app.config['SERVER_NAME'] = 'localhost'
-        @app.route('/')
-        def normal_index():
-            return 'normal index'
-        @app.route('/', subdomain='test')
-        def test_index():
-            return 'test index'
-
-        c = app.test_client()
-        rv = c.get('/', 'http://localhost/')
-        self.assert_equal(rv.data, 'normal index')
-
-        rv = c.get('/', 'http://test.localhost/')
-        self.assert_equal(rv.data, 'test index')
-
-    @emits_module_deprecation_warning
-    def test_module_static_path_subdomain(self):
-        app = flask.Flask(__name__)
-        app.config['SERVER_NAME'] = 'example.com'
-        from subdomaintestmodule import mod
-        app.register_module(mod)
-        c = app.test_client()
-        rv = c.get('/static/hello.txt', 'http://foo.example.com/')
-        self.assert_equal(rv.data.strip(), 'Hello Subdomain')
-
-    def test_subdomain_matching(self):
-        app = flask.Flask(__name__)
-        app.config['SERVER_NAME'] = 'localhost'
-        @app.route('/', subdomain='<user>')
-        def index(user):
-            return 'index for %s' % user
-
-        c = app.test_client()
-        rv = c.get('/', 'http://mitsuhiko.localhost/')
-        self.assert_equal(rv.data, 'index for mitsuhiko')
-
-    def test_subdomain_matching_with_ports(self):
-        app = flask.Flask(__name__)
-        app.config['SERVER_NAME'] = 'localhost:3000'
-        @app.route('/', subdomain='<user>')
-        def index(user):
-            return 'index for %s' % user
-
-        c = app.test_client()
-        rv = c.get('/', 'http://mitsuhiko.localhost:3000/')
-        self.assert_equal(rv.data, 'index for mitsuhiko')
-
-    @emits_module_deprecation_warning
-    def test_module_subdomain_support(self):
-        app = flask.Flask(__name__)
-        mod = flask.Module(__name__, 'test', subdomain='testing')
-        app.config['SERVER_NAME'] = 'localhost'
-
-        @mod.route('/test')
-        def test():
-            return 'Test'
-
-        @mod.route('/outside', subdomain='xtesting')
-        def bar():
-            return 'Outside'
-
-        app.register_module(mod)
-
-        c = app.test_client()
-        rv = c.get('/test', 'http://testing.localhost/')
-        self.assert_equal(rv.data, 'Test')
-        rv = c.get('/outside', 'http://xtesting.localhost/')
-        self.assert_equal(rv.data, 'Outside')
-
-
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(unittest.makeSuite(BasicFunctionalityTestCase))
-    suite.addTest(unittest.makeSuite(ContextTestCase))
-    suite.addTest(unittest.makeSuite(SubdomainTestCase))
-    return suite

main/lib/flask/testsuite/blueprints.py

-# -*- coding: utf-8 -*-
-"""
-    flask.testsuite.blueprints
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Blueprints (and currently modules)
-
-    :copyright: (c) 2011 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from __future__ import with_statement
-
-import flask
-import unittest
-import warnings
-from flask.testsuite import FlaskTestCase, emits_module_deprecation_warning
-from werkzeug.exceptions import NotFound
-from werkzeug.http import parse_cache_control_header
-from jinja2 import TemplateNotFound
-
-
-# import moduleapp here because it uses deprecated features and we don't
-# want to see the warnings
-warnings.simplefilter('ignore', DeprecationWarning)
-from moduleapp import app as moduleapp
-warnings.simplefilter('default', DeprecationWarning)
-
-
-class ModuleTestCase(FlaskTestCase):
-
-    @emits_module_deprecation_warning
-    def test_basic_module(self):
-        app = flask.Flask(__name__)
-        admin = flask.Module(__name__, 'admin', url_prefix='/admin')
-        @admin.route('/')
-        def admin_index():
-            return 'admin index'
-        @admin.route('/login')
-        def admin_login():
-            return 'admin login'
-        @admin.route('/logout')
-        def admin_logout():
-            return 'admin logout'
-        @app.route('/')
-        def index():
-            return 'the index'
-        app.register_module(admin)
-        c = app.test_client()
-        self.assert_equal(c.get('/').data, 'the index')
-        self.assert_equal(c.get('/admin/').data, 'admin index')
-        self.assert_equal(c.get('/admin/login').data, 'admin login')
-        self.assert_equal(c.get('/admin/logout').data, 'admin logout')
-
-    @emits_module_deprecation_warning
-    def test_default_endpoint_name(self):
-        app = flask.Flask(__name__)
-        mod = flask.Module(__name__, 'frontend')
-        def index():
-            return 'Awesome'
-        mod.add_url_rule('/', view_func=index)
-        app.register_module(mod)
-        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, 'Awesome')
-        with app.test_request_context():
-            self.assert_equal(flask.url_for('frontend.index'), '/')
-
-    @emits_module_deprecation_warning
-    def test_request_processing(self):
-        catched = []
-        app = flask.Flask(__name__)
-        admin = flask.Module(__name__, 'admin', url_prefix='/admin')
-        @admin.before_request
-        def before_admin_request():
-            catched.append('before-admin')
-        @admin.after_request
-        def after_admin_request(response):
-            catched.append('after-admin')
-            return response
-        @admin.route('/')
-        def admin_index():
-            return 'the admin'
-        @app.before_request
-        def before_request():
-            catched.append('before-app')
-        @app.after_request
-        def after_request(response):
-            catched.append('after-app')
-            return response
-        @app.route('/')
-        def index():
-            return 'the index'
-        app.register_module(admin)
-        c = app.test_client()
-
-        self.assert_equal(c.get('/').data, 'the index')
-        self.assert_equal(catched, ['before-app', 'after-app'])
-        del catched[:]
-
-        self.assert_equal(c.get('/admin/').data, 'the admin')
-        self.assert_equal(catched, ['before-app', 'before-admin',
-                           'after-admin', 'after-app'])
-
-    @emits_module_deprecation_warning
-    def test_context_processors(self):
-        app = flask.Flask(__name__)
-        admin = flask.Module(__name__, 'admin', url_prefix='/admin')
-        @app.context_processor
-        def inject_all_regualr():
-            return {'a': 1}
-        @admin.context_processor
-        def inject_admin():
-            return {'b': 2}
-        @admin.app_context_processor
-        def inject_all_module():
-            return {'c': 3}
-        @app.route('/')
-        def index():
-            return flask.render_template_string('{{ a }}{{ b }}{{ c }}')
-        @admin.route('/')
-        def admin_index():
-            return flask.render_template_string('{{ a }}{{ b }}{{ c }}')
-        app.register_module(admin)
-        c = app.test_client()
-        self.assert_equal(c.get('/').data, '13')
-        self.assert_equal(c.get('/admin/').data, '123')
-
-    @emits_module_deprecation_warning
-    def test_late_binding(self):
-        app = flask.Flask(__name__)
-        admin = flask.Module(__name__, 'admin')
-        @admin.route('/')
-        def index():
-            return '42'
-        app.register_module(admin, url_prefix='/admin')
-        self.assert_equal(app.test_client().get('/admin/').data, '42')
-
-    @emits_module_deprecation_warning
-    def test_error_handling(self):
-        app = flask.Flask(__name__)
-        admin = flask.Module(__name__, 'admin')
-        @admin.app_errorhandler(404)
-        def not_found(e):
-            return 'not found', 404
-        @admin.app_errorhandler(500)
-        def internal_server_error(e):
-            return 'internal server error', 500
-        @admin.route('/')
-        def index():
-            flask.abort(404)
-        @admin.route('/error')
-        def error():
-            1 // 0
-        app.register_module(admin)
-        c = app.test_client()
-        rv = c.get('/')
-        self.assert_equal(rv.status_code, 404)
-        self.assert_equal(rv.data, 'not found')
-        rv = c.get('/error')
-        self.assert_equal(rv.status_code, 500)
-        self.assert_equal('internal server error', rv.data)
-
-    def test_templates_and_static(self):
-        app = moduleapp
-        app.testing = True
-        c = app.test_client()
-
-        rv = c.get('/')
-        self.assert_equal(rv.data, 'Hello from the Frontend')
-        rv = c.get('/admin/')
-        self.assert_equal(rv.data, 'Hello from the Admin')
-        rv = c.get('/admin/index2')
-        self.assert_equal(rv.data, 'Hello from the Admin')
-        rv = c.get('/admin/static/test.txt')
-        self.assert_equal(rv.data.strip(), 'Admin File')
-        rv = c.get('/admin/static/css/test.css')
-        self.assert_equal(rv.data.strip(), '/* nested file */')
-
-        with app.test_request_context():
-            self.assert_equal(flask.url_for('admin.static', filename='test.txt'),
-                              '/admin/static/test.txt')
-
-        with app.test_request_context():
-            try:
-                flask.render_template('missing.html')
-            except TemplateNotFound, e:
-                self.assert_equal(e.name, 'missing.html')
-            else:
-                self.assert_(0, 'expected exception')
-
-        with flask.Flask(__name__).test_request_context():
-            self.assert_equal(flask.render_template('nested/nested.txt'), 'I\'m nested')
-
-    def test_safe_access(self):
-        app = moduleapp
-
-        with app.test_request_context():
-            f = app.view_functions['admin.static']
-
-            try:
-                f('/etc/passwd')
-            except NotFound:
-                pass
-            else:
-                self.assert_(0, 'expected exception')
-            try:
-                f('../__init__.py')
-            except NotFound:
-                pass
-            else:
-                self.assert_(0, 'expected exception')
-
-            # testcase for a security issue that may exist on windows systems
-            import os
-            import ntpath
-            old_path = os.path
-            os.path = ntpath
-            try:
-                try:
-                    f('..\\__init__.py')
-                except NotFound:
-                    pass
-                else:
-                    self.assert_(0, 'expected exception')
-            finally:
-                os.path = old_path
-
-    @emits_module_deprecation_warning
-    def test_endpoint_decorator(self):
-        from werkzeug.routing import Submount, Rule
-        from flask import Module
-
-        app = flask.Flask(__name__)
-        app.testing = True
-        app.url_map.add(Submount('/foo', [
-            Rule('/bar', endpoint='bar'),
-            Rule('/', endpoint='index')
-        ]))
-        module = Module(__name__, __name__)
-
-        @module.endpoint('bar')
-        def bar():
-            return 'bar'
-
-        @module.endpoint('index')
-        def index():
-            return 'index'
-
-        app.register_module(module)
-
-        c = app.test_client()
-        self.assert_equal(c.get('/foo/').data, 'index')
-        self.assert_equal(c.get('/foo/bar').data, 'bar')
-
-
-class BlueprintTestCase(FlaskTestCase):
-
-    def test_blueprint_specific_error_handling(self):
-        frontend = flask.Blueprint('frontend', __name__)
-        backend = flask.Blueprint('backend', __name__)
-        sideend = flask.Blueprint('sideend', __name__)
-
-        @frontend.errorhandler(403)
-        def frontend_forbidden(e):
-            return 'frontend says no', 403
-
-        @frontend.route('/frontend-no')
-        def frontend_no():
-            flask.abort(403)
-
-        @backend.errorhandler(403)
-        def backend_forbidden(e):
-            return 'backend says no', 403
-
-        @backend.route('/backend-no')
-        def backend_no():
-            flask.abort(403)
-
-        @sideend.route('/what-is-a-sideend')
-        def sideend_no():
-            flask.abort(403)
-
-        app = flask.Flask(__name__)
-        app.register_blueprint(frontend)
-        app.register_blueprint(backend)
-        app.register_blueprint(sideend)
-
-        @app.errorhandler(403)
-        def app_forbidden(e):
-            return 'application itself says no', 403
-
-        c = app.test_client()
-
-        self.assert_equal(c.get('/frontend-no').data, 'frontend says no')
-        self.assert_equal(c.get('/backend-no').data, 'backend says no')
-        self.assert_equal(c.get('/what-is-a-sideend').data, 'application itself says no')
-
-    def test_blueprint_url_definitions(self):
-        bp = flask.Blueprint('test', __name__)
-
-        @bp.route('/foo', defaults={'baz': 42})
-        def foo(bar, baz):
-            return '%s/%d' % (bar, baz)
-
-        @bp.route('/bar')
-        def bar(bar):
-            return unicode(bar)
-
-        app = flask.Flask(__name__)
-        app.register_blueprint(bp, url_prefix='/1', url_defaults={'bar': 23})
-        app.register_blueprint(bp, url_prefix='/2', url_defaults={'bar': 19})
-
-        c = app.test_client()
-        self.assert_equal(c.get('/1/foo').data, u'23/42')
-        self.assert_equal(c.get('/2/foo').data, u'19/42')
-        self.assert_equal(c.get('/1/bar').data, u'23')
-        self.assert_equal(c.get('/2/bar').data, u'19')
-
-    def test_blueprint_url_processors(self):
-        bp = flask.Blueprint('frontend', __name__, url_prefix='/<lang_code>')
-
-        @bp.url_defaults
-        def add_language_code(endpoint, values):
-            values.setdefault('lang_code', flask.g.lang_code)
-
-        @bp.url_value_preprocessor
-        def pull_lang_code(endpoint, values):
-            flask.g.lang_code = values.pop('lang_code')
-
-        @bp.route('/')
-        def index():
-            return flask.url_for('.about')
-
-        @bp.route('/about')
-        def about():
-            return flask.url_for('.index')
-
-        app = flask.Flask(__name__)
-        app.register_blueprint(bp)
-
-        c = app.test_client()
-
-        self.assert_equal(c.get('/de/').data, '/de/about')
-        self.assert_equal(c.get('/de/about').data, '/de/')
-
-    def test_templates_and_static(self):
-        from blueprintapp import app
-        c = app.test_client()
-
-        rv = c.get('/')
-        self.assert_equal(rv.data, 'Hello from the Frontend')
-        rv = c.get('/admin/')
-        self.assert_equal(rv.data, 'Hello from the Admin')
-        rv = c.get('/admin/index2')
-        self.assert_equal(rv.data, 'Hello from the Admin')
-        rv = c.get('/admin/static/test.txt')
-        self.assert_equal(rv.data.strip(), 'Admin File')
-        rv = c.get('/admin/static/css/test.css')
-        self.assert_equal(rv.data.strip(), '/* nested file */')
-
-        # try/finally, in case other tests use this app for Blueprint tests.
-        max_age_default = app.config['SEND_FILE_MAX_AGE_DEFAULT']
-        try:
-            expected_max_age = 3600
-            if app.config['SEND_FILE_MAX_AGE_DEFAULT'] == expected_max_age:
-                expected_max_age = 7200
-            app.config['SEND_FILE_MAX_AGE_DEFAULT'] = expected_max_age
-            rv = c.get('/admin/static/css/test.css')
-            cc = parse_cache_control_header(rv.headers['Cache-Control'])
-            self.assert_equal(cc.max_age, expected_max_age)
-        finally:
-            app.config['SEND_FILE_MAX_AGE_DEFAULT'] = max_age_default
-
-        with app.test_request_context():
-            self.assert_equal(flask.url_for('admin.static', filename='test.txt'),
-                              '/admin/static/test.txt')
-
-        with app.test_request_context():
-            try:
-                flask.render_template('missing.html')
-            except TemplateNotFound, e:
-                self.assert_equal(e.name, 'missing.html')
-            else:
-                self.assert_(0, 'expected exception')
-
-        with flask.Flask(__name__).test_request_context():
-            self.assert_equal(flask.render_template('nested/nested.txt'), 'I\'m nested')
-
-    def test_default_static_cache_timeout(self):
-        app = flask.Flask(__name__)
-        class MyBlueprint(flask.Blueprint):
-            def get_send_file_max_age(self, filename):
-                return 100
-
-        blueprint = MyBlueprint('blueprint', __name__, static_folder='static')
-        app.register_blueprint(blueprint)
-