flask-appbuilder 3.2.1__py3-none-any.whl → 5.0.2__py3-none-any.whl

flask_appbuilder/tests/_test_auth_oauth.py

@@ -1,419 +0,0 @@
-import logging
-import os
-import unittest
-
-from flask import Flask
-from flask_appbuilder import AppBuilder, SQLA
-from flask_appbuilder.const import AUTH_OAUTH
-import jinja2
-
-logging.basicConfig(format="%(asctime)s:%(levelname)s:%(name)s:%(message)s")
-logging.getLogger().setLevel(logging.DEBUG)
-log = logging.getLogger(__name__)
-
-
-class OAuthRegistrationRoleTestCase(unittest.TestCase):
-    def setUp(self):
-        # start Flask
-        self.app = Flask(__name__)
-        self.app.jinja_env.undefined = jinja2.StrictUndefined
-        self.app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get(
-            "SQLALCHEMY_DATABASE_URI"
-        )
-        self.app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
-        self.app.config["AUTH_TYPE"] = AUTH_OAUTH
-        self.app.config[
-            "OAUTH_PROVIDERS"
-        ] = []  # can be empty, because we dont use the external providers in tests
-
-        # start Database
-        self.db = SQLA(self.app)
-
-    def tearDown(self):
-        # stop Flask
-        self.app = None
-
-        # stop Flask-AppBuilder
-        self.appbuilder = None
-
-        # stop Database
-        self.db.session.remove()
-        self.db.drop_all()
-        self.db = None
-
-    # ----------------
-    # Userinfo Objects
-    # ----------------
-    userinfo_alice = {
-        "username": "alice",
-        "first_name": "Alice",
-        "last_name": "Doe",
-        "email": "alice@example.com",
-        "role_keys": ["GROUP_1", "GROUP_2"],
-    }
-
-    # ----------------
-    # Unit Tests
-    # ----------------
-    def test__inactive_user(self):
-        """
-        OAUTH: test login flow for - inactive user
-        """
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # register a user
-        new_user = sm.add_user(
-            username="alice",
-            first_name="Alice",
-            last_name="Doe",
-            email="alice@example.com",
-            role=[],
-        )
-
-        # validate - user was registered
-        self.assertEqual(len(sm.get_all_users()), 1)
-
-        # set user inactive
-        new_user.active = False
-
-        # attempt login
-        user = sm.auth_user_oauth(self.userinfo_alice)
-
-        # validate - user was not allowed to log in
-        self.assertIsNone(user)
-
-    def test__missing_username(self):
-        """
-        OAUTH: test login flow for - missing credentials
-        """
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # create userinfo with missing info
-        userinfo_missing = self.userinfo_alice.copy()
-        userinfo_missing["username"] = ""
-
-        # attempt login
-        user = sm.auth_user_oauth(userinfo_missing)
-
-        # validate - login failure (missing username)
-        self.assertIsNone(user)
-
-        # validate - no users were created
-        self.assertEqual(sm.get_all_users(), [])
-
-    def test__unregistered(self):
-        """
-        OAUTH: test login flow for - unregistered user
-        """
-        self.app.config["AUTH_USER_REGISTRATION"] = True
-        self.app.config["AUTH_USER_REGISTRATION_ROLE"] = "Public"
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # attempt login
-        user = sm.auth_user_oauth(self.userinfo_alice)
-
-        # validate - user was allowed to log in
-        self.assertIsInstance(user, sm.user_model)
-
-        # validate - user was registered
-        self.assertEqual(len(sm.get_all_users()), 1)
-
-        # validate - user was given the AUTH_USER_REGISTRATION_ROLE role
-        self.assertEqual(user.roles, [sm.find_role("Public")])
-
-        # validate - user was given the correct attributes
-        self.assertEqual(user.first_name, "Alice")
-        self.assertEqual(user.last_name, "Doe")
-        self.assertEqual(user.email, "alice@example.com")
-
-    def test__unregistered__no_self_register(self):
-        """
-        OAUTH: test login flow for - unregistered user - no self-registration
-        """
-        self.app.config["AUTH_USER_REGISTRATION"] = False
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # attempt login
-        user = sm.auth_user_oauth(self.userinfo_alice)
-
-        # validate - user was not allowed to log in
-        self.assertIsNone(user)
-
-        # validate - no users were registered
-        self.assertEqual(sm.get_all_users(), [])
-
-    def test__unregistered__single_role(self):
-        """
-        OAUTH: test login flow for - unregistered user
-                                   - single role mapping
-        """
-        self.app.config["AUTH_ROLES_MAPPING"] = {
-            "GROUP_1": ["Admin"],
-            "GROUP_2": ["User"],
-        }
-        self.app.config["AUTH_USER_REGISTRATION"] = True
-        self.app.config["AUTH_USER_REGISTRATION_ROLE"] = "Public"
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # add User role
-        sm.add_role("User")
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # attempt login
-        user = sm.auth_user_oauth(self.userinfo_alice)
-
-        # validate - user was allowed to log in
-        self.assertIsInstance(user, sm.user_model)
-
-        # validate - user was registered
-        self.assertEqual(len(sm.get_all_users()), 1)
-
-        # validate - user was given the correct roles
-        self.assertListEqual(
-            user.roles,
-            [sm.find_role("Admin"), sm.find_role("Public"), sm.find_role("User")],
-        )
-
-        # validate - user was given the correct attributes (read from LDAP)
-        self.assertEqual(user.first_name, "Alice")
-        self.assertEqual(user.last_name, "Doe")
-        self.assertEqual(user.email, "alice@example.com")
-
-    def test__unregistered__multi_role(self):
-        """
-        OAUTH: test login flow for - unregistered user - multi role mapping
-        """
-        self.app.config["AUTH_ROLES_MAPPING"] = {"GROUP_1": ["Admin", "User"]}
-        self.app.config["AUTH_USER_REGISTRATION"] = True
-        self.app.config["AUTH_USER_REGISTRATION_ROLE"] = "Public"
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # add User role
-        sm.add_role("User")
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # attempt login
-        user = sm.auth_user_oauth(self.userinfo_alice)
-
-        # validate - user was allowed to log in
-        self.assertIsInstance(user, sm.user_model)
-
-        # validate - user was registered
-        self.assertEqual(len(sm.get_all_users()), 1)
-
-        # validate - user was given the correct roles
-        self.assertListEqual(
-            user.roles,
-            [sm.find_role("Admin"), sm.find_role("Public"), sm.find_role("User")],
-        )
-
-        # validate - user was given the correct attributes (read from LDAP)
-        self.assertEqual(user.first_name, "Alice")
-        self.assertEqual(user.last_name, "Doe")
-        self.assertEqual(user.email, "alice@example.com")
-
-    def test__unregistered__jmespath_role(self):
-        """
-        OAUTH: test login flow for - unregistered user - jmespath registration role
-        """
-        self.app.config["AUTH_USER_REGISTRATION"] = True
-        self.app.config[
-            "AUTH_USER_REGISTRATION_ROLE_JMESPATH"
-        ] = "contains(['alice'], username) && 'User' || 'Public'"
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # add User role
-        sm.add_role("User")
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # attempt login
-        user = sm.auth_user_oauth(self.userinfo_alice)
-
-        # validate - user was allowed to log in
-        self.assertIsInstance(user, sm.user_model)
-
-        # validate - user was registered
-        self.assertEqual(len(sm.get_all_users()), 1)
-
-        # validate - user was given the correct roles
-        self.assertListEqual(user.roles, [sm.find_role("User")])
-
-        # validate - user was given the correct attributes (read from LDAP)
-        self.assertEqual(user.first_name, "Alice")
-        self.assertEqual(user.last_name, "Doe")
-        self.assertEqual(user.email, "alice@example.com")
-
-    def test__registered__multi_role__no_role_sync(self):
-        """
-        OAUTH: test login flow for - registered user - multi role mapping - no login role-sync
-        """  # noqa
-        self.app.config["AUTH_ROLES_MAPPING"] = {"GROUP_1": ["Admin", "User"]}
-        self.app.config["AUTH_ROLES_SYNC_AT_LOGIN"] = False
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # add User role
-        sm.add_role("User")
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # register a user
-        new_user = sm.add_user(  # noqa
-            username="alice",
-            first_name="Alice",
-            last_name="Doe",
-            email="alice@example.com",
-            role=[],
-        )
-
-        # validate - user was registered
-        self.assertEqual(len(sm.get_all_users()), 1)
-
-        # attempt login
-        user = sm.auth_user_oauth(self.userinfo_alice)
-
-        # validate - user was allowed to log in
-        self.assertIsInstance(user, sm.user_model)
-
-        # validate - user was given no roles
-        self.assertListEqual(user.roles, [])
-
-    def test__registered__multi_role__with_role_sync(self):
-        """
-        OAUTH: test login flow for - registered user - multi role mapping - with login role-sync
-        """  # noqa
-        self.app.config["AUTH_ROLES_MAPPING"] = {"GROUP_1": ["Admin", "User"]}
-        self.app.config["AUTH_ROLES_SYNC_AT_LOGIN"] = True
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # add User role
-        sm.add_role("User")
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # register a user
-        new_user = sm.add_user(  # noqa
-            username="alice",
-            first_name="Alice",
-            last_name="Doe",
-            email="alice@example.com",
-            role=[],
-        )
-
-        # validate - user was registered
-        self.assertEqual(len(sm.get_all_users()), 1)
-
-        # attempt login
-        user = sm.auth_user_oauth(self.userinfo_alice)
-
-        # validate - user was allowed to log in
-        self.assertIsInstance(user, sm.user_model)
-
-        # validate - user was given the correct roles
-        self.assertListEqual(user.roles, [sm.find_role("Admin"), sm.find_role("User")])
-
-    def test__registered__jmespath_role__no_role_sync(self):
-        """
-        OAUTH: test login flow for - registered user - jmespath registration role - no login role-sync
-        """  # noqa
-        self.app.config["AUTH_ROLES_SYNC_AT_LOGIN"] = False
-        self.app.config["AUTH_USER_REGISTRATION"] = True
-        self.app.config[
-            "AUTH_USER_REGISTRATION_ROLE_JMESPATH"
-        ] = "contains(['alice'], username) && 'User' || 'Public'"
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # add User role
-        sm.add_role("User")
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # register a user
-        new_user = sm.add_user(  # noqa
-            username="alice",
-            first_name="Alice",
-            last_name="Doe",
-            email="alice@example.com",
-            role=[],
-        )
-
-        # validate - user was registered
-        self.assertEqual(len(sm.get_all_users()), 1)
-
-        # attempt login
-        user = sm.auth_user_oauth(self.userinfo_alice)
-
-        # validate - user was allowed to log in
-        self.assertIsInstance(user, sm.user_model)
-
-        # validate - user was given no roles
-        self.assertListEqual(user.roles, [])
-
-    def test__registered__jmespath_role__with_role_sync(self):
-        """
-        OAUTH: test login flow for - registered user - jmespath registration role - with login role-sync
-        """  # noqa
-        self.app.config["AUTH_ROLES_SYNC_AT_LOGIN"] = True
-        self.app.config["AUTH_USER_REGISTRATION"] = True
-        self.app.config[
-            "AUTH_USER_REGISTRATION_ROLE_JMESPATH"
-        ] = "contains(['alice'], username) && 'User' || 'Public'"
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-        sm = self.appbuilder.sm
-
-        # add User role
-        sm.add_role("User")
-
-        # validate - no users are registered
-        self.assertEqual(sm.get_all_users(), [])
-
-        # register a user
-        new_user = sm.add_user(  # noqa
-            username="alice",
-            first_name="Alice",
-            last_name="Doe",
-            email="alice@example.com",
-            role=[],
-        )
-
-        # validate - user was registered
-        self.assertEqual(len(sm.get_all_users()), 1)
-
-        # attempt login
-        user = sm.auth_user_oauth(self.userinfo_alice)
-
-        # validate - user was allowed to log in
-        self.assertIsInstance(user, sm.user_model)
-
-        # validate - user was given the correct roles
-        self.assertListEqual(user.roles, [sm.find_role("User")])

