add test and fixture for models

tracim/fixtures/__init__.py

@@ -0,0 +1,37 @@
+import transaction
+
+class Fixture(object):
+
+    """ Fixture classes (list) required for this fixtures"""
+    require = NotImplemented
+
+    def __init__(self, session):
+        self._session = session
+
+    def insert(self):
+        raise NotImplementedError()
+
+
+class FixturesLoader(object):
+    """
+    Fixtures loader. Load each fixture once.
+    """
+
+    def __init__(self, session, loaded=None):
+        loaded = [] if loaded is None else loaded
+        self._loaded = loaded
+        self._session = session
+
+    def loads(self, fixtures_classes):
+        for fixture_class in fixtures_classes:
+            for required_fixture_class in fixture_class.require:
+                self._load(required_fixture_class)
+            self._load(fixture_class)
+
+    def _load(self, fixture_class: Fixture):
+        if fixture_class not in self._loaded:
+            fixture = fixture_class(self._session)
+            fixture.insert()
+            self._loaded.append(fixture_class)
+            self._session.flush()
+            transaction.commit()

tracim/fixtures/content.py

@@ -0,0 +1,137 @@
+# TODO : Reenable this when API where availables
+# # -*- coding: utf-8 -*-
+# from depot.io.utils import FileIntent
+#
+# from tracim import models
+# from tracim.fixtures import Fixture
+# from tracim.fixtures.users_and_groups import Test
+# from tracim.lib.content import ContentApi
+# from tracim.lib.userworkspace import RoleApi
+# from tracim.lib.workspace import WorkspaceApi
+# from tracim.models.data import ContentType
+# from tracim.models.data import UserRoleInWorkspace
+#
+#
+# class Content(Fixture):
+#     require = [Test]
+#
+#     def insert(self):
+#         admin = self._session.query(models.User) \
+#             .filter(models.User.email == 'admin@admin.admin') \
+#             .one()
+#         bob = self._session.query(models.User) \
+#             .filter(models.User.email == 'bob@fsf.local') \
+#             .one()
+#         admin_workspace_api = WorkspaceApi(admin)
+#         bob_workspace_api = WorkspaceApi(bob)
+#         content_api = ContentApi(admin)
+#         role_api = RoleApi(admin)
+#
+#         # Workspaces
+#         w1 = admin_workspace_api.create_workspace('w1', save_now=True)
+#         w2 = bob_workspace_api.create_workspace('w2', save_now=True)
+#         w3 = admin_workspace_api.create_workspace('w3', save_now=True)
+#
+#         # Workspaces roles
+#         role_api.create_one(
+#             user=bob,
+#             workspace=w1,
+#             role_level=UserRoleInWorkspace.CONTENT_MANAGER,
+#             with_notif=False,
+#         )
+#
+#         # Folders
+#         w1f1 = content_api.create(
+#             content_type=ContentType.Folder,
+#             workspace=w1,
+#             label='w1f1',
+#             do_save=True,
+#         )
+#         w1f2 = content_api.create(
+#             content_type=ContentType.Folder,
+#             workspace=w1,
+#             label='w1f2',
+#             do_save=True,
+#         )
+#
+#         w2f1 = content_api.create(
+#             content_type=ContentType.Folder,
+#             workspace=w2,
+#             label='w2f1',
+#             do_save=True,
+#         )
+#         w2f2 = content_api.create(
+#             content_type=ContentType.Folder,
+#             workspace=w2,
+#             label='w2f2',
+#             do_save=True,
+#         )
+#
+#         w3f1 = content_api.create(
+#             content_type=ContentType.Folder,
+#             workspace=w3,
+#             label='w3f3',
+#             do_save=True,
+#         )
+#
+#         # Pages, threads, ..
+#         w1f1p1 = content_api.create(
+#             content_type=ContentType.Page,
+#             workspace=w1,
+#             parent=w1f1,
+#             label='w1f1p1',
+#             do_save=True,
+#         )
+#         w1f1t1 = content_api.create(
+#             content_type=ContentType.Thread,
+#             workspace=w1,
+#             parent=w1f1,
+#             label='w1f1t1',
+#             do_save=False,
+#         )
+#         w1f1t1.description = 'w1f1t1 description'
+#         self._session.add(w1f1t1)
+#         w1f1d1_txt = content_api.create(
+#             content_type=ContentType.File,
+#             workspace=w1,
+#             parent=w1f1,
+#             label='w1f1d1',
+#             do_save=False,
+#         )
+#         w1f1d1_txt.file_extension = '.txt'
+#         w1f1d1_txt.depot_file = FileIntent(
+#             b'w1f1d1 content',
+#             'w1f1d1.txt',
+#             'text/plain',
+#         )
+#         self._session.add(w1f1d1_txt)
+#         w1f1d2_html = content_api.create(
+#             content_type=ContentType.File,
+#             workspace=w1,
+#             parent=w1f1,
+#             label='w1f1d2',
+#             do_save=False,
+#         )
+#         w1f1d2_html.file_extension = '.html'
+#         w1f1d2_html.depot_file = FileIntent(
+#             b'<p>w1f1d2 content</p>',
+#             'w1f1d2.html',
+#             'text/html',
+#         )
+#         self._session.add(w1f1d2_html)
+#         w1f1f1 = content_api.create(
+#             content_type=ContentType.Folder,
+#             workspace=w1,
+#             label='w1f1f1',
+#             parent=w1f1,
+#             do_save=True,
+#         )
+#
+#         w2f1p1 = content_api.create(
+#             content_type=ContentType.Page,
+#             workspace=w2,
+#             parent=w2f1,
+#             label='w2f1p1',
+#             do_save=True,
+#         )
+#         self._session.flush()

