tests: reorganize tests to something more sane

ziggurat_foundations/tests/__init__.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+from __future__ import with_statement, unicode_literals
+
+from ziggurat_foundations.tests.conftest import (
+    User, Group, UserGroup, GroupPermission, UserPermission,
+    UserResourcePermission, GroupResourcePermission, Resource,
+    ExternalIdentity, TestResource, TestResourceB)
+
+
+def check_one_in_other(first, second):
+    while first:
+        item = first.pop()
+        ix = second.index(item)
+        second.pop(ix)
+    assert len(first) == len(second)
+
+
+def add_user(db_session, user_name='username', email='email',
+             perms=['root', 'alter_users']):
+    user = User(user_name=user_name, email=email, status=0)
+    user.set_password('password')
+    for perm in perms:
+        u_perm = UserPermission(perm_name=perm)
+        user.user_permissions.append(u_perm)
+    db_session.add(user)
+    db_session.flush()
+    return user
+
+
+def add_resource(db_session, resource_id, resource_name='test_resource'):
+    Resource.__possible_permissions__ = [
+        'test_perm', 'test_perm1',
+        'test_perm2', 'foo_perm',
+        'group_perm', 'group_perm2']
+    resource = TestResource(resource_id=resource_id,
+                            resource_name=resource_name)
+    db_session.add(resource)
+    db_session.flush()
+    return resource
+
+
+def add_resource_b(db_session, resource_id, resource_name='test_resource'):
+    Resource.__possible_permissions__ = ['test_perm', 'test_perm1',
+                                         'test_perm2', 'foo_perm',
+                                         'group_perm', 'group_perm2']
+    resource = TestResourceB(resource_id=resource_id,
+                             resource_name=resource_name)
+    db_session.add(resource)
+    db_session.flush()
+    return resource
+
+
+def add_group(db_session, group_name='group', description='desc'):
+    group = Group(
+        group_name=group_name,
+        description=description
+    )
+    test_perm = GroupPermission(perm_name='manage_apps')
+    group.permissions.append(test_perm)
+    db_session.add(group)
+    db_session.flush()
+    return group
+
+
+class BaseTestCase(object):
+    def set_up_user_group_and_perms(self, db_session):
+        """
+        perm map:
+
+        username:
+            first_user : root, alter_users
+            res_perms: r1:g1:foo_perm, r1:g1:test_perm2
+
+        foouser:
+            user_perms : custom
+            res_perms: r2:foo_perm
+
+        baruser:
+            user_perms : root, alter_users
+            res_perms: r2:test_perm
+
+        bazuser:
+            user_perms : root, alter_users
+            res_perms: r1:g2:group_perm
+
+        """
+        created_user = add_user(db_session, user_name="first_user")
+        created_user2 = add_user(db_session, user_name='foouser',
+                                 email='new_email',
+                                 perms=['custom'])
+        created_user3 = add_user(db_session,
+                                 user_name='baruser', email='new_email2')
+        created_user4 = add_user(db_session,
+                                 user_name='bazuser', email='new_email3')
+        resource = add_resource(db_session, 1, 'test_resource')
+        resource2 = add_resource_b(db_session, 2, 'other_resource')
+        group = add_group(db_session, )
+        group2 = add_group(db_session, group_name='group2')
+        group.users.append(created_user)
+        group2.users.append(created_user4)
+        group_permission = GroupResourcePermission(
+            perm_name='group_perm',
+            group_id=group.id,
+        )
+        group_permission2 = GroupResourcePermission(
+            perm_name='group_perm',
+            group_id=group2.id,
+        )
+        user_permission = UserResourcePermission(
+            perm_name='test_perm2',
+            user_id=created_user.id,
+        )
+        user_permission2 = UserResourcePermission(
+            perm_name='foo_perm',
+            user_id=created_user.id,
+        )
+        user2_permission = UserResourcePermission(
+            perm_name='foo_perm',
+            user_id=created_user2.id,
+        )
+        user3_permission = UserResourcePermission(
+            perm_name='test_perm',
+            user_id=created_user3.id,
+        )
+        resource.group_permissions.append(group_permission)
+        resource.group_permissions.append(group_permission2)
+        resource.user_permissions.append(user_permission)
+        resource.user_permissions.append(user_permission2)
+        resource2.user_permissions.append(user2_permission)
+        resource2.user_permissions.append(user3_permission)
+        db_session.flush()
+        self.resource = resource
+        self.resource2 = resource2
+        self.user = created_user
+        self.user2 = created_user2
+        self.user3 = created_user3
+        self.user4 = created_user4
+        self.group = group
+        self.group2 = group2
+
+
+class DummyUserObj(object):
+    def __init__(self):
+        self.user_name = 'new_name'
+        self.user_password = 'foo'
+        self.email = 'change@email.com'