flask_appbuilder/tests/_test_ldapsearch.py

@@ -1,135 +0,0 @@
-import logging
-import unittest
-
-from flask import Flask
-from flask_appbuilder import AppBuilder, SQLA
-import jinja2
-import ldap
-from mockldap import MockLdap
-
-
-logging.basicConfig(format="%(asctime)s:%(levelname)s:%(name)s:%(message)s")
-logging.getLogger().setLevel(logging.DEBUG)
-log = logging.getLogger(__name__)
-
-
-class LDAPSearchTestCase(unittest.TestCase):
-
-    top = ("o=test", {"o": ["test"]})
-    example = ("ou=example,o=test", {"ou": ["example"]})
-    manager = (
-        "cn=manager,ou=example,o=test",
-        {"cn": ["manager"], "userPassword": ["ldaptest"]},
-    )
-    alice = (
-        "cn=alice,ou=example,o=test",
-        {
-            "cn": ["alice"],
-            "memberOf": ["cn=group,ou=groups,o=test"],
-            "userPassword": ["alicepw"],
-        },
-    )
-    group = (
-        "cn=group,ou=groups,o=test",
-        {"cn": ["group"], "member": ["cn=alice,ou=example,o=test"]},
-    )
-
-    directory = dict([top, example, group, manager, alice])
-
-    @classmethod
-    def setUpClass(cls):
-        # We only need to create the MockLdap instance once. The content we
-        # pass in will be used for all LDAP connections.
-        cls.mockldap = MockLdap(cls.directory)
-
-    @classmethod
-    def tearDownClass(cls):
-        del cls.mockldap
-
-    def setUp(self):
-
-        self.mockldap.start()
-        self.ldapobj = self.mockldap["ldap://localhost/"]
-
-        self.app = Flask(__name__)
-        self.app.jinja_env.undefined = jinja2.StrictUndefined
-        self.db = SQLA(self.app)
-
-        self.app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
-        self.app.config["AUTH_LDAP_UID_FIELD"] = "cn"
-        self.app.config["AUTH_LDAP_ALLOW_SELF_SIGNED"] = False
-        self.app.config["AUTH_LDAP_USE_TLS"] = False
-        self.app.config["AUTH_LDAP_SERVER"] = "ldap://localhost/"
-        self.app.config["AUTH_LDAP_SEARCH"] = "ou=example,o=test"
-        self.app.config["AUTH_LDAP_APPEND_DOMAIN"] = False
-        self.app.config["AUTH_LDAP_FIRSTNAME_FIELD"] = None
-        self.app.config["AUTH_LDAP_LASTNAME_FIELD"] = None
-        self.app.config["AUTH_LDAP_EMAIL_FIELD"] = None
-
-    def tearDown(self):
-        self.mockldap.stop()
-        del self.ldapobj
-        log.debug("TEAR DOWN")
-
-        self.appbuilder = None
-        self.app = None
-        self.db = None
-
-    def test_ldapsearch(self):
-        con = ldap.initialize("ldap://localhost/")
-        con.simple_bind_s("cn=manager,ou=example,o=test", "ldaptest")
-
-        self.app.config["AUTH_LDAP_SEARCH_FILTER"] = ""
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-
-        initialize_call = ("initialize", ("ldap://localhost/",), {})
-        simple_bind_s_call = (
-            "simple_bind_s",
-            ("cn=manager,ou=example,o=test", "ldaptest"),
-            {},
-        )
-        search_s_call = (
-            "search_s",
-            ("ou=example,o=test", 2, "(cn=alice)", [None, None, None]),
-            {},
-        )
-
-        user = self.appbuilder.sm._search_ldap(ldap, con, "alice")
-        self.assertEqual(
-            self.ldapobj.methods_called(with_args=True),
-            [initialize_call, simple_bind_s_call, search_s_call],
-        )
-        self.assertEqual(user[0][0], self.alice[0])
-
-    def test_ldapsearchfilter(self):
-        con = ldap.initialize("ldap://localhost/")
-        con.simple_bind_s("cn=manager,ou=example,o=test", "ldaptest")
-
-        self.app.config[
-            "AUTH_LDAP_SEARCH_FILTER"
-        ] = "(memberOf=cn=group,ou=groups,o=test)"
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-
-        initialize_call = ("initialize", ("ldap://localhost/",), {})
-        simple_bind_s_call = (
-            "simple_bind_s",
-            ("cn=manager,ou=example,o=test", "ldaptest"),
-            {},
-        )
-        search_s_call = (
-            "search_s",
-            (
-                "ou=example,o=test",
-                2,
-                "(&(memberOf=cn=group,ou=groups,o=test)(cn=alice))",
-                [None, None, None],
-            ),
-            {},
-        )
-
-        user = self.appbuilder.sm._search_ldap(ldap, con, "alice")
-        self.assertEqual(
-            self.ldapobj.methods_called(with_args=True),
-            [initialize_call, simple_bind_s_call, search_s_call],
-        )
-        self.assertEqual(user[0][0], self.alice[0])

