Flask App factory PR #1

requirements-dev.txt

@@ -17,6 +17,7 @@
 black==19.3b0
 coverage==4.5.3
 flask-cors==3.0.7
+flask-testing==0.7.1
 ipdb==0.12
 isort==4.3.21
 mypy==0.670

setup.py

@@ -110,6 +110,7 @@ def get_git_sha():
     extras_require={
         "bigquery": ["pybigquery>=0.4.10", "pandas_gbq>=0.10.0"],
         "cors": ["flask-cors>=2.0.0"],
+        "flask-testing": ["Flask-Testing==0.7.1"],
         "gsheets": ["gsheetsdb>=0.1.9"],
         "hive": ["pyhive[hive]>=0.6.1", "tableschema", "thrift>=0.11.0, <1.0.0"],
         "mysql": ["mysqlclient==1.4.2.post1"],

superset/app.py

@@ -94,7 +94,7 @@ def post_init(self) -> None:
         pass
 
     def configure_celery(self) -> None:
-        celery_app.config_from_object(self.config.get("CELERY_CONFIG"))
+        celery_app.config_from_object(self.config["CELERY_CONFIG"])
         celery_app.set_default()
 
     def init_views(self) -> None:
@@ -112,7 +112,7 @@ def init_app_in_ctx(self) -> None:
 
         # Hook that provides administrators a handle on the Flask APP
         # after initialization
-        flask_app_mutator = self.config.get("FLASK_APP_MUTATOR")
+        flask_app_mutator = self.config["FLASK_APP_MUTATOR"]
         if flask_app_mutator:
             flask_app_mutator(self.flask_app)
 
@@ -155,8 +155,8 @@ def setup_event_logger(self):
 
     def configure_data_sources(self):
         # Registering sources
-        module_datasource_map = self.config.get("DEFAULT_MODULE_DS_MAP")
-        module_datasource_map.update(self.config.get("ADDITIONAL_MODULE_DS_MAP"))
+        module_datasource_map = self.config["DEFAULT_MODULE_DS_MAP"]
+        module_datasource_map.update(self.config["ADDITIONAL_MODULE_DS_MAP"])
         ConnectorRegistry.register_sources(module_datasource_map)
 
     def configure_cache(self):
@@ -167,10 +167,10 @@ def configure_feature_flags(self):
         feature_flag_manager.init_app(self.flask_app)
 
     def configure_fab(self):
-        if self.config.get("SILENCE_FAB"):
+        if self.config["SILENCE_FAB"]:
             logging.getLogger("flask_appbuilder").setLevel(logging.ERROR)
 
-        custom_sm = self.config.get("CUSTOM_SECURITY_MANAGER") or SupersetSecurityManager
+        custom_sm = self.config["CUSTOM_SECURITY_MANAGER"] or SupersetSecurityManager
         if not issubclass(custom_sm, SupersetSecurityManager):
             raise Exception(
                 """Your CUSTOM_SECURITY_MANAGER must now extend SupersetSecurityManager,
@@ -185,17 +185,17 @@ def configure_fab(self):
         appbuilder.init_app(self.flask_app, db.session)
 
     def configure_middlewares(self):
-        if self.config.get("ENABLE_CORS"):
+        if self.config["ENABLE_CORS"]:
             from flask_cors import CORS
 
-            CORS(self.flask_app, **self.config.get("CORS_OPTIONS"))
+            CORS(self.flask_app, **self.config["CORS_OPTIONS"])
 
-        if self.config.get("ENABLE_PROXY_FIX"):
+        if self.config["ENABLE_PROXY_FIX"]:
             from werkzeug.middleware.proxy_fix import ProxyFix
 
-            self.flask_app.wsgi_app = ProxyFix(self.flask_app.wsgi_app, **self.config.get("PROXY_FIX_CONFIG"))
+            self.flask_app.wsgi_app = ProxyFix(self.flask_app.wsgi_app, **self.config["PROXY_FIX_CONFIG"])
 
-        if self.config.get("ENABLE_CHUNK_ENCODING"):
+        if self.config["ENABLE_CHUNK_ENCODING"]:
 
             class ChunkedEncodingFix(object):
                 def __init__(self, app):
@@ -210,17 +210,17 @@ def __call__(self, environ, start_response):
 
             self.flask_app.wsgi_app = ChunkedEncodingFix(self.flask_app.wsgi_app)
 
-        if self.config.get("UPLOAD_FOLDER"):
+        if self.config["UPLOAD_FOLDER"]:
             try:
-                os.makedirs(self.config.get("UPLOAD_FOLDER"))
+                os.makedirs(self.config["UPLOAD_FOLDER"])
             except OSError:
                 pass
 
-        for middleware in self.config.get("ADDITIONAL_MIDDLEWARE"):
+        for middleware in self.config["ADDITIONAL_MIDDLEWARE"]:
             self.flask_app.wsgi_app = middleware(self.flask_app.wsgi_app)
 
         # Flask-Compress
-        if self.config.get("ENABLE_FLASK_COMPRESS"):
+        if self.config["ENABLE_FLASK_COMPRESS"]:
             Compress(self.flask_app)
 
         if self.config["TALISMAN_ENABLED"]:
@@ -240,14 +240,14 @@ def setup_db(self):
         migrate.init_app(self.flask_app, db=db, directory=APP_DIR + "/migrations")
 
     def configure_wtf(self):
-        if self.config.get("WTF_CSRF_ENABLED"):
+        if self.config["WTF_CSRF_ENABLED"]:
             csrf = CSRFProtect(self.flask_app)
             csrf_exempt_list = self.config.get("WTF_CSRF_EXEMPT_LIST", [])
             for ex in csrf_exempt_list:
                 csrf.exempt(ex)
 
     def register_blueprints(self):
-        for bp in self.config.get("BLUEPRINTS"):
+        for bp in self.config["BLUEPRINTS"]:
             try:
                 logger.info("Registering blueprint: '{}'".format(bp.name))
                 self.flask_app.register_blueprint(bp)

tests/__init__.py

@@ -19,5 +19,10 @@
 TODO: Clean this up! The current pattern of accessing app props on package init means
     that we need to ensure the creation of our Flask app BEFORE any tests load
 """
+from os import environ
+environ.setdefault("SUPERSET_CONFIG", "tests.superset_test_config")
+
 from superset.app import create_app
-create_app().app_context().push()
+app = create_app()
+# ctx = app.test_request_context()
+# ctx.push()

tests/base_tests.py

@@ -22,22 +22,29 @@
 
 import pandas as pd
 from flask_appbuilder.security.sqla import models as ab_models
+from flask_testing import TestCase
 
 from superset import app, db, security_manager
+from superset.app import create_app
 from superset.connectors.druid.models import DruidCluster, DruidDatasource
 from superset.connectors.sqla.models import SqlaTable
 from superset.models import core as models
 from superset.models.core import Database
 from superset.utils.core import get_example_database
 
-BASE_DIR = app.config["BASE_DIR"]
 
-
-class SupersetTestCase(unittest.TestCase):
+class SupersetTestCase(TestCase):
     def __init__(self, *args, **kwargs):
         super(SupersetTestCase, self).__init__(*args, **kwargs)
-        self.client = app.test_client()
         self.maxDiff = None
+        self.BASE_DIR = ""
+
+    def create_app(self):
+        from tests import app
+        return app
+
+    def setUp(self) -> None:
+        self.BASE_DIR = app.config["BASE_DIR"]
 
     @classmethod
     def create_druid_test_objects(cls):

tests/core_tests.py

@@ -50,16 +50,13 @@ class CoreTests(SupersetTestCase):
     def __init__(self, *args, **kwargs):
         super(CoreTests, self).__init__(*args, **kwargs)
 
-    @classmethod
-    def setUpClass(cls):
-        cls.table_ids = {
-            tbl.table_name: tbl.id for tbl in (db.session.query(SqlaTable).all())
-        }
-
     def setUp(self):
         db.session.query(Query).delete()
         db.session.query(models.DatasourceAccessRequest).delete()
         db.session.query(models.Log).delete()
+        self.table_ids = {
+            tbl.table_name: tbl.id for tbl in (db.session.query(SqlaTable).all())
+        }
 
     def tearDown(self):
         db.session.query(Query).delete()