Merge pull request #3 from lebouquetin/master

tracim/test.ini

 port = 8080
 
 [app:main]
-sqlalchemy.url = sqlite:///:memory:
+sqlalchemy.url = postgresql://postgres:dummy@127.0.0.1:5432/tracim_test?client_encoding=utf8
 use = config:development.ini
 
 [app:main_without_authn]

tracim/tracim/config/app_cfg.py

         self.WEBSITE_HOME_TITLE_COLOR = tg.config.get('website.title.color', '#555')
         self.WEBSITE_HOME_IMAGE_URL = tg.lurl('/assets/img/home_illustration.jpg')
         self.WEBSITE_HOME_BACKGROUND_IMAGE_URL = tg.lurl('/assets/img/bg.jpg')
-        self.WEBSITE_BASE_URL = tg.config.get('website.base_url')
+        self.WEBSITE_BASE_URL = tg.config.get('website.base_url', '')
 
-        self.WEBSITE_HOME_TAG_LINE = tg.config.get('website.home.tag_line')
-        self.WEBSITE_SUBTITLE = tg.config.get('website.home.subtitle')
-        self.WEBSITE_HOME_BELOW_LOGIN_FORM = tg.config.get('website.home.below_login_form')
+        self.WEBSITE_HOME_TAG_LINE = tg.config.get('website.home.tag_line', '')
+        self.WEBSITE_SUBTITLE = tg.config.get('website.home.subtitle', '')
+        self.WEBSITE_HOME_BELOW_LOGIN_FORM = tg.config.get('website.home.below_login_form', '')
 
 
         self.EMAIL_NOTIFICATION_FROM = tg.config.get('email.notification.from')

tracim/tracim/controllers/root.py

 
 
     @expose()
-    def post_login(self, came_from=lurl('/')):
+    def post_login(self, came_from=lurl('/dashboard')):
         """
         Redirect the user to the initially requested page on successful
         authentication or redirect her back to the login page if login failed.

tracim/tracim/lib/content.py

 import tg
 
 from sqlalchemy.orm.attributes import get_history
+from sqlalchemy import not_
 from tracim.lib import cmp_to_key
-from tracim.lib.notifications import Notifier
+from tracim.lib.notifications import NotifierFactory
 from tracim.model import DBSession
 from tracim.model.auth import User
 from tracim.model.data import ContentStatus, ContentRevisionRO, ActionDescription
 
     def _base_query(self, workspace: Workspace=None):
         result = DBSession.query(Content)
+
         if workspace:
             result = result.filter(Content.workspace_id==workspace.workspace_id)
 
         content.revision_type = ActionDescription.CREATION
 
         if do_save:
+            DBSession.add(content)
             self.save(content, ActionDescription.CREATION)
         return content
 
 
     def get_all(self, parent_id: int, content_type: str, workspace: Workspace=None) -> Content:
         assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
-        assert content_type is not None # DYN_REMOVE
+        assert content_type is not None# DYN_REMOVE
         assert isinstance(content_type, str) # DYN_REMOVE
 
-        if not parent_id:
-            return
+        resultset = self._base_query(workspace)
 
-        return self._base_query(workspace).\
-            filter(Content.parent_id==parent_id).\
-            filter(Content.type==content_type).\
-            all()
+        if content_type!=ContentType.Any:
+            resultset.filter(Content.type==content_type)
+
+        if parent_id:
+            resultset.filter(Content.parent_id==parent_id)
+
+        return resultset.all()
 
     def set_allowed_content(self, folder: Content, allowed_content_dict:dict):
         """
         content.is_deleted = False
         content.revision_type = ActionDescription.UNDELETION
 
+    def flush(self):
+        DBSession.flush()
+
     def save(self, content: Content, action_description: str=None, do_flush=True, do_notify=True):
         """
         Save an object, flush the session and set the revision_type property
             DBSession.flush()
 
         if do_notify:
-            Notifier(self._user).notify_content_update(content)
+            NotifierFactory.create(self._user).notify_content_update(content)
+

tracim/tracim/lib/notifications.py

 
 from tgext.asyncjob import asyncjob_perform
 
-class Notifier(object):
+class INotifier(object):
+    """
+    Interface for Notifier instances
+    """
+    def __init__(self, current_user: User=None):
+        raise NotImplementedError
+
+    def notify_content_update(self, content: Content):
+        raise NotImplementedError
+
+
+class NotifierFactory(object):
+
+    @classmethod
+    def create(cls, current_user: User=None) -> INotifier:
+        cfg = CFG.get_instance()
+        if cfg.EMAIL_NOTIFICATION_ACTIVATED:
+            return DummyNotifier(current_user)
 
+        return RealNotifier(current_user)
+
+
+class DummyNotifier(INotifier):
     def __init__(self, current_user: User=None):
-        """
+        logger.info(self, 'Instantiating Dummy Notifier')
+
+    def notify_content_update(self, content: Content):
+        logger.info(self, 'Fake notifier, do not send email-notification for update of content {} by user {}'.format(content.content_id, self._user.user_id))
 
