def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__,

                                  self.permission_id, self.permission_name)

    @classmethod

    def get_by_key(cls, key):

        return cls.query().filter(cls.permission_name == key).scalar()

    @classmethod

    def get_default_perms(cls, default_user_id, cache=True):

        q = Session().query(UserRepoToPerm, Repository, cls)\

            .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\

            .join((cls, UserRepoToPerm.permission_id == cls.permission_id))\

            .filter(UserRepoToPerm.user_id == default_user_id)

        if cache:

            q = q.options(FromCache("sql_cache_short", "get_default_perms"))

        return q.all()

class UserRepoToPerm(Base, BaseModel):

    __tablename__ = 'repo_to_perm'

    __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'extend_existing':True})

    repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

    user = relationship('User')

    permission = relationship('Permission')

    repository = relationship('Repository')

    @classmethod

    def create(cls, user, repository, permission):

        n = cls()

        n.user = user

        n.repository = repository

        n.permission = permission

        Session().add(n)

        return n

    def __repr__(self):

        return '<user:%s => %s >' % (self.user, self.repository)

class UserToPerm(Base, BaseModel):

    __tablename__ = 'user_to_perm'

    __table_args__ = (UniqueConstraint('user_id', 'permission_id'), {'extend_existing':True})

    user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    user = relationship('User')

    permission = relationship('Permission', lazy='joined')

    @classmethod

    def has_perm(cls, user_id, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class')

        return cls.query().filter(cls.user_id == user_id)\

            .filter(cls.permission == perm).scalar() is not None

    @classmethod

    def grant_perm(cls, user_id, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class')

        new = cls()

        new.user_id = user_id

        new.permission = perm

        try:

            Session().add(new)

            Session().commit()

        except:

            Session().rollback()

    @classmethod

    def revoke_perm(cls, user_id, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class')

        try:

            obj = cls.query().filter(cls.user_id == user_id)\

                    .filter(cls.permission == perm).one()

            Session().delete(obj)

            Session().commit()

        except:

            Session().rollback()

class UsersGroupRepoToPerm(Base, BaseModel):

    __tablename__ = 'users_group_repo_to_perm'

    __table_args__ = (UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), {'extend_existing':True})

    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UsersGroup')

    permission = relationship('Permission')

    repository = relationship('Repository')

    @classmethod

    def create(cls, users_group, repository, permission):

        n = cls()

        n.users_group = users_group

        n.repository = repository

        n.permission = permission

        Session().add(n)

        return n

    def __repr__(self):

        return '<userGroup:%s => %s >' % (self.users_group, self.repository)

class UsersGroupToPerm(Base, BaseModel):

    __tablename__ = 'users_group_to_perm'

    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UsersGroup')

    permission = relationship('Permission')

    @classmethod

    def has_perm(cls, users_group_id, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class')

        return cls.query().filter(cls.users_group_id ==

                                         users_group_id)\

                                         .filter(cls.permission == perm)\

                                         .scalar() is not None

    @classmethod

    def grant_perm(cls, users_group_id, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class')

        new = cls()

        new.users_group_id = users_group_id

        new.permission = perm

        try:

            Session().add(new)

            Session().commit()

        except:

            Session().rollback()

    @classmethod

    def revoke_perm(cls, users_group_id, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class')

        try:

            obj = cls.query().filter(cls.users_group_id == users_group_id)\

                .filter(cls.permission == perm).one()

            Session().delete(obj)

            Session().commit()

        except:

            Session().rollback()

class UserRepoGroupToPerm(Base, BaseModel):

    __tablename__ = 'group_to_perm'

    __table_args__ = (UniqueConstraint('group_id', 'permission_id'), {'extend_existing':True})

    group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

    user = relationship('User')

    permission = relationship('Permission')

    group = relationship('RepoGroup')

class UsersGroupRepoGroupToPerm(Base, BaseModel):

    __tablename__ = 'users_group_repo_group_to_perm'

    __table_args__ = (UniqueConstraint('group_id', 'permission_id'), {'extend_existing':True})

    users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UsersGroup')

    permission = relationship('Permission')

    group = relationship('RepoGroup')

class Statistics(Base, BaseModel):

    __tablename__ = 'statistics'

    __table_args__ = (UniqueConstraint('repository_id'), {'extend_existing':True})

    stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)

    stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)

    commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data

    commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data

    languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data

    repository = relationship('Repository', single_parent=True)

class UserFollowing(Base, BaseModel):

    __tablename__ = 'user_followings'

    __table_args__ = (UniqueConstraint('user_id', 'follows_repository_id'),

                      UniqueConstraint('user_id', 'follows_user_id')

                      , {'extend_existing':True})

    user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)

    follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

    follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

    user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

    follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

    follows_repository = relationship('Repository', order_by='Repository.repo_name')

    @classmethod

    def get_repo_followers(cls, repo_id):

        return cls.query().filter(cls.follows_repo_id == repo_id)

class CacheInvalidation(Base, BaseModel):

    __tablename__ = 'cache_invalidation'

    __table_args__ = (UniqueConstraint('cache_key'), {'extend_existing':True})

    cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    cache_key = Column("cache_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    cache_args = Column("cache_args", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)

    def __init__(self, cache_key, cache_args=''):

        self.cache_key = cache_key

        self.cache_args = cache_args

        self.cache_active = False

    def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__,

                                  self.cache_id, self.cache_key)

    @classmethod

    def invalidate(cls, key):

        """

        Returns Invalidation object if this given key should be invalidated

        None otherwise. `cache_active = False` means that this cache

        state is not valid and needs to be invalidated

        :param key:

        """

        return cls.query()\

                .filter(CacheInvalidation.cache_key == key)\

                .filter(CacheInvalidation.cache_active == False)\

                .scalar()

    @classmethod

    def set_invalidate(cls, key):

        """

        Mark this Cache key for invalidation

        :param key:

        """

        log.debug('marking %s for invalidation' % key)

        inv_obj = Session().query(cls)\

            .filter(cls.cache_key == key).scalar()

        if inv_obj:

            inv_obj.cache_active = False

        else:

            log.debug('cache key not found in invalidation db -> creating one')

            inv_obj = CacheInvalidation(key)

        try:

            Session().add(inv_obj)

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            Session().rollback()

    @classmethod

    def set_valid(cls, key):

        """

        Mark this cache key as active and currently cached

        :param key:

        """

        inv_obj = CacheInvalidation.query()\

            .filter(CacheInvalidation.cache_key == key).scalar()

        inv_obj.cache_active = True

        Session().add(inv_obj)

        Session().commit()

class ChangesetComment(Base, BaseModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = ({'extend_existing':True},)

    comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)

    repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    revision = Column('revision', String(40), nullable=False)

    line_no = Column('line_no', Unicode(10), nullable=True)

    f_path = Column('f_path', Unicode(1000), nullable=True)

    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    text = Column('text', Unicode(25000), nullable=False)

    modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)

    author = relationship('User', lazy='joined')

    repo = relationship('Repository')

    @classmethod

    def get_users(cls, revision):

        """

        Returns user associated with this changesetComment. ie those

        who actually commented

        :param cls:

        :param revision:

        """

        return Session().query(User)\

                .filter(cls.revision == revision)\

                .join(ChangesetComment.author).all()

class Notification(Base, BaseModel):

    __tablename__ = 'notifications'

    __table_args__ = ({'extend_existing':True})

    TYPE_CHANGESET_COMMENT = u'cs_comment'

    TYPE_MESSAGE = u'message'

    TYPE_MENTION = u'mention'

    TYPE_REGISTRATION = u'registration'

    notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)

    subject = Column('subject', Unicode(512), nullable=True)

    body = Column('body', Unicode(50000), nullable=True)

    created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)

    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    type_ = Column('type', Unicode(256))

    created_by_user = relationship('User')

    notifications_to_users = relationship('UserNotification', lazy='joined',

                                          cascade="all, delete, delete-orphan")

    @property

    def recipients(self):

        return [x.user for x in UserNotification.query()\

                .filter(UserNotification.notification == self).all()]

    @classmethod

    def create(cls, created_by, subject, body, recipients, type_=None):

        if type_ is None:

            type_ = Notification.TYPE_MESSAGE

        notification = cls()

        notification.created_by_user = created_by

        notification.subject = subject

        notification.body = body

        notification.type_ = type_

        notification.created_on = datetime.datetime.now()

        for u in recipients:

            assoc = UserNotification()

            assoc.notification = notification

            u.notifications.append(assoc)

        Session().add(notification)

        return notification

    @property

    def description(self):

        from rhodecode.model.notification import NotificationModel

        return NotificationModel().make_description(self)

