Clean test code

tracim/tracim/tests/__init__.py

 from gearbox.commands.setup_app import SetupAppCommand
 from ldap_test import LdapServer
 from nose.tools import eq_
+from nose.tools import make_decorator
 from nose.tools import ok_
 from paste.deploy import loadapp
 from sqlalchemy.engine import reflection
 from tracim.fixtures import FixturesLoader
 from tracim.fixtures.users_and_groups import Base as BaseFixture
 from tracim.fixtures.users_and_groups import Test as TestFixture
-from tracim.config.app_cfg import daemons, start_daemons
+from tracim.config.app_cfg import daemons
 from tracim.lib.base import logger
 from tracim.lib.content import ContentApi
 from tracim.lib.workspace import WorkspaceApi
 from tracim.model import DBSession, Content
-from tracim.model.data import Workspace, ContentType, ContentRevisionRO
-from tracim.lib.calendar import CALENDAR_BASE_URL_TEMPLATE
-from tracim.lib.calendar import CALENDAR_WORKSPACE_URL_TEMPLATE
-from tracim.lib.calendar import CALENDAR_USER_URL_TEMPLATE
+from tracim.model.data import Workspace
+from tracim.model.data import ContentType
 
 __all__ = ['setup_app', 'setup_db', 'teardown_db', 'TestController']
 
                 shutil.rmtree('{0}/{1}'.format(radicale_fs_path, file))
         except FileNotFoundError:
             pass  # Dir not exists yet, no need to clear it
+
+
+def not_raises(*exceptions):
+    """
+    Test must not raise one of expected exceptions to pass.
+    """
+    valid = ' or '.join([e.__name__ for e in exceptions])
+
+    def decorate(func):
+        name = func.__name__
+
+        def newfunc(*arg, **kw):
+            try:
+                func(*arg, **kw)
+            except exceptions as exc:
+                message = '{0} raise {1} exception and should be not'\
+                    .format(name, exc)
+                raise AssertionError(message)
+            except:
+                raise
+        newfunc = make_decorator(func)(newfunc)
+        return newfunc
+    return decorate

tracim/tracim/tests/functional/test_calendar.py

 import caldav
 import transaction
 from caldav.lib.error import AuthorizationError
-from nose.tools import eq_, ok_
+from nose.tools import eq_
+from nose.tools import ok_
+from nose.tools import raises
 import requests
 from requests.exceptions import ConnectionError
 from sqlalchemy.orm.exc import NoResultFound
 from tracim.lib.workspace import WorkspaceApi
 from tracim.model import DBSession
 from tracim.tests import TestCalendar as BaseTestCalendar
+from tracim.tests import not_raises
 from tracim.model.auth import User
 from tracim.model.data import Content
 
         except ConnectionError as exc:
             ok_(False, 'Unable to contact radicale on HTTP: {0}'.format(exc))
 
+    @not_raises(AuthorizationError)
     def test_func__radicale_auth__ok__as_lawrence(self):
         radicale_base_url = CalendarManager.get_base_url()
         client = caldav.DAVClient(
             username='lawrence-not-real-email@fsf.local',
             password='foobarbaz'
         )
-        try:
-            client.propfind()
-            ok_(True, 'No auth error when communicate with radicale server')
-        except AuthorizationError:
-            ok_(False, 'AuthorizationError when communicate with radicale')
+        client.propfind()
 
+    @raises(AuthorizationError)
     def test_func__radicale_auth__fail__as_john_doe(self):
         radicale_base_url = CalendarManager.get_base_url()
         client = caldav.DAVClient(
             username='john.doe@foo.local',
             password='nopasswd'
         )
-        try:
-            client.propfind()
-            ok_(False, 'Auth with unknown user should be raise'
-                       ' AuthorizationError !')
-        except AuthorizationError:
-            ok_(True, 'AuthorizationError thrown correctly')
+        client.propfind()
 
+    @not_raises(AuthorizationError)
     def test_func__rights_read_user_calendar__ok__as_lawrence(self):
         radicale_base_url = CalendarManager.get_base_url()
         client = caldav.DAVClient(
             User.email == 'lawrence-not-real-email@fsf.local'
         ).one()
         user_calendar_url = CalendarManager.get_user_calendar_url(user.user_id)
-        try:
-            caldav.Calendar(
-                parent=client,
-                client=client,
-                url=user_calendar_url
-            ).events()
-
-            ok_(True, 'User can access it\'s own calendar')
-        except AuthorizationError:
-            ok_(False, 'User should not access that')
+        caldav.Calendar(
+            parent=client,
+            client=client,
+            url=user_calendar_url
+        ).events()
 
+    @raises(AuthorizationError)
     def test_func__rights_read_user_calendar__fail__as_john_doe(self):
         radicale_base_url = CalendarManager.get_base_url()
         client = caldav.DAVClient(
             User.email == 'admin@admin.admin'
         ).one()
         user_calendar_url = CalendarManager.get_user_calendar_url(other_user.user_id)
-        try:
-            caldav.Calendar(
-                parent=client,
-                client=client,
-                url=user_calendar_url
-            ).events()
-
-            ok_(False, 'User can\'t acces other user calendar')
-        except AuthorizationError:
-            ok_(True, 'User should not acces other user calendar')
+        caldav.Calendar(
+            parent=client,
+            client=client,
+            url=user_calendar_url
+        ).events()
 
+    @not_raises(AuthorizationError)
     def test_func__rights_read_workspace_calendar__ok__as_owner(self):
         lawrence = DBSession.query(User).filter(
             User.email == 'lawrence-not-real-email@fsf.local'
             username='lawrence-not-real-email@fsf.local',
             password='foobarbaz'
         )
-        try:
-            caldav.Calendar(
-                parent=client,
-                client=client,
-                url=workspace_calendar_url
-            ).events()
-
-            ok_(True, 'User can acces own workspace calendar')
-        except AuthorizationError:
-            ok_(False, 'User should not acces own workspace calendar')
+        caldav.Calendar(
+            parent=client,
+            client=client,
+            url=workspace_calendar_url
+        ).events()
 
+    @raises(AuthorizationError)
     def test_func__rights_read_workspace_calendar__fail__as_unauthorized(self):
         lawrence = DBSession.query(User).filter(
             User.email == 'lawrence-not-real-email@fsf.local'
             username='bob@fsf.local',
             password='foobarbaz'
         )
-        try:
-            caldav.Calendar(
-                parent=client,
-                client=client,
-                url=workspace_calendar_url
-            ).events()
-
-            ok_(False, 'User can\'t access unright workspace calendar')
-        except AuthorizationError:
-            ok_(True, 'User should not access unright workspace calendar')
+        caldav.Calendar(
+            parent=client,
+            client=client,
+            url=workspace_calendar_url
+        ).events()
 
     def test_func__event_create__ok__nominal_case(self):
         lawrence = DBSession.query(User).filter(