+
+class RealNotifier(object):
+
+    def __init__(self, current_user: User=None):
+        """
         :param current_user: the user that has triggered the notification
         :return:
         """
+        logger.info(self, 'Instantiating Real Notifier')
         cfg = CFG.get_instance()
 
         self._user = current_user
                                        cfg.EMAIL_NOTIFICATION_SMTP_PASSWORD)
 
     def notify_content_update(self, content: Content):
-        logger.info(self, 'About to email-notify update of content {} by user {}'.format(content.content_id, self._user.user_id))
+        logger.info(self, 'About to email-notify update of content {} by user {}'.format(content.content_id, self._user.user_id if self._user else 0)) # 0 means "no user"
 
         global_config = CFG.get_instance()
 

tracim/tracim/lib/user.py

         if do_save:
             self.save(user)
 
-        if user.user_id==self._user.user_id:
+        if self._user and user.user_id==self._user.user_id:
             # this is required for the session to keep on being up-to-date
             tg.request.identity['repoze.who.userid'] = email
 
 
 class UserStaticApi(object):
 
-  @classmethod
-  def get_current_user(cls) -> User:
-    identity = tg.request.identity
+    @classmethod
+    def get_current_user(cls) -> User:
+        identity = tg.request.identity
 
-    if tg.request.identity:
-        return pbma.User.by_email_address(tg.request.identity['repoze.who.userid'])
-    return None
+        if tg.request.identity:
+            return cls._get_user(tg.request.identity['repoze.who.userid'])
+
+        return None
+
+    @classmethod
+    def _get_user(cls, email) -> User:
+        """
+        Do not use directly in your code.
+        :param email:
+        :return:
+        """
+        return pbma.User.by_email_address(email)

tracim/tracim/model/auth.py

 
 __all__ = ['User', 'Group', 'Permission']
 
-from sqlalchemy import Table, ForeignKey, Column
-from sqlalchemy.types import Unicode, Integer, DateTime, Boolean
+from sqlalchemy import Column
+from sqlalchemy import ForeignKey
+from sqlalchemy import Sequence
+from sqlalchemy import Table
+
+from sqlalchemy.types import Unicode
+from sqlalchemy.types import Integer
+from sqlalchemy.types import DateTime
+from sqlalchemy.types import Boolean
 from sqlalchemy.orm import relation, relationship, synonym
 
 from tracim.model import DeclarativeBase, metadata, DBSession
 
     __tablename__ = 'groups'
 
