Beispiel #1
0
def test_users_model_api_database():
    sys.path.insert(0, os.getcwd() + "/examples/user/database-model")
    try:
        from authkit.users.sqlalchemy_driver import UsersFromDatabase
    except ImportError:
        raise Exception("Could not run the SQLAlchemy tests, not installed")
    if os.path.exists("test.db"):
        os.remove("test.db")
    import model as test_model

    # Setup SQLAlchemy database engine
    from sqlalchemy import engine_from_config

    engine = engine_from_config({"sqlalchemy.url": "sqlite:///test.db"}, "sqlalchemy.")
    test_model.init_model(engine)
    test_model.engine = engine

    d = UsersFromDatabase(test_model)

    test_model.meta.metadata.create_all(test_model.engine)

    d.role_create("wiki")
    d.role_create("adMin")
    d.role_create("editor")
    d.group_create("pyLOns")
    d.group_create("dJAngo")
    d.user_create("jaMEs", "passWOrd1", "pyLoNs")
    d.user_create("ben", "password2")
    d.user_create("Simon", "password3")
    d.user_create("ian", "paSsword4")
    assertEqual(d.list_roles(), ["admin", "editor", "wiki"])
    assertEqual(d.list_groups(), ["django", "pylons"])
    assertEqual(d.list_users(), ["ben", "ian", "james", "simon"])
    assertEqual(d.user_has_password("james", "passWOrd1"), True)
    assertEqual(d.user_has_password("james", "password1"), False)

    d.role_create("test_role")
    d.group_create("test_group")
    d.user_create("test_user", "password")
    assertEqual(d.list_roles(), ["admin", "editor", "test_role", "wiki"])
    assertEqual(d.list_groups(), ["django", "pylons", "test_group"])
    assertEqual(d.list_users(), ["ben", "ian", "james", "simon", "test_user"])
    d.role_delete("test_role")
    d.group_delete("test_group")
    d.user_delete("test_user")
    assertEqual(d.list_roles(), ["admin", "editor", "wiki"])
    assertEqual(d.list_groups(), ["django", "pylons"])
    assertEqual(d.list_users(), ["ben", "ian", "james", "simon"])

    assertEqual(d.user_has_role("james", "admin"), False)
    d.user_add_role("james", "admin")
    assertEqual(d.user_has_role("james", "admin"), True)
    d.user_remove_role("james", "admin")
    assertEqual(d.user_has_role("james", "admin"), False)

    d.user_add_role("james", "wiki")
    d.user_add_role("simon", "wiki")
    d.user_add_role("james", "admin")
    # d.user_add_role("james", "editor")
    d.user_add_role("ben", "editor")

    assertEqual(d.user_has_group("james", "pylons"), True)
    assertEqual(d.user_has_group("simon", None), True)
    assertEqual(d.user_has_group("simon", "django"), False)
    d.user_set_group("simon", "dJangO")
    assertEqual(d.user_has_group("simon", None), False)
    d.user_set_group("bEn", "PyLONS")
    assertEqual(d.user_has_group("simon", "django"), True)
    assertEqual(d.user_has_group("bEn", "pYlons"), True)
    d.user_remove_group("bEn")
    assertEqual(d.user_has_group("bEn", "pYlons"), False)
    d.user_set_group("bEn", "PyLONS")
    assertEqual(d.user_has_group("bEn", "pYlons"), True)

    assertEqual(d.list_users(), ["ben", "ian", "james", "simon"])
    d.user_set_username("james", "jim")
    assertEqual(d.list_users(), ["ben", "ian", "jim", "simon"])
    d.user_set_username("jim", "james")

    from authkit.users import (
        UsersFromFile,
        UsersFromString,
        AuthKitNoSuchUserError,
        AuthKitNoSuchGroupError,
        AuthKitNoSuchRoleError,
    )

    string_data = """jaMEs:passWOrd1:pyLOns wiki adMin
    ben:password2:pylons admin editor
    simon:password3:dJAngo
    ian:paSsword4 wiki
    """
    filename = "test/user_file_data.txt"

    s = UsersFromString(string_data)
    f = UsersFromFile(filename)

    # Test Parsing
    assertAllEqual(
        s.passwords, f.passwords, {"james": "passWOrd1", "ben": "password2", "simon": "password3", "ian": "paSsword4"}
    )
    assertAllEqual(
        s.roles, f.roles, {"james": ["admin", "wiki"], "ben": ["admin", "editor"], "ian": ["wiki"], "simon": []}
    )
    assertAllEqual(s.groups, f.groups, {"james": "pylons", "ben": "pylons", "ian": None, "simon": "django"})
    assertAllEqual(s.usernames, f.usernames, ["ben", "ian", "james", "simon"])

    # Test list functions
    assertAllEqual(s.list_users(), f.list_users(), d.list_users(), ["ben", "ian", "james", "simon"])
    assertAllEqual(s.list_roles(), f.list_roles(), d.list_roles(), ["admin", "editor", "wiki"])
    assertAllEqual(s.list_groups(), f.list_groups(), d.list_groups(), ["django", "pylons"])

    # Test user has functions
    assertAllEqual(
        s.user_has_role("jAMes", "WiKi"), f.user_has_role("jAMes", "WiKi"), d.user_has_role("jAMes", "WiKi"), True
    )
    assertAllEqual(
        s.user_has_role("jAMes", "editOr"),
        f.user_has_role("jAMes", "editOr"),
        d.user_has_role("jAMes", "editOr"),
        False,
    )

    assertAllEqual(
        s.user_has_group("jAMeS", "PyLons"),
        f.user_has_group("jAMes", "pylOns"),
        d.user_has_group("jAMes", "pylOns"),
        True,
    )
    assertAllEqual(
        s.user_has_group("jameS", "djaNgo"),
        f.user_has_group("JAMes", "djAngo"),
        d.user_has_group("JAMes", "djAngo"),
        False,
    )

    assertAllEqual(
        s.user_has_password("jAMeS", "passWOrd1"),
        f.user_has_password("jAMes", "passWOrd1"),
        d.user_has_password("jAMes", "passWOrd1"),
        True,
    )
    assertAllEqual(
        s.user_has_password("jameS", "PASSWORD1"),
        f.user_has_password("JAMes", "PASSWORD1"),
        d.user_has_password("JAMes", "PASSWORD1"),
        False,
    )

    # Existence Methods
    assertAllEqual(s.user_exists("jAMeS"), f.user_exists("jAMes"), d.user_exists("jAMes"), True)
    assertAllEqual(s.user_exists("nobody"), f.user_exists("nobody"), d.user_exists("nobody"), False)

    # Existence Methods
    assertAllEqual(s.role_exists("wiKi"), f.role_exists("Wiki"), d.role_exists("Wiki"), True)
    assertAllEqual(s.role_exists("norole"), f.role_exists("norole"), d.role_exists("norole"), False)

    assertAllEqual(s.group_exists("pyLons"), f.group_exists("PYlons"), d.group_exists("PYlons"), True)
    assertAllEqual(s.group_exists("nogroup"), f.group_exists("nogroup"), d.group_exists("nogroup"), False)

    # User Methods

    assertAllEqual(
        s.user("James"),
        f.user("James"),
        d.user("James"),
        {"username": "******", "group": "pylons", "password": "******", "roles": ["admin", "wiki"]},
    )

    # Test all user methods raise:
    for plugin in [s, f, d]:
        for func in ["user", "user_roles", "user_group", "user_password"]:
            try:
                getattr(plugin, func)("nouser")
            except AuthKitNoSuchUserError, e:
                pass
            else:
                raise AssertionError("Failed to throw a no user error")