ziggurat_foundations/tests/conftest.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, unicode_literals
+
+import os
+import pytest
+
+from alembic.config import Config
+from alembic import command
+
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+
+from ziggurat_foundations import ziggurat_model_init
+from ziggurat_foundations.models.user import UserMixin
+from ziggurat_foundations.models.group import GroupMixin
+from ziggurat_foundations.models.group_permission import GroupPermissionMixin
+from ziggurat_foundations.models.user_permission import UserPermissionMixin
+from ziggurat_foundations.models.user_group import UserGroupMixin
+from ziggurat_foundations.models.user_resource_permission import UserResourcePermissionMixin
+from ziggurat_foundations.models.group_resource_permission import GroupResourcePermissionMixin
+from ziggurat_foundations.models.resource import ResourceMixin
+from ziggurat_foundations.models.external_identity import ExternalIdentityMixin
+
+
+Base = declarative_base()
+
+class Group(GroupMixin, Base):
+    __possible_permissions__ = ('root_administration',
+                                'administration',
+                                'backend_admin_panel',
+                                'manage_apps',)
+
+
+class GroupPermission(GroupPermissionMixin, Base):
+    pass
+
+
+class UserGroup(UserGroupMixin, Base):
+    pass
+
+
+class GroupResourcePermission(GroupResourcePermissionMixin, Base):
+    pass
+
+
+class Resource(ResourceMixin, Base):
+    def __acl__(self):
+        acls = []
+
+        if self.owner_user_id:
+            acls.extend([(Allow, self.owner_user_id, ALL_PERMISSIONS,), ])
+
+        if self.owner_group_id:
+            acls.extend([(Allow, "group:%s" % self.owner_group_id,
+                          ALL_PERMISSIONS,), ])
+        return acls
+
+
+class TestResource(Resource):
+    __mapper_args__ = {'polymorphic_identity': 'test_resource'}
+
+
+class TestResourceB(Resource):
+    __mapper_args__ = {'polymorphic_identity': 'test_resource_b'}
+
+
+class UserPermission(UserPermissionMixin, Base):
+    pass
+
+
+class UserResourcePermission(UserResourcePermissionMixin, Base):
+    pass
+
+
+class ExternalIdentity(ExternalIdentityMixin, Base):
+    pass
+
+
+class User(UserMixin, Base):
+    __possible_permissions__ = ['root', 'alter_users', 'custom1']
+
+
+ziggurat_model_init(User, Group, UserGroup, GroupPermission, UserPermission,
+                    UserResourcePermission, GroupResourcePermission, Resource,
+                    ExternalIdentity)
+
+
+
+@pytest.fixture
+def db_session(request):
+    sql_str = os.environ.get("DB_STRING", 'sqlite://', )
+    engine = create_engine(sql_str)
+    # pyramid way
+    maker = sessionmaker(bind=engine)
+    Base.metadata.bind = engine
+    Base.metadata.drop_all(engine)
+    engine.execute(
+        'DROP TABLE IF EXISTS alembic_ziggurat_foundations_version')
+    if sql_str.startswith('sqlite'):
+        # sqlite will not work with alembic
+        Base.metadata.create_all(engine)
+    else:
+        alembic_cfg = Config()
+        alembic_cfg.set_main_option('script_location',
+                                    'ziggurat_foundations:migrations')
+        alembic_cfg.set_main_option('sqlalchemy.url', sql_str)
+        command.upgrade(alembic_cfg, "head")
+
+    session = maker()
+
+    def teardown():
+        session.rollback()
+        session.close()
+
+    request.addfinalizer(teardown)
+
+    return session