flask_appbuilder/tests/_test_oauth_registration_role.py

@@ -1,59 +0,0 @@
-import logging
-import unittest
-
-from flask import Flask
-from flask_appbuilder import AppBuilder, SQLA
-
-
-logging.basicConfig(format="%(asctime)s:%(levelname)s:%(name)s:%(message)s")
-logging.getLogger().setLevel(logging.DEBUG)
-log = logging.getLogger(__name__)
-
-
-class OAuthRegistrationRoleTestCase(unittest.TestCase):
-    def setUp(self):
-        self.app = Flask(__name__)
-        self.app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
-        self.db = SQLA(self.app)
-
-    def tearDown(self):
-        self.appbuilder = None
-        self.app = None
-        self.db = None
-
-    def test_self_registration_not_enabled(self):
-        self.app.config["AUTH_USER_REGISTRATION"] = False
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-
-        result = self.appbuilder.sm.auth_user_oauth(userinfo={"username": "testuser"})
-
-        self.assertIsNone(result)
-        self.assertEqual(len(self.appbuilder.sm.get_all_users()), 0)
-
-    def test_register_and_attach_static_role(self):
-        self.app.config["AUTH_USER_REGISTRATION"] = True
-        self.app.config["AUTH_USER_REGISTRATION_ROLE"] = "Public"
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-
-        user = self.appbuilder.sm.auth_user_oauth(userinfo={"username": "testuser"})
-
-        self.assertEqual(user.roles[0].name, "Public")
-
-    def test_register_and_attach_dynamic_role(self):
-        self.app.config["AUTH_USER_REGISTRATION"] = True
-        self.app.config[
-            "AUTH_USER_REGISTRATION_ROLE_JMESPATH"
-        ] = "contains(['alice', 'celine'], username) && 'Admin' || 'Public'"
-        self.appbuilder = AppBuilder(self.app, self.db.session)
-
-        # Role for admin
-        user = self.appbuilder.sm.auth_user_oauth(
-            userinfo={"username": "alice", "email": "alice@example.com"}
-        )
-        self.assertEqual(user.roles[0].name, "Admin")
-
-        # Role for non-admin
-        user = self.appbuilder.sm.auth_user_oauth(
-            userinfo={"username": "bob", "email": "bob@example.com"}
-        )
-        self.assertEqual(user.roles[0].name, "Public")