Beispiel #2
0
def test_users_api_database():
    try:
        from authkit.users.sqlalchemy_04_driver import UsersFromDatabase, setup_model
    except ImportError:
        raise Exception("Could not run the SQLAlchemy tests, not installed")
    try:
        from sqlalchemymanager import SQLAlchemyManager
    except ImportError:
        raise Exception("Could not run the SQLAlchemy tests, SQLAlchemyManager is not installed")
    if os.path.exists("mydb.db"):
        os.remove("mydb.db")

    app = SQLAlchemyManager(None, {"sqlalchemy.url": "sqlite:///mydb.db"}, [setup_model])
    app.create_all()
    connection = app.engine.connect()
    session = app.session_maker(bind=connection)
    try:
        environ = {}
        environ["sqlalchemy.session"] = session
        environ["sqlalchemy.model"] = app.model
        d = UsersFromDatabase(environ)
        d.role_create("wiki")
        d.role_create("adMin")
        d.role_create("editor")
        d.group_create("pyLOns")
        d.group_create("dJAngo")
        d.user_create("jaMEs", "passWOrd1", "pyLoNs")
        d.user_create("ben", "password2")
        d.user_create("Simon", "password3")
        d.user_create("ian", "paSsword4")
        assertEqual(d.list_roles(), ["admin", "editor", "wiki"])
        assertEqual(d.list_groups(), ["django", "pylons"])
        assertEqual(d.list_users(), ["ben", "ian", "james", "simon"])
        assertEqual(d.user_has_password("james", "passWOrd1"), True)
        assertEqual(d.user_has_password("james", "password1"), False)

        d.role_create("test_role")
        d.group_create("test_group")
        d.user_create("test_user", "password")
        assertEqual(d.list_roles(), ["admin", "editor", "test_role", "wiki"])
        assertEqual(d.list_groups(), ["django", "pylons", "test_group"])
        assertEqual(d.list_users(), ["ben", "ian", "james", "simon", "test_user"])
        d.role_delete("test_role")
        d.group_delete("test_group")
        d.user_delete("test_user")
        assertEqual(d.list_roles(), ["admin", "editor", "wiki"])
        assertEqual(d.list_groups(), ["django", "pylons"])
        assertEqual(d.list_users(), ["ben", "ian", "james", "simon"])

        assertEqual(d.user_has_role("james", "admin"), False)
        d.user_add_role("james", "admin")
        assertEqual(d.user_has_role("james", "admin"), True)
        d.user_remove_role("james", "admin")
        assertEqual(d.user_has_role("james", "admin"), False)

        d.user_add_role("james", "wiki")
        d.user_add_role("simon", "wiki")
        d.user_add_role("james", "admin")
        # d.user_add_role("james", "editor")
        d.user_add_role("ben", "editor")

        assertEqual(d.user_has_group("james", "pylons"), True)
        assertEqual(d.user_has_group("simon", None), True)
        assertEqual(d.user_has_group("simon", "django"), False)
        d.user_set_group("simon", "dJangO")
        assertEqual(d.user_has_group("simon", None), False)
        d.user_set_group("bEn", "PyLONS")
        assertEqual(d.user_has_group("simon", "django"), True)
        assertEqual(d.user_has_group("bEn", "pYlons"), True)
        d.user_remove_group("bEn")
        assertEqual(d.user_has_group("bEn", "pYlons"), False)
        d.user_set_group("bEn", "PyLONS")
        assertEqual(d.user_has_group("bEn", "pYlons"), True)

        assertEqual(d.list_users(), ["ben", "ian", "james", "simon"])
        d.user_set_username("james", "jim")
        assertEqual(d.list_users(), ["ben", "ian", "jim", "simon"])
        d.user_set_username("jim", "james")

        from authkit.users import (
            UsersFromFile,
            UsersFromString,
            AuthKitNoSuchUserError,
            AuthKitNoSuchGroupError,
            AuthKitNoSuchRoleError,
        )

        string_data = """jaMEs:passWOrd1:pyLOns wiki adMin
        ben:password2:pylons admin editor
        simon:password3:dJAngo
        ian:paSsword4 wiki
        """
        filename = "test/user_file_data.txt"

        s = UsersFromString(string_data)
        f = UsersFromFile(filename)

        # Test Parsing
        assertAllEqual(
            s.passwords,
            f.passwords,
            {"james": "passWOrd1", "ben": "password2", "simon": "password3", "ian": "paSsword4"},
        )
        assertAllEqual(
            s.roles, f.roles, {"james": ["admin", "wiki"], "ben": ["admin", "editor"], "ian": ["wiki"], "simon": []}
        )
        assertAllEqual(s.groups, f.groups, {"james": "pylons", "ben": "pylons", "ian": None, "simon": "django"})
        assertAllEqual(s.usernames, f.usernames, ["ben", "ian", "james", "simon"])

        # Test list functions
        assertAllEqual(s.list_users(), f.list_users(), d.list_users(), ["ben", "ian", "james", "simon"])
        assertAllEqual(s.list_roles(), f.list_roles(), d.list_roles(), ["admin", "editor", "wiki"])
        assertAllEqual(s.list_groups(), f.list_groups(), d.list_groups(), ["django", "pylons"])

        # Test user has functions
        assertAllEqual(
            s.user_has_role("jAMes", "WiKi"), f.user_has_role("jAMes", "WiKi"), d.user_has_role("jAMes", "WiKi"), True
        )
        assertAllEqual(
            s.user_has_role("jAMes", "editOr"),
            f.user_has_role("jAMes", "editOr"),
            d.user_has_role("jAMes", "editOr"),
            False,
        )

        assertAllEqual(
            s.user_has_group("jAMeS", "PyLons"),
            f.user_has_group("jAMes", "pylOns"),
            d.user_has_group("jAMes", "pylOns"),
            True,
        )
        assertAllEqual(
            s.user_has_group("jameS", "djaNgo"),
            f.user_has_group("JAMes", "djAngo"),
            d.user_has_group("JAMes", "djAngo"),
            False,
        )

        assertAllEqual(
            s.user_has_password("jAMeS", "passWOrd1"),
            f.user_has_password("jAMes", "passWOrd1"),
            d.user_has_password("jAMes", "passWOrd1"),
            True,
        )
        assertAllEqual(
            s.user_has_password("jameS", "PASSWORD1"),
            f.user_has_password("JAMes", "PASSWORD1"),
            d.user_has_password("JAMes", "PASSWORD1"),
            False,
        )

        # Existence Methods
        assertAllEqual(s.user_exists("jAMeS"), f.user_exists("jAMes"), d.user_exists("jAMes"), True)
        assertAllEqual(s.user_exists("nobody"), f.user_exists("nobody"), d.user_exists("nobody"), False)

        # Existence Methods
        assertAllEqual(s.role_exists("wiKi"), f.role_exists("Wiki"), d.role_exists("Wiki"), True)
        assertAllEqual(s.role_exists("norole"), f.role_exists("norole"), d.role_exists("norole"), False)

        assertAllEqual(s.group_exists("pyLons"), f.group_exists("PYlons"), d.group_exists("PYlons"), True)
        assertAllEqual(s.group_exists("nogroup"), f.group_exists("nogroup"), d.group_exists("nogroup"), False)

        # User Methods

        assertAllEqual(
            s.user("James"),
            f.user("James"),
            d.user("James"),
            {"username": "******", "group": "pylons", "password": "******", "roles": ["admin", "wiki"]},
        )

        # Test all user methods raise:
        for plugin in [s, f, d]:
            for func in ["user", "user_roles", "user_group", "user_password"]:
                try:
                    getattr(plugin, func)("nouser")
                except AuthKitNoSuchUserError, e:
                    pass
                else:
                    raise AssertionError("Failed to throw a no user error")
        for plugin in [s, f, d]:
            for func in ["user_has_password", "user_has_role", "user_has_group"]:
                try:
                    getattr(plugin, func)("nouser", "somevar")
                except AuthKitNoSuchUserError, e:
                    pass
                else:
                    raise AssertionError("Failed to throw a no user error")
