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