コード例 #1
0
def test_group_subscribe(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, SubscriptionPolicy, \
            Membership, MembershipState
        from invenio_accounts.models import User

        g_o = Group.create(name="test_open",
                           subscription_policy=SubscriptionPolicy.OPEN)
        g_a = Group.create(name="test_approval",
                           subscription_policy=SubscriptionPolicy.APPROVAL)
        g_c = Group.create(name="test_closed",
                           subscription_policy=SubscriptionPolicy.CLOSED)
        u = User(email="test", password="******")
        db.session.add(u)
        db.session.commit()

        m_o = g_o.subscribe(u)
        m_c = g_c.subscribe(u)
        m_a = g_a.subscribe(u)

        assert m_c is None
        assert m_a.state == MembershipState.PENDING_ADMIN
        assert m_o.state == MembershipState.ACTIVE
        assert Membership.query.count() == 2
コード例 #2
0
def test_membership_query_requests(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership, \
            MembershipState
        from invenio_accounts.models import User
        from flask.ext.sqlalchemy import BaseQuery

        a = User(email="*****@*****.**", password="******")
        u1 = User(email="*****@*****.**", password="******")
        u2 = User(email="[email protected]", password="******")
        db.session.add_all([a, u1, u2])
        db.session.commit()
        g = Group.create(name="test", admins=[a])
        Membership.create(g, u1, MembershipState.PENDING_ADMIN)
        Membership.create(g, u2, MembershipState.PENDING_USER)

        assert isinstance(Membership.query_requests(u1), BaseQuery)
        assert Membership.query_requests(a).count() == 1

        ad = Group.create(name="admin")
        g2 = Group.create(name="test2", admins=[ad])
        u3 = User(email="[email protected]", password="******")
        u4 = User(email="[email protected]", password="******")
        u5 = User(email="[email protected]", password="******")
        db.session.add_all([u3, u4, u5])
        db.session.commit()
        Membership.create(ad, u3, MembershipState.ACTIVE)
        Membership.create(g2, u4, MembershipState.PENDING_ADMIN)
        Membership.create(g2, u5, MembershipState.PENDING_USER)

        assert Membership.query_requests(u3).count() == 1
コード例 #3
0
def test_group_creation_existing_name(app):
    """Test what happens if group with identical name is created."""
    with app.app_context():
        from invenio_groups.models import Group

        g = Group.create(name="test", )
        with pytest.raises(IntegrityError):
            Group.create(name="test", admins=[g])
コード例 #4
0
def test_group_search(example_group):
    """Test group search function."""
    app = example_group
    with app.app_context():
        group = app.get_group()
        assert group == Group.search(Group.query, 'test_group').one()
        assert group == Group.search(Group.query, '_group').one()
        assert group == Group.search(Group.query, '_group').one()
        assert group == Group.search(Group.query, 'st_gro').one()
コード例 #5
0
def test_group_update_duplicated_names(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group

        g = Group.create(name="test")
        Group.create(name="test-change")
        assert Group.query.count() == 2
        with pytest.raises(IntegrityError):
            g.update(name="test-change")
コード例 #6
0
def test_group_query_by_user(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership, \
            GroupAdmin, MembershipState
        from invenio_accounts.models import User

        u1 = User(email="[email protected]", password="******")
        u2 = User(email="[email protected]", password="******")
        u3 = User(email="[email protected]", password="******")
        db.session.add(u1)
        db.session.add(u2)
        db.session.add(u3)
        db.session.commit()
        g1 = Group.create(name="test1", admins=[u1])
        g2 = Group.create(name="test2", admins=[u1])

        g1.add_member(u2, state=MembershipState.PENDING_ADMIN)
        g1.add_member(u3, state=MembershipState.ACTIVE)
        g2.add_member(u2, state=MembershipState.ACTIVE)

        assert Group.query.count() == 2
        assert GroupAdmin.query.count() == 2
        assert Membership.query.count() == 3
        assert Group.query_by_user(u1).count() == 2
        assert Group.query_by_user(u1, with_pending=True).count() == 2
        assert Group.query_by_user(u2).count() == 1
        assert Group.query_by_user(u2, with_pending=True).count() == 2
        assert Group.query_by_user(u3).count() == 1
        assert Group.query_by_user(u3, with_pending=True).count() == 1
        assert 1 == Group.query_by_user(
            u3, with_pending=True, eager=[Group.members]).count()
コード例 #7
0
def test_group_admin_query_by_admin(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, GroupAdmin
        from flask.ext.sqlalchemy import BaseQuery

        a = Group.create(name="admin")
        g = Group.create(name="test", admins=[a])

        assert isinstance(GroupAdmin.query_by_admin(a), BaseQuery)
        assert GroupAdmin.query_by_admin(a).count() == 1
        assert GroupAdmin.query_by_admin(g).count() == 0
コード例 #8
0
def test_group_admin_create(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, GroupAdmin
        a = Group.create(name="admin")
        g = Group.create(name="test")

        ga = GroupAdmin.create(g, a)

        assert ga.admin_type == 'Group'
        assert ga.admin_id == a.id
        assert ga.group.id == g.id
        assert GroupAdmin.query.count() == 1
コード例 #9
0
def test_group_add_admin(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, GroupAdmin

        a = Group.create(name="admin")
        g = Group.create(name="test")

        obj = g.add_admin(a)

        assert isinstance(obj, GroupAdmin)
        assert GroupAdmin.query.count() == 1
        with pytest.raises(IntegrityError):
            g.add_admin(a)
コード例 #10
0
def test_group_admin_query_admins_by_group_ids(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, GroupAdmin
        from sqlalchemy.orm.query import Query

        a = Group.create(name="admin")
        g = Group.create(name="test", admins=[a])

        assert isinstance(GroupAdmin.query_admins_by_group_ids([g.id]), Query)
        assert 1 == GroupAdmin.query_admins_by_group_ids([g.id]).count()
        assert 0 == GroupAdmin.query_admins_by_group_ids([a.id]).count()
        with pytest.raises(AssertionError):
            GroupAdmin.query_admins_by_group_ids('invalid')
コード例 #11
0
def test_group_remove_admin(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, GroupAdmin

        a = Group.create(name="admin")
        g = Group.create(name="test", admins=[a])

        assert GroupAdmin.query.count() == 1

        g.remove_admin(a)

        assert GroupAdmin.query.count() == 0
        with pytest.raises(NoResultFound):
            g.remove_admin(a)
コード例 #12
0
def example_group(app):
    """Create example groups."""
    with app.app_context():
        admin = User(email='*****@*****.**', password='******')
        member = User(email='*****@*****.**', password='******')
        non_member = User(email='*****@*****.**', password='******')
        db.session.add(admin)
        db.session.add(member)
        db.session.add(non_member)
        group = Group.create(name='test_group', admins=[admin])
        membership = group.invite(member)
        membership.accept()

        admin_id = admin.id
        member_id = member.id
        non_member_id = non_member.id
        group_id = group.id
        db.session.commit()

    app.get_admin = lambda: User.query.get(admin_id)
    app.get_member = lambda: User.query.get(member_id)
    app.get_non_member = lambda: User.query.get(non_member_id)
    app.get_group = lambda: Group.query.get(group_id)

    return app
コード例 #13
0
def test_invite_by_emails(app):
    """Test inviting users by email."""
    with app.app_context():

        u1 = User(email='*****@*****.**', password='******')
        u2 = User(email='*****@*****.**', password='******')
        g = Group.create(name='test_group')

        db.session.add(u1)
        db.session.add(u2)
        db.session.commit()

        result = g.invite_by_emails(
            [
                u1.email,
                u2.email,
                '*****@*****.**'
            ]
        )

        assert result[0].state is MembershipState.PENDING_USER
        assert result[1].state is MembershipState.PENDING_USER
        assert result[2] is None

        assert g.is_member(u1, with_pending=True)
        assert g.is_member(u2, with_pending=True)
        assert not g.is_member('*****@*****.**', with_pending=True)
コード例 #14
0
def test_group_is_admin(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group
        from invenio_accounts.models import User

        g = Group.create(name="test")
        u = User(email="test", password="******")
        db.session.add(u)
        db.session.commit()

        g.add_admin(u)

        assert g.is_admin(u)

        a = Group.create(name="admin")
        g = Group.create(name="test2", admins=[a])
        assert g.is_admin(a)
コード例 #15
0
def test_membership_query_by_group(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership, \
            MembershipState
        from invenio_accounts.models import User
        from flask.ext.sqlalchemy import BaseQuery

        g = Group.create(name="test")
        Group.create(name="test2")
        u = User(email="*****@*****.**", password="******")
        u2 = User(email="[email protected]", password="******")
        db.session.add(u)
        db.session.add(u2)
        db.session.commit()

        Membership.create(g, u, MembershipState.ACTIVE)
        assert isinstance(Membership.query_by_group(g), BaseQuery)
        assert 1 == Membership.query_by_group(g).count()
        assert 0 == Membership.query_by_user(u2).count()
コード例 #16
0
def test_group_creation_signals(app):
    """Test signals sent after creation."""
    with app.app_context():
        from invenio_groups.models import Group

        Group.called = False

        @event.listens_for(Group, 'after_insert')
        def _receiver(mapper, connection, target):
            Group.called = True
            assert isinstance(target, Group)
            assert target.name == 'signaltest'

        Group.create(name="signaltest")
        assert Group.called

        Group.called = False
        with pytest.raises(IntegrityError):
            Group.create(name="signaltest")
        assert not Group.called

        event.remove(Group, 'after_insert', _receiver)
コード例 #17
0
def test_group_creation(app):
    """Test creation of groups."""
    with app.app_context():
        from invenio_groups.models import Group, \
            GroupAdmin, Membership, SubscriptionPolicy, PrivacyPolicy

        g = Group.create(name="test")
        assert g.name == 'test'
        assert g.description == ''
        assert g.subscription_policy == SubscriptionPolicy.CLOSED
        assert g.privacy_policy == PrivacyPolicy.ADMINS
        assert not g.is_managed
        assert g.created
        assert g.modified
        assert GroupAdmin.query.count() == 0
        assert Membership.query.count() == 0

        g2 = Group.create(
            name="admintest",
            description="desc",
            subscription_policy=SubscriptionPolicy.OPEN,
            privacy_policy=PrivacyPolicy.PUBLIC,
            is_managed=True,
            admins=[g]
        )
        assert g2.name == 'admintest'
        assert g2.description == 'desc'
        assert g2.subscription_policy == SubscriptionPolicy.OPEN
        assert g2.privacy_policy == PrivacyPolicy.PUBLIC
        assert g2.is_managed
        assert g2.created
        assert g2.modified
        assert GroupAdmin.query.count() == 1
        admin = g2.admins[0]
        assert admin.admin_type == 'Group'
        assert admin.admin_id == g.id
        assert Membership.query.count() == 0
コード例 #18
0
def test_group_delete(app):
    """Test deletion of a group."""
    with app.app_context():
        from invenio_groups.models import Group, GroupAdmin, Membership
        from invenio_accounts.models import User

        g1 = Group.create(name="test1")
        g2 = Group.create(name="test2", admins=[g1])
        u = User(email="*****@*****.**", password="******")
        db.session.add(u)
        db.session.commit()

        g2.add_member(u)

        # Group is admin of another group, which will be left without admins
        g1.delete()
        assert Group.query.count() == 1
        assert GroupAdmin.query.count() == 0
        assert Membership.query.count() == 1

        g2.delete()
        assert Group.query.count() == 0
        assert GroupAdmin.query.count() == 0
        assert Membership.query.count() == 0
コード例 #19
0
def test_membership_reject(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership
        from invenio_accounts.models import User

        g = Group.create(name="test")
        u = User(email="*****@*****.**", password="******")
        db.session.add(u)
        db.session.commit()

        m = Membership.create(g, u)
        m.reject()

        assert Membership.query.count() == 0
コード例 #20
0
def test_group_invite(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership, \
            MembershipState
        from invenio_accounts.models import User

        g = Group.create(name="test")
        u = User(email="*****@*****.**", password="******")
        u2 = User(email="*****@*****.**", password="******")
        db.session.add(u)
        db.session.add(u2)
        db.session.commit()

        m = g.invite(u)
        assert Membership.query.count() == 1
        assert m.state == MembershipState.PENDING_USER

        a = Group.create(name="admin")
        g2 = Group.create(name="test2", admins=[a])
        assert g2.invite(u2, admin=g) is None
        m = g2.invite(u2, admin=a)
        assert Membership.query.count() == 2
        assert m.state == MembershipState.PENDING_USER
コード例 #21
0
def test_group_get_by_name(app):
    """Test get by name."""
    with app.app_context():
        from invenio_groups.models import Group

        Group.create(name="test1")
        Group.create(name="test2")

        assert Group.get_by_name("test1").name == "test1"
        assert Group.get_by_name("invalid") is None
コード例 #22
0
def test_membership_accept(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership, \
            MembershipState
        from invenio_accounts.models import User

        g = Group.create(name="test")
        u = User(email="*****@*****.**", password="******")
        db.session.add(u)
        db.session.commit()

        m = Membership.create(g, u, MembershipState.PENDING_ADMIN)
        m.accept()

        assert m.state == MembershipState.ACTIVE
        assert m.is_active()
コード例 #23
0
def test_group_creation_invalid_data(app):
    """Test what happens if group with invalid data is created."""
    with app.app_context():
        from invenio_groups.models import Group

        with pytest.raises(AssertionError):
            Group.create(name="")
        with pytest.raises(AssertionError):
            Group.create(name="test", privacy_policy='invalid')
        with pytest.raises(AssertionError):
            Group.create(name="test", subscription_policy='invalid')
        assert Group.query.count() == 0
コード例 #24
0
def test_membership_create(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership, \
            MembershipState
        from invenio_accounts.models import User

        g = Group.create(name="test")
        u = User(email="*****@*****.**", password="******")
        db.session.add(u)
        db.session.commit()

        m = Membership.create(g, u)
        assert m.state == MembershipState.ACTIVE
        assert m.group.name == g.name
        assert m.user.id == u.id
        with pytest.raises(FlushError):
            Membership.create(g, u)
コード例 #25
0
def test_group_add_member(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership
        from invenio_accounts.models import User

        g = Group.create(name="test1")
        u = User(email="*****@*****.**", password="******")
        db.session.add(u)
        db.session.commit()

        obj = g.add_member(u)

        assert isinstance(obj, Membership)
        assert Group.query.count() == 1
        assert Membership.query.count() == 1
        with pytest.raises(FlushError):
            g.add_member(u)
コード例 #26
0
def test_group_remove_member(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership
        from invenio_accounts.models import User

        g = Group.create(name="test1")
        u = User(email="*****@*****.**", password="******")
        db.session.add(u)
        db.session.commit()

        g.add_member(u)

        assert Membership.query.count() == 1

        g.remove_member(u)

        assert Membership.query.count() == 0
        assert g.remove_member(u) is None
コード例 #27
0
def test_membership_get(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership
        from invenio_accounts.models import User

        g = Group.create(name="test")
        u = User(email="*****@*****.**", password="******")
        u2 = User(email="[email protected]", password="******")
        db.session.add(u)
        db.session.add(u2)
        db.session.commit()

        Membership.create(g, u)
        m = Membership.get(g, u)
        m2 = Membership.get(g, u2)

        assert m.group.id == g.id
        assert m.user.id == u.id
        assert m2 is None
コード例 #28
0
def test_membership_query_invitations(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, Membership, \
            MembershipState
        from invenio_accounts.models import User
        from flask.ext.sqlalchemy import BaseQuery

        g = Group.create(name="test")
        u1 = User(email="*****@*****.**", password="******")
        u2 = User(email="[email protected]", password="******")
        u3 = User(email="[email protected]", password="******")
        db.session.add_all([u1, u2, u3])
        db.session.commit()
        Membership.create(g, u1, MembershipState.ACTIVE)
        Membership.create(g, u2, MembershipState.PENDING_USER)
        Membership.create(g, u3, MembershipState.PENDING_ADMIN)

        assert isinstance(Membership.query_by_user(u1), BaseQuery)
        assert Membership.query_invitations(u1).count() == 0
        assert Membership.query_invitations(u2).count() == 1
        assert Membership.query_invitations(u3).count() == 0
コード例 #29
0
def test_group_update(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group, SubscriptionPolicy, \
            PrivacyPolicy

        g = Group.create(name="test")
        m = g.modified
        g.update(
            name="test-change",
            description="changed",
            subscription_policy=SubscriptionPolicy.OPEN,
            privacy_policy=PrivacyPolicy.MEMBERS,
            is_managed=True,
        )

        assert g.name == 'test-change'
        assert g.description == 'changed'
        assert g.subscription_policy == SubscriptionPolicy.OPEN
        assert g.privacy_policy == PrivacyPolicy.MEMBERS
        assert g.is_managed
        assert m is not g.modified
        assert g.created
コード例 #30
0
def test_group_is_member(app):
    """."""
    with app.app_context():
        from invenio_groups.models import Group
        from invenio_accounts.models import User

        g = Group.create(name='test_group')
        u = User(email='*****@*****.**', password='******')
        u2 = User(email='*****@*****.**', password='******')
        u3 = User(email='*****@*****.**', password='******')
        db.session.add(u)
        db.session.add(u2)
        db.session.add(u3)
        db.session.commit()

        g.add_member(u)
        g.add_member(u2, state=MembershipState.PENDING_USER)
        g.add_member(u3, state=MembershipState.PENDING_ADMIN)

        assert g.is_member(u)
        assert not g.is_member(u2)
        assert g.is_member(u2, with_pending=True)
        assert not g.is_member(u3)
        assert g.is_member(u3, with_pending=True)