Beispiel #3
0
def test_users_model_api_database():
    sys.path.insert(0, os.getcwd()+'/examples/user/database-model')
    try: 
        from authkit.users.sqlalchemy_driver import UsersFromDatabase
    except ImportError:
        raise Exception("Could not run the SQLAlchemy tests, not installed")
    if os.path.exists("test.db"):
        os.remove("test.db")
    import model as test_model

    # Setup SQLAlchemy database engine
    from sqlalchemy import engine_from_config
    engine = engine_from_config({'sqlalchemy.url':'sqlite:///test.db'}, 'sqlalchemy.')
    test_model.init_model(engine)
    test_model.engine = engine
 
    d = UsersFromDatabase(test_model)
    
    test_model.meta.metadata.create_all(test_model.engine)
    
    d.role_create("wiki")
    d.role_create("adMin")
    d.role_create("editor")
    d.group_create("pyLOns")
    d.group_create("dJAngo")
    d.user_create("jaMEs", "passWOrd1", "pyLoNs")
    d.user_create("ben", "password2")
    d.user_create("Simon", "password3")
    d.user_create("ian", "paSsword4")
    assertEqual(d.list_roles(),["admin", "editor", "wiki"])
    assertEqual(d.list_groups(),["django", "pylons"])
    assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
    assertEqual(d.user_has_password("james", "passWOrd1"), True)
    assertEqual(d.user_has_password("james", "password1"), False)
    
    d.role_create("test_role")
    d.group_create("test_group")
    d.user_create("test_user", "password")
    assertEqual(d.list_roles(),["admin", "editor", "test_role", "wiki"])
    assertEqual(d.list_groups(),["django", "pylons", "test_group"])
    assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon', "test_user"])
    d.role_delete("test_role")
    d.group_delete("test_group")
    d.user_delete("test_user")
    assertEqual(d.list_roles(),["admin", "editor", "wiki"])
    assertEqual(d.list_groups(),["django", "pylons"])
    assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])

    assertEqual(d.user_has_role("james", "admin"), False)
    d.user_add_role("james", "admin")
    assertEqual(d.user_has_role("james", "admin"), True)
    d.user_remove_role("james", "admin")
    assertEqual(d.user_has_role("james", "admin"), False)

    d.user_add_role("james", "wiki")
    d.user_add_role("simon", "wiki")
    d.user_add_role("james", "admin")
    #d.user_add_role("james", "editor")
    d.user_add_role("ben", "editor")
    
    assertEqual(d.user_has_group("james", "pylons"), True)
    assertEqual(d.user_has_group("simon", None), True)
    assertEqual(d.user_has_group("simon", "django"), False)
    d.user_set_group("simon", "dJangO")
    assertEqual(d.user_has_group("simon", None), False)
    d.user_set_group("bEn", "PyLONS")
    assertEqual(d.user_has_group("simon", "django"), True)
    assertEqual(d.user_has_group("bEn", "pYlons"), True)
    d.user_remove_group("bEn")
    assertEqual(d.user_has_group("bEn", "pYlons"), False)
    d.user_set_group("bEn", "PyLONS")
    assertEqual(d.user_has_group("bEn", "pYlons"), True)
    
    assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
    d.user_set_username("james", "jim")
    assertEqual(d.list_users(),['ben', 'ian', 'jim', 'simon'])
    d.user_set_username("jim", "james")
    
    from authkit.users import UsersFromFile, UsersFromString, AuthKitNoSuchUserError, AuthKitNoSuchGroupError,AuthKitNoSuchRoleError
    string_data = """jaMEs:passWOrd1:pyLOns wiki adMin
    ben:password2:pylons admin editor
    simon:password3:dJAngo
    ian:paSsword4 wiki
    """
    filename = 'test/user_file_data.txt'
    
    s = UsersFromString(string_data)
    f = UsersFromFile(filename)

    # Test Parsing
    assertAllEqual(
        s.passwords,
        f.passwords,
        {
            'james':'passWOrd1',
            'ben':'password2',
            'simon':'password3',
            'ian':'paSsword4',
        },
    )
    assertAllEqual(
        s.roles, 
        f.roles,
        {
            'james':['admin', 'wiki'],
            'ben':['admin','editor'],
            'ian':['wiki'],
            'simon':[],
        },
    )
    assertAllEqual(
        s.groups, 
        f.groups,
        {
            'james':'pylons',
            'ben':'pylons',
            'ian': None,
            'simon':'django',
        },
    )
    assertAllEqual(
        s.usernames, 
        f.usernames,
        ['ben', 'ian', 'james', 'simon'],
    )

    # Test list functions
    assertAllEqual(
        s.list_users(),
        f.list_users(),
        d.list_users(),
        ['ben', 'ian', 'james', 'simon'],
    )
    assertAllEqual(
        s.list_roles(), 
        f.list_roles(),
        d.list_roles(),
        ['admin', 'editor', 'wiki'],
    )
    assertAllEqual(
        s.list_groups(), 
        f.list_groups(),
        d.list_groups(),
        ['django','pylons'],
    )

    # Test user has functions
    assertAllEqual(
        s.user_has_role('jAMes','WiKi'), 
        f.user_has_role('jAMes','WiKi'), 
        d.user_has_role('jAMes','WiKi'), 
        True
    )
    assertAllEqual(
        s.user_has_role('jAMes','editOr'), 
        f.user_has_role('jAMes','editOr'), 
        d.user_has_role('jAMes','editOr'), 
        False
    )
    
    assertAllEqual(
        s.user_has_group('jAMeS','PyLons'), 
        f.user_has_group('jAMes','pylOns'), 
        d.user_has_group('jAMes','pylOns'), 
        True
    )
    assertAllEqual(
        s.user_has_group('jameS','djaNgo'), 
        f.user_has_group('JAMes','djAngo'), 
        d.user_has_group('JAMes','djAngo'), 
        False
    )

    assertAllEqual(
        s.user_has_password('jAMeS','passWOrd1'), 
        f.user_has_password('jAMes','passWOrd1'), 
        d.user_has_password('jAMes','passWOrd1'), 
        True
    )
    assertAllEqual(
        s.user_has_password('jameS','PASSWORD1'), 
        f.user_has_password('JAMes','PASSWORD1'), 
        d.user_has_password('JAMes','PASSWORD1'), 
        False
    )

    # Existence Methods
    assertAllEqual(
        s.user_exists('jAMeS'), 
        f.user_exists('jAMes'), 
        d.user_exists('jAMes'), 
        True
    )
    assertAllEqual(
        s.user_exists('nobody'), 
        f.user_exists('nobody'), 
        d.user_exists('nobody'), 
        False
    )
    
    # Existence Methods
    assertAllEqual(
        s.role_exists('wiKi'), 
        f.role_exists('Wiki'), 
        d.role_exists('Wiki'), 
        True
    )
    assertAllEqual(
        s.role_exists('norole'), 
        f.role_exists('norole'), 
        d.role_exists('norole'), 
        False
    )
    
    assertAllEqual(
        s.group_exists('pyLons'), 
        f.group_exists('PYlons'), 
        d.group_exists('PYlons'), 
        True
    )
    assertAllEqual(
        s.group_exists('nogroup'), 
        f.group_exists('nogroup'), 
        d.group_exists('nogroup'), 
        False
    )


    # User Methods
    
    assertAllEqual(
        s.user('James'), 
        f.user('James'),
        d.user('James'),
        {
            'username': '******',
            'group':    'pylons',
            'password': '******',
            'roles':    ['admin','wiki'],
        }
    )
    
    # Test all user methods raise:
    for plugin in [s,f,d]:
        for func in [
            'user',
            'user_roles',
            'user_group',
            'user_password',
        ]:
            try:
                getattr(plugin, func)('nouser')
            except AuthKitNoSuchUserError, e:
                pass
            else:
                raise AssertionError("Failed to throw a no user error")
