def test_get_entities_is_working_properly_with_filters(self):
"""testing if get_entities() method is working properly with filters
"""
from stalker import db, Status, StatusList
test_status1 = Status(name='Test Status 1', code='TST1')
test_status2 = Status(name='Test Status 2', code='TST2')
test_status3 = Status(name='Test Status 3', code='TST3')
test_status4 = Status(name='Test Status 4', code='TST4')
test_status5 = Status(name='Test Status 5', code='TST5')
test_status_list_1 = StatusList(
name='Status List 1',
statuses=[test_status1, test_status2, test_status3, test_status4],
target_entity_type='Project',
created_by=self.admin)
db.DBSession.add_all([
test_status1, test_status2, test_status3, test_status4,
test_status5, test_status_list_1
])
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.params = DummyMultiDict()
request.params['target_entity_type'] = 'Project'
status_list_view = status.StatusListViews(request)
response = status_list_view.get_entities()
self.assertEqual(response.json_body,
[{
'id': sl.id,
'$ref': '/api/status_lists/%s' % sl.id,
'name': sl.name,
'entity_type': sl.entity_type
} for sl in [test_status_list_1]])
def test_delete_statuses_is_working_properly(self):
"""testing if delete_statuses() method is working properly
"""
from stalker import db, Status, StatusList
test_status1 = Status(name='Test Status 1', code='TST1')
test_status2 = Status(name='Test Status 2', code='TST2')
test_status3 = Status(name='Test Status 3', code='TST3')
test_status4 = Status(name='Test Status 4', code='TST4')
test_status5 = Status(name='Test Status 5', code='TST5')
test_status_list = StatusList(
name='Test Status List',
target_entity_type='Project',
statuses=[test_status1, test_status2, test_status3, test_status4])
db.DBSession.add_all([
test_status1, test_status2, test_status3, test_status4,
test_status5, test_status_list
])
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = test_status_list.id
request.params = DummyMultiDict()
request.params['status_id'] = [test_status4.id]
status_list_view = status.StatusListViews(request)
status_list_view.delete_statuses()
self.maxDiff = None
self.assertEqual(sorted(test_status_list.statuses),
sorted([test_status1, test_status2, test_status3]))
def test_delete_entity_is_working_properly(self):
"""testing if delete_entity() method is working properly
"""
# create a time log
import datetime
start = datetime.datetime(2016, 7, 26, 16)
end = datetime.datetime(2016, 7, 26, 17)
from stalker import db, TimeLog
db.DBSession.flush()
db.DBSession.commit()
t1 = TimeLog(task=self.test_task1,
resource=self.test_user1,
start=start,
end=end,
created_by=self.test_user2)
db.DBSession.add(t1)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = t1.id
time_log_view = time_log.TimeLogViews(request)
response = time_log_view.delete_entity()
self.assertIsNone(
TimeLog.query.filter(TimeLog.task == self.test_task1).filter(
TimeLog.resource == self.test_user1).first())
def test_delete_entity(self):
"""testing if delete_entity() method is working properly
"""
from stalker import db, User, Vacation
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
import datetime
start = datetime.datetime(2016, 4, 22, 10)
end = datetime.datetime(2016, 4, 22, 16)
vac1 = Vacation(user=user1, start=start, end=end)
db.DBSession.commit()
vac1 = Vacation.query.filter(Vacation.name == vac1.name).first()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = vac1.id
vacation_views = vacation.VacationViews(request)
vacation_views.delete_entity()
vac = Vacation.query.filter(Vacation.name == vac1.name).all()
self.assertEqual(vac, [])
def test_remove_users_is_working_properly_with_non_related_user(self):
"""testing if remove_users() method is working properly with users that
is not related to the department
"""
from stalker import db
# add some users first to see if patching works
self.test_department1.users = \
[self.test_user1, self.test_user2]
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_department1.id
request.params = DummyMultiDict()
request.params['user_id'] = [self.test_user2.id, self.test_user3.id]
department_view = department.DepartmentViews(request)
response = department_view.remove_users()
from stalker import Department
test_dep_db = Department.query\
.filter(Department.id == self.test_department1.id)\
.first()
self.assertEqual(sorted(test_dep_db.users), sorted([self.test_user1]))
def test_create_entity_with_missing_end(self):
"""testing if create_entity() method is working properly with missing
end parameter
"""
from stalker import db, User
user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(user1)
db.DBSession.commit()
import datetime
start = datetime.datetime(2016, 4, 22, 10)
user1 = User.query.filter(User.login == user1.login).first()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
from stalker_pyramid.views import EntityViewBase
request = DummyRequest()
request.params = DummyMultiDict()
request.params['user_id'] = user1.id
request.params['start'] = \
EntityViewBase.milliseconds_since_epoch(start)
vacation_views = vacation.VacationViews(request)
from pyramid.httpexceptions import HTTPServerError
with self.assertRaises(HTTPServerError) as cm:
vacation_views.create_entity()
self.assertEqual(str(cm.exception), 'Missing "end" parameter')
def test_entity_notes_is_working_properly(self):
"""testing if get_notes is working properly
"""
from stalker import db, Entity, Note
test_entity = Entity(name='Test Entity')
db.DBSession.add(test_entity)
# Note 1
test_note1 = Note(content='Note 1')
db.DBSession.add(test_note1)
# Note 2
test_note2 = Note(content='Note 2')
db.DBSession.add(test_note2)
# Note 3
test_note3 = Note(content='Note 3')
db.DBSession.add(test_note3)
# dummy Note 4
test_note4 = Note(content='Note 4')
db.DBSession.add(test_note4)
test_entity.notes = [test_note1, test_note2, test_note3]
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = test_entity.id
request.method = 'GET'
entity_view = entity.EntityViews(request)
response = entity_view.get_notes()
self.assertEqual(
sorted(response.json_body),
sorted([
{
'id': test_note1.id,
'$ref': '/api/notes/%s' % test_note1.id,
'name': test_note1.name,
'entity_type': 'Note'
},
{
'id': test_note2.id,
'$ref': '/api/notes/%s' % test_note2.id,
'name': test_note2.name,
'entity_type': 'Note'
},
{
'id': test_note3.id,
'$ref': '/api/notes/%s' % test_note3.id,
'name': test_note3.name,
'entity_type': 'Note'
},
]))
def test_update_entity_is_working_properly(self):
"""testing if update_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_structure1.id
request.method = 'POST'
request.params = DummyMultiDict()
request.params['name'] = 'New Structure Name'
request.params['description'] = 'New description'
request.params['custom_template'] = 'New custom template code'
request.params['template_id'] = [
self.test_filename_template2.id, self.test_filename_template3.id
]
structure_view = structure.StructureViews(request)
self.patch_logged_in_user(request)
response = structure_view.update_entity()
from stalker import Structure
structure_db = Structure.query.get(self.test_structure1.id)
self.assertEqual(structure_db.name, 'New Structure Name')
self.assertEqual(structure_db.description, 'New description')
self.assertEqual(structure_db.custom_template,
'New custom template code')
self.assertEqual(
sorted(structure_db.templates),
sorted(
[self.test_filename_template2, self.test_filename_template3]))
def test_update_entity_is_working_properly(self):
"""testing if update_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_repo1.id
request.params = DummyMultiDict()
request.params['name'] = 'New Repo Name'
request.params['description'] = 'New description'
request.params['windows_path'] = 'C:/new/windows/path/'
request.params['linux_path'] = '/mnt/new/linux/path/'
request.params['osx_path'] = '/Volumes/new/osx/path/'
repo_view = repository.RepositoryViews(request)
self.patch_logged_in_user(request)
response = repo_view.update_entity()
from stalker import Repository
repo_db = Repository.query.get(self.test_repo1.id)
self.assertEqual(repo_db.name, 'New Repo Name')
self.assertEqual(repo_db.description, 'New description')
self.assertEqual(repo_db.windows_path, 'C:/new/windows/path/')
self.assertEqual(repo_db.linux_path, '/mnt/new/linux/path/')
self.assertEqual(repo_db.osx_path, '/Volumes/new/osx/path/')
def test_delete_entity_is_working_properly(self):
"""testing if delete_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = self.test_group1.id
group_view = group.GroupViews(request)
response = group_view.delete_entity()
from stalker import Group
self.assertIsNone(
Group.query.filter(Group.name == self.test_group1.name).first()
)
def test_update_entity_method_is_working_properly(self):
"""testing if the update_entity() method is working properly
"""
from stalker import db, ImageFormat
test_image_format = ImageFormat(name='HD 1080',
description='A test image format',
width=1920,
height=1080,
pixel_aspect=1.0,
print_resolution=300.0,
created_by=self.admin)
db.DBSession.add(test_image_format)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = test_image_format.id
request.params = DummyMultiDict()
request.params['description'] = 'New description'
request.params['name'] = 'HD 720'
request.params['width'] = 1280
request.params['height'] = 720
self.patch_logged_in_user(request)
image_format_view = format.ImageFormatViews(request)
response = image_format_view.update_entity()
test_image_format_db = ImageFormat.query.get(test_image_format.id)
self.assertEqual(test_image_format_db.name, 'HD 720')
self.assertEqual(test_image_format_db.description, 'New description')
self.assertEqual(test_image_format_db.width, 1280)
self.assertEqual(test_image_format_db.height, 720)
def test_update_entity_is_working_properly(self):
"""testing if update_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_group1.id
request.params = DummyMultiDict()
request.params['name'] = 'New Group Name'
request.params['user_id'] = [self.test_user1.id, self.test_user2.id]
request.params['description'] = 'New description'
request.params['permission'] = \
['%s_%s_%s' % (p.access, p.action, p.class_name)
for p in self.all_permissions[0:5]]
group_view = group.GroupViews(request)
self.patch_logged_in_user(request)
response = group_view.update_entity()
# get group1 from db
from stalker import Group
test_group1_db = Group.query.get(self.test_group1.id)
self.assertEqual(test_group1_db.name, 'New Group Name')
self.assertEqual(
sorted(test_group1_db.users),
sorted([self.test_user1, self.test_user2])
)
self.assertEqual(test_group1_db.description, 'New description')
self.assertEqual(
sorted(test_group1_db.permissions),
sorted(self.all_permissions[0:5])
)
def test_update_entity_is_working_properly(self):
"""testing if update_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_link1.id
request.params = DummyMultiDict()
request.params['name'] = 'New Link Name'
request.params['description'] = 'New description'
request.params['full_path'] = '/new/path/to/a/file'
request.params['original_filename'] = 'new_original_file_name'
link_view = link.LinkViews(request)
self.patch_logged_in_user(request)
response = link_view.update_entity()
from stalker import Link
link_db = Link.query.get(self.test_link1.id)
self.assertEqual(link_db.name, 'New Link Name')
self.assertEqual(link_db.description, 'New description')
self.assertEqual(link_db.full_path, '/new/path/to/a/file')
self.assertEqual(link_db.original_filename, 'new_original_file_name')
def test_get_entity(self):
"""testing if get_entity() method is working properly
"""
from stalker import db, Tag
tag1 = Tag(name='Test Tag 1')
db.DBSession.add(tag1)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = tag1.id
tag_view = tag.TagViews(request)
response = tag_view.get_entity()
from stalker_pyramid.views import EntityViewBase
import stalker
self.assertEqual(
response.json_body, {
'created_by':
None,
'date_created':
EntityViewBase.milliseconds_since_epoch(tag1.date_created),
'date_updated':
EntityViewBase.milliseconds_since_epoch(tag1.date_updated),
'description':
'',
'entity_type':
'Tag',
'generic_data': {
'$ref': '/api/simple_entities/%s/generic_data' % tag1.id,
'length': 0
},
'generic_text':
'',
'id':
tag1.id,
'name':
'Test Tag 1',
'stalker_version':
stalker.__version__,
'thumbnail':
None,
'type':
None,
'updated_by':
None
})
def test_delete_entity_is_working_properly(self):
"""testing if the delete_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = self.test_department1.id
department_view = department.DepartmentViews(request)
department_view.delete_entity()
from stalker import Department
dep_db = Department.query\
.filter(Department.id == self.test_department1.id)\
.first()
self.assertIsNone(dep_db)
def test_delete_entity_is_working_properly(self):
"""testing if delete_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = self.test_link1.id
link_view = link.LinkViews(request)
self.patch_logged_in_user(request)
response = link_view.delete_entity()
from stalker import Link
self.assertIsNone(
Link.query.filter(Link.id == self.test_link1.id).first())
def test_delete_entity_is_working_properly(self):
"""testing if delete_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = self.test_role1.id
role_view = role.RoleViews(request)
self.patch_logged_in_user(request)
response = role_view.delete_entity()
from stalker import Role
self.assertIsNone(
Role.query.filter(Role.id == self.test_role1.id).first())
def test_get_entities_is_working_properly(self):
"""testing if get_entities() method is working properly
"""
from stalker import db, Status
test_status1 = Status(name='Test Entity 1', code='TST1')
test_status2 = Status(name='Test Entity 2', code='TST2')
test_status3 = Status(name='Test Entity 3', code='TST3')
db.DBSession.add_all([test_status1, test_status2, test_status3])
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
status_view = status.StatusViews(request)
response = status_view.get_entities()
all_statuses = Status.query.all()
self.maxDiff = None
self.assertEqual(
sorted(response.json_body),
sorted([
{
'id': s.id,
'$ref': '/api/statuses/%s' % s.id,
'name': s.name,
'entity_type': s.entity_type
} for s in all_statuses])
)
def test_get_entities_method_is_working_properly(self):
"""testing if the get_entities() method is working properly
"""
# create a couple of image formats
from stalker import db, ImageFormat
im1 = ImageFormat(name='HD 720', width=1280, height=720)
db.DBSession.add(im1)
im2 = ImageFormat(name='HD 1080', width=1920, height=1080)
db.DBSession.add(im2)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
image_format_view = format.ImageFormatViews(request)
response = image_format_view.get_entities()
self.maxDiff = None
self.assertEqual(
sorted(response.json_body),
sorted([{
'id': im.id,
'$ref': '/api/image_formats/%s' % im.id,
'name': im.name,
'entity_type': im.entity_type
} for im in [im1, im2]]))
def test_delete_entity_is_working_properly(self):
"""testing if the delete_entity method is working properly
"""
from stalker import db, Note
test_note = Note(content='This is a test note')
db.DBSession.add(test_note)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = test_note.id
note_view = note.NoteViews(request)
note_view.delete_entity()
test_note_db = Note.query.filter(Note.name == test_note.name).first()
self.assertIsNone(test_note_db)
def test_remove_tags_is_working_properly_with_non_existing_tags(self):
"""testing if the remove_tags() method is working properly
"""
# create some tags
from stalker import db, Tag
t1 = Tag(name='tag1')
t2 = Tag(name='tag2')
t3 = Tag(name='tag3')
from stalker import Entity
test_entity = Entity(name='Test Entity', tags=[t1, t2])
db.DBSession.add_all([t1, t2, t3, test_entity])
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.method = 'DELETE'
request.matchdict['id'] = test_entity.id
request.params = DummyMultiDict()
request.params['tag'] = ['tag3']
request.POST = request.params
entity_view = entity.EntityViews(request)
entity_view.remove_tags()
# now query entity tags
test_entity = Entity.query.filter(Entity.id == test_entity.id).first()
response = [t.name for t in test_entity.tags]
expected = ['tag1', 'tag2']
self.assertEqual(sorted(response), sorted(expected))
def test_update_entity_is_working_properly(self):
"""testing if update_entity() is working properly
"""
from stalker import db, Status
test_status1 = Status(name='Test Status 1', code='TST1')
db.DBSession.add(test_status1)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.params = DummyMultiDict()
request.matchdict['id'] = test_status1.id
self.patch_logged_in_user(request)
new_name = 'New Status Name'
new_code = 'NSN'
new_description = 'This should also be present'
request.params['name'] = new_name
request.params['code'] = new_code
request.params['description'] = new_description
status_view = status.StatusViews(request)
response = status_view.update_entity()
test_status1_db = Status.query.get(test_status1.id)
self.assertEqual(test_status1_db.name, new_name)
self.assertEqual(test_status1_db.code, new_code)
self.assertEqual(test_status1_db.description, new_description)
def test_update_entity_is_working_properly(self):
"""testing if the update_entity() method is working properly
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_department1.id
request.params = DummyMultiDict()
new_name = 'New Department Name'
new_description = 'New Description'
request.params['name'] = new_name
request.params['description'] = new_description
request.params['user_id'] = [self.test_user1.id, self.test_user2.id]
department_view = department.DepartmentViews(request)
self.patch_logged_in_user(request)
response = department_view.update_entity()
from stalker import Department
test_department1_db = Department.query\
.filter(Department.id == self.test_department1.id)\
.first()
self.assertEqual(test_department1_db.name, new_name)
self.assertEqual(test_department1_db.description, new_description)
self.assertEqual(sorted(test_department1_db.users),
sorted([self.test_user1, self.test_user2]))
def test_update_entity_is_working_properly_with_patch(self):
"""testing if update_entity() method is working properly with PATCH
"""
from stalker import db, Tag
new_tag = Tag(name='Test Tag 1')
db.DBSession.add(new_tag)
db.DBSession.flush()
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = new_tag.id
self.patch_logged_in_user(request)
request.params = DummyMultiDict()
request.params['name'] = 'New Tag Name'
request.params['description'] = 'This also should be updated'
request.method = 'PATCH'
tag_view = tag.TagViews(request)
tag_view.update_entity()
new_tag_db = Tag.query.get(new_tag.id)
self.assertEqual(new_tag_db.name, 'New Tag Name')
self.assertEqual(new_tag_db.description, 'This also should be updated')
self.assertEqual(new_tag_db.updated_by, self.admin)
def test_update_tags_is_working_properly_with_post(self):
"""testing if the update_tags() view is working properly when the
request.method is POST
"""
# create some tags
from stalker import db, Tag
t1 = Tag(name='tag1')
t2 = Tag(name='tag2')
t3 = Tag(name='tag3')
db.DBSession.add_all([t1, t2, t3])
from stalker import Entity
test_entity = Entity(name='Test Entity')
db.DBSession.add(test_entity)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = test_entity.id
request.method = 'POST'
request.params = DummyMultiDict()
request.params['tag'] = ['tag1', 'tag2']
request.POST = request.params
entity_view = entity.EntityViews(request)
entity_view.update_tags()
# now query entity tags
test_entity = Entity.query.filter(Entity.id == test_entity.id).first()
self.assertEqual(sorted([t.name for t in test_entity.tags]),
sorted(['tag1', 'tag2']))
def test_update_entity_method_is_working_properly(self):
"""testing if the update_entity() method is working properly
"""
from stalker import db, Type
test_type = Type(name='Test Type',
code='TT',
description='A test type',
target_entity_type='Project',
created_by=self.admin)
db.DBSession.add(test_type)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = test_type.id
request.params = DummyMultiDict()
request.params['description'] = 'New description'
request.params['name'] = 'New Name'
request.params['code'] = 'New Code'
self.patch_logged_in_user(request)
type_view = type.TypeViews(request)
response = type_view.update_entity()
test_type_db = Type.query.get(test_type.id)
self.assertEqual(test_type_db.name, 'New Name')
self.assertEqual(test_type_db.code, 'New Code')
self.assertEqual(test_type_db.description, 'New description')
def test_delete_entity_is_working_properly(self):
"""testing if delete_entity() method is working properly
"""
from stalker import db, Status
test_status = Status(name='Test Status', code='TST')
db.DBSession.add(test_status)
db.DBSession.commit()
self.assertIsNotNone(Status.query.filter(Status.code == 'TST').first())
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = test_status.id
status_view = status.StatusViews(request)
status_view.delete_entity()
self.assertIsNone(Status.query.filter(Status.code == 'TST').first())
def test_remove_users_is_working_properly(self):
"""testing if remove_users() method is working properly
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_group1.id
request.params = DummyMultiDict()
request.params['user_id'] = [self.test_user2.id]
group_view = group.GroupViews(request)
response = group_view.remove_users()
from stalker import Group
test_group1_db = Group.query.get(self.test_group1.id)
self.assertEqual(
sorted(test_group1_db.users),
sorted([self.test_user1])
)
def test_remove_templates_is_working_properly(self):
"""testing if remove_templates() method is working properly
"""
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = self.test_structure1.id
request.params = DummyMultiDict()
request.params['template_id'] = \
[self.test_filename_template1.id]
structure_view = structure.StructureViews(request)
response = structure_view.remove_templates()
from stalker import Structure
structure_db = Structure.query.get(self.test_structure1.id)
self.assertEqual(sorted(structure_db.templates),
sorted([self.test_filename_template2]))
def test_get_users_is_working_properly(self):
"""testing if get_users() method is working properly
"""
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = self.test_group1.id
group_view = group.GroupViews(request)
response = group_view.get_users()
self.assertEqual(
sorted(response.json_body),
sorted([
{
'id': u.id,
'name': u.name,
'entity_type': 'User',
'$ref': '/api/users/%s' % u.id
} for u in [self.test_user1, self.test_user2]
])
)