-    group_id = Column(Integer, autoincrement=True, primary_key=True)
+    group_id = Column(Integer, Sequence('seq__groups__group_id'), autoincrement=True, primary_key=True)
     group_name = Column(Unicode(16), unique=True, nullable=False)
     display_name = Column(Unicode(255))
     created = Column(DateTime, default=datetime.now)
     """
     __tablename__ = 'users'
 
-    user_id = Column(Integer, autoincrement=True, primary_key=True)
+    user_id = Column(Integer, Sequence('seq__users__user_id'), autoincrement=True, primary_key=True)
     email = Column(Unicode(255), unique=True, nullable=False)
     display_name = Column(Unicode(255))
     _password = Column('password', Unicode(128))
     __tablename__ = 'permissions'
 
 
-    permission_id = Column(Integer, autoincrement=True, primary_key=True)
+    permission_id = Column(Integer, Sequence('seq__permissions__permission_id'), autoincrement=True, primary_key=True)
     permission_name = Column(Unicode(63), unique=True, nullable=False)
     description = Column(Unicode(255))
 

tracim/tracim/model/data.py

 
 from sqlalchemy import Column
 from sqlalchemy import ForeignKey
+from sqlalchemy import Sequence
 
 from sqlalchemy.ext.hybrid import hybrid_property
 
 
     __tablename__ = 'workspaces'
 
-    workspace_id = Column(Integer, autoincrement=True, primary_key=True)
+    workspace_id = Column(Integer, Sequence('seq__workspaces__workspace_id'), autoincrement=True, primary_key=True)
 
     label   = Column(Unicode(1024), unique=False, nullable=False, default='')
     description = Column(Text(), unique=False, nullable=False, default='')
 
     revision_to_serialize = -0  # This flag allow to serialize a given revision if required by the user
 
-    content_id = Column(Integer, autoincrement=True, primary_key=True)
+    content_id = Column(Integer, Sequence('seq__contents__content_id'), autoincrement=True, primary_key=True)
     parent_id = Column(Integer, ForeignKey('contents.content_id'), nullable=True, default=None)
     owner_id = Column(Integer, ForeignKey('users.user_id'), nullable=True, default=None)
 
 
     __tablename__ = 'content_revisions'
 
-    revision_id = Column(Integer, primary_key=True)
+    revision_id = Column(Integer, Sequence('seq__content_revisions__revision_id'), primary_key=True)
     content_id = Column(Integer, ForeignKey('contents.content_id'))
     owner_id = Column(Integer, ForeignKey('users.user_id'), nullable=True)
     label = Column(Unicode(1024), unique=False, nullable=False)

tracim/tracim/templates/index.mak

                     <p class="text-center" style="color: ${h.CFG.WEBSITE_HOME_TITLE_COLOR};">${h.CFG.WEBSITE_SUBTITLE|n}</p>
                 </div>
             </div>
+
             <div class="row">
                 <div class="col-sm-offset-3 col-sm-2">
                     <a class="thumbnail">
                 <div class="col-sm-4">
                     <div class="well">
                         <h2 style="margin-top: 0;">${TIM.ICO(32, 'status/status-locked')} ${_('Login')}</h2>
-                        <form role="form" method="POST" action="${tg.url('/login_handler', params=dict(came_from=came_from, __logins=login_counter))}">
+                        <form id='w-login-form' role="form" method="POST" action="${tg.url('/login_handler', params=dict(came_from=came_from, __logins=login_counter))}">
                             <div class="form-group">
                                 <div class="input-group">
                                     <div class="input-group-addon"><i class="fa fa-envelope-o"></i></div>
                 <div class="col-sm-offset-3 col-sm-6 text-center">${h.CFG.WEBSITE_HOME_BELOW_LOGIN_FORM|n}</div>
             </div>
 
+
         </div>
     </div>
 </div>

tracim/tracim/templates/master_anonymous.mak

     background-size: cover;
     -o-background-size: cover;">
         <script src="${tg.url('/assets/js/jquery.min.js')}"></script>
-## FIXME - REMOVE        <script src="${tg.url('/javascript/tracim.js')}"></script>
 
         <div class="container-fluid">
             ${self.main_menu()}

tracim/tracim/tests/__init__.py

 from tg import config
 from tg.util import Bunch
 
-from tracim import model
+from sqlalchemy.engine import reflection
+
+from sqlalchemy.schema import DropConstraint
+from sqlalchemy.schema import DropSequence
+from sqlalchemy.schema import DropTable
+from sqlalchemy.schema import ForeignKeyConstraint
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Sequence
+from sqlalchemy.schema import Table
+
+import transaction
+
+from tracim.lib.base import logger
 
 __all__ = ['setup_app', 'setup_db', 'teardown_db', 'TestController']
 
 
 def setup_app():
     """Setup the application."""
+
+    engine = config['tg.app_globals'].sa_engine
+    inspector = reflection.Inspector.from_engine(engine)
+    metadata = MetaData()
+
+    logger.debug(setup_app, 'Before setup...')
+
     cmd = SetupAppCommand(Bunch(options=Bunch(verbose_level=1)), Bunch())
+    logger.debug(setup_app, 'After setup, before run...')
+
     cmd.run(Bunch(config_file='config:test.ini', section_name=None))
+    logger.debug(setup_app, 'After run...')
+
+
 
 def setup_db():
     """Create the database schema (not needed when you run setup_app)."""
+
     engine = config['tg.app_globals'].sa_engine
-    model.init_model(engine)
-    model.metadata.create_all(engine)
+    # model.init_model(engine)
+    # model.metadata.create_all(engine)
+
 
 
 def teardown_db():
     """Destroy the database schema."""
     engine = config['tg.app_globals'].sa_engine
-    model.metadata.drop_all(engine)
+    connection = engine.connect()
+
+    # INFO - D.A. - 2014-12-04
+    # Recipe taken from bitbucket:
+    # https://bitbucket.org/zzzeek/sqlalchemy/wiki/UsageRecipes/DropEverything
+
+    inspector = reflection.Inspector.from_engine(engine)
+    metadata = MetaData()
+
+    tbs = []
+    all_fks = []
+    views = []
+
+    # INFO - D.A. - 2014-12-04
+    # Sequences are hard defined here because SQLA does not allow to reflect them from existing schema
+    seqs = [
+        Sequence('seq__groups__group_id'),
+        Sequence('seq__contents__content_id'),
+        Sequence('seq__content_revisions__revision_id'),
+        Sequence('seq__permissions__permission_id'),
+        Sequence('seq__users__user_id'),
+        Sequence('seq__workspaces__workspace_id')
+    ]
+
+    for view_name in inspector.get_view_names():
+        v = Table(view_name,metadata)
+        views.append(v)
+
+    for table_name in inspector.get_table_names():
+
+        fks = []
+        for fk in inspector.get_foreign_keys(table_name):
+            if not fk['name']:
+                continue
+            fks.append(
+                ForeignKeyConstraint((),(),name=fk['name'])
+                )
+        t = Table(table_name,metadata,*fks)
+        tbs.append(t)
+        all_fks.extend(fks)
 
+    for fkc in all_fks:
+        connection.execute(DropConstraint(fkc))
+
+    for view in views:
+        drop_statement = 'DROP VIEW {}'.format(view.name)
+        # engine.execute(drop_statement)
+        connection.execute(drop_statement)
+
+    for table in tbs:
+        connection.execute(DropTable(table))
+
+
+    for sequence in seqs:
+        try:
+            connection.execute(DropSequence(sequence))
+        except Exception as e:
+            logger.debug(teardown_db, 'Exception while trying to remove sequence {}'.format(sequence.name))
+
+    transaction.commit()
+    engine.dispose()
+
+
+class TestStandard(object):
+
+    def setUp(self):
+        self.app = load_app('main')
+
+        logger.debug(self, 'Start setUp() by trying to clean database...')
+        try:
+            teardown_db()
+        except Exception as e:
+            logger.debug(self, 'teardown() throwed an exception {}'.format(e.__str__()))
+        logger.debug(self, 'Start setUp() by trying to clean database... -> done')
+
+        logger.debug(self, 'Start Application Setup...')
+        setup_app()
+        logger.debug(self, 'Start Application Setup... -> done')
+
+        logger.debug(self, 'Start Database Setup...')
+        setup_db()
+        logger.debug(self, 'Start Database Setup... -> done')
+
+    def tearDown(self):
+        transaction.commit()
 
 class TestController(object):
     """Base functional test case for the controllers.
     def setUp(self):
         """Setup test fixture for each functional test method."""
         self.app = load_app(self.application_under_test)