Beispiel #4
0
def test_users_api_database():
    try: 
        from authkit.users.sqlalchemy_04_driver import UsersFromDatabase, setup_model
    except ImportError:
        raise Exception("Could not run the SQLAlchemy tests, not installed")
    try: 
        from sqlalchemymanager import SQLAlchemyManager
    except ImportError:
        raise Exception("Could not run the SQLAlchemy tests, SQLAlchemyManager is not installed")
    if os.path.exists("mydb.db"):
        os.remove("mydb.db")

    app = SQLAlchemyManager(
        None, 
        {'sqlalchemy.url':'sqlite:///mydb.db'}, 
        [setup_model]
    )
    app.create_all()
    connection = app.engine.connect()
    session = app.session_maker(bind=connection)
    try:
        environ = {}
        environ['sqlalchemy.session'] = session
        environ['sqlalchemy.model'] = app.model
        d = UsersFromDatabase(environ)
        d.role_create("wiki")
        d.role_create("adMin")
        d.role_create("editor")
        d.group_create("pyLOns")
        d.group_create("dJAngo")
        d.user_create("jaMEs", "passWOrd1", "pyLoNs")
        d.user_create("ben", "password2")
        d.user_create("Simon", "password3")
        d.user_create("ian", "paSsword4")
        assertEqual(d.list_roles(),["admin", "editor", "wiki"])
        assertEqual(d.list_groups(),["django", "pylons"])
        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
        assertEqual(d.user_has_password("james", "passWOrd1"), True)
        assertEqual(d.user_has_password("james", "password1"), False)
        
        d.role_create("test_role")
        d.group_create("test_group")
        d.user_create("test_user", "password")
        assertEqual(d.list_roles(),["admin", "editor", "test_role", "wiki"])
        assertEqual(d.list_groups(),["django", "pylons", "test_group"])
        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon', "test_user"])
        d.role_delete("test_role")
        d.group_delete("test_group")
        d.user_delete("test_user")
        assertEqual(d.list_roles(),["admin", "editor", "wiki"])
        assertEqual(d.list_groups(),["django", "pylons"])
        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
    
        assertEqual(d.user_has_role("james", "admin"), False)
        d.user_add_role("james", "admin")
        assertEqual(d.user_has_role("james", "admin"), True)
        d.user_remove_role("james", "admin")
        assertEqual(d.user_has_role("james", "admin"), False)
    
        d.user_add_role("james", "wiki")
        d.user_add_role("simon", "wiki")
        d.user_add_role("james", "admin")
        #d.user_add_role("james", "editor")
        d.user_add_role("ben", "editor")
        
        assertEqual(d.user_has_group("james", "pylons"), True)
        assertEqual(d.user_has_group("simon", None), True)
        assertEqual(d.user_has_group("simon", "django"), False)
        d.user_set_group("simon", "dJangO")
        assertEqual(d.user_has_group("simon", None), False)
        d.user_set_group("bEn", "PyLONS")
        assertEqual(d.user_has_group("simon", "django"), True)
        assertEqual(d.user_has_group("bEn", "pYlons"), True)
        d.user_remove_group("bEn")
        assertEqual(d.user_has_group("bEn", "pYlons"), False)
        d.user_set_group("bEn", "PyLONS")
        assertEqual(d.user_has_group("bEn", "pYlons"), True)
        
        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
        d.user_set_username("james", "jim")
        assertEqual(d.list_users(),['ben', 'ian', 'jim', 'simon'])
        d.user_set_username("jim", "james")
        
        from authkit.users import UsersFromFile, UsersFromString, AuthKitNoSuchUserError, AuthKitNoSuchGroupError,AuthKitNoSuchRoleError
        string_data = """jaMEs:passWOrd1:pyLOns wiki adMin
        ben:password2:pylons admin editor
        simon:password3:dJAngo
        ian:paSsword4 wiki
        """
        filename = 'test/user_file_data.txt'
        
        s = UsersFromString(string_data)
        f = UsersFromFile(filename)
    
        # Test Parsing
        assertAllEqual(
            s.passwords,
            f.passwords,
            {
                'james':'passWOrd1',
                'ben':'password2',
                'simon':'password3',
                'ian':'paSsword4',
            },
        )
        assertAllEqual(
            s.roles, 
            f.roles,
            {
                'james':['admin', 'wiki'],
                'ben':['admin','editor'],
                'ian':['wiki'],
                'simon':[],
            },
        )
        assertAllEqual(
            s.groups, 
            f.groups,
            {
                'james':'pylons',
                'ben':'pylons',
                'ian': None,
                'simon':'django',
            },
        )
        assertAllEqual(
            s.usernames, 
            f.usernames,
            ['ben', 'ian', 'james', 'simon'],
        )
    
        # Test list functions
        assertAllEqual(
            s.list_users(),
            f.list_users(),
            d.list_users(),
            ['ben', 'ian', 'james', 'simon'],
        )
        assertAllEqual(
            s.list_roles(), 
            f.list_roles(),
            d.list_roles(),
            ['admin', 'editor', 'wiki'],
        )
        assertAllEqual(
            s.list_groups(), 
            f.list_groups(),
            d.list_groups(),
            ['django','pylons'],
        )
    
        # Test user has functions
        assertAllEqual(
            s.user_has_role('jAMes','WiKi'), 
            f.user_has_role('jAMes','WiKi'), 
            d.user_has_role('jAMes','WiKi'), 
            True
        )
        assertAllEqual(
            s.user_has_role('jAMes','editOr'), 
            f.user_has_role('jAMes','editOr'), 
            d.user_has_role('jAMes','editOr'), 
            False
        )
        
        assertAllEqual(
            s.user_has_group('jAMeS','PyLons'), 
            f.user_has_group('jAMes','pylOns'), 
            d.user_has_group('jAMes','pylOns'), 
            True
        )
        assertAllEqual(
            s.user_has_group('jameS','djaNgo'), 
            f.user_has_group('JAMes','djAngo'), 
            d.user_has_group('JAMes','djAngo'), 
            False
        )
    
        assertAllEqual(
            s.user_has_password('jAMeS','passWOrd1'), 
            f.user_has_password('jAMes','passWOrd1'), 
            d.user_has_password('jAMes','passWOrd1'), 
            True
        )
        assertAllEqual(
            s.user_has_password('jameS','PASSWORD1'), 
            f.user_has_password('JAMes','PASSWORD1'), 
            d.user_has_password('JAMes','PASSWORD1'), 
            False
        )
    
        # Existence Methods
        assertAllEqual(
            s.user_exists('jAMeS'), 
            f.user_exists('jAMes'), 
            d.user_exists('jAMes'), 
            True
        )
        assertAllEqual(
            s.user_exists('nobody'), 
            f.user_exists('nobody'), 
            d.user_exists('nobody'), 
            False
        )
        
        # Existence Methods
        assertAllEqual(
            s.role_exists('wiKi'), 
            f.role_exists('Wiki'), 
            d.role_exists('Wiki'), 
            True
        )
        assertAllEqual(
            s.role_exists('norole'), 
            f.role_exists('norole'), 
            d.role_exists('norole'), 
            False
        )
        
        assertAllEqual(
            s.group_exists('pyLons'), 
            f.group_exists('PYlons'), 
            d.group_exists('PYlons'), 
            True
        )
        assertAllEqual(
            s.group_exists('nogroup'), 
            f.group_exists('nogroup'), 
            d.group_exists('nogroup'), 
            False
        )
    
    
        # User Methods
        
        assertAllEqual(
            s.user('James'), 
            f.user('James'),
            d.user('James'),
            {
                'username': '******',
                'group':    'pylons',
                'password': '******',
                'roles':    ['admin','wiki'],
            }
        )
        
        # Test all user methods raise:
        for plugin in [s,f,d]:
            for func in [
                'user',
                'user_roles',
                'user_group',
                'user_password',
            ]:
                try:
                    getattr(plugin, func)('nouser')
                except AuthKitNoSuchUserError, e:
                    pass
                else:
                    raise AssertionError("Failed to throw a no user error")
        for plugin in [s,f,d]:
            for func in [
                'user_has_password',
                'user_has_role',
                'user_has_group',
            ]:
                try:
                    getattr(plugin, func)('nouser','somevar')
                except AuthKitNoSuchUserError, e:
                    pass
                else:
                    raise AssertionError("Failed to throw a no user error")