class UserNotification(Base, BaseModel):

    __tablename__ = 'user_to_notification'

    __table_args__ = (UniqueConstraint('user_id', 'notification_id'),

                      {'extend_existing':True})

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), primary_key=True)

    notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

    read = Column('read', Boolean, default=False)

    sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

    user = relationship('User', lazy="joined")

    notification = relationship('Notification', lazy="joined",

    def mark_as_read(self):

        self.read = True

        Session().add(self)

class DbMigrateVersion(Base, BaseModel):

    __tablename__ = 'db_migrate_version'

    __table_args__ = {'extend_existing':True}

    repository_id = Column('repository_id', String(250), primary_key=True)

    repository_path = Column('repository_path', Text)

    version = Column('version', Integer)

import os

import unittest

from rhodecode.tests import *

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.repo import RepoModel

from rhodecode.model.db import RepoGroup, User, Notification, UserNotification, \

    UsersGroup, UsersGroupMember

from sqlalchemy.exc import IntegrityError

from rhodecode.model.user import UserModel

from rhodecode.model.meta import Session

from rhodecode.model.notification import NotificationModel

from rhodecode.model.users_group import UsersGroupModel

class TestReposGroups(unittest.TestCase):

    def setUp(self):

        self.g1 = self.__make_group('test1', skip_if_exists=True)

        self.g2 = self.__make_group('test2', skip_if_exists=True)

        self.g3 = self.__make_group('test3', skip_if_exists=True)

    def tearDown(self):

        print 'out'

    def __check_path(self, *path):

        path = [TESTS_TMP_PATH] + list(path)

        path = os.path.join(*path)

        return os.path.isdir(path)

    def _check_folders(self):

        print os.listdir(TESTS_TMP_PATH)

    def __make_group(self, path, desc='desc', parent_id=None,

                     skip_if_exists=False):

        gr = RepoGroup.get_by_group_name(path)

        if gr and skip_if_exists:

            return gr

        form_data = dict(group_name=path,

                         group_description=desc,

                         group_parent_id=parent_id)

        gr = ReposGroupModel().create(form_data)

        return gr

    def __delete_group(self, id_):

        ReposGroupModel().delete(id_)

    def __update_group(self, id_, path, desc='desc', parent_id=None):

        form_data = dict(group_name=path,

                         group_description=desc,

                         group_parent_id=parent_id)

        gr = ReposGroupModel().update(id_, form_data)

        return gr

    def test_create_group(self):

        g = self.__make_group('newGroup')

        self.assertEqual(g.full_path, 'newGroup')

        self.assertTrue(self.__check_path('newGroup'))

    def test_create_same_name_group(self):

        self.assertRaises(IntegrityError, lambda:self.__make_group('newGroup'))

    def test_same_subgroup(self):

        sg1 = self.__make_group('sub1', parent_id=self.g1.group_id)

        self.assertEqual(sg1.parent_group, self.g1)

        self.assertEqual(sg1.full_path, 'test1/sub1')

        self.assertTrue(self.__check_path('test1', 'sub1'))

        ssg1 = self.__make_group('subsub1', parent_id=sg1.group_id)

        self.assertEqual(ssg1.parent_group, sg1)

        self.assertEqual(ssg1.full_path, 'test1/sub1/subsub1')

        self.assertTrue(self.__check_path('test1', 'sub1', 'subsub1'))

    def test_remove_group(self):

        sg1 = self.__make_group('deleteme')

        self.__delete_group(sg1.group_id)

        self.assertEqual(RepoGroup.get(sg1.group_id), None)

        self.assertFalse(self.__check_path('deteteme'))

        sg1 = self.__make_group('deleteme', parent_id=self.g1.group_id)

        self.__delete_group(sg1.group_id)

        self.assertEqual(RepoGroup.get(sg1.group_id), None)

        self.assertFalse(self.__check_path('test1', 'deteteme'))

    def test_rename_single_group(self):

        sg1 = self.__make_group('initial')

        new_sg1 = self.__update_group(sg1.group_id, 'after')

        self.assertTrue(self.__check_path('after'))

        self.assertEqual(RepoGroup.get_by_group_name('initial'), None)

    def test_update_group_parent(self):

        sg1 = self.__make_group('initial', parent_id=self.g1.group_id)

        new_sg1 = self.__update_group(sg1.group_id, 'after', parent_id=self.g1.group_id)

        self.assertTrue(self.__check_path('test1', 'after'))

        self.assertEqual(RepoGroup.get_by_group_name('test1/initial'), None)

        new_sg1 = self.__update_group(sg1.group_id, 'after', parent_id=self.g3.group_id)

        self.assertTrue(self.__check_path('test3', 'after'))

        self.assertEqual(RepoGroup.get_by_group_name('test3/initial'), None)

        new_sg1 = self.__update_group(sg1.group_id, 'hello')

        self.assertTrue(self.__check_path('hello'))

        self.assertEqual(RepoGroup.get_by_group_name('hello'), new_sg1)

    def test_subgrouping_with_repo(self):

        g1 = self.__make_group('g1')

        g2 = self.__make_group('g2')

        # create new repo

        form_data = dict(repo_name='john',

                         repo_name_full='john',

                         fork_name=None,

                         description=None,

                         repo_group=None,

                         private=False,

                         repo_type='hg',

                         clone_uri=None)

        cur_user = User.get_by_username(TEST_USER_ADMIN_LOGIN)

        r = RepoModel().create(form_data, cur_user)

        self.assertEqual(r.repo_name, 'john')

        # put repo into group

        form_data = form_data

        form_data['repo_group'] = g1.group_id

        form_data['perms_new'] = []

        form_data['perms_updates'] = []

        RepoModel().update(r.repo_name, form_data)

        self.assertEqual(r.repo_name, 'g1/john')

        self.__update_group(g1.group_id, 'g1', parent_id=g2.group_id)

        self.assertTrue(self.__check_path('g2', 'g1'))

        # test repo

        self.assertEqual(r.repo_name, os.path.join('g2', 'g1', r.just_name))

class TestUser(unittest.TestCase):

    def test_create_and_remove(self):

        usr = UserModel().create_or_update(username=u'test_user', password=u'qweqwe',

                                     email=u'u232@rhodecode.org',

                                     name=u'u1', lastname=u'u1')

        self.assertEqual(User.get_by_username(u'test_user'), usr)

        # make users group

        users_group = UsersGroupModel().create_('some_example_group')

        Session().commit()

        UsersGroupModel().add_user_to_group(users_group, usr)

        self.assertEqual(UsersGroup.get(users_group.users_group_id), users_group)

        self.assertEqual(UsersGroupMember.query().count(), 1)

        UserModel().delete(usr.user_id)

        self.assertEqual(UsersGroupMember.query().all(), [])

class TestNotifications(unittest.TestCase):

    def __init__(self, methodName='runTest'):

        self.u1 = UserModel().create_or_update(username=u'u1',

                                        password=u'qweqwe',

                                        email=u'u1@rhodecode.org',

                                        name=u'u1', lastname=u'u1').user_id

        self.u2 = UserModel().create_or_update(username=u'u2',

                                        password=u'qweqwe',

                                        email=u'u2@rhodecode.org',

                                        name=u'u2', lastname=u'u3').user_id

        self.u3 = UserModel().create_or_update(username=u'u3',

                                        password=u'qweqwe',

                                        email=u'u3@rhodecode.org',

                                        name=u'u3', lastname=u'u3').user_id

        super(TestNotifications, self).__init__(methodName=methodName)

    def _clean_notifications(self):

        for n in Notification.query().all():

            Session().delete(n)

        Session().commit()

        self.assertEqual(Notification.query().all(), [])

    def test_create_notification(self):

        self.assertEqual([], Notification.query().all())

        self.assertEqual([], UserNotification.query().all())

        usrs = [self.u1, self.u2]

        notification = NotificationModel().create(created_by=self.u1,

                                           subject=u'subj', body=u'hi there',

                                           recipients=usrs)

        Session().commit()

        u1 = User.get(self.u1)

        u2 = User.get(self.u2)

        u3 = User.get(self.u3)

        notifications = Notification.query().all()

        self.assertEqual(len(notifications), 1)

        unotification = UserNotification.query()\

            .filter(UserNotification.notification == notification).all()

        self.assertEqual(notifications[0].recipients, [u1, u2])

        self.assertEqual(notification.notification_id,

                         notifications[0].notification_id)

        self.assertEqual(len(unotification), len(usrs))

        self.assertEqual([x.user.user_id for x in unotification], usrs)

        self._clean_notifications()

    def test_user_notifications(self):

        self.assertEqual([], Notification.query().all())

        self.assertEqual([], UserNotification.query().all())

        notification1 = NotificationModel().create(created_by=self.u1,

                                            subject=u'subj', body=u'hi there1',

                                            recipients=[self.u3])

        Session().commit()

        notification2 = NotificationModel().create(created_by=self.u1,

                                            subject=u'subj', body=u'hi there2',

                                            recipients=[self.u3])

        Session().commit()

        u3 = Session().query(User).get(self.u3)

        self.assertEqual(sorted([x.notification for x in u3.notifications]),

                         sorted([notification2, notification1]))

        self._clean_notifications()

    def test_delete_notifications(self):

        self.assertEqual([], Notification.query().all())

        self.assertEqual([], UserNotification.query().all())

        notification = NotificationModel().create(created_by=self.u1,

                                           subject=u'title', body=u'hi there3',

                                    recipients=[self.u3, self.u1, self.u2])

        Session().commit()

        notifications = Notification.query().all()

        self.assertTrue(notification in notifications)

        Notification.delete(notification.notification_id)

        Session().commit()

        notifications = Notification.query().all()

        self.assertFalse(notification in notifications)

        un = UserNotification.query().filter(UserNotification.notification

                                             == notification).all()

        self.assertEqual(un, [])

        self._clean_notifications()

    def test_delete_association(self):

        self.assertEqual([], Notification.query().all())

        self.assertEqual([], UserNotification.query().all())

        notification = NotificationModel().create(created_by=self.u1,

                                           subject=u'title', body=u'hi there3',

                                    recipients=[self.u3, self.u1, self.u2])

        Session().commit()

        unotification = UserNotification.query()\

                            .filter(UserNotification.notification ==

                                    notification)\

                            .filter(UserNotification.user_id == self.u3)\

                            .scalar()

        self.assertEqual(unotification.user_id, self.u3)

        NotificationModel().delete(self.u3,

                                   notification.notification_id)

        Session().commit()

                            .filter(UserNotification.notification ==

                                    notification)\

                            .filter(UserNotification.user_id == self.u3)\

                            .scalar()

        self._clean_notifications()

    def test_notification_counter(self):

        self._clean_notifications()

        self.assertEqual([], Notification.query().all())

        self.assertEqual([], UserNotification.query().all())

        NotificationModel().create(created_by=self.u1,

                            subject=u'title', body=u'hi there_delete',

                            recipients=[self.u3, self.u1])

        Session().commit()

        self.assertEqual(NotificationModel()

                         .get_unread_cnt_for_user(self.u1), 1)

        self.assertEqual(NotificationModel()

                         .get_unread_cnt_for_user(self.u2), 0)

        self.assertEqual(NotificationModel()

                         .get_unread_cnt_for_user(self.u3), 1)

        notification = NotificationModel().create(created_by=self.u1,

                                           subject=u'title', body=u'hi there3',

                                    recipients=[self.u3, self.u1, self.u2])

        Session().commit()

        self.assertEqual(NotificationModel()

                         .get_unread_cnt_for_user(self.u1), 2)

        self.assertEqual(NotificationModel()

                         .get_unread_cnt_for_user(self.u2), 1)

        self.assertEqual(NotificationModel()

                         .get_unread_cnt_for_user(self.u3), 2)

        self._clean_notifications()