flask_appbuilder/tests/base.py

@@ -1,90 +0,0 @@
-import json
-import unittest
-
-from flask_appbuilder.const import (
-    API_SECURITY_PASSWORD_KEY,
-    API_SECURITY_PROVIDER_KEY,
-    API_SECURITY_USERNAME_KEY,
-    API_SECURITY_VERSION,
-)
-
-
-class FABTestCase(unittest.TestCase):
-    @staticmethod
-    def auth_client_get(client, token, uri):
-        return client.get(uri, headers={"Authorization": "Bearer {}".format(token)})
-
-    @staticmethod
-    def auth_client_delete(client, token, uri):
-        return client.delete(uri, headers={"Authorization": "Bearer {}".format(token)})
-
-    @staticmethod
-    def auth_client_put(client, token, uri, json):
-        return client.put(
-            uri, json=json, headers={"Authorization": "Bearer {}".format(token)}
-        )
-
-    @staticmethod
-    def auth_client_post(client, token, uri, json):
-        return client.post(
-            uri, json=json, headers={"Authorization": "Bearer {}".format(token)}
-        )
-
-    @staticmethod
-    def _login(client, username, password):
-        """
-            Login help method
-        :param client: Flask test client
-        :param username: username
-        :param password: password
-        :return: Flask client response class
-        """
-        return client.post(
-            "api/{}/security/login".format(API_SECURITY_VERSION),
-            data=json.dumps(
-                {
-                    API_SECURITY_USERNAME_KEY: username,
-                    API_SECURITY_PASSWORD_KEY: password,
-                    API_SECURITY_PROVIDER_KEY: "db",
-                }
-            ),
-            content_type="application/json",
-        )
-
-    def login(self, client, username, password):
-        # Login with default admin
-        rv = self._login(client, username, password)
-        try:
-            return json.loads(rv.data.decode("utf-8")).get("access_token")
-        except Exception:
-            return rv
-
-    def browser_login(self, client, username, password):
-        # Login with default admin
-        return client.post(
-            "/login/",
-            data=dict(username=username, password=password),
-            follow_redirects=True,
-        )
-
-    @staticmethod
-    def browser_logout(client):
-        return client.get("/logout/")
-
-    def create_admin_user(self, appbuilder, username, password):
-        self.create_user(appbuilder, username, password, "Admin")
-
-    @staticmethod
-    def create_user(
-        appbuilder,
-        username,
-        password,
-        role_name,
-        first_name="admin",
-        last_name="user",
-        email="admin@fab.org",
-    ):
-        role_admin = appbuilder.sm.find_role(role_name)
-        appbuilder.sm.add_user(
-            username, first_name, last_name, email, role_admin, password
-        )