Beispiel #5
0
def test_users_model_api_database():
    sys.path.insert(0, os.getcwd()+'/examples/user/database-model')
    try: 
        from authkit.users.sqlalchemy_driver import UsersFromDatabase
    except ImportError:
        raise Exception("Could not run the SQLAlchemy tests, not installed")
    if os.path.exists("test.db"):
        os.remove("test.db")
    import model as test_model

    # Setup SQLAlchemy database engine
    from sqlalchemy import engine_from_config
    engine = engine_from_config({'sqlalchemy.url':'sqlite:///test.db'}, 'sqlalchemy.')
    test_model.init_model(engine)
    test_model.engine = engine
 
    d = UsersFromDatabase(test_model)
    
    test_model.meta.metadata.create_all(test_model.engine)
    
    d.role_create("wiki")
    d.role_create("adMin")
    d.role_create("editor")
    d.group_create("pyLOns")
    d.group_create("dJAngo")
    d.user_create("jaMEs", "passWOrd1", "pyLoNs")
    d.user_create("ben", "password2")
    d.user_create("Simon", "password3")
    d.user_create("ian", "paSsword4")
    assertEqual(d.list_roles(),["admin", "editor", "wiki"])
    assertEqual(d.list_groups(),["django", "pylons"])
    assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
    assertEqual(d.user_has_password("james", "passWOrd1"), True)
    assertEqual(d.user_has_password("james", "password1"), False)
    
    d.role_create("test_role")
    d.group_create("test_group")
    d.user_create("test_user", "password")
    assertEqual(d.list_roles(),["admin", "editor", "test_role", "wiki"])
    assertEqual(d.list_groups(),["django", "pylons", "test_group"])
    assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon', "test_user"])
    d.role_delete("test_role")
    d.group_delete("test_group")
    d.user_delete("test_user")
    assertEqual(d.list_roles(),["admin", "editor", "wiki"])
    assertEqual(d.list_groups(),["django", "pylons"])
    assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])

    assertEqual(d.user_has_role("james", "admin"), False)
    d.user_add_role("james", "admin")
    assertEqual(d.user_has_role("james", "admin"), True)
    d.user_remove_role("james", "admin")
    assertEqual(d.user_has_role("james", "admin"), False)

    d.user_add_role("james", "wiki")
    d.user_add_role("simon", "wiki")
    d.user_add_role("james", "admin")
    #d.user_add_role("james", "editor")
    d.user_add_role("ben", "editor")
    
    assertEqual(d.user_has_group("james", "pylons"), True)
    assertEqual(d.user_has_group("simon", None), True)
    assertEqual(d.user_has_group("simon", "django"), False)
    d.user_set_group("simon", "dJangO")
    assertEqual(d.user_has_group("simon", None), False)
    d.user_set_group("bEn", "PyLONS")
    assertEqual(d.user_has_group("simon", "django"), True)
    assertEqual(d.user_has_group("bEn", "pYlons"), True)
    d.user_remove_group("bEn")
    assertEqual(d.user_has_group("bEn", "pYlons"), False)
    d.user_set_group("bEn", "PyLONS")
    assertEqual(d.user_has_group("bEn", "pYlons"), True)
    
    assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
    d.user_set_username("james", "jim")
    assertEqual(d.list_users(),['ben', 'ian', 'jim', 'simon'])
    d.user_set_username("jim", "james")
    
    from authkit.users import UsersFromFile, UsersFromString, AuthKitNoSuchUserError, AuthKitNoSuchGroupError,AuthKitNoSuchRoleError
    string_data = """jaMEs:passWOrd1:pyLOns wiki adMin
    ben:password2:pylons admin editor
    simon:password3:dJAngo
    ian:paSsword4 wiki
    """
    filename = 'test/user_file_data.txt'
    
    s = UsersFromString(string_data)
    f = UsersFromFile(filename)

    # Test Parsing
    assertAllEqual(
        s.passwords,
        f.passwords,
        {
            'james':'passWOrd1',
            'ben':'password2',
            'simon':'password3',
            'ian':'paSsword4',
        },
    )
    assertAllEqual(
        s.roles, 
        f.roles,
        {
            'james':['admin', 'wiki'],
            'ben':['admin','editor'],
            'ian':['wiki'],
            'simon':[],
        },
    )
    assertAllEqual(
        s.groups, 
        f.groups,
        {
            'james':'pylons',
            'ben':'pylons',
            'ian': None,
            'simon':'django',
        },
    )
    assertAllEqual(
        s.usernames, 
        f.usernames,
        ['ben', 'ian', 'james', 'simon'],
    )

    # Test list functions
    assertAllEqual(
        s.list_users(),
        f.list_users(),
        d.list_users(),
        ['ben', 'ian', 'james', 'simon'],
    )
    assertAllEqual(
        s.list_roles(), 
        f.list_roles(),
        d.list_roles(),
        ['admin', 'editor', 'wiki'],
    )
    assertAllEqual(
        s.list_groups(), 
        f.list_groups(),
        d.list_groups(),
        ['django','pylons'],
    )

    # Test user has functions
    assertAllEqual(
        s.user_has_role('jAMes','WiKi'), 
        f.user_has_role('jAMes','WiKi'), 
        d.user_has_role('jAMes','WiKi'), 
        True
    )
    assertAllEqual(
        s.user_has_role('jAMes','editOr'), 
        f.user_has_role('jAMes','editOr'), 
        d.user_has_role('jAMes','editOr'), 
        False
    )
    
    assertAllEqual(
        s.user_has_group('jAMeS','PyLons'), 
        f.user_has_group('jAMes','pylOns'), 
        d.user_has_group('jAMes','pylOns'), 
        True
    )
    assertAllEqual(
        s.user_has_group('jameS','djaNgo'), 
        f.user_has_group('JAMes','djAngo'), 
        d.user_has_group('JAMes','djAngo'), 
        False
    )

    assertAllEqual(
        s.user_has_password('jAMeS','passWOrd1'), 
        f.user_has_password('jAMes','passWOrd1'), 
        d.user_has_password('jAMes','passWOrd1'), 
        True
    )
    assertAllEqual(
        s.user_has_password('jameS','PASSWORD1'), 
        f.user_has_password('JAMes','PASSWORD1'), 
        d.user_has_password('JAMes','PASSWORD1'), 
        False
    )

    # Existence Methods
    assertAllEqual(
        s.user_exists('jAMeS'), 
        f.user_exists('jAMes'), 
        d.user_exists('jAMes'), 
        True
    )
    assertAllEqual(
        s.user_exists('nobody'), 
        f.user_exists('nobody'), 
        d.user_exists('nobody'), 
        False
    )
    
    # Existence Methods
    assertAllEqual(
        s.role_exists('wiKi'), 
        f.role_exists('Wiki'), 
        d.role_exists('Wiki'), 
        True
    )
    assertAllEqual(
        s.role_exists('norole'), 
        f.role_exists('norole'), 
        d.role_exists('norole'), 
        False
    )
    
    assertAllEqual(
        s.group_exists('pyLons'), 
        f.group_exists('PYlons'), 
        d.group_exists('PYlons'), 
        True
    )
    assertAllEqual(
        s.group_exists('nogroup'), 
        f.group_exists('nogroup'), 
        d.group_exists('nogroup'), 
        False
    )


    # User Methods
    
    assertAllEqual(
        s.user('James'), 
        f.user('James'),
        d.user('James'),
        {
            'username': '******',
            'group':    'pylons',
            'password': '******',
            'roles':    ['admin','wiki'],
        }
    )
    
    # Test all user methods raise:
    for plugin in [s,f,d]:
        for func in [
            'user',
            'user_roles',
            'user_group',
            'user_password',
        ]:
            try:
                getattr(plugin, func)('nouser')
            except AuthKitNoSuchUserError, e:
                pass
            else:
                raise AssertionError("Failed to throw a no user error")