tracim/fixtures/ldap.py

@@ -0,0 +1,58 @@
+ldap_test_server_fixtures = {
+    'port': 3333,
+    'password': 'toor',
+
+    'bind_dn': 'cn=admin,dc=directory,dc=fsf,dc=org',
+    'base': {
+        'objectclass': ['dcObject', 'organization'],
+        'dn': 'dc=directory,dc=fsf,dc=org',
+        'attributes': {
+            'o': 'Free Software Foundation',
+            'dc': 'directory'
+        }
+    },
+
+    'entries': [
+        {
+            'objectclass': ['organizationalRole'],
+            'dn': 'cn=admin,dc=directory,dc=fsf,dc=org',
+            'attributes': {
+                'cn': 'admin'
+            }
+        },
+        {
+            'objectclass': ['organizationalUnit'],
+            'dn': 'ou=people,dc=directory,dc=fsf,dc=org',
+            'attributes': {
+                'ou': 'people',
+            }
+        },
+        {
+            'objectclass': ['organizationalUnit'],
+            'dn': 'ou=groups,dc=directory,dc=fsf,dc=org',
+            'attributes': {
+                'ou': 'groups',
+            }
+        },
+        {
+            'objectclass': ['account', 'top'],
+            'dn': 'cn=richard-not-real-email@fsf.org,ou=people,dc=directory,dc=fsf,dc=org',
+            'attributes': {
+                'uid': 'richard-not-real-email@fsf.org',
+                'userPassword': 'rms',
+                'mail': 'richard-not-real-email@fsf.org',
+                'pubname': 'Richard Stallman',
+            }
+        },
+        {
+            'objectclass': ['account', 'top'],
+            'dn': 'cn=lawrence-not-real-email@fsf.local,ou=people,dc=directory,dc=fsf,dc=org',
+            'attributes': {
+                'uid': 'lawrence-not-real-email@fsf.local',
+                'userPassword': 'foobarbaz',
+                'mail': 'lawrence-not-real-email@fsf.local',
+                'pubname': 'Lawrence Lessig',
+            }
+        },
+    ]
+}

