Merge branch 'master' of github.com:mitsuhiko/flask

flask/testsuite/basic.py

@@ -659,6 +659,35 @@ class BasicFunctionalityTestCase(FlaskTestCase):
             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, None, 'application/json')
+            self.assertEqual(rv.status_code, 400)
+            self.assertEqual(rv.headers['Content-Type'], 'application/json')
+
+            rv = flask.make_response(
+                flask.Response('', mimetype='application/json'),
+                400, {'Content-Type': 'text/html'})
+            self.assertEqual(rv.status_code, 400)
+            self.assertEqual(rv.headers['Content-Type'], 'text/html')
+
+
     def test_url_generation(self):
         app = flask.Flask(__name__)
         @app.route('/hello/<name>', methods=['POST'])

flask/testsuite/blueprints.py

@@ -16,6 +16,7 @@ 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
 
 
@@ -357,6 +358,19 @@ class BlueprintTestCase(FlaskTestCase):
         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')

flask/testsuite/config.py

@@ -69,6 +69,24 @@ class ConfigTestCase(FlaskTestCase):
         finally:
             os.environ = env
 
+    def test_config_from_envvar_missing(self):
+        env = os.environ
+        try:
+            os.environ = {'FOO_SETTINGS': 'missing.cfg'}
+            try:
+                app = flask.Flask(__name__)
+                app.config.from_envvar('FOO_SETTINGS')
+            except IOError, e:
+                msg = str(e)
+                self.assert_(msg.startswith('[Errno 2] Unable to load configuration '
+                                            'file (No such file or directory):'))
+                self.assert_(msg.endswith("missing.cfg'"))
+            else:
+                self.fail('expected IOError')
+            self.assertFalse(app.config.from_envvar('FOO_SETTINGS', silent=True))
+        finally:
+            os.environ = env
+
     def test_config_missing(self):
         app = flask.Flask(__name__)
         try:

flask/testsuite/helpers.py

@@ -17,7 +17,7 @@ import unittest
 from logging import StreamHandler
 from StringIO import StringIO
 from flask.testsuite import FlaskTestCase, catch_warnings, catch_stderr
-from werkzeug.http import parse_options_header
+from werkzeug.http import parse_cache_control_header, parse_options_header
 
 
 def has_encoding(name):
@@ -40,6 +40,18 @@ class JSONTestCase(FlaskTestCase):
         rv = c.post('/json', data='malformed', content_type='application/json')
         self.assert_equal(rv.status_code, 400)
 
+    def test_json_bad_requests_content_type(self):
+        app = flask.Flask(__name__)
+        @app.route('/json', methods=['POST'])
+        def return_json():
+            return unicode(flask.request.json)
+        c = app.test_client()
+        rv = c.post('/json', data='malformed', content_type='application/json')
+        self.assert_equal(rv.status_code, 400)
+        self.assert_equal(rv.mimetype, 'application/json')
+        self.assert_('description' in flask.json.loads(rv.data))
+        self.assert_('<p>' not in flask.json.loads(rv.data)['description'])
+
     def test_json_body_encoding(self):
         app = flask.Flask(__name__)
         app.testing = True
@@ -61,11 +73,25 @@ class JSONTestCase(FlaskTestCase):
         @app.route('/dict')
         def return_dict():
             return flask.jsonify(d)
+        @app.route("/padded")
+        def return_padded_json():
+            return flask.jsonify(d, padded=True)
+        @app.route("/padded_custom")
+        def return_padded_json_custom_callback():
+            return flask.jsonify(d, padded='my_func_name')
         c = app.test_client()
         for url in '/kw', '/dict':
             rv = c.get(url)
             self.assert_equal(rv.mimetype, 'application/json')
             self.assert_equal(flask.json.loads(rv.data), d)
+        for get_arg in 'callback=funcName', 'jsonp=funcName':
+            rv = c.get('/padded?' + get_arg)
+            self.assert_( rv.data.startswith("funcName(") )
+            self.assert_( rv.data.endswith(")") )
+            rv_json = rv.data.split('(')[1].split(')')[0]
+            self.assert_equal(flask.json.loads(rv_json), d)
+        rv = c.get('/padded_custom?my_func_name=funcName')
+        self.assert_( rv.data.startswith("funcName(") )
 
     def test_json_attr(self):
         app = flask.Flask(__name__)
@@ -204,6 +230,33 @@ class SendfileTestCase(FlaskTestCase):
             self.assert_equal(value, 'attachment')
             self.assert_equal(options['filename'], 'index.txt')
 
+    def test_static_file(self):
+        app = flask.Flask(__name__)
+        # default cache timeout is 12 hours
+        with app.test_request_context():
+            rv = app.send_static_file('index.html')
+            cc = parse_cache_control_header(rv.headers['Cache-Control'])
+            self.assert_equal(cc.max_age, 12 * 60 * 60)
+        app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 3600
+        with app.test_request_context():
+            rv = app.send_static_file('index.html')
+            cc = parse_cache_control_header(rv.headers['Cache-Control'])
+            self.assert_equal(cc.max_age, 3600)
+        # override get_send_file_options with some new values and check them
+        class StaticFileApp(flask.Flask):
+            def get_send_file_options(self, filename):
+                opts = super(StaticFileApp, self).get_send_file_options(filename)
+                opts['cache_timeout'] = 10
+                # this test catches explicit inclusion of the conditional
+                # keyword arg in the guts
+                opts['conditional'] = True
+                return opts
+        app = StaticFileApp(__name__)
+        with app.test_request_context():
+            rv = app.send_static_file('index.html')
+            cc = parse_cache_control_header(rv.headers['Cache-Control'])
+            self.assert_equal(cc.max_age, 10)
+
 
 class LoggingTestCase(FlaskTestCase):