Beispiel #6
0
def test_users_api_database():
    try: 
        from authkit.users.sqlalchemy_04_driver import UsersFromDatabase, setup_model
    except ImportError:
        raise Exception("Could not run the SQLAlchemy tests, not installed")
    try: 
        from sqlalchemymanager import SQLAlchemyManager
    except ImportError:
        raise Exception("Could not run the SQLAlchemy tests, SQLAlchemyManager is not installed")
    if os.path.exists("mydb.db"):
        os.remove("mydb.db")

    app = SQLAlchemyManager(
        None, 
        {'sqlalchemy.url':'sqlite:///mydb.db'}, 
        [setup_model]
    )
    app.create_all()
    connection = app.engine.connect()
    session = app.session_maker(bind=connection)
    try:
        environ = {}
        environ['sqlalchemy.session'] = session
        environ['sqlalchemy.model'] = app.model
        d = UsersFromDatabase(environ)
        d.role_create("wiki")
        d.role_create("adMin")
        d.role_create("editor")
        d.group_create("pyLOns")
        d.group_create("dJAngo")
        d.user_create("jaMEs", "passWOrd1", "pyLoNs")
        d.user_create("ben", "password2")
        d.user_create("Simon", "password3")
        d.user_create("ian", "paSsword4")
        assertEqual(d.list_roles(),["admin", "editor", "wiki"])
        assertEqual(d.list_groups(),["django", "pylons"])
        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
        assertEqual(d.user_has_password("james", "passWOrd1"), True)
        assertEqual(d.user_has_password("james", "password1"), False)
        
        d.role_create("test_role")
        d.group_create("test_group")
        d.user_create("test_user", "password")
        assertEqual(d.list_roles(),["admin", "editor", "test_role", "wiki"])
        assertEqual(d.list_groups(),["django", "pylons", "test_group"])
        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon', "test_user"])
        d.role_delete("test_role")
        d.group_delete("test_group")
        d.user_delete("test_user")
        assertEqual(d.list_roles(),["admin", "editor", "wiki"])
        assertEqual(d.list_groups(),["django", "pylons"])
        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
    
        assertEqual(d.user_has_role("james", "admin"), False)
        d.user_add_role("james", "admin")
        assertEqual(d.user_has_role("james", "admin"), True)
        d.user_remove_role("james", "admin")
        assertEqual(d.user_has_role("james", "admin"), False)
    
        d.user_add_role("james", "wiki")
        d.user_add_role("simon", "wiki")
        d.user_add_role("james", "admin")
        #d.user_add_role("james", "editor")
        d.user_add_role("ben", "editor")
        
        assertEqual(d.user_has_group("james", "pylons"), True)
        assertEqual(d.user_has_group("simon", None), True)
        assertEqual(d.user_has_group("simon", "django"), False)
        d.user_set_group("simon", "dJangO")
        assertEqual(d.user_has_group("simon", None), False)
        d.user_set_group("bEn", "PyLONS")
        assertEqual(d.user_has_group("simon", "django"), True)
        assertEqual(d.user_has_group("bEn", "pYlons"), True)
        d.user_remove_group("bEn")
        assertEqual(d.user_has_group("bEn", "pYlons"), False)
        d.user_set_group("bEn", "PyLONS")
        assertEqual(d.user_has_group("bEn", "pYlons"), True)
        
        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
        d.user_set_username("james", "jim")
        assertEqual(d.list_users(),['ben', 'ian', 'jim', 'simon'])
        d.user_set_username("jim", "james")
        
        from authkit.users import UsersFromFile, UsersFromString, AuthKitNoSuchUserError, AuthKitNoSuchGroupError,AuthKitNoSuchRoleError
        string_data = """jaMEs:passWOrd1:pyLOns wiki adMin
        ben:password2:pylons admin editor
        simon:password3:dJAngo
        ian:paSsword4 wiki
        """
        filename = 'test/user_file_data.txt'
        
        s = UsersFromString(string_data)
        f = UsersFromFile(filename)
    
        # Test Parsing
        assertAllEqual(
            s.passwords,
            f.passwords,
            {
                'james':'passWOrd1',
                'ben':'password2',
                'simon':'password3',
                'ian':'paSsword4',
            },
        )
        assertAllEqual(
            s.roles, 
            f.roles,
            {
                'james':['admin', 'wiki'],
                'ben':['admin','editor'],
                'ian':['wiki'],
                'simon':[],
            },
        )
        assertAllEqual(
            s.groups, 
            f.groups,
            {
                'james':'pylons',
                'ben':'pylons',
                'ian': None,
                'simon':'django',
            },
        )
        assertAllEqual(
            s.usernames, 
            f.usernames,
            ['ben', 'ian', 'james', 'simon'],
        )
    
        # Test list functions
        assertAllEqual(
            s.list_users(),
            f.list_users(),
            d.list_users(),
            ['ben', 'ian', 'james', 'simon'],
        )
        assertAllEqual(
            s.list_roles(), 
            f.list_roles(),
            d.list_roles(),
            ['admin', 'editor', 'wiki'],
        )
        assertAllEqual(
            s.list_groups(), 
            f.list_groups(),
            d.list_groups(),
            ['django','pylons'],
        )
    
        # Test user has functions
        assertAllEqual(
            s.user_has_role('jAMes','WiKi'), 
            f.user_has_role('jAMes','WiKi'), 
            d.user_has_role('jAMes','WiKi'), 
            True
        )
        assertAllEqual(
            s.user_has_role('jAMes','editOr'), 
            f.user_has_role('jAMes','editOr'), 
            d.user_has_role('jAMes','editOr'), 
            False
        )
        
        assertAllEqual(
            s.user_has_group('jAMeS','PyLons'), 
            f.user_has_group('jAMes','pylOns'), 
            d.user_has_group('jAMes','pylOns'), 
            True
        )
        assertAllEqual(
            s.user_has_group('jameS','djaNgo'), 
            f.user_has_group('JAMes','djAngo'), 
            d.user_has_group('JAMes','djAngo'), 
            False
        )
    
        assertAllEqual(
            s.user_has_password('jAMeS','passWOrd1'), 
            f.user_has_password('jAMes','passWOrd1'), 
            d.user_has_password('jAMes','passWOrd1'), 
            True
        )
        assertAllEqual(
            s.user_has_password('jameS','PASSWORD1'), 
            f.user_has_password('JAMes','PASSWORD1'), 
            d.user_has_password('JAMes','PASSWORD1'), 
            False
        )
    
        # Existence Methods
        assertAllEqual(
            s.user_exists('jAMeS'), 
            f.user_exists('jAMes'), 
            d.user_exists('jAMes'), 
            True
        )
        assertAllEqual(
            s.user_exists('nobody'), 
            f.user_exists('nobody'), 
            d.user_exists('nobody'), 
            False
        )
        
        # Existence Methods
        assertAllEqual(
            s.role_exists('wiKi'), 
            f.role_exists('Wiki'), 
            d.role_exists('Wiki'), 
            True
        )
        assertAllEqual(
            s.role_exists('norole'), 
            f.role_exists('norole'), 
            d.role_exists('norole'), 
            False
        )
        
        assertAllEqual(
            s.group_exists('pyLons'), 
            f.group_exists('PYlons'), 
            d.group_exists('PYlons'), 
            True
        )
        assertAllEqual(
            s.group_exists('nogroup'), 
            f.group_exists('nogroup'), 
            d.group_exists('nogroup'), 
            False
        )
    
    
        # User Methods
        
        assertAllEqual(
            s.user('James'), 
            f.user('James'),
            d.user('James'),
            {
                'username': '******',
                'group':    'pylons',
                'password': '******',
                'roles':    ['admin','wiki'],
            }
        )
        
        # Test all user methods raise:
        for plugin in [s,f,d]:
            for func in [
                'user',
                'user_roles',
                'user_group',
                'user_password',
            ]:
                try:
                    getattr(plugin, func)('nouser')
                except AuthKitNoSuchUserError, e:
                    pass
                else:
                    raise AssertionError("Failed to throw a no user error")
        for plugin in [s,f,d]:
            for func in [
                'user_has_password',
                'user_has_role',
                'user_has_group',
            ]:
                try:
                    getattr(plugin, func)('nouser','somevar')
                except AuthKitNoSuchUserError, e:
                    pass
                else:
                    raise AssertionError("Failed to throw a no user error")