+
+        try:
+            teardown_db()
+        except Exception as e:
+            print('-> err ({})'.format(e.__str__()))
+
         setup_app()
+        setup_db()
+
 
     def tearDown(self):
         """Tear down test fixture for each functional test method."""
-        model.DBSession.remove()
+        # model.DBSession.remove()
         teardown_db()

tracim/tracim/tests/functional/test_authentication.py

 
 from nose.tools import eq_, ok_
 
+from tracim.lib.user import UserApi
 from tracim.tests import TestController
 
 
 
     application_under_test = 'main'
 
+    login = 'admin@admin.admin'
+    password = 'admin@admin.admin'
+
     def test_forced_login(self):
         """Anonymous users are forced to login
 
         should be redirected to the initially requested page.
 
         """
+
         # Requesting a protected area
-        resp = self.app.get('/secc/', status=302)
+        resp = self.app.get('/dashboard/', status=302)
         ok_( resp.location.startswith('http://localhost/login'))
         # Getting the login form:
         resp = resp.follow(status=200)
         form = resp.form
         # Submitting the login form:
-        form['login'] = 'manager'
-        form['password'] = 'managepass'
+        form['login'] = self.login
+        form['password'] = self.password
         post_login = form.submit(status=302)
         # Being redirected to the initially requested page:
         ok_(post_login.location.startswith('http://localhost/post_login'))
         initial_page = post_login.follow(status=302)
         ok_('authtkt' in initial_page.request.cookies,
             "Session cookie wasn't defined: %s" % initial_page.request.cookies)