tracim/fixtures/users_and_groups.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+from tracim import models
+from tracim.fixtures import Fixture
+#from tracim.lib.user import UserApi
+
+
+class Base(Fixture):
+    require = []
+
+    def insert(self):
+        u = models.User()
+        u.display_name = 'Global manager'
+        u.email = 'admin@admin.admin'
+        u.password = 'admin@admin.admin'
+        self._session.add(u)
+        #uapi = UserApi(u)
+        #uapi.execute_created_user_actions(u)
+
+        g1 = models.Group()
+        g1.group_id = 1
+        g1.group_name = 'users'
+        g1.display_name = 'Users'
+        g1.users.append(u)
+        self._session.add(g1)
+
+        g2 = models.Group()
+        g2.group_id = 2
+        g2.group_name = 'managers'
+        g2.display_name = 'Global Managers'
+        g2.users.append(u)
+        self._session.add(g2)
+
+        g3 = models.Group()
+        g3.group_id = 3
+        g3.group_name = 'administrators'
+        g3.display_name = 'Administrators'
+        g3.users.append(u)
+        self._session.add(g3)
+
+
+class Test(Fixture):
+    require = [Base, ]
+
+    def insert(self):
+        g2 = self._session.query(models.Group).filter(models.Group.group_name == 'managers').one()
+
+        lawrence = models.User()
+        lawrence.display_name = 'Lawrence L.'
+        lawrence.email = 'lawrence-not-real-email@fsf.local'
+        lawrence.password = 'foobarbaz'
+        self._session.add(lawrence)
+        g2.users.append(lawrence)
+
+        bob = models.User()
+        bob.display_name = 'Bob i.'
+        bob.email = 'bob@fsf.local'
+        bob.password = 'foobarbaz'
+        self._session.add(bob)
+        g2.users.append(bob)

tracim/tests/__init__.py

@@ -0,0 +1,85 @@
+import unittest
+import transaction
+from pyramid import testing
+
+from tracim.models.data import Workspace
+from tracim.models.data import Content
+from tracim.logger import logger
+from tracim.fixtures import FixturesLoader
+from tracim.fixtures.users_and_groups import Base as BaseFixture
+
+
+class BaseTest(unittest.TestCase):
+    """
+    Pyramid default test.
+    """
+    def setUp(self):
+        logger.debug(self, 'Setup Test...')
+        self.config = testing.setUp(settings={
+            'sqlalchemy.url': 'sqlite:///:memory:'
+        })
+        self.config.include('tracim.models')
+        settings = self.config.get_settings()
+
+        from tracim.models import (
+            get_engine,
+            get_session_factory,
+            get_tm_session,
+            )
+
+        self.engine = get_engine(settings)
+        session_factory = get_session_factory(self.engine)
+
+        self.session = get_tm_session(session_factory, transaction.manager)
+        self.init_database()
+
+    def init_database(self):
+        logger.debug(self, 'Init Database Schema...')
+        from tracim.models.meta import DeclarativeBase
+        DeclarativeBase.metadata.create_all(self.engine)
+
+    def tearDown(self):
+        logger.debug(self, 'TearDown Test...')
+        from tracim.models.meta import DeclarativeBase
+
+        testing.tearDown()
+        transaction.abort()
+        DeclarativeBase.metadata.drop_all(self.engine)
+
+# class DefaultTest(object):
+#
+#     def _create_workspace_and_test(self, name, user) -> Workspace:
+#         """
+#         All extra parameters (*args, **kwargs) are for Workspace init
+#         :return: Created workspace instance
+#         """
+#         WorkspaceApi(user).create_workspace(name, save_now=True)
+#
+#         eq_(1, self.session.query(Workspace).filter(Workspace.label == name).count())
+#         return self.session.query(Workspace).filter(Workspace.label == name).one()
+#
+#     def _create_content_and_test(self, name, workspace, *args, **kwargs) -> Content:
+#         """
+#         All extra parameters (*args, **kwargs) are for Content init
+#         :return: Created Content instance
+#         """
+#         content = Content(*args, **kwargs)
+#         content.label = name
+#         content.workspace = workspace
+#         self.session.add(content)
+#         self.session.flush()
+#
+#         eq_(1, ContentApi.get_canonical_query().filter(Content.label == name).count())
+#         return ContentApi.get_canonical_query().filter(Content.label == name).one()
+#
+#
+# class StandardTest(BaseTest):
+#     """
+#     BaseTest with default fixtures
+#     """
+#     fixtures = [BaseFixture]
+#
+#     def init_database(self):
+#         BaseTest.init_database(self)
+#         fixtures_loader = FixturesLoader([BaseFixture])
+#         fixtures_loader.loads(self.fixtures)

