def test_func__rights_read_workspace_calendar__fail__as_unauthorized(self): lawrence = DBSession.query(User).filter( User.email == '*****@*****.**' ).one() workspace = WorkspaceApi(lawrence).create_workspace( 'workspace_1', save_now=False ) workspace.calendar_enabled = True DBSession.flush() workspace_calendar_url = CalendarManager.get_workspace_calendar_url( workspace.workspace_id ) transaction.commit() radicale_base_url = CalendarManager.get_base_url() client = caldav.DAVClient( radicale_base_url, username='******', password='******' ) caldav.Calendar( parent=client, client=client, url=workspace_calendar_url ).events()
def test_new_revision(self): admin = DBSession.query(User).filter(User.email == '*****@*****.**').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 ) DBSession.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)
def _load(self, fixture_class): if fixture_class not in self._loaded: fixture = fixture_class(DBSession) fixture.insert() self._loaded.append(fixture_class) DBSession.flush() transaction.commit()
def test_unit__rename_content__ok(self): provider = self._get_provider() environ = self._get_environ( provider, '*****@*****.**', ) w1f1d1 = provider.getResourceInst( '/w1/w1f1/w1f1d1.txt', environ, ) content_w1f1d1 = DBSession.query(ContentRevisionRO) \ .filter(Content.label == 'w1f1d1') \ .one() # It must exist only one revision, cf fixtures ok_(content_w1f1d1, msg='w1f1d1 should be exist') content_w1f1d1_id = content_w1f1d1.content_id w1f1d1.moveRecursive('/w1/w1f1/w1f1d1_RENAMED.txt') # Database content is renamed content_w1f1d1 = DBSession.query(ContentRevisionRO) \ .filter(ContentRevisionRO.content_id == content_w1f1d1_id) \ .order_by(ContentRevisionRO.revision_id.desc()) \ .first() eq_( 'w1f1d1_RENAMED', content_w1f1d1.label, msg='File should be labeled w1f1d1_RENAMED, not {0}'.format( content_w1f1d1.label ) )
def ensure_calendar_exist(self, workspace: Workspace) -> None: # Note: Cyclic imports from tracim.lib.calendar import CalendarManager from tracim.model.organisational import WorkspaceCalendar calendar_manager = CalendarManager(self._user) try: calendar_manager.enable_calendar_file( calendar_class=WorkspaceCalendar, related_object_id=workspace.workspace_id, raise_=True, ) # If previous calendar file no exist, calendar must be created except FileNotFoundError: self._user.ensure_auth_token() # Ensure database is up-to-date DBSession.flush() transaction.commit() calendar_manager.create_then_remove_fake_event( calendar_class=WorkspaceCalendar, related_object_id=workspace.workspace_id, )
def test_create(self, key='1'): eq_(0, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_%s' % key).count()) eq_(0, DBSession.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_%s' % key).count()) user_admin = DBSession.query(User).filter(User.email == '*****@*****.**').one() workspace = Workspace(label="TEST_WORKSPACE_%s" % key) DBSession.add(workspace) DBSession.flush() eq_(1, DBSession.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, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_%s' % key).count()) content = DBSession.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 delete(self, token): """Delete lock. Returns True on success. False, if token does not exist, or is expired. """ self._lock.acquireWrite() try: lock_db = self.__base_query().filter(Lock.token == token).one_or_none() _logger.debug("delete %s" % lockString(from_base_to_dict(lock_db))) if lock_db is None: return False # Remove url to lock mapping url2token = DBSession.query(Url2Token).filter( Url2Token.path == lock_db.root, Url2Token.token == token).one_or_none() if url2token is not None: DBSession.delete(url2token) # Remove the lock DBSession.delete(lock_db) transaction.commit() self._flush() finally: self._lock.release() return True
def test_create_user(self): self._connect_user( '*****@*****.**', '*****@*****.**', ) user_count = DBSession.query(User) \ .filter(User.email == '*****@*****.**').count() eq_(0, user_count, 'User should not exist yet') # Create a new user try_post_user = self.app.post( '/admin/users', OrderedDict([ ('name', 'TEST'), ('email', '*****@*****.**'), ('password', 'password'), ('is_tracim_manager', 'off'), ('is_tracim_admin', 'off'), ('send_email', 'off'), ]) ) eq_(try_post_user.status_code, 302, "Code should be 302, but is %d" % try_post_user.status_code) user = DBSession.query(User) \ .filter(User.email == '*****@*****.**').one() ok_(user, msg="User should exist now") ok_(user.validate_password('password')) # User must have webdav digest ok_(user.webdav_left_digest_response_hash)
def test_update_password(self): self._connect_user( '*****@*****.**', 'foobarbaz', ) user = DBSession.query(User) \ .filter(User.email == '*****@*****.**').one() webdav_digest = user.webdav_left_digest_response_hash try_post_user = self.app.post( '/user/{user_id}/password?_method=PUT'.format( user_id=user.user_id ), OrderedDict([ ('current_password', 'foobarbaz'), ('new_password1', 'new-password'), ('new_password2', 'new-password'), ]) ) eq_(try_post_user.status_code, 302, "Code should be 302, but is %d" % try_post_user.status_code) user = DBSession.query(User) \ .filter(User.email == '*****@*****.**').one() ok_(user.validate_password('new-password')) ok_( webdav_digest != user.webdav_left_digest_response_hash, msg='Webdav digest should be updated', )
def create(self, content_type: str, workspace: Workspace, parent: Content=None, label:str ='', do_save=False, is_temporary: bool=False) -> Content: assert content_type in ContentType.allowed_types() if content_type == ContentType.Folder and not label: label = self.generate_folder_label(workspace, parent) content = Content() content.owner = self._user content.parent = parent content.workspace = workspace content.type = content_type content.label = label content.is_temporary = is_temporary content.revision_type = ActionDescription.CREATION if content.type in ( ContentType.Page, ContentType.Thread, ): content.file_extension = '.html' if do_save: DBSession.add(content) self.save(content, ActionDescription.CREATION) return content
def tearDown(self): """Tear down test fixture for each functional test method.""" DBSession.close() daemons.execute_in_thread('radicale', lambda: transaction.commit()) teardown_db() transaction.commit() DBSession.close_all() config['tg.app_globals'].sa_engine.dispose()
def _get_content_by_label(self, label: str) -> Content: revision = DBSession.query(ContentRevisionRO) \ .filter(ContentRevisionRO.label == label) \ .one() return DBSession.query(Content) \ .filter(Content.id == revision.content_id) \ .one()
def restore_one(self, workspace_id, flush=True): workspace = DBSession.query(Workspace).filter(Workspace.is_deleted==True).filter(Workspace.workspace_id==workspace_id).one() workspace.is_deleted = False if flush: DBSession.flush() return workspace
def test_ldap_auth_fail_no_account(self): # User is unknown in tracim database eq_(0, DBSession.query(User).filter(User.email == '*****@*****.**').count()) self._connect_user('*****@*****.**', 'no-pass') # User is registered in tracim database eq_(0, DBSession.query(User).filter(User.email == '*****@*****.**').count())
def test_ldap_auth_sync(self): # User is unknown in tracim database eq_(0, DBSession.query(User).filter(User.email == '*****@*****.**').count()) self._connect_user('*****@*****.**', 'rms') # User is registered in tracim database eq_(1, DBSession.query(User).filter(User.email == '*****@*****.**').count())
def _base_query(self): if self._user.profile.id>=Group.TIM_ADMIN: return DBSession.query(Workspace).filter(Workspace.is_deleted==False) return DBSession.query(Workspace).\ join(Workspace.roles).\ filter(UserRoleInWorkspace.user_id==self._user.user_id).\ filter(Workspace.is_deleted==False)
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, DBSession.query(Workspace).filter(Workspace.label == name).count()) return DBSession.query(Workspace).filter(Workspace.label == name).one()
def test_create_with_group(self): more_args = ['--add-to-group', 'managers', '--add-to-group', 'administrators'] self._create_user('*****@*****.**', 'toor', more_args=more_args) user = DBSession.query(User).filter(User.email == '*****@*****.**').one() group_managers = DBSession.query(Group).filter(Group.group_name == 'managers').one() group_administrators = DBSession.query(Group).filter(Group.group_name == 'administrators').one() ok_(user in group_managers.users) ok_(user in group_administrators.users)
def create_one(self, user: User, workspace: Workspace, role_level: int, with_notif: bool, flush: bool=True) -> UserRoleInWorkspace: role = self.create_role() role.user_id = user.user_id role.workspace = workspace role.role = role_level role.do_notify = with_notif if flush: DBSession.flush() return role
def test_change_groups(self): # create an user in managers group more_args = ['--add-to-group', 'managers'] self._create_user('*****@*****.**', 'toor', more_args=more_args) user = DBSession.query(User).filter(User.email == '*****@*****.**').one() group_managers = DBSession.query(Group).filter(Group.group_name == 'managers').one() group_administrators = DBSession.query(Group).filter(Group.group_name == 'administrators').one() ok_(user in group_managers.users) ok_(user not in group_administrators.users) # Update him and add to administrators group add_to_admins_argvs = ['-l', '*****@*****.**', '--add-to-group', 'administrators'] self._execute_command(UpdateUserCommand, 'gearbox user update', add_to_admins_argvs) user = DBSession.query(User).filter(User.email == '*****@*****.**').one() group_managers = DBSession.query(Group).filter(Group.group_name == 'managers').one() group_administrators = DBSession.query(Group).filter(Group.group_name == 'administrators').one() ok_(user in group_managers.users) ok_(user in group_administrators.users) # remove him from administrators group remove_from_admins_argvs = ['-l', '*****@*****.**', '--remove-from-group', 'administrators'] self._execute_command(UpdateUserCommand, 'gearbox user update', remove_from_admins_argvs) user = DBSession.query(User).filter(User.email == '*****@*****.**').one() group_managers = DBSession.query(Group).filter(Group.group_name == 'managers').one() group_administrators = DBSession.query(Group).filter(Group.group_name == 'administrators').one() ok_(user in group_managers.users) ok_(user not in group_administrators.users)
def test_created_workspace_radicale_calendar(self): self._connect_user( '*****@*****.**', '*****@*****.**', ) workspaces_count = DBSession.query(Workspace)\ .filter(Workspace.label == 'WTESTCAL').count() eq_(0, workspaces_count, 'Workspace should not exist yet !') radicale_workspaces_folder = '{0}/workspace'\ .format(config.get('radicale.server.filesystem.folder')) eq_( False, os.path.isdir(radicale_workspaces_folder), 'Radicale workskpaces folder should not exist yet', ) # Create a new workspace, his calendar should be created to try_post_workspace = self.app.post( '/admin/workspaces', OrderedDict([ ('name', 'WTESTCAL'), ('description', 'WTESTCALDESCR'), ('calendar_enabled', 'on'), ]) ) eq_(try_post_workspace.status_code, 302, "Code should be 302, but is %d" % try_post_workspace.status_code) workspaces_calendars = len([ name for name in os.listdir(radicale_workspaces_folder) if name.endswith('.ics') ]) workspace = DBSession.query(Workspace) \ .filter(Workspace.label == 'WTESTCAL').one() eq_( 1, workspaces_calendars, 'Radicale workspace path should list 1 calendar', ) workspace_calendar = '{0}/{1}.ics'.format( radicale_workspaces_folder, workspace.workspace_id, ) workspace_calendar_exist = os.path.isfile(workspace_calendar) eq_( True, workspace_calendar_exist, 'Workspace calendar should be created', )
def get_last_unread(self, parent_id: int, content_type: str, workspace: Workspace=None, limit=10) -> [Content]: assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE assert content_type is not None# DYN_REMOVE assert isinstance(content_type, str) # DYN_REMOVE read_revision_ids = DBSession.query(RevisionReadStatus.revision_id) \ .filter(RevisionReadStatus.user_id==self._user_id) not_read_revisions = self._revisions_base_query(workspace) \ .filter(~ContentRevisionRO.revision_id.in_(read_revision_ids)) \ .subquery() not_read_content_ids_query = DBSession.query( distinct(not_read_revisions.c.content_id) ) not_read_content_ids = list(map( itemgetter(0), not_read_content_ids_query, )) not_read_contents = self._base_query(workspace) \ .filter(Content.content_id.in_(not_read_content_ids)) \ .order_by(desc(Content.updated)) if content_type != ContentType.Any: not_read_contents = not_read_contents.filter( Content.type==content_type) else: not_read_contents = not_read_contents.filter( Content.type!=ContentType.Folder) if parent_id: not_read_contents = not_read_contents.filter( Content.parent_id==parent_id) result = [] for item in not_read_contents: new_item = None if ContentType.Comment == item.type: new_item = item.parent else: new_item = item # INFO - D.A. - 2015-05-20 # We do not want to show only one item if the last 10 items are # comments about one thread for example if new_item not in result: result.append(new_item) if len(result) >= limit: break return result
def create_one(self, user: User, workspace: Workspace, role_level: int, with_notif: bool, flush: bool=True) -> UserRoleInWorkspace: role = self.create_role() role.user_id = user.user_id role.workspace = workspace role.role = role_level if with_notif is not None: from tracim.lib.helpers import on_off_to_boolean role.do_notify = on_off_to_boolean(with_notif) if flush: DBSession.flush() return role
def test_children(self): admin = DBSession.query(User).filter(User.email == '*****@*****.**').one() self._create_thread_and_test( workspace_name='workspace_1', folder_name='folder_1', thread_name='thread_1', user=admin ) workspace = DBSession.query(Workspace).filter(Workspace.label == 'workspace_1').one() folder = ContentApi.get_canonical_query().filter(Content.label == 'folder_1').one() eq_([folder, ], list(workspace.get_valid_children()))
def test_ldap_attributes_sync(self): # User is already know in database eq_(1, DBSession.query(User).filter(User.email == '*****@*****.**').count()) # His display name is Lawrence L. lawrence = DBSession.query(User).filter(User.email == '*****@*****.**').one() eq_('Lawrence L.', lawrence.display_name) # After connexion with LDAP, his display_name is updated (see ldap fixtures) self._connect_user('*****@*****.**', 'foobarbaz') lawrence = DBSession.query(User).filter(User.email == '*****@*****.**').one() eq_('Lawrence Lessig', lawrence.display_name)
def test_func__event_create__ok__nominal_case(self): lawrence = DBSession.query(User).filter( User.email == '*****@*****.**' ).one() radicale_base_url = CalendarManager.get_base_url() client = caldav.DAVClient( radicale_base_url, username='******', password='******' ) user_calendar_url = CalendarManager.get_user_calendar_url( lawrence.user_id ) user_calendar = caldav.Calendar( parent=client, client=client, url=user_calendar_url ) event_ics = """BEGIN:VCALENDAR VERSION:2.0 PRODID:-//Example Corp.//CalDAV Client//EN BEGIN:VEVENT UID:1234567890 DTSTAMP:20100510T182145Z DTSTART:20100512T170000Z DTEND:20100512T180000Z SUMMARY:This is an event LOCATION:Here END:VEVENT END:VCALENDAR """ user_calendar.add_event(event_ics) user_calendar.save() daemons.execute_in_thread('radicale', lambda: transaction.commit()) # TODO - 20160606 - Bastien: lock should be better here ? time.sleep(3) # Wait for be sure transaction commited in daemon transaction.commit() try: event = DBSession.query(Content) \ .filter(Content.label == 'This is an event') \ .filter(Content.owner_id == lawrence.user_id) \ .filter(Content.id == ContentRevisionRO.content_id) \ .one() except NoResultFound: ok_(False, 'Content record should exist for ' '"This is an event" label') eq_(event.properties['location'], 'Here') eq_(event.properties['start'], '2010-05-12 18:00:00+0000') eq_(event.properties['end'], '2010-05-12 17:00:00+0000')
def post(self, name, description, calendar_enabled: str='off'): # FIXME - Check user profile user = tmpl_context.current_user workspace_api_controller = WorkspaceApi(user) calendar_enabled = on_off_to_boolean(calendar_enabled) workspace = workspace_api_controller.create_workspace(name, description) workspace.calendar_enabled = calendar_enabled DBSession.flush() tg.flash(_('{} workspace created.').format(workspace.label), CST.STATUS_OK) tg.redirect(self.url()) return
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 DBSession.add(content) DBSession.flush() eq_(1, ContentApi.get_canonical_query().filter(Content.label == name).count()) return ContentApi.get_canonical_query().filter(Content.label == name).one()
def __revisions_real_base_query(self, workspace: Workspace=None): result = DBSession.query(ContentRevisionRO) if workspace: result = result.filter(ContentRevisionRO.workspace_id==workspace.workspace_id) if self._user: user = DBSession.query(User).get(self._user_id) # Filter according to user workspaces workspace_ids = [r.workspace_id for r in user.roles \ if r.role>=UserRoleInWorkspace.READER] result = result.filter(ContentRevisionRO.workspace_id.in_(workspace_ids)) return result
def create(self, content_type: str, workspace: Workspace, parent: Content=None, label:str ='', do_save=False) -> Content: assert content_type in ContentType.allowed_types() content = Content() content.owner = self._user content.parent = parent content.workspace = workspace content.type = content_type content.label = label content.revision_type = ActionDescription.CREATION if do_save: DBSession.add(content) self.save(content, ActionDescription.CREATION) return content
def _get_all_for_user(self, user_id): return DBSession.query(UserRoleInWorkspace).filter( UserRoleInWorkspace.user_id == user_id)
def get_all_for_workspace(self, workspace_id): return DBSession.query(UserRoleInWorkspace).filter( UserRoleInWorkspace.workspace_id == workspace_id).all()
def tearDown(self): """Tear down test fixture for each functional test method.""" DBSession.close() daemons.execute_in_thread('radicale', lambda: transaction.commit()) teardown_db()
def delete_one(self, user_id, workspace_id, flush=True): self._get_one_rsc(user_id, workspace_id).delete() if flush: DBSession.flush()
def flush(self): DBSession.flush()
def _base_query(self): return DBSession.query(User)
def save(self, role: UserRoleInWorkspace): DBSession.flush()
def put(self, new_profile): # FIXME - Allow only self password or operation for managers current_user = tmpl_context.current_user user = tmpl_context.user group_api = GroupApi(current_user) if current_user.user_id == user.user_id: tg.flash(_('You can\'t change your own profile'), CST.STATUS_ERROR) tg.redirect(self.parent_controller.url()) redirect_url = self.parent_controller.url(skip_id=True) if new_profile not in self.allowed_profiles: tg.flash(_('Unknown profile'), CST.STATUS_ERROR) tg.redirect(redirect_url) pod_user_group = group_api.get_one(Group.TIM_USER) pod_manager_group = group_api.get_one(Group.TIM_MANAGER) pod_admin_group = group_api.get_one(Group.TIM_ADMIN) flash_message = _( 'User updated.') # this is the default value ; should never appear if new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_USER: if pod_user_group not in user.groups: user.groups.append(pod_user_group) try: user.groups.remove(pod_manager_group) except: pass try: user.groups.remove(pod_admin_group) except: pass flash_message = _('User {} is now a basic user').format( user.get_display_name()) elif new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_MANAGER: if pod_user_group not in user.groups: user.groups.append(pod_user_group) if pod_manager_group not in user.groups: user.groups.append(pod_manager_group) try: user.groups.remove(pod_admin_group) except: pass flash_message = _('User {} can now workspaces').format( user.get_display_name()) elif new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_ADMIN: if pod_user_group not in user.groups: user.groups.append(pod_user_group) if pod_manager_group not in user.groups: user.groups.append(pod_manager_group) if pod_admin_group not in user.groups: user.groups.append(pod_admin_group) flash_message = _('User {} is now an administrator').format( user.get_display_name()) else: logger.error( self, 'Trying to change user {} profile with unexpected profile {}'. format(user.user_id, new_profile)) tg.flash(_('Unknown profile'), CST.STATUS_ERROR) tg.redirect(redirect_url) DBSession.flush() tg.flash(flash_message, CST.STATUS_OK) tg.redirect(redirect_url)
def test_update(self): created_content = self.test_create() content = DBSession.query(Content).filter(Content.id == created_content.id).one() eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count()) with new_revision(content): time.sleep(0.00001) content.description = 'TEST_CONTENT_DESCRIPTION_1_UPDATED' DBSession.flush() eq_(2, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count()) eq_(1, DBSession.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' DBSession.flush() eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1_UPDATED_2').count()) eq_(1, DBSession.query(Content).filter(Content.id == created_content.id).count()) revision_1 = DBSession.query(ContentRevisionRO)\ .filter(ContentRevisionRO.description == 'TEST_CONTENT_DESCRIPTION_1').one() revision_2 = DBSession.query(ContentRevisionRO)\ .filter(ContentRevisionRO.description == 'TEST_CONTENT_DESCRIPTION_1_UPDATED').one() revision_3 = DBSession.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_search_in_label_or_description(self): # HACK - D.A. - 2015-03-09 # This test is based on a bug which does NOT return results found # at root of a workspace (eg a folder) uapi = UserApi(None) groups = [ GroupApi(None).get_one(Group.TIM_USER), GroupApi(None).get_one(Group.TIM_MANAGER), GroupApi(None).get_one(Group.TIM_ADMIN) ] user = uapi.create_user(email='this.is@user', groups=groups, save_now=True) workspace = WorkspaceApi(user).create_workspace('test workspace', save_now=True) api = ContentApi(user) a = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', True) p1 = api.create(ContentType.Page, workspace, a, 'this is dummy label content', True) p2 = api.create(ContentType.Page, workspace, a, 'Hey ! Jon !', True) with new_revision(p1): p1.description = 'This is some amazing test' with new_revision(p2): p2.description = 'What\'s up ?' api.save(p1) api.save(p2) id1 = p1.content_id id2 = p2.content_id eq_( 1, DBSession.query(Workspace).filter( Workspace.label == 'test workspace').count()) eq_( 1, DBSession.query(ContentRevisionRO).filter( ContentRevisionRO.label == 'this is randomized folder').count()) eq_( 2, DBSession.query(ContentRevisionRO).filter( ContentRevisionRO.label == 'this is dummy label content').count()) eq_( 1, DBSession.query(ContentRevisionRO).filter( ContentRevisionRO.description == 'This is some amazing test').count()) eq_( 2, DBSession.query(ContentRevisionRO).filter( ContentRevisionRO.label == 'Hey ! Jon !').count()) eq_( 1, DBSession.query(ContentRevisionRO).filter( ContentRevisionRO.description == 'What\'s up ?').count()) res = api.search(['dummy', 'jon']) eq_(2, len(res.all())) eq_(True, id1 in [o.content_id for o in res.all()]) eq_(True, id2 in [o.content_id for o in res.all()])
def by_group_name(cls, group_name): """Return the user object whose email address is ``email``.""" return DBSession.query(cls).filter_by(group_name=group_name).first()
def by_user_name(cls, username): """Return the user object whose user name is ``username``.""" return DBSession.query(cls).filter_by(email=username).first()
def by_email_address(cls, email): """Return the user object whose email address is ``email``.""" return DBSession.query(cls).filter_by(email=email).first()
def is_authenticated(user: str, password: str) -> bool: """ see tracim.lib.radicale.auth.Auth#is_authenticated """ DBSession.expire_all() return Auth.is_authenticated(user, password)
def _check_db_user(self, email, count=1): eq_(count, DBSession.query(User).filter(User.email == email).count())
def get_all(self): return DBSession.query(User).order_by(User.display_name).all()
def test_creates(self): eq_(0, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count()) eq_(0, DBSession.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_1').count()) user_admin = DBSession.query(User).filter(User.email == '*****@*****.**').one() workspace = Workspace(label="TEST_WORKSPACE_1") DBSession.add(workspace) DBSession.flush() eq_(1, DBSession.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, # TODO: pk ? is_archived=False, # TODO: pk ? #file_content=None, # TODO: pk ? (J'ai du mettre nullable=True) ) eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count()) content = DBSession.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, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_2').count()) content = DBSession.query(Content).filter(Content.id == second_content.id).one() eq_('TEST_CONTENT_2', content.label) eq_('TEST_CONTENT_DESCRIPTION_2', content.description)
def _base_query_without_roles(self): return DBSession.query(Workspace).filter(Workspace.is_deleted==False)
def delete_one(self, workspace_id, flush=True): workspace = self.get_one(workspace_id) workspace.is_deleted = True if flush: DBSession.flush()
def save(self, workspace: Workspace): DBSession.flush()
def _create_content(self, *args, **kwargs): content = Content(*args, **kwargs) DBSession.add(content) DBSession.flush() return content
def test_unit__create_delete_and_create_file__ok(self): provider = self._get_provider() environ = self._get_environ( provider, '*****@*****.**', ) new_file = provider.getResourceInst( '/w1/w1f1/new_file.txt', environ, ) eq_(None, new_file, msg='Result should be None instead {0}'.format( new_file )) # create it new_file = self._put_new_text_file( provider, environ, '/w1/w1f1/new_file.txt', b'hello\n', ) ok_(new_file, msg='Result should not be None instead {0}'.format( new_file )) content_new_file = DBSession.query(ContentRevisionRO) \ .filter(Content.label == 'new_file') \ .one() # It must exist only one revision eq_( False, content_new_file.is_deleted, msg='Content should not be deleted !' ) content_new_file_id = content_new_file.content_id # Delete if new_file.delete() DBSession.flush() content_w1f1d1 = DBSession.query(ContentRevisionRO) \ .filter(Content.content_id == content_new_file_id) \ .order_by(Content.revision_id.desc()) \ .first() eq_( True, content_w1f1d1.is_deleted, msg='Content should be deleted !' ) result = provider.getResourceInst( '/w1/w1f1/new_file.txt', self._get_environ( provider, '*****@*****.**', ) ) eq_(None, result, msg='Result should be None instead {0}'.format( result )) # Then create it again new_file = self._put_new_text_file( provider, environ, '/w1/w1f1/new_file.txt', b'hello\n', ) ok_(new_file, msg='Result should not be None instead {0}'.format( new_file )) # Previous file is still dleeted DBSession.flush() content_w1f1d1 = DBSession.query(ContentRevisionRO) \ .filter(Content.content_id == content_new_file_id) \ .order_by(Content.revision_id.desc()) \ .first() eq_( True, content_w1f1d1.is_deleted, msg='Content should be deleted !' ) # And an other file exist for this name content_new_new_file = DBSession.query(ContentRevisionRO) \ .filter(Content.label == 'new_file') \ .order_by(Content.revision_id.desc()) \ .first() ok_( content_new_new_file.content_id != content_new_file_id, msg='Contents ids should not be same !' ) eq_( False, content_new_new_file.is_deleted, msg='Content should not be deleted !' )
def _base_query(self) -> Query: return DBSession.query(Group)
def save(self, user: User): DBSession.flush()