-        ok_(initial_page.location.startswith('http://localhost/secc/'),
+        ok_(initial_page.location.startswith('http://localhost/dashboard/'),
             initial_page.location)
 
+
     def test_voluntary_login(self):
         """Voluntary logins must work correctly"""
         # Going to the login form voluntarily:
-        resp = self.app.get('/login', status=200)
+        resp = self.app.get('/', status=200)
         form = resp.form
         # Submitting the login form:
-        form['login'] = 'manager'
-        form['password'] = 'managepass'
+        form['login'] = self.login
+        form['password'] = self.password
         post_login = form.submit(status=302)
+
         # Being redirected to the home page:
         ok_(post_login.location.startswith('http://localhost/post_login'))
+        # FIXME - D.A - 2014-12-04 - Why double redirect to post_login ?!
         home_page = post_login.follow(status=302)
-        ok_('authtkt' in home_page.request.cookies,
-            'Session cookie was not defined: %s' % home_page.request.cookies)
-        eq_(home_page.location, 'http://localhost/')
+        real_home_page = home_page.follow(status=302)
+        ok_('authtkt' in real_home_page.request.cookies,
+            'Session cookie was not defined: %s' % real_home_page.request.cookies)
+        eq_(real_home_page.location, 'http://localhost/dashboard')
 
     def test_logout(self):
         """Logouts must work correctly"""
         # Logging in voluntarily the quick way:
-        resp = self.app.get('/login_handler?login=manager&password=managepass',
+        resp = self.app.get('/login_handler?login={}&password={}'.format(self.login, self.password),
                             status=302)
         resp = resp.follow(status=302)
         ok_('authtkt' in resp.request.cookies,

tracim/tracim/tests/functional/test_root.py

 
 """
 
+from bs4 import BeautifulSoup
+
+from nose.tools import eq_
 from nose.tools import ok_
 
+from tracim.lib import helpers as h
 from tracim.tests import TestController
 
 
     """Tests for the method in the root controller."""
 
     def test_index(self):
-        """The front page is working properly"""
         response = self.app.get('/')
-        msg = 'TurboGears 2 is rapid web application development toolkit '\
-              'designed to make your life easier.'
-        # You can look for specific strings:
-        ok_(msg in response)
-
-        # You can also access a BeautifulSoup'ed response in your tests
-        # (First run $ easy_install BeautifulSoup
-        # and then uncomment the next two lines)
-
-        # links = response.html.findAll('a')
-        # print links
-        # ok_(links, "Mummy, there are no links here!")
-
-    def test_environ(self):
-        """Displaying the wsgi environ works"""
-        response = self.app.get('/environ.html')
-        ok_('The keys in the environment are: ' in response)
+        eq_(200, response.status_int)
 
-    def test_data(self):
-        """The data display demo works with HTML"""
-        response = self.app.get('/data.html?a=1&b=2')
-        expected1 = """<td>a</td>\n                <td>1</td>"""
-        expected2 = """<td>b</td>\n                <td>2</td>"""
-        body = '\n'.join(response.text.splitlines())
-        ok_(expected1 in body, response)
-        ok_(expected2 in body, response)
-
-    def test_data_json(self):
-        """The data display demo works with JSON"""
-        resp = self.app.get('/data.json?a=1&b=2')
-        ok_(dict(page='data', params={'a':'1', 'b':'2'}) == resp.json, resp.json)
-
-    def test_secc_with_manager(self):
-        """The manager can access the secure controller"""
-        # Note how authentication is forged:
-        environ = {'REMOTE_USER': 'manager'}
-        resp = self.app.get('/secc', extra_environ=environ, status=200)
-        ok_('Secure Controller here' in resp.text, resp.text)
-
-    def test_secc_with_editor(self):
-        """The editor cannot access the secure controller"""
-        environ = {'REMOTE_USER': 'editor'}
-        self.app.get('/secc', extra_environ=environ, status=403)
-        # It's enough to know that authorization was denied with a 403 status
+        msg = 'copyright &copy; 2013 - {} tracim project.'.format(h.current_year())
+        ok_(msg in response)
 
-    def test_secc_with_anonymous(self):
-        """Anonymous users must not access the secure controller"""
-        self.app.get('/secc', status=401)
-        # It's enough to know that authorization was denied with a 401 status
+        forms = BeautifulSoup(response.body).find_all('form')
+        print('FORMS = ',forms)
+        eq_(1, len(forms))
+        eq_('w-login-form', forms[0].get('id'))

tracim/tracim/tests/library/__init__.py

-__author__ = 'damien'
+# -*- coding: utf-8 -*-
+"""Unit test suite for the models of the application."""

tracim/tracim/tests/library/test_content_api.py

+# -*- coding: utf-8 -*-
+
+from nose.tools import eq_
+
+import transaction
+
+from tracim.lib.content import compare_content_for_sorting_by_type_and_name
+from tracim.lib.content import ContentApi
+
+from tracim.model.data import Content
+from tracim.model.data import ContentType
+
+from tracim.tests import TestStandard
+
+
+class TestContentApi(TestStandard):
+
+    def test_compare_content_for_sorting_by_type(self):
+        c1 = Content()
+        c1.label = ''
+        c1.type = 'file'
+
+        c2 = Content()
+        c2.label = ''
+        c2.type = 'folder'
+
+        c11 = c1
+
+        eq_(1, compare_content_for_sorting_by_type_and_name(c1, c2))
+        eq_(-1, compare_content_for_sorting_by_type_and_name(c2, c1))
+        eq_(0, compare_content_for_sorting_by_type_and_name(c1, c11))
+
+    def test_compare_content_for_sorting_by_label(self):
+        c1 = Content()
+        c1.label = 'bbb'
+        c1.type = 'file'
+
+        c2 = Content()
+        c2.label = 'aaa'
+        c2.type = 'file'
+
+        c11 = c1
+
+        eq_(1, compare_content_for_sorting_by_type_and_name(c1, c2))
+        eq_(-1, compare_content_for_sorting_by_type_and_name(c2, c1))
+        eq_(0, compare_content_for_sorting_by_type_and_name(c1, c11))
+
+    def test_sort_by_label_or_filename(self):
+        c1 = Content()
+        c1.label = 'ABCD'
+        c1.type = 'file'
+
+        c2 = Content()
+        c2.label = ''
+        c2.type = 'file'
+        c2.file_name = 'AABC'
+
+        c3 = Content()
+        c3.label = 'BCDE'
+        c3.type = 'file'
+
+        items = [c1, c2, c3]
+        sorteds = ContentApi.sort_content(items)
+
+        eq_(sorteds[0], c2)
+        eq_(sorteds[1], c1)
+        eq_(sorteds[2], c3)
+
+    def test_sort_by_content_type(self):
+        c1 = Content()
+        c1.label = 'AAAA'
+        c1.type = 'file'
+
+        c2 = Content()
+        c2.label = 'BBBB'
+        c2.type = 'folder'
+
+        items = [c1, c2]
+        sorteds = ContentApi.sort_content(items)
+
+        eq_(sorteds[0], c2, 'value is {} instead of {}'.format(sorteds[0].content_id, c2.content_id))
+        eq_(sorteds[1], c1, 'value is {} instead of {}'.format(sorteds[1].content_id, c1.content_id))
+
+class TestContentApiFilteringDeletedItem(TestStandard):
+
+    def test_delete(self):
+        api = ContentApi(None)
+        item = api.create(ContentType.Folder, None, None, 'not_deleted', True)
+        item2 = api.create(ContentType.Folder, None, None, 'to_delete', True)
+        transaction.commit()
+
+        items = api.get_all(None, ContentType.Any, None)
+        eq_(2, len(items))
+
+        items = api.get_all(None, ContentType.Any, None)
+        api.delete(items[0])
+        transaction.commit()
+
+        items = api.get_all(None, ContentType.Any, None)
+        eq_(1, len(items))
+        transaction.commit()
+
+        # Test that the item is still available if "show deleted" is activated
+        api = ContentApi(None, show_deleted=True)
+        items = api.get_all(None, ContentType.Any, None)
+        eq_(2, len(items))
+
+
+    def test_archive(self):
+        api = ContentApi(None)
+        item = api.create(ContentType.Folder, None, None, 'not_archived', True)
+        item2 = api.create(ContentType.Folder, None, None, 'to_archive', True)
+        transaction.commit()
+
+        items = api.get_all(None, ContentType.Any, None)
+        eq_(2, len(items))
+
+        items = api.get_all(None, ContentType.Any, None)
+        api.archive(items[0])
+        transaction.commit()
+
+        items = api.get_all(None, ContentType.Any, None)
+        eq_(1, len(items))
+        transaction.commit()
+
+        # Test that the item is still available if "show deleted" is activated
+        api = ContentApi(None, show_archived=True)
+        items = api.get_all(None, ContentType.Any, None)
+        eq_(2, len(items))

tracim/tracim/tests/library/test_serializers.py

+# -*- coding: utf-8 -*-
+
+from nose.tools import eq_
+from nose.tools import ok_
+from nose.tools import raises
+
+from sqlalchemy.orm.exc import NoResultFound
+
+import transaction
+
+
+from tracim.model.data import Content
+
+from tracim.model.serializers import Context
+from tracim.model.serializers import ContextConverterNotFoundException
+from tracim.model.serializers import CTX
+from tracim.model.serializers import DictLikeClass
+
+from tracim.model.data import ActionDescription
+
+from tracim.lib.user import UserApi
+
+from tracim.tests import TestStandard
+
+
+
+class TestSerializers(TestStandard):
+
+    def test_DictLikeClass(self):
+        instance = DictLikeClass()
+
+        instance.bob = 'titi'
+        ok_(instance.bob==instance['bob'])
+
+        instance['titi'] = 'bob'
+        ok_(instance.titi==instance['titi'])
+
+        instance2 = DictLikeClass(instance)
+        ok_(instance2.bob==instance2['bob'])
+        ok_(instance2.bob==instance.bob)
+        ok_(instance2.titi==instance2['titi'])
+        ok_(instance2.titi==instance.titi)
+
+        instance3 = DictLikeClass({'bob': 'titi', 'toto': 'bib'})
+        ok_(instance3.bob=='titi')
+        ok_(instance3.bob==instance3['bob'])
+
+        ok_(instance3.toto=='bib')
+        ok_(instance3.toto==instance3['toto'])
+
+    def test_ContextConverterNotFoundException(self):
+        class DummyClass(object):
+            pass
+        context = 'some_context'
+        e = ContextConverterNotFoundException(context, DummyClass)
+        eq_('converter not found (context: some_context - model: DummyClass)', e.__str__())
+
+    def test_serialize_ActionDescription_DEFAULT(self):
+        obj = ActionDescription('archiving')
+        obj.icon = 'places/folder-remote'
+        obj.label = 'edit the content'
+
+        res = Context(CTX.DEFAULT).toDict(obj)
+        eq_(res.__class__, DictLikeClass)
+        eq_(obj.id, res.id)
+        eq_(obj.label, res.label)
+        eq_(obj.icon, res.icon)
+        eq_(3, len(res.keys()))
+
+    def test_serialize_Content_DEFAULT(self):
+        obj = Content()
+        obj.content_id = 132
+        obj.label = 'Some label'
+        obj.description = 'Some Description'
+
+        res = Context(CTX.DEFAULT).toDict(obj)
+        eq_(res.__class__, DictLikeClass, res)
+        eq_(obj.content_id, res.id, res)
+        eq_(obj.label, res.label, res)
+
+        ok_('folder' in res.keys())
+        ok_('id' in res.folder.keys())
+        eq_(None, res.folder.id)
+        eq_(1, len(res.folder.keys()))
+
+        ok_('workspace' in res.keys())
+        eq_(None, res.workspace, res)
+        eq_(4, len(res.keys()), res)
+
+
+

tracim/tracim/tests/library/test_user_api.py

+# -*- coding: utf-8 -*-
+
+from nose.tools import eq_
+from nose.tools import ok_
+from nose.tools import raises
+
+from sqlalchemy.orm.exc import NoResultFound
+
+import transaction
+
+from tracim.lib.user import UserApi
+from tracim.tests import TestStandard
+
+
+
+class TestUserApi(TestStandard):
+
+    def test_create_and_update_user(self):
+        api = UserApi(None)
+        u = api.create_user()
+        api.update(u, 'bob', 'bob@bob', True)
+
+        nu = api.get_one_by_email('bob@bob')
+        ok_(nu!=None)
+        eq_('bob@bob', nu.email)
+        eq_('bob', nu.display_name)
+
+
+    def test_user_with_email_exists(self):
+        api = UserApi(None)
+        u = api.create_user()
+        api.update(u, 'bibi', 'bibi@bibi', True)
+        transaction.commit()
+
+        eq_(True, api.user_with_email_exists('bibi@bibi'))
+        eq_(False, api.user_with_email_exists('unknown'))
+
+
+    def test_get_one_by_email(self):
+        api = UserApi(None)
+        u = api.create_user()
+        api.update(u, 'bibi', 'bibi@bibi', True)
+        uid = u.user_id
+        transaction.commit()
+
+        eq_(uid, api.get_one_by_email('bibi@bibi').user_id)
+
+    @raises(NoResultFound)
+    def test_get_one_by_email_exception(self):
+        api = UserApi(None)
+        api.get_one_by_email('unknown')
+
+    def test_get_all(self):
+        api = UserApi(None)
+        # u1 = api.create_user(True)
+        # u2 = api.create_user(True)
+
+        # users = api.get_all()
+        # ok_(2==len(users))
+
+    def test_get_one(self):
+        api = UserApi(None)
+        u = api.create_user()
+        api.update(u, 'titi', 'titi@titi', True)
+        one = api.get_one(u.user_id)
+        eq_(u.user_id, one.user_id)

tracim/tracim/tests/models/__init__.py

 # -*- coding: utf-8 -*-
 """Unit test suite for the models of the application."""
-
-from nose.tools import eq_
-from tracim.model import DBSession
-from tracim.tests import load_app
-from tracim.tests import setup_db, teardown_db
-
-__all__ = ['ModelTest']
-
-
-def setup():
-    """Setup test fixture for all model tests."""
-    load_app()
-    setup_db()
-
-
-def teardown():
-    """Tear down test fixture for all model tests."""
-    teardown_db()
-
-
-class ModelTest(object):
-    """Base unit test case for the models."""
-
-    klass = None
-    attrs = {}
-
-    def setUp(self):
-        """Setup test fixture for each model test method."""
-        try:
-            new_attrs = {}
-            new_attrs.update(self.attrs)
-            new_attrs.update(self.do_get_dependencies())
-            self.obj = self.klass(**new_attrs)
-            DBSession.add(self.obj)
-            DBSession.flush()
-            return self.obj
-        except:
-            DBSession.rollback()
-            raise
-
-    def tearDown(self):
-        """Tear down test fixture for each model test method."""
-        DBSession.rollback()
-
-    def do_get_dependencies(self):
-        """Get model test dependencies.
-
-        Use this method to pull in other objects that need to be created
-        for this object to be build properly.
-
-        """
-        return {}
-
-    def test_create_obj(self):
-        """Model objects can be created"""
-        pass
-
-    def test_query_obj(self):
-        """Model objects can be queried"""
-        obj = DBSession.query(self.klass).one()
-        for key, value in self.attrs.items():
-            eq_(getattr(obj, key), value)

tracim/tracim/tests/models/test_auth.py

-# -*- coding: utf-8 -*-
-"""Test suite for the TG app's models"""
-from __future__ import unicode_literals
-from nose.tools import eq_
-
-from tracim import model
-from tracim.tests.models import ModelTest
-
-class TestGroup(ModelTest):
-    """Unit test case for the ``Group`` model."""
-    klass = model.Group
-    attrs = dict(
-        group_name = "test_group",
-        display_name = "Test Group"
-        )
-
-
-class TestUser(ModelTest):
-    """Unit test case for the ``User`` model."""
-    
-    klass = model.User
-    attrs = dict(
-        user_name = "ignucius",
-        email = "ignucius@example.org"
-        )
-
-    def test_obj_creation_username(self):
-        """The obj constructor must set the user name right"""
-        eq_(self.obj.user_name, "ignucius")
-
-    def test_obj_creation_email(self):
-        """The obj constructor must set the email right"""
-        eq_(self.obj.email, "ignucius@example.org")
-
-    def test_no_permissions_by_default(self):
-        """User objects should have no permission by default."""
-        eq_(len(self.obj.permissions), 0)
-
-    def test_getting_by_email(self):
-        """Users should be fetcheable by their email addresses"""
-        him = model.User.by_email_address("ignucius@example.org")
-        eq_(him, self.obj)
-
-
-class TestPermission(ModelTest):
-    """Unit test case for the ``Permission`` model."""
-    
-    klass = model.Permission
-    attrs = dict(
-        permission_name = "test_permission",
-        description = "This is a test Description"
-        )

tracim/tracim/tests/models/test_user.py

+import transaction
+
+from nose.tools import eq_
+from nose.tools import ok_
+
+from tracim.model import DBSession
+
+from tracim.tests import TestStandard
+
+
+from tracim.model.auth import User
+
+
+class TestUserModel(TestStandard):
+
+    def test_create(self):
+        DBSession.flush()
+        transaction.commit()
+        name = 'Damien'
+        email = 'damien@accorsi.info'
+
+        user = User()
+        user.display_name = name
+        user.email = email
+
+        DBSession.add(user)
+        DBSession.flush()
+        transaction.commit()
+
+        new_user = DBSession.query(User).filter(User.display_name==name).one()
+
+        eq_(new_user.display_name, name)
+        eq_(new_user.email, email)
+        eq_(new_user.email_address, email)

tracim/tracim/websetup/schema.py

 -- COMMENT ON EXTENSION plpgsql IS 'PL/pgSQL procedural language';
 SET search_path = public, pg_catalog;
 
-CREATE FUNCTION update_node() RETURNS trigger
+
+CREATE OR REPLACE FUNCTION update_node() RETURNS trigger
     LANGUAGE plpgsql
     AS $$
 BEGIN
 END;
 $$;
 
-CREATE FUNCTION set_created() RETURNS trigger
+CREATE OR REPLACE FUNCTION set_created() RETURNS trigger
     LANGUAGE plpgsql
     AS $$
 BEGIN
 END;
 $$;
 
-CREATE FUNCTION set_updated() RETURNS trigger
+CREATE OR REPLACE FUNCTION set_updated() RETURNS trigger
     LANGUAGE plpgsql
     AS $$
 BEGIN