tracim/tests/models/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+"""Unit test suite for the models of the application."""

tracim/tests/models/test_content.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+import time
+
+from depot.fields.upload import UploadedFile
+from nose.tools import ok_
+from nose.tools import raises
+from sqlalchemy.sql.elements import and_
+from sqlalchemy.testing import eq_
+
+# from tracim.lib.content import ContentApi
+from tracim.exceptions import ContentRevisionUpdateError
+from tracim.models import Content
+from tracim.models.revision_protection import new_revision
+from tracim.models import User
+from tracim.models.data import ActionDescription
+from tracim.models.data import ContentRevisionRO
+from tracim.models.data import ContentType
+from tracim.models.data import Workspace
+from tracim.tests import BaseTest
+
+
+class TestContent(BaseTest):
+
+    @raises(ContentRevisionUpdateError)
+    def test_update_without_prepare(self):
+        content1 = self.test_create()
+        content1.description = 'FOO'  # Raise ContentRevisionUpdateError because revision can't be updated
+
+    # TODO - G.M - 28-03-2018 - Reenable this test when libContent is available
+    # def test_query(self):
+    #     content1 = self.test_create()
+    #     with new_revision(content1):
+    #         content1.description = 'TEST_CONTENT_DESCRIPTION_1_UPDATED'
+    #     DBSession.flush()
+    #
+    #     content2 = self.test_create(key='2')
+    #     with new_revision(content2):
+    #         content2.description = 'TEST_CONTENT_DESCRIPTION_2_UPDATED'
+    #     DBSession.flush()
+    #
+    #     workspace1 = DBSession.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_1').one()
+    #     workspace2 = DBSession.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_2').one()
+    #
+    #     # To get Content in database we have to join Content and ContentRevisionRO with particular condition:
+    #     # Join have to be on most recent revision
+    #     join_sub_query = DBSession.query(ContentRevisionRO.revision_id)\
+    #         .filter(ContentRevisionRO.content_id == Content.id)\
+    #         .order_by(ContentRevisionRO.revision_id.desc())\
+    #         .limit(1)\
+    #         .correlate(Content)
+    #
+    #     base_query = DBSession.query(Content)\
+    #         .join(ContentRevisionRO, and_(Content.id == ContentRevisionRO.content_id,
+    #                                       ContentRevisionRO.revision_id == join_sub_query))
+    #
+    #     pattern = 'TEST_CONTENT_DESCRIPTION_%_UPDATED'
+    #     eq_(2, base_query.filter(Content.description.like(pattern)).count())
+    #
+    #     eq_(1, base_query.filter(Content.workspace == workspace1).count())
+    #     eq_(1, base_query.filter(Content.workspace == workspace2).count())
+    #
+    #     content1_from_query = base_query.filter(Content.workspace == workspace1).one()
+    #     eq_(content1.id, content1_from_query.id)
+    #     eq_('TEST_CONTENT_DESCRIPTION_1_UPDATED', content1_from_query.description)
+    #
+    #     user_admin = DBSession.query(User).filter(User.email == 'admin@admin.admin').one()
+    #
+    #     api = ContentApi(None)
+    #
+    #     content1_from_api = api.get_one(content1.id, ContentType.Page, workspace1)
+
+    def test_update(self):
+        created_content = self.test_create()
+        content = self.session.query(Content).filter(Content.id == created_content.id).one()
+        eq_(1, self.session.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count())
+
+        with new_revision(content):
+            time.sleep(0.00001)
+            content.description = 'TEST_CONTENT_DESCRIPTION_1_UPDATED'
+        self.session.flush()
+
+        eq_(2, self.session.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count())
+        eq_(1, self.session.query(Content).filter(Content.id == created_content.id).count())
+
+        with new_revision(content):
+            time.sleep(0.00001)
+            content.description = 'TEST_CONTENT_DESCRIPTION_1_UPDATED_2'
+            content.label = 'TEST_CONTENT_1_UPDATED_2'
+        self.session.flush()
+
+        eq_(1, self.session.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1_UPDATED_2').count())
+        eq_(1, self.session.query(Content).filter(Content.id == created_content.id).count())
+
+        revision_1 = self.session.query(ContentRevisionRO)\
+            .filter(ContentRevisionRO.description == 'TEST_CONTENT_DESCRIPTION_1').one()
+        revision_2 = self.session.query(ContentRevisionRO)\
+            .filter(ContentRevisionRO.description == 'TEST_CONTENT_DESCRIPTION_1_UPDATED').one()
+        revision_3 = self.session.query(ContentRevisionRO)\
+            .filter(ContentRevisionRO.description == 'TEST_CONTENT_DESCRIPTION_1_UPDATED_2').one()
+
+        # Updated dates must be different
+        ok_(revision_1.updated < revision_2.updated < revision_3.updated)
+        # Created dates must be equal
+        ok_(revision_1.created == revision_2.created == revision_3.created)
+
+    def test_creates(self):
+        eq_(0, self.session.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count())
+        eq_(0, self.session.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_1').count())
+
+        user_admin = self.session.query(User).filter(User.email == 'admin@admin.admin').one()
+        workspace = Workspace(label="TEST_WORKSPACE_1")
+        self.session.add(workspace)
+        self.session.flush()
+        eq_(1, self.session.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_1').count())
+
+        first_content = self._create_content(
+            owner=user_admin,
+            workspace=workspace,
+            type=ContentType.Page,
+            label='TEST_CONTENT_1',
+            description='TEST_CONTENT_DESCRIPTION_1',
+            revision_type=ActionDescription.CREATION,
+            is_deleted=False,
+            is_archived=False,
+        )
+
+        eq_(1, self.session.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count())
+
+        content = self.session.query(Content).filter(Content.id == first_content.id).one()
+        eq_('TEST_CONTENT_1', content.label)
+        eq_('TEST_CONTENT_DESCRIPTION_1', content.description)
+
+        # Create a second content
+        second_content = self._create_content(
+            owner=user_admin,
+            workspace=workspace,
+            type=ContentType.Page,
+            label='TEST_CONTENT_2',
+            description='TEST_CONTENT_DESCRIPTION_2',
+            revision_type=ActionDescription.CREATION
+        )
+
+        eq_(1, self.session.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_2').count())
+
+        content = self.session.query(Content).filter(Content.id == second_content.id).one()
+        eq_('TEST_CONTENT_2', content.label)
+        eq_('TEST_CONTENT_DESCRIPTION_2', content.description)
+
+    def test_create(self, key='1'):
+        eq_(0, self.session.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_%s' % key).count())
+        eq_(0, self.session.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_%s' % key).count())
+
+        user_admin = self.session.query(User).filter(User.email == 'admin@admin.admin').one()
+        workspace = Workspace(label="TEST_WORKSPACE_%s" % key)
+        self.session.add(workspace)
+        self.session.flush()
+        eq_(1, self.session.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_%s' % key).count())
+
+        created_content = self._create_content(
+            owner=user_admin,
+            workspace=workspace,
+            type=ContentType.Page,
+            label='TEST_CONTENT_%s' % key,
+            description='TEST_CONTENT_DESCRIPTION_%s' % key,
+            revision_type=ActionDescription.CREATION
+        )
+
+        eq_(1, self.session.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_%s' % key).count())
+
+        content = self.session.query(Content).filter(Content.id == created_content.id).one()
+        eq_('TEST_CONTENT_%s' % key, content.label)
+        eq_('TEST_CONTENT_DESCRIPTION_%s' % key, content.description)
+
+        return created_content
+
+    def _get_user(self):
+        email = 'admin@admin.admin'
+        user_query = self.session.query(User)
+        user_filter = user_query.filter(User.email == email)
+        user = user_filter.one()
+        return user
+
+    def _create_content(self, *args, **kwargs):
+        content = Content(*args, **kwargs)
+        self.session.add(content)
+        self.session.flush()
+        return content
+
+    def _create_content_from_nothing(self):
+        user_admin = self._get_user()
+        workspace = Workspace(label="TEST_WORKSPACE_1")
+        content = self._create_content(
+            owner=user_admin,
+            workspace=workspace,
+            type=ContentType.File,
+            label='TEST_CONTENT_1',
+            description='TEST_CONTENT_DESCRIPTION_1',
+            revision_type=ActionDescription.CREATION,
+        )
+        return content
+
+    def test_unit__content_depot_file(self):
+        """ Depot file access thought content property methods. """
+        content = self._create_content_from_nothing()
+        # tests uninitialized depot file
+        eq_(content.depot_file, None)
+        # initializes depot file
+        # which is able to behave like a python file object
+        content.depot_file = b'test'
+        # tests initialized depot file
+        ok_(content.depot_file)
+        # tests type of initialized depot file
+        eq_(type(content.depot_file), UploadedFile)
+        # tests content of initialized depot file
+        # using depot_file.file of type StoredFile to fetch content back
+        eq_(content.depot_file.file.read(), b'test')

tracim/tests/models/test_content_revision.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+from collections import OrderedDict
+
+from nose.tools import eq_
+from sqlalchemy import inspect
+
+from tracim.models import ContentRevisionRO
+from tracim.models import User
+from tracim.models.data import ContentType
+from tracim.tests import BaseTest
+
+
+class TestContentRevision(BaseTest):
+
+    def _new_from(self, revision):
+        excluded_columns = (
+            'revision_id',
+            '_sa_instance_state',
+            'depot_file',
+            'node',
+            'revision_read_statuses',
+        )
+        revision_columns = [attr.key for attr in inspect(revision).attrs if not attr.key in excluded_columns]
+        new_revision = ContentRevisionRO()
+
+        for revision_column in revision_columns:
+            old_revision_column_value = getattr(revision, revision_column)
+            setattr(new_revision, revision_column, old_revision_column_value)
+
+        return new_revision
+
+    def _get_dict_representation(self, revision):
+        keys_to_remove = ('updated', '_sa_instance_state')
+        dict_repr = OrderedDict(sorted(revision.__dict__.items()))
+        for key_to_remove in keys_to_remove:
+            dict_repr.pop(key_to_remove, None)
+        return dict_repr
+
+    # TODO - G.M - 28-03-2018 - Reenable this test
+    # def test_new_revision(self):
+    #     admin = self.session.query(User).filter(User.email == 'admin@admin.admin').one()
+    #     workspace = self._create_workspace_and_test(name='workspace_1', user=admin)
+    #     folder = self._create_content_and_test(name='folder_1', workspace=workspace, type=ContentType.Folder)
+    #     page = self._create_content_and_test(
+    #         workspace=workspace,
+    #         parent=folder,
+    #         name='file_1',
+    #         description='content of file_1',
+    #         type=ContentType.Page,
+    #         owner=admin
+    #     )
+    #
+    #     self.session.flush()
+    #
+    #     # Model create a new instance with list of column
+    #     new_revision_by_model = ContentRevisionRO.new_from(page.revision)
+    #     # Test create a new instance from dynamic listing of model columns mapping
+    #     new_revision_by_test = self._new_from(page.revision)
+    #
+    #     new_revision_by_model_dict = self._get_dict_representation(new_revision_by_model)
+    #     new_revision_by_test_dict = self._get_dict_representation(new_revision_by_test)
+    #
+    #     # They must be identical
+    #     eq_(new_revision_by_model_dict, new_revision_by_test_dict)

tracim/tests/models/test_user.py

@@ -0,0 +1,44 @@
+import transaction
+
+from nose.tools import eq_
+from nose.tools import ok_
+
+from tracim.tests import BaseTest
+
+from tracim.models.auth import User
+
+
+class TestUserModel(BaseTest):
+
+    def test_create(self):
+        self.session.flush()
+        transaction.commit()
+        name = 'Damien'
+        email = 'damien@accorsi.info'
+
+        user = User()
+        user.display_name = name
+        user.email = email
+
+        self.session.add(user)
+        self.session.flush()
+        transaction.commit()
+
+        new_user = self.session.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)
+
+    def test_null_password(self):
+        # Check bug #70 fixed
+        # http://tracim.org/workspaces/4/folders/5/threads/70
+
+        name = 'Damien'
+        email = 'tracim@trac.im'
+
+        user = User()
+        user.display_name = name
+        user.email = email
+
+        eq_(False, user.validate_password(None))