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()
