refactor: tests.

abilian/core/tests/test_permissions.py

@@ -5,59 +5,56 @@
 
 from abilian.core.entities import Entity
 from abilian.services import security
-from abilian.testing import BaseTestCase as AbilianTestCase
 
 
-class PermissionsTestCase(AbilianTestCase):
+def test_default_permissions(app, db, session):
 
-    def test_default_permissions(self):
-
-        class MyRestrictedType(Entity):
-            __default_permissions__ = {
-                security.READ: {security.Anonymous},
-                security.WRITE: {security.Owner},
-                security.CREATE: {security.Writer},
-                security.DELETE: {security.Owner},
-            }
-
-        assert isinstance(MyRestrictedType.__default_permissions__, frozenset)
-
-        expected = frozenset({
-            (security.READ, frozenset({security.Anonymous})),
-            #
-            (security.WRITE, frozenset({security.Owner})),
-            #
-            (security.CREATE, frozenset({security.Writer})),
-            #
-            (security.DELETE, frozenset({security.Owner})),
-        })
-        assert MyRestrictedType.__default_permissions__ == expected
-
-        self.app.db.create_all()  # create missing 'mytype' table
-
-        obj = MyRestrictedType(name='test object')
-        self.session.add(obj)
-        PA = security.PermissionAssignment
-        query = self.session.query(PA.role) \
-            .filter(PA.object == obj)
-
-        assert query.filter(PA.permission == security.READ).all() \
-            == [(security.Anonymous,)]
-
-        assert query.filter(PA.permission == security.WRITE).all() \
-            == [(security.Owner,)]
-
-        assert query.filter(PA.permission == security.DELETE).all() \
-            == [(security.Owner,)]
-
-        # special case:
-        assert query.filter(PA.permission == security.CREATE).all() \
-            == []
-
-        security_svc = self.app.services['security']
-        permissions = security_svc.get_permissions_assignments(obj)
-        assert permissions == {
+    class MyRestrictedType(Entity):
+        __default_permissions__ = {
             security.READ: {security.Anonymous},
             security.WRITE: {security.Owner},
+            security.CREATE: {security.Writer},
             security.DELETE: {security.Owner},
         }
+
+    assert isinstance(MyRestrictedType.__default_permissions__, frozenset)
+
+    expected = frozenset({
+        (security.READ, frozenset({security.Anonymous})),
+        #
+        (security.WRITE, frozenset({security.Owner})),
+        #
+        (security.CREATE, frozenset({security.Writer})),
+        #
+        (security.DELETE, frozenset({security.Owner})),
+    })
+    assert MyRestrictedType.__default_permissions__ == expected
+
+    db.create_all()  # create missing 'mytype' table
+
+    obj = MyRestrictedType(name='test object')
+    session.add(obj)
+    PA = security.PermissionAssignment
+    query = session.query(PA.role) \
+        .filter(PA.object == obj)
+
+    assert query.filter(PA.permission == security.READ).all() \
+        == [(security.Anonymous,)]
+
+    assert query.filter(PA.permission == security.WRITE).all() \
+        == [(security.Owner,)]
+
+    assert query.filter(PA.permission == security.DELETE).all() \
+        == [(security.Owner,)]
+
+    # special case:
+    assert query.filter(PA.permission == security.CREATE).all() \
+        == []
+
+    security_svc = app.services['security']
+    permissions = security_svc.get_permissions_assignments(obj)
+    assert permissions == {
+        security.READ: {security.Anonymous},
+        security.WRITE: {security.Owner},
+        security.DELETE: {security.Owner},
+    }

abilian/core/tests/test_sa_extensions.py

@@ -7,9 +7,7 @@
 from sqlalchemy import Column
 
 from abilian.core.entities import Entity
-from abilian.core.extensions import db
 from abilian.core.sqlalchemy import UUID, JSONDict, JSONList
-from abilian.testing import BaseTestCase
 
 
 class DummyModel2(Entity):
@@ -18,54 +16,54 @@ class DummyModel2(Entity):
     uuid = Column(UUID())
 
 
-class SAExtensionTestCase(BaseTestCase):
-
-    def test_list_attribute(self):
-        model = DummyModel2(list_attr=[1, 2, 3])
-        db.session.add(model)
-        db.session.commit()
-        model_id = model.id
-        db.session.remove()
-        model2 = DummyModel2.query.get(model_id)
-        assert model2.list_attr == [1, 2, 3]
-
-        model2.list_attr.append(4)
-        assert model2.list_attr == [1, 2, 3, 4]
-
-        del model2.list_attr[0]
-        assert model2.list_attr == [2, 3, 4]
-
-    def test_dict_attribute(self):
-        model = DummyModel2(dict_attr=dict(a=3, b=4))
-        db.session.add(model)
-        db.session.commit()
-        model_id = model.id
-        db.session.remove()
-        model2 = DummyModel2.query.get(model_id)
-        assert model2.dict_attr == dict(a=3, b=4)
-
-        model2.dict_attr['c'] = 5
-        assert model2.dict_attr == dict(a=3, b=4, c=5)
-
-    def test_uuid_attribute(self):
-        # uuid from string
-        model = DummyModel2(uuid='c5ad316a-2cd0-4f78-a49b-cff216c10713')
-        db.session.add(model)
-        db.session.commit()
-        model_id = model.id
-        db.session.remove()
-        model2 = DummyModel2.query.get(model_id)
-
-        assert isinstance(model2.uuid, uuid.UUID)
-
-        # plain UUID object
-        u = uuid.UUID('3eb7f164-bf15-4564-a058-31bdea0196e6')
-        model = DummyModel2(uuid=u)
-        db.session.add(model)
-        db.session.commit()
-        model_id = model.id
-        db.session.remove()
-        model2 = DummyModel2.query.get(model_id)
-
-        assert isinstance(model2.uuid, uuid.UUID)
-        assert model2.uuid == u
+def test_list_attribute(session):
+    model = DummyModel2(list_attr=[1, 2, 3])
+    session.add(model)
+    session.commit()
+    model_id = model.id
+    session.remove()
+    model2 = DummyModel2.query.get(model_id)
+    assert model2.list_attr == [1, 2, 3]
+
+    model2.list_attr.append(4)
+    assert model2.list_attr == [1, 2, 3, 4]
+
+    del model2.list_attr[0]
+    assert model2.list_attr == [2, 3, 4]
+
+
+def test_dict_attribute(session):
+    model = DummyModel2(dict_attr=dict(a=3, b=4))
+    session.add(model)
+    session.commit()
+    model_id = model.id
+    session.remove()
+    model2 = DummyModel2.query.get(model_id)
+    assert model2.dict_attr == dict(a=3, b=4)
+
+    model2.dict_attr['c'] = 5
+    assert model2.dict_attr == dict(a=3, b=4, c=5)
+
+
+def test_uuid_attribute(session):
+    # uuid from string
+    model = DummyModel2(uuid='c5ad316a-2cd0-4f78-a49b-cff216c10713')
+    session.add(model)
+    session.commit()
+    model_id = model.id
+    session.remove()
+    model2 = DummyModel2.query.get(model_id)
+
+    assert isinstance(model2.uuid, uuid.UUID)
+
+    # plain UUID object
+    u = uuid.UUID('3eb7f164-bf15-4564-a058-31bdea0196e6')
+    model = DummyModel2(uuid=u)
+    session.add(model)
+    session.commit()
+    model_id = model.id
+    session.remove()
+    model2 = DummyModel2.query.get(model_id)
+
+    assert isinstance(model2.uuid, uuid.UUID)
+    assert model2.uuid == u

abilian/services/activity/tests.py

@@ -3,9 +3,10 @@
 from __future__ import absolute_import, division, print_function, \
     unicode_literals
 
+from pytest import yield_fixture
+
 from abilian.core.entities import Entity
 from abilian.core.models.subjects import User
-from abilian.testing import BaseTestCase
 
 from .service import ActivityService
 
@@ -14,51 +15,53 @@ class Message1(Entity):
     pass
 
 
-class ActivityTestCase(BaseTestCase):
-
-    def setUp(self):
-        BaseTestCase.setUp(self)
-        self.activity_service = ActivityService()
-        self.activity_service.start()
-
-    def test(self):
-        service = self.activity_service
-        user = User(email='test@example.com')
-        message = Message1(creator=user, owner=user, name='test message')
-
-        with self.session.begin_nested():
-            self.session.add(user)
-            self.session.add(message)
-        service.log_activity(None, user, "post", message)
-        self.session.flush()
-
-        m_id, m_type = message.id, message.entity_type
-
-        entries = service.entries_for_actor(user, 10)
-        assert len(entries) == 1
-
-        entry = entries[0]
-        assert entry.actor == user
-        assert entry.actor_id == user.id
-        assert entry.object == message
-        assert entry.object_type == m_type
-        assert entry._fk_object_id == m_id
-        assert entry.object_id == m_id
-        assert entry.target is None
-
-        # test entry doesn't reference target if its in deleted state
-        self.session.delete(message)
-        self.session.flush()
-        # send activity after flush: activity should not reference an instance in
-        # "deleted state"
-        service.log_activity(None, user, "delete", message)
-        self.session.flush()
-
-        entries = service.entries_for_actor(user, 10)
-        assert len(entries) == 2
-        entry = entries[1]
-        assert entry.object is None
-        assert entry.object_type == m_type
-        assert entry._fk_object_id is None
-        assert entry.object_id == m_id
-        assert entry.target is None
+@yield_fixture
+def activity_service(app, db):
+    service = ActivityService()
+    service.start()
+    yield service
+    service.stop()
+
+
+def test(app, session, activity_service):
+    service = activity_service
+    user = User(email='test@example.com')
+    message = Message1(creator=user, owner=user, name='test message')
+
+    with session.begin_nested():
+        session.add(user)
+        session.add(message)
+    service.log_activity(None, user, "post", message)
+    session.flush()
+
+    m_id, m_type = message.id, message.entity_type
+
+    entries = service.entries_for_actor(user, 10)
+    assert len(entries) == 1
+
+    entry = entries[0]
+    assert entry.actor == user
+    assert entry.actor_id == user.id
+    assert entry.object == message
+    assert entry.object_type == m_type
+    assert entry._fk_object_id == m_id
+    assert entry.object_id == m_id
+    assert entry.target is None
+
+    # test entry doesn't reference target if its in deleted state
+    session.delete(message)
+    session.flush()
+    # send activity after flush: activity should not reference
+    # an instance in "deleted state"
+    service.log_activity(None, user, "delete", message)
+    session.flush()
+
+    entries = service.entries_for_actor(user, 10)
+    assert len(entries) == 2
+
+    entry = entries[1]
+    assert entry.object is None
+    assert entry.object_type == m_type
+    assert entry._fk_object_id is None
+    assert entry.object_id == m_id
+    assert entry.target is None