def test_update_with_studio_is_working_properly(self): """testing if the default values are updated with the Studio instance if there is a database connection and there is a Studio in there """ import datetime from stalker import db, defaults from stalker.db.session import DBSession from stalker.models.studio import Studio db.setup() db.init() # check the defaults are still using them self self.assertEqual( defaults.timing_resolution, datetime.timedelta(hours=1) ) studio = Studio( name='Test Studio', timing_resolution=datetime.timedelta(minutes=15) ) DBSession.add(studio) DBSession.commit() # now check it again self.assertEqual( defaults.timing_resolution, studio.timing_resolution )
def test_update_with_studio_is_working_properly(self): """testing if the default values are updated with the Studio instance if there is a database connection and there is a Studio in there """ import datetime from stalker import db, defaults from stalker.db.session import DBSession from stalker.models.studio import Studio db.setup() db.init() # check the defaults are still using them self self.assertEqual( defaults.timing_resolution, datetime.timedelta(hours=1) ) studio = Studio( name='Test Studio', timing_resolution=datetime.timedelta(minutes=15) ) DBSession.add(studio) DBSession.commit() # now check it again self.assertEqual( defaults.timing_resolution, studio.timing_resolution )
def tearDown(self): """clean up the test """ # clean up test database from stalker.db.declarative import Base Base.metadata.drop_all(db.DBSession.connection()) DBSession.commit()
def test_logged_in_user_returns_the_stored_User_instance_from_last_time( self): """testing if logged_in_user returns the logged in user """ # create a new user new_user = User(name='Test User', login='******', email='*****@*****.**', password='******') # save it to the Database DBSession.add(new_user) DBSession.commit() self.assertTrue(new_user.id is not None) # save it to the local storage local_session = LocalSession() local_session.store_user(new_user) # save the session local_session.save() # now get it back with a new local_session local_session2 = LocalSession() self.assertEqual(local_session2.logged_in_user_id, new_user.id) self.assertEqual(local_session2.logged_in_user, new_user)
def setUp(self): """set up """ from stalker.db.declarative import Base Base.metadata.drop_all(db.DBSession.connection()) DBSession.commit() super(TaskJugglerScheduler_PostgreSQL_Tester, self).setUp()
def setUp(self): """set up """ from stalker.db.declarative import Base Base.metadata.drop_all(db.DBSession.connection()) DBSession.commit() super(TaskJugglerScheduler_PostgreSQL_Tester, self).setUp()
def save_as(self, version): """the save action for houdini environment """ if not version: return from stalker import Version assert isinstance(version, Version) # get the current version, and store it as the parent of the new version current_version = self.get_current_version() # initialize path variables by using update_paths() version.update_paths() # set the extension to hip if not hou.isApprentice(): version.extension = '.hip' else: version.extension = '.hipnc' # define that this version is created with Houdini version.created_with = self.name # create the folder if it doesn't exists try: os.makedirs(os.path.dirname(version.absolute_full_path)) except OSError: # dirs exist pass # houdini uses / instead of \ under windows # lets fix it # set the environment variables self.set_environment_variables(version) # set the render file name self.set_render_filename(version) # houdini accepts only strings as file name, no unicode support as I # see hou.hipFile.save(file_name=str(version.absolute_full_path)) # set the environment variables again self.set_environment_variables(version) # append it to the recent file list self.append_to_recent_files(version.absolute_full_path) # update the parent info if current_version: version.parent = current_version # update database with new version info DBSession.commit() return True
def test_deleting_time_log_for_a_task_with_status_complete(self): """testing if it is not allowed to delete a time log of a task with status completed """ # TODO: This is also testing some functionality from view.task, slit it # create two new task task0 = Task( name='Test Task 0', project=self.proj1, status_list=self.task_status_list ) task1 = Task( name='Test Task 1', parent=task0, status_list=self.task_status_list, resources=[self.user1] ) task1.status = self.status_wip DBSession.add_all([task0, task1]) DBSession.commit() DBSession.flush() transaction.commit() self.assertEqual(task0.status, self.status_new) self.assertEqual(task1.status, self.status_wip) # now add a time log for task3 through create_time_log view request = testing.DummyRequest() # patch get_logged_in_user admins = Group.query.filter(Group.name == 'admins').first() self.user1.groups.append(admins) m = mocker.Mocker() obj = m.replace("stalker_pyramid.views.auth.get_logged_in_user") obj(request) m.result(self.user1) m.count(1, 1000000000) m.replay() request.route_url = lambda x, id=1: 'view_user' request.params['task_id'] = task1.id request.params['resource_id'] = self.user1.id request.params['start'] = "Fri, 19 Nov 2013 08:00:00 GMT" request.params['end'] = "Fri, 19 Nov 2013 17:00:00 GMT" response = time_log.create_time_log(request) self.assertEqual(response.status_int, 200) # set it to complete task1.status = self.status_cmpl # now try to remove it request.matchdict['id'] = task1.time_logs[0].id response = time_log.delete_time_log(request) self.assertEqual(response.status_int, 500) self.assertEqual( response.body, 'Error: You can not delete a TimeLog of a Task with status CMPL' )
def tearDown(self): """clean up the test """ # clean up test database from stalker.db.declarative import Base Base.metadata.drop_all(db.DBSession.connection()) from sqlalchemy.exc import ProgrammingError try: DBSession.commit() except ProgrammingError: DBSession.rollback()
def tearDown(self): """clean up the test """ # clean up test database from stalker.db.declarative import Base Base.metadata.drop_all(db.DBSession.connection()) from sqlalchemy.exc import ProgrammingError try: DBSession.commit() except ProgrammingError: DBSession.rollback()
def test_delete_will_delete_the_session_cache(self): """testing if the LocalSession.delete() will delete the current cache file """ # create a new user new_user = User( name='Test User', login='******', email='*****@*****.**', password='******' ) # save it to the Database DBSession.add(new_user) DBSession.commit() self.assertTrue(new_user.id is not None) # save it to the local storage local_session = LocalSession() local_session.store_user(new_user) # save the session local_session.save() # check if the file is created # check if a file is created in the users local storage self.assertTrue( os.path.exists( os.path.join( defaults.local_storage_path, defaults.local_session_data_file_name ) ) ) # now delete the session by calling delete() local_session.delete() # check if the file is gone # check if a file is created in the users local storage self.assertFalse( os.path.exists( os.path.join( defaults.local_storage_path, defaults.local_session_data_file_name ) ) ) # delete a second time # this should not raise an OSError local_session.delete()
def setUpClass(cls): """setup tests in class level """ cls.config = { 'sqlalchemy.url': 'postgresql://*****:*****@localhost/stalker_test', 'sqlalchemy.echo': False } # clean up test database db.setup(cls.config) from stalker.db.declarative import Base Base.metadata.drop_all(db.DBSession.connection()) DBSession.commit()
def setUpClass(cls): """setup tests in class level """ cls.config = { 'sqlalchemy.url': 'postgresql://*****:*****@localhost/stalker_test', 'sqlalchemy.echo': False } # clean up test database db.setup(cls.config) from stalker.db.declarative import Base Base.metadata.drop_all(db.DBSession.connection()) DBSession.commit()
def test_LocalSession_will_not_use_the_stored_data_if_it_is_invalid(self): """testing if the LocalSession will not use the stored session if it is not valid anymore """ # create a new user new_user = User( name='Test User', login='******', email='*****@*****.**', password='******' ) # save it to the Database DBSession.add(new_user) DBSession.commit() self.assertTrue(new_user.id is not None) # save it to the local storage local_session = LocalSession() local_session.store_user(new_user) # save the session local_session.save() # set the valid time to an early date local_session.valid_to = \ datetime.datetime.now() - datetime.timedelta(10) # pickle the data data = json.dumps( { 'valid_to': local_session.valid_to, 'logged_in_user_id': -1 }, default=local_session.default_json_serializer ) print('data: %s' % data) local_session._write_data(data) # now get it back with a new local_session local_session2 = LocalSession() self.assertEqual( local_session2.logged_in_user_id, None ) self.assertTrue(local_session2.logged_in_user is None)
def test_LocalSession_will_not_use_the_stored_data_if_it_is_invalid(self): """testing if the LocalSession will not use the stored session if it is not valid anymore """ # create a new user new_user = User(name='Test User', login='******', email='*****@*****.**', password='******') # save it to the Database DBSession.add(new_user) DBSession.commit() self.assertTrue(new_user.id is not None) # save it to the local storage local_session = LocalSession() local_session.store_user(new_user) # save the session local_session.save() # set the valid time to an early date local_session.valid_to = \ datetime.datetime.now() - datetime.timedelta(10) # pickle the data data = json.dumps( { 'valid_to': local_session.valid_to, 'logged_in_user_id': -1 }, default=local_session.default_json_serializer) print('data: %s' % data) local_session._write_data(data) # now get it back with a new local_session local_session2 = LocalSession() self.assertEqual(local_session2.logged_in_user_id, None) self.assertTrue(local_session2.logged_in_user is None)
def test_delete_will_delete_the_session_cache(self): """testing if the LocalSession.delete() will delete the current cache file """ # create a new user new_user = User(name='Test User', login='******', email='*****@*****.**', password='******') # save it to the Database DBSession.add(new_user) DBSession.commit() self.assertTrue(new_user.id is not None) # save it to the local storage local_session = LocalSession() local_session.store_user(new_user) # save the session local_session.save() # check if the file is created # check if a file is created in the users local storage self.assertTrue( os.path.exists( os.path.join(defaults.local_storage_path, defaults.local_session_data_file_name))) # now delete the session by calling delete() local_session.delete() # check if the file is gone # check if a file is created in the users local storage self.assertFalse( os.path.exists( os.path.join(defaults.local_storage_path, defaults.local_session_data_file_name))) # delete a second time # this should not raise an OSError local_session.delete()
def test_logged_in_user_returns_the_stored_User_instance_from_last_time(self): """testing if logged_in_user returns the logged in user """ # create a new user new_user = User( name='Test User', login='******', email='*****@*****.**', password='******' ) # save it to the Database DBSession.add(new_user) DBSession.commit() self.assertIsNotNone(new_user.id) # save it to the local storage local_session = LocalSession() local_session.store_user(new_user) # save the session local_session.save() # now get it back with a new local_session local_session2 = LocalSession() self.assertEqual( local_session2.logged_in_user_id, new_user.id ) self.assertEqual( local_session2.logged_in_user, new_user )
def save_as(self, version): """the save action for houdini environment """ if not version: return from stalker import Version assert isinstance(version, Version) # get the current version, and store it as the parent of the new version current_version = self.get_current_version() # initialize path variables by using update_paths() version.update_paths() # set the extension to hip if not hou.isApprentice(): version.extension = '.hip' else: version.extension = '.hipnc' # define that this version is created with Houdini version.created_with = self.name # create the folder if it doesn't exists try: os.makedirs( os.path.dirname( version.absolute_full_path ) ) except OSError: # dirs exist pass # houdini uses / instead of \ under windows # lets fix it # set the environment variables self.set_environment_variables(version) # set the render file name self.set_render_filename(version) # houdini accepts only strings as file name, no unicode support as I # see hou.hipFile.save(file_name=str(version.absolute_full_path)) # set the environment variables again self.set_environment_variables(version) # append it to the recent file list self.append_to_recent_files( version.absolute_full_path ) # update the parent info if current_version: version.parent = current_version # update database with new version info DBSession.commit() return True
def save_as(self, version): """"the save action for nuke environment uses Nukes own python binding """ # get the current version, and store it as the parent of the new version current_version = self.get_current_version() # first initialize the version path version.update_paths() # set the extension to '.nk' version.extension = '.nk' # set created_with to let the UI show Nuke icon in versions list version.created_with = self.name # set project_directory # self.project_directory = os.path.dirname(version.absolute_path) # create the main write node self.create_main_write_node(version) # replace read and write node paths # self.replace_external_paths() # create the path before saving try: os.makedirs(version.absolute_path) except OSError: # path already exists OSError pass # set frame range # if this is a shot related task set it to shots resolution is_shot_related_task = False shot = None from stalker import Shot for task in version.task.parents: if isinstance(task, Shot): is_shot_related_task = True shot = task break # set scene fps project = version.task.project self.set_fps(project.fps) if version.version_number == 1: if is_shot_related_task: # just set if the frame range is not 1-1 if shot.cut_in != 1 and shot.cut_out != 1: self.set_frame_range( shot.cut_in, shot.cut_out ) imf = shot.image_format else: imf = project.image_format # TODO: set the render resolution later # self.set_resolution( # imf.width, # imf.height, # imf.pixel_aspect # ) nuke.scriptSaveAs(version.absolute_full_path) if current_version: # update the parent info version.parent = current_version # update database with new version info DBSession.commit() return True
def test_get_version_from_full_path_with_multiple_repositories(self): """testing if the get version from full path is working fine with multiple repositories and with same version names """ repo1 = Repository(name='Test Repo 1', linux_path='/mnt/T/', windows_path='T:/', osx_path='/Volumes/T/') DBSession.add(repo1) repo2 = Repository(name='Test Repo 2', linux_path='/mnt/S/', windows_path='S:/', osx_path='/Volumes/S/') DBSession.add(repo2) task_ft = FilenameTemplate( name='Task Filename Template', target_entity_type='Task', path='$REPO{{project.repository.code}}/{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/{%- endfor -%}', filename='{{task.nice_name}}_{{version.take_name}}' '_v{{"%03d"|format(version.version_number)}}', ) DBSession.add(task_ft) structure1 = Structure(name='Commercial Project Structure', templates=[task_ft]) DBSession.add(structure1) status1 = Status(name='Status 1', code='STS1') status2 = Status(name='Status 2', code='STS2') status3 = Status(name='Status 3', code='STS3') DBSession.add_all([status1, status2, status3]) proj_status_list = \ StatusList.query.filter_by(target_entity_type='Project').first() task_status_list = \ StatusList.query.filter_by(target_entity_type='Task').first() version_status_list = StatusList(name='Version Statuses', target_entity_type='Version', statuses=[status1, status2, status3]) DBSession.add(version_status_list) project1 = Project(name='Test Project 1', code='TP1', repositories=[repo1], structure=structure1, status_list=proj_status_list) DBSession.add(project1) project2 = Project(name='Test Project 2', code='TP2', repositories=[repo2], structure=structure1, status_list=proj_status_list) DBSession.add(project2) task1 = Task(name='Test Task 1', code='TT1', project=project1, status_list=task_status_list) DBSession.add(task1) task2 = Task(name='Test Task 1', code='TT1', project=project2, status_list=task_status_list) DBSession.add(task2) DBSession.commit() # now create versions version1 = Version(task=task1, status_list=version_status_list) DBSession.add(version1) DBSession.commit() version1.update_paths() version2 = Version(task=task2, status_list=version_status_list) DBSession.add(version2) DBSession.commit() version2.update_paths() DBSession.commit() logger.debug('version1.full_path : %s' % version1.full_path) logger.debug('version2.full_path : %s' % version2.full_path) # now try to get the versions with an EnvironmentBase instance env = EnvironmentBase() # version1 version1_found = env.get_version_from_full_path( '/mnt/T/TP1/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(version1_found, version1) # version2 version2_found = env.get_version_from_full_path( '/mnt/S/TP2/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(version2_found, version2) # version1 in windows version1_found = env.get_version_from_full_path( 'T:/TP1/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(version1_found, version1) # version2 in windows version2_found = env.get_version_from_full_path( 'S:/TP2/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(version2_found, version2) # version1 in linux version1_found = env.get_version_from_full_path( '/mnt/T/TP1/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(version1_found, version1) # version2 in linux version2_found = env.get_version_from_full_path( '/mnt/S/TP2/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(version2_found, version2) # version1 in osx version1_found = env.get_version_from_full_path( '/Volumes/T/TP1/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(version1_found, version1) # version2 in osx version2_found = env.get_version_from_full_path( '/Volumes/S/TP2/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(version2_found, version2)
def setUp(self): """set up the test """ # we need a database db.setup(self.config) db.init() # replace datetime now function # create departments self.test_dep1 = Department(name='Dep1') self.test_dep2 = Department(name='Dep2') # create resources self.test_user1 = User( login='******', name='User1', email='*****@*****.**', password='******', departments=[self.test_dep1] ) DBSession.add(self.test_user1) self.test_user2 = User( login='******', name='User2', email='*****@*****.**', password='******', departments=[self.test_dep1] ) DBSession.add(self.test_user2) self.test_user3 = User( login='******', name='User3', email='*****@*****.**', password='******', departments=[self.test_dep2] ) DBSession.add(self.test_user3) self.test_user4 = User( login='******', name='User4', email='*****@*****.**', password='******', departments=[self.test_dep2] ) DBSession.add(self.test_user4) # user with two departments self.test_user5 = User( login='******', name='User5', email='*****@*****.**', password='******', departments=[self.test_dep1, self.test_dep2] ) DBSession.add(self.test_user5) # user with no departments self.test_user6 = User( login='******', name='User6', email='*****@*****.**', password='******' ) DBSession.add(self.test_user6) # repository self.test_repo = Repository( name='Test Repository', linux_path='/mnt/T/', windows_path='T:/', osx_path='/Volumes/T/' ) DBSession.add(self.test_repo) # statuses self.test_status1 = Status(name='Status 1', code='STS1') self.test_status2 = Status(name='Status 2', code='STS2') self.test_status3 = Status(name='Status 3', code='STS3') self.test_status4 = Status(name='Status 4', code='STS4') self.test_status5 = Status(name='Status 5', code='STS5') DBSession.add_all([self.test_status1, self.test_status2, self.test_status3, self.test_status4, self.test_status5]) # status lists self.test_proj_status_list = StatusList( name='Project Status List', statuses=[self.test_status1, self.test_status2, self.test_status3], target_entity_type='Project' ) DBSession.add(self.test_proj_status_list) # create one project self.test_proj1 = Project( name='Test Project 1', code='TP1', repository=self.test_repo, status_list=self.test_proj_status_list, start=datetime.datetime(2013, 4, 4), end=datetime.datetime(2013, 5, 4) ) DBSession.add(self.test_proj1) self.test_proj1.now = datetime.datetime(2013, 4, 4) # create task status list with DBSession.no_autoflush: self.test_task_status_list = StatusList.query\ .filter_by(target_entity_type='Task').first() # create two tasks with the same resources self.test_task1 = Task( name='Task1', project=self.test_proj1, resources=[self.test_user1, self.test_user2], alternative_resources=[ self.test_user3, self.test_user4, self.test_user5 ], schedule_model=0, schedule_timing=50, schedule_unit='h', status_list=self.test_task_status_list ) DBSession.add(self.test_task1) self.test_task2 = Task( name='Task2', project=self.test_proj1, resources=[self.test_user1, self.test_user2], alternative_resources=[ self.test_user3, self.test_user4, self.test_user5 ], depends=[self.test_task1], schedule_model=0, schedule_timing=60, schedule_unit='h', status_list=self.test_task_status_list ) DBSession.add(self.test_task2) DBSession.commit()
def setUp(self): """set up the test """ db.setup() db.init() self.user1 = User( name='Test User 1', login='******', email='*****@*****.**', password='******' ) DBSession.add(self.user1) self.user2 = User( name='Test User 2', login='******', email='*****@*****.**', password='******' ) DBSession.add(self.user2) self.user3 = User( name='Test User 2', login='******', email='*****@*****.**', password='******' ) DBSession.add(self.user3) # Review Statuses self.status_new = Status.query.filter_by(code='NEW').first() self.status_rrev = Status.query.filter_by(code='RREV').first() self.status_app = Status.query.filter_by(code='APP').first() # Task Statuses self.status_wfd = Status.query.filter_by(code='WFD').first() self.status_rts = Status.query.filter_by(code='RTS').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_prev = Status.query.filter_by(code='PREV').first() self.status_hrev = Status.query.filter_by(code='HREV').first() self.status_drev = Status.query.filter_by(code='DREV').first() self.status_cmpl = Status.query.filter_by(code='CMPL').first() self.project_status_list = StatusList( target_entity_type='Project', statuses=[ self.status_new, self.status_wip, self.status_cmpl ] ) DBSession.add(self.project_status_list) self.temp_path = tempfile.mkdtemp() self.repo = Repository( name='Test Repository', linux_path=self.temp_path, windows_path=self.temp_path, osx_path=self.temp_path ) DBSession.add(self.repo) self.structure = Structure( name='Test Project Structure' ) DBSession.add(self.structure) self.project = Project( name='Test Project', code='TP', status_list=self.project_status_list, repository=self.repo ) DBSession.add(self.project) self.task1 = Task( name='Test Task 1', project=self.project, resources=[self.user1], responsible=[self.user2] ) DBSession.add(self.task1) self.task2 = Task( name='Test Task 2', project=self.project, responsible=[self.user1] ) DBSession.add(self.task2) self.task3 = Task( name='Test Task 3', parent=self.task2, resources=[self.user1] ) DBSession.add(self.task3) self.task4 = Task( name='Test Task 4', project=self.project, resources=[self.user1], depends=[self.task3], responsible=[self.user2], schedule_timing=2, schedule_unit='h' ) DBSession.add(self.task4) self.task5 = Task( name='Test Task 5', project=self.project, resources=[self.user2], depends=[self.task3], responsible=[self.user2], schedule_timing=2, schedule_unit='h' ) DBSession.add(self.task5) self.task6 = Task( name='Test Task 6', project=self.project, resources=[self.user3], depends=[self.task3], responsible=[self.user2], schedule_timing=2, schedule_unit='h' ) DBSession.add(self.task6) self.kwargs = { 'task': self.task1, 'reviewer': self.user1 } #self.review = Review(**self.kwargs) #DBSession.add(self.review) # add everything to the db DBSession.commit()
def setUp(self): """set up the test """ # we need a database db.setup(self.config) db.init() # replace datetime now function # create departments self.test_dep1 = Department(name="Dep1") self.test_dep2 = Department(name="Dep2") # create resources self.test_user1 = User( login="******", name="User1", email="*****@*****.**", password="******", departments=[self.test_dep1] ) DBSession.add(self.test_user1) self.test_user2 = User( login="******", name="User2", email="*****@*****.**", password="******", departments=[self.test_dep1] ) DBSession.add(self.test_user2) self.test_user3 = User( login="******", name="User3", email="*****@*****.**", password="******", departments=[self.test_dep2] ) DBSession.add(self.test_user3) self.test_user4 = User( login="******", name="User4", email="*****@*****.**", password="******", departments=[self.test_dep2] ) DBSession.add(self.test_user4) # user with two departments self.test_user5 = User( login="******", name="User5", email="*****@*****.**", password="******", departments=[self.test_dep1, self.test_dep2], ) DBSession.add(self.test_user5) # user with no departments self.test_user6 = User(login="******", name="User6", email="*****@*****.**", password="******") DBSession.add(self.test_user6) # repository self.test_repo = Repository( name="Test Repository", linux_path="/mnt/T/", windows_path="T:/", osx_path="/Volumes/T/" ) DBSession.add(self.test_repo) # statuses self.test_status1 = Status(name="Status 1", code="STS1") self.test_status2 = Status(name="Status 2", code="STS2") self.test_status3 = Status(name="Status 3", code="STS3") self.test_status4 = Status(name="Status 4", code="STS4") self.test_status5 = Status(name="Status 5", code="STS5") DBSession.add_all( [self.test_status1, self.test_status2, self.test_status3, self.test_status4, self.test_status5] ) # status lists self.test_proj_status_list = StatusList( name="Project Status List", statuses=[self.test_status1, self.test_status2, self.test_status3], target_entity_type="Project", ) DBSession.add(self.test_proj_status_list) # create one project self.test_proj1 = Project( name="Test Project 1", code="TP1", repository=self.test_repo, status_list=self.test_proj_status_list, start=datetime.datetime(2013, 4, 4), end=datetime.datetime(2013, 5, 4), ) DBSession.add(self.test_proj1) self.test_proj1.now = datetime.datetime(2013, 4, 4) # create task status list with DBSession.no_autoflush: self.test_task_status_list = StatusList.query.filter_by(target_entity_type="Task").first() # create two tasks with the same resources self.test_task1 = Task( name="Task1", project=self.test_proj1, resources=[self.test_user1, self.test_user2], alternative_resources=[self.test_user3, self.test_user4, self.test_user5], schedule_model=0, schedule_timing=50, schedule_unit="h", status_list=self.test_task_status_list, ) DBSession.add(self.test_task1) self.test_task2 = Task( name="Task2", project=self.test_proj1, resources=[self.test_user1, self.test_user2], alternative_resources=[self.test_user3, self.test_user4, self.test_user5], depends=[self.test_task1], schedule_model=0, schedule_timing=60, schedule_unit="h", status_list=self.test_task_status_list, ) DBSession.add(self.test_task2) DBSession.commit()
def setUp(self): """set up the test """ # we need a database db.setup(self.config) db.init() # replace datetime now function # create departments self.test_dep1 = Department(name='Dep1') self.test_dep2 = Department(name='Dep2') # create resources self.test_user1 = User( login='******', name='User1', email='*****@*****.**', password='******', departments=[self.test_dep1] ) DBSession.add(self.test_user1) self.test_user2 = User( login='******', name='User2', email='*****@*****.**', password='******', departments=[self.test_dep1] ) DBSession.add(self.test_user2) self.test_user3 = User( login='******', name='User3', email='*****@*****.**', password='******', departments=[self.test_dep2] ) DBSession.add(self.test_user3) self.test_user4 = User( login='******', name='User4', email='*****@*****.**', password='******', departments=[self.test_dep2] ) DBSession.add(self.test_user4) # user with two departments self.test_user5 = User( login='******', name='User5', email='*****@*****.**', password='******', departments=[self.test_dep1, self.test_dep2] ) DBSession.add(self.test_user5) # user with no departments self.test_user6 = User( login='******', name='User6', email='*****@*****.**', password='******' ) DBSession.add(self.test_user6) # repository self.test_repo = Repository( name='Test Repository', linux_path='/mnt/T/', windows_path='T:/', osx_path='/Volumes/T/' ) DBSession.add(self.test_repo) # statuses self.test_status1 = Status(name='Status 1', code='STS1') self.test_status2 = Status(name='Status 2', code='STS2') self.test_status3 = Status(name='Status 3', code='STS3') self.test_status4 = Status(name='Status 4', code='STS4') self.test_status5 = Status(name='Status 5', code='STS5') DBSession.add_all([self.test_status1, self.test_status2, self.test_status3, self.test_status4, self.test_status5]) # status lists self.test_proj_status_list = StatusList( name='Project Status List', statuses=[self.test_status1, self.test_status2, self.test_status3], target_entity_type='Project' ) DBSession.add(self.test_proj_status_list) # create one project self.test_proj1 = Project( name='Test Project 1', code='TP1', repository=self.test_repo, status_list=self.test_proj_status_list, start=datetime.datetime(2013, 4, 4), end=datetime.datetime(2013, 5, 4) ) DBSession.add(self.test_proj1) self.test_proj1.now = datetime.datetime(2013, 4, 4) # create task status list with DBSession.no_autoflush: self.test_task_status_list = StatusList.query\ .filter_by(target_entity_type='Task').first() # create two tasks with the same resources self.test_task1 = Task( name='Task1', project=self.test_proj1, resources=[self.test_user1, self.test_user2], alternative_resources=[ self.test_user3, self.test_user4, self.test_user5 ], schedule_model=0, schedule_timing=50, schedule_unit='h', status_list=self.test_task_status_list ) DBSession.add(self.test_task1) self.test_task2 = Task( name='Task2', project=self.test_proj1, resources=[self.test_user1, self.test_user2], alternative_resources=[ self.test_user3, self.test_user4, self.test_user5 ], depends=[self.test_task1], schedule_model=0, schedule_timing=60, schedule_unit='h', status_list=self.test_task_status_list ) DBSession.add(self.test_task2) DBSession.commit()
def test_get_version_from_full_path_with_multiple_repositories(self): """testing if the get version from full path is working fine with multiple repositories and with same version names """ repo1 = Repository(name="Test Repo 1", linux_path="/mnt/T/", windows_path="T:/", osx_path="/Volumes/T/") DBSession.add(repo1) repo2 = Repository(name="Test Repo 2", linux_path="/mnt/S/", windows_path="S:/", osx_path="/Volumes/S/") DBSession.add(repo2) task_ft = FilenameTemplate( name="Task Filename Template", target_entity_type="Task", path="$REPO{{project.repository.id}}/{{project.code}}/" "{%- for parent_task in parent_tasks -%}" "{{parent_task.nice_name}}/{%- endfor -%}", filename="{{task.nice_name}}_{{version.take_name}}" '_v{{"%03d"|format(version.version_number)}}', ) DBSession.add(task_ft) structure1 = Structure(name="Commercial Project Structure", templates=[task_ft]) DBSession.add(structure1) status1 = Status(name="Status 1", code="STS1") status2 = Status(name="Status 2", code="STS2") status3 = Status(name="Status 3", code="STS3") DBSession.add_all([status1, status2, status3]) proj_status_list = StatusList( name="Project Statuses", target_entity_type="Project", statuses=[status1, status2, status3] ) DBSession.add(proj_status_list) task_status_list = StatusList( name="Task Statuses", target_entity_type="Task", statuses=[status1, status2, status3] ) DBSession.add(task_status_list) version_status_list = StatusList( name="Version Statuses", target_entity_type="Version", statuses=[status1, status2, status3] ) DBSession.add(version_status_list) project1 = Project( name="Test Project 1", code="TP1", repositories=[repo1], structure=structure1, status_list=proj_status_list ) DBSession.add(project1) project2 = Project( name="Test Project 2", code="TP2", repositories=[repo2], structure=structure1, status_list=proj_status_list ) DBSession.add(project2) task1 = Task(name="Test Task 1", code="TT1", project=project1, status_list=task_status_list) DBSession.add(task1) task2 = Task(name="Test Task 1", code="TT1", project=project2, status_list=task_status_list) DBSession.add(task2) DBSession.commit() # now create versions version1 = Version(task=task1, status_list=version_status_list) DBSession.add(version1) DBSession.commit() version1.update_paths() version2 = Version(task=task2, status_list=version_status_list) DBSession.add(version2) DBSession.commit() version2.update_paths() DBSession.commit() logger.debug("version1.full_path : %s" % version1.full_path) logger.debug("version2.full_path : %s" % version2.full_path) # now try to get the versions with an EnvironmentBase instance env = EnvironmentBase() # version1 version1_found = env.get_version_from_full_path("/mnt/T/TP1/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(version1_found, version1) # version2 version2_found = env.get_version_from_full_path("/mnt/S/TP2/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(version2_found, version2) # version1 in windows version1_found = env.get_version_from_full_path("T:/TP1/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(version1_found, version1) # version2 in windows version2_found = env.get_version_from_full_path("S:/TP2/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(version2_found, version2) # version1 in linux version1_found = env.get_version_from_full_path("/mnt/T/TP1/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(version1_found, version1) # version2 in linux version2_found = env.get_version_from_full_path("/mnt/S/TP2/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(version2_found, version2) # version1 in osx version1_found = env.get_version_from_full_path("/Volumes/T/TP1/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(version1_found, version1) # version2 in osx version2_found = env.get_version_from_full_path("/Volumes/S/TP2/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(version2_found, version2)
def test_trim_repo_path_with_multiple_repositories(self): """testing if the trim_repo_path is working fine with multiple repositories and with same version names """ repo0 = Repository( name="Test Repo 0", linux_path="/mnt/T/with_a_very_long_path_which_will_cause_errors/", windows_path="T:/with_a_very_long_path_which_will_cause_errors/", osx_path="/Volumes/T/" "with_a_very_long_path_which_will_cause_errors/", ) DBSession.add(repo0) repo1 = Repository(name="Test Repo 1", linux_path="/mnt/T/", windows_path="T:/", osx_path="/Volumes/T/") DBSession.add(repo1) repo2 = Repository(name="Test Repo 2", linux_path="/mnt/S/", windows_path="S:/", osx_path="/Volumes/S/") DBSession.add(repo2) task_ft = FilenameTemplate( name="Task Filename Template", target_entity_type="Task", path="{{project.code}}/{%- for parent_task in parent_tasks -%}" "{{parent_task.nice_name}}/{%- endfor -%}", filename="{{task.nice_name}}_{{version.take_name}}" '_v{{"%03d"|format(version.version_number)}}', ) DBSession.add(task_ft) structure1 = Structure(name="Commercial Project Structure", templates=[task_ft]) DBSession.add(structure1) status1 = Status(name="Status 1", code="STS1") status2 = Status(name="Status 2", code="STS2") status3 = Status(name="Status 3", code="STS3") DBSession.add_all([status1, status2, status3]) proj_status_list = StatusList( name="Project Statuses", target_entity_type="Project", statuses=[status1, status2, status3] ) DBSession.add(proj_status_list) task_status_list = StatusList( name="Task Statuses", target_entity_type="Task", statuses=[status1, status2, status3] ) DBSession.add(task_status_list) version_status_list = StatusList( name="Version Statuses", target_entity_type="Version", statuses=[status1, status2, status3] ) DBSession.add(version_status_list) project1 = Project( name="Test Project 1", code="TP1", repositories=[repo1], structure=structure1, status_list=proj_status_list ) DBSession.add(project1) project2 = Project( name="Test Project 2", code="TP2", repositories=[repo2], structure=structure1, status_list=proj_status_list ) DBSession.add(project2) task1 = Task(name="Test Task 1", code="TT1", project=project1, status_list=task_status_list) DBSession.add(task1) task2 = Task(name="Test Task 1", code="TT1", project=project2, status_list=task_status_list) DBSession.add(task2) DBSession.commit() # now create versions version1 = Version(task=task1, status_list=version_status_list) DBSession.add(version1) DBSession.commit() version1.update_paths() version2 = Version(task=task1, status_list=version_status_list) DBSession.add(version2) DBSession.commit() version2.update_paths() version3 = Version(task=task2, status_list=version_status_list) DBSession.add(version3) DBSession.commit() version3.update_paths() version4 = Version(task=task2, status_list=version_status_list) DBSession.add(version4) DBSession.commit() version4.update_paths() DBSession.commit() logger.debug("version1.full_path : %s" % version1.full_path) logger.debug("version2.full_path : %s" % version2.full_path) logger.debug("version3.full_path : %s" % version2.full_path) logger.debug("version4.full_path : %s" % version2.full_path) # now try to get the versions with an EnvironmentBase instance env = EnvironmentBase() expected_value1 = "TP1/Test_Task_1/Test_Task_1_Main_v001" expected_value2 = "TP2/Test_Task_1/Test_Task_1_Main_v001" # version1 native trimmed_path = env.trim_repo_path("/mnt/T/TP1/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(trimmed_path, expected_value1) # version2 native trimmed_path = env.trim_repo_path("/mnt/S/TP2/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(trimmed_path, expected_value2) # version1 windows trimmed_path = env.trim_repo_path("T:/TP1/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(trimmed_path, expected_value1) # version2 windows trimmed_path = env.trim_repo_path("S:/TP2/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(trimmed_path, expected_value2) # version1 linux trimmed_path = env.trim_repo_path("/mnt/T/TP1/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(trimmed_path, expected_value1) # version2 linux trimmed_path = env.trim_repo_path("/mnt/S/TP2/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(trimmed_path, expected_value2) # version1 osx trimmed_path = env.trim_repo_path("/Volumes/T/TP1/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(trimmed_path, expected_value1) # version2 osx trimmed_path = env.trim_repo_path("/Volumes/S/TP2/Test_Task_1/Test_Task_1_Main_v001") self.assertEqual(trimmed_path, expected_value2)
def test_trim_repo_path_with_multiple_repositories(self): """testing if the trim_repo_path is working fine with multiple repositories and with same version names """ repo0 = Repository( name='Test Repo 0', linux_path='/mnt/T/with_a_very_long_path_which_will_cause_errors/', windows_path='T:/with_a_very_long_path_which_will_cause_errors/', osx_path='/Volumes/T/' 'with_a_very_long_path_which_will_cause_errors/') DBSession.add(repo0) repo1 = Repository(name='Test Repo 1', linux_path='/mnt/T/', windows_path='T:/', osx_path='/Volumes/T/') DBSession.add(repo1) repo2 = Repository(name='Test Repo 2', linux_path='/mnt/S/', windows_path='S:/', osx_path='/Volumes/S/') DBSession.add(repo2) task_ft = FilenameTemplate( name='Task Filename Template', target_entity_type='Task', path='{{project.code}}/{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/{%- endfor -%}', filename='{{task.nice_name}}_{{version.take_name}}' '_v{{"%03d"|format(version.version_number)}}', ) DBSession.add(task_ft) structure1 = Structure(name='Commercial Project Structure', templates=[task_ft]) DBSession.add(structure1) status1 = Status(name='Status 1', code='STS1') status2 = Status(name='Status 2', code='STS2') status3 = Status(name='Status 3', code='STS3') DBSession.add_all([status1, status2, status3]) proj_status_list = \ StatusList.query.filter_by(target_entity_type='Project').first() task_status_list = \ StatusList.query.filter_by(target_entity_type='Task').first() DBSession.add(task_status_list) project1 = Project(name='Test Project 1', code='TP1', repositories=[repo1], structure=structure1, status_list=proj_status_list) DBSession.add(project1) project2 = Project(name='Test Project 2', code='TP2', repositories=[repo2], structure=structure1, status_list=proj_status_list) DBSession.add(project2) task1 = Task(name='Test Task 1', code='TT1', project=project1, status_list=task_status_list) DBSession.add(task1) task2 = Task(name='Test Task 1', code='TT1', project=project2, status_list=task_status_list) DBSession.add(task2) DBSession.commit() # now create versions version1 = Version(task=task1, status_list=version_status_list) DBSession.add(version1) DBSession.commit() version1.update_paths() version2 = Version(task=task1) DBSession.add(version2) DBSession.commit() version2.update_paths() version3 = Version(task=task2) DBSession.add(version3) DBSession.commit() version3.update_paths() version4 = Version(task=task2) DBSession.add(version4) DBSession.commit() version4.update_paths() DBSession.commit() logger.debug('version1.full_path : %s' % version1.full_path) logger.debug('version2.full_path : %s' % version2.full_path) logger.debug('version3.full_path : %s' % version2.full_path) logger.debug('version4.full_path : %s' % version2.full_path) # now try to get the versions with an EnvironmentBase instance env = EnvironmentBase() expected_value1 = 'TP1/Test_Task_1/Test_Task_1_Main_v001' expected_value2 = 'TP2/Test_Task_1/Test_Task_1_Main_v001' # version1 native trimmed_path = env.trim_repo_path( '/mnt/T/TP1/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(trimmed_path, expected_value1) # version2 native trimmed_path = env.trim_repo_path( '/mnt/S/TP2/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(trimmed_path, expected_value2) # version1 windows trimmed_path = env.trim_repo_path( 'T:/TP1/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(trimmed_path, expected_value1) # version2 windows trimmed_path = env.trim_repo_path( 'S:/TP2/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(trimmed_path, expected_value2) # version1 linux trimmed_path = env.trim_repo_path( '/mnt/T/TP1/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(trimmed_path, expected_value1) # version2 linux trimmed_path = env.trim_repo_path( '/mnt/S/TP2/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(trimmed_path, expected_value2) # version1 osx trimmed_path = env.trim_repo_path( '/Volumes/T/TP1/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(trimmed_path, expected_value1) # version2 osx trimmed_path = env.trim_repo_path( '/Volumes/S/TP2/Test_Task_1/Test_Task_1_Main_v001') self.assertEqual(trimmed_path, expected_value2)
def setUp(self): """set up the test """ db.setup() db.init() # get statuses self.status_new = Status.query.filter_by(code="NEW").first() self.status_wfd = Status.query.filter_by(code="WFD").first() self.status_rts = Status.query.filter_by(code="RTS").first() self.status_wip = Status.query.filter_by(code="WIP").first() self.status_prev = Status.query.filter_by(code="PREV").first() self.status_hrev = Status.query.filter_by(code="HREV").first() self.status_drev = Status.query.filter_by(code="DREV").first() self.status_oh = Status.query.filter_by(code="OH").first() self.status_stop = Status.query.filter_by(code="STOP").first() self.status_cmpl = Status.query.filter_by(code="CMPL").first() self.test_user1 = User( name='Test User 1', login='******', email='*****@*****.**', password='******' ) self.test_user2 = User( name='Test User 2', login='******', email='*****@*****.**', password='******' ) self.test_user3 = User( name='Test User 1', login='******', email='*****@*****.**', password='******' ) self.test_repo = Repository( name='Test Repository' ) self.test_structure = Structure( name='test structure' ) # project status list self.test_project_status_list = StatusList( name='Project Statuses', target_entity_type='Project', statuses=[ self.status_new, self.status_wip, self.status_oh, self.status_stop, self.status_cmpl ] ) self.test_project1 = Project( name='Test Project 1', code='TP1', lead=self.test_user1, repository=self.test_repo, structure=self.test_structure, status_list=self.test_project_status_list ) # create three Tasks self.test_task1 = Task( name='Test Task 1', project=self.test_project1 ) self.test_task2 = Task( name='Test Task 2', project=self.test_project1 ) self.test_task3 = Task( name='Test Task 3', project=self.test_project1 ) # add everything to db DBSession.add_all([ self.test_project1, self.test_project_status_list, self.test_repo, self.test_structure, self.test_task1, self.test_task2, self.test_task3, self.test_user1, self.test_user2 ]) DBSession.commit() self.kwargs = { 'task': self.test_task1, 'depends_to': self.test_task2, 'dependency_target': 'onend', 'gap_timing': 0, 'gap_unit': 'h', 'gap_model': 'length' }
def test_generic_data_attribute_can_hold_a_wide_variety_of_object_types(self): """testing if the generic_data attribute can hold any kind of object as a list """ from stalker import db db.setup() new_simple_entity = SimpleEntity(**self.kwargs) test_user = User( name='email', login='******', email='*****@*****.**', password='******', ) from stalker import Department test_department = Department( name='department1' ) from stalker import Repository test_repo = Repository( name='Test Repository' ) from stalker import Structure test_struct = Structure( name='Test Project Structure' ) from stalker import Status, StatusList test_project_status_list = StatusList( name='Project Status List', target_entity_type='Project', statuses=[ Status(name='Active', code='ACT') ] ) from stalker import Project test_proj = Project( name='Test Project 1', code='tp1', repository=test_repo, structure=test_struct, status_list=test_project_status_list ) new_simple_entity.generic_data.extend( [test_proj, test_project_status_list, test_struct, test_repo, test_department, test_user] ) DBSession.add(new_simple_entity) DBSession.commit() # now check if it is added to the database correctly del new_simple_entity new_simple_entity_db = SimpleEntity.query \ .filter_by(name=self.kwargs['name']) \ .first() self.assertTrue(test_proj in new_simple_entity_db.generic_data) self.assertTrue( test_project_status_list in new_simple_entity_db.generic_data) self.assertTrue(test_struct in new_simple_entity_db.generic_data) self.assertTrue(test_repo in new_simple_entity_db.generic_data) self.assertTrue(test_department in new_simple_entity_db.generic_data) self.assertTrue(test_user in new_simple_entity_db.generic_data) DBSession.remove()
def setUp(self): """set up the test """ db.setup() db.init() # get statuses self.status_new = Status.query.filter_by(code="NEW").first() self.status_wfd = Status.query.filter_by(code="WFD").first() self.status_rts = Status.query.filter_by(code="RTS").first() self.status_wip = Status.query.filter_by(code="WIP").first() self.status_prev = Status.query.filter_by(code="PREV").first() self.status_hrev = Status.query.filter_by(code="HREV").first() self.status_drev = Status.query.filter_by(code="DREV").first() self.status_oh = Status.query.filter_by(code="OH").first() self.status_stop = Status.query.filter_by(code="STOP").first() self.status_cmpl = Status.query.filter_by(code="CMPL").first() self.test_user1 = User(name='Test User 1', login='******', email='*****@*****.**', password='******') self.test_user2 = User(name='Test User 2', login='******', email='*****@*****.**', password='******') self.test_user3 = User(name='Test User 1', login='******', email='*****@*****.**', password='******') self.test_repo = Repository(name='Test Repository') self.test_structure = Structure(name='test structure') # project status list self.test_project_status_list = StatusList( name='Project Statuses', target_entity_type='Project', statuses=[ self.status_new, self.status_wip, self.status_oh, self.status_stop, self.status_cmpl ]) self.test_project1 = Project(name='Test Project 1', code='TP1', repository=self.test_repo, structure=self.test_structure, status_list=self.test_project_status_list) # create three Tasks self.test_task1 = Task(name='Test Task 1', project=self.test_project1) self.test_task2 = Task(name='Test Task 2', project=self.test_project1) self.test_task3 = Task(name='Test Task 3', project=self.test_project1) # add everything to db DBSession.add_all([ self.test_project1, self.test_project_status_list, self.test_repo, self.test_structure, self.test_task1, self.test_task2, self.test_task3, self.test_user1, self.test_user2 ]) DBSession.commit() self.kwargs = { 'task': self.test_task1, 'depends_to': self.test_task2, 'dependency_target': 'onend', 'gap_timing': 0, 'gap_unit': 'h', 'gap_model': 'length' }
def test_generic_data_attribute_can_hold_a_wide_variety_of_object_types(self): """testing if the generic_data attribute can hold any kind of object as a list """ from stalker import db db.setup() new_simple_entity = SimpleEntity(**self.kwargs) test_user = User( name='email', login='******', email='*****@*****.**', password='******', ) from stalker import Department test_department = Department( name='department1' ) from stalker import Repository test_repo = Repository( name='Test Repository' ) from stalker import Structure test_struct = Structure( name='Test Project Structure' ) from stalker import Status, StatusList test_project_status_list = StatusList( name='Project Status List', target_entity_type='Project', statuses=[ Status(name='Active', code='ACT') ] ) from stalker import Project test_proj = Project( name='Test Project 1', code='tp1', repository=test_repo, structure=test_struct, status_list=test_project_status_list ) new_simple_entity.generic_data.extend( [test_proj, test_project_status_list, test_struct, test_repo, test_department, test_user] ) DBSession.add(new_simple_entity) DBSession.commit() # now check if it is added to the database correctly del new_simple_entity new_simple_entity_db = SimpleEntity.query \ .filter_by(name=self.kwargs['name']) \ .first() self.assertTrue(test_proj in new_simple_entity_db.generic_data) self.assertTrue( test_project_status_list in new_simple_entity_db.generic_data) self.assertTrue(test_struct in new_simple_entity_db.generic_data) self.assertTrue(test_repo in new_simple_entity_db.generic_data) self.assertTrue(test_department in new_simple_entity_db.generic_data) self.assertTrue(test_user in new_simple_entity_db.generic_data) DBSession.remove()
def setUp(self): """set up the test """ db.setup() db.init() self.user1 = User( name='Test User 1', login='******', email='*****@*****.**', password='******' ) DBSession.add(self.user1) self.user2 = User( name='Test User 2', login='******', email='*****@*****.**', password='******' ) DBSession.add(self.user2) self.user3 = User( name='Test User 2', login='******', email='*****@*****.**', password='******' ) DBSession.add(self.user3) # Review Statuses self.status_new = Status.query.filter_by(code='NEW').first() self.status_rrev = Status.query.filter_by(code='RREV').first() self.status_app = Status.query.filter_by(code='APP').first() # Task Statuses self.status_wfd = Status.query.filter_by(code='WFD').first() self.status_rts = Status.query.filter_by(code='RTS').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_prev = Status.query.filter_by(code='PREV').first() self.status_hrev = Status.query.filter_by(code='HREV').first() self.status_drev = Status.query.filter_by(code='DREV').first() self.status_cmpl = Status.query.filter_by(code='CMPL').first() self.project_status_list = StatusList( target_entity_type='Project', statuses=[ self.status_new, self.status_wip, self.status_cmpl ] ) DBSession.add(self.project_status_list) self.temp_path = tempfile.mkdtemp() self.repo = Repository( name='Test Repository', linux_path=self.temp_path, windows_path=self.temp_path, osx_path=self.temp_path ) DBSession.add(self.repo) self.structure = Structure( name='Test Project Structure' ) DBSession.add(self.structure) self.project = Project( name='Test Project', code='TP', lead=self.user1, status_list=self.project_status_list, repository=self.repo ) DBSession.add(self.project) self.task1 = Task( name='Test Task 1', project=self.project, resources=[self.user1] ) DBSession.add(self.task1) self.task2 = Task( name='Test Task 2', project=self.project ) DBSession.add(self.task2) self.task3 = Task( name='Test Task 3', parent=self.task2, resources=[self.user1] ) DBSession.add(self.task3) self.kwargs = { 'task': self.task1, 'reviewer': self.user1 } #self.review = Review(**self.kwargs) #DBSession.add(self.review) # add everything to the db DBSession.commit()
def test_creating_a_time_log_for_a_leaf_task_will_set_its_parents_status_to_wip(self): """testing if the status of the parent task will turn to wip if time log is entered to a child task """ # TODO: This is also testing some functionality from view.task, slit it # create two new task task0 = Task( name='Test Task 0', project=self.proj1, status_list=self.task_status_list ) task1 = Task( name='Test Task 1', parent=task0, status_list=self.task_status_list ) task2 = Task( name='Test Task 2', parent=task1, resources=[self.user1], status_list=self.task_status_list, status=self.status_rts ) task3 = Task( name='Test Task 3', parent=task1, resources=[self.user1], status_list=self.task_status_list, status=self.status_rts ) task4 = Task( name='Test Task 4', parent=task0, resources=[self.user1], status_list=self.task_status_list, status=self.status_rts ) DBSession.add_all([task0, task1, task2, task3, task4]) DBSession.commit() DBSession.flush() transaction.commit() self.assertEqual(task0.status, self.status_new) self.assertEqual(task1.status, self.status_new) self.assertEqual(task2.status, self.status_rts) self.assertEqual(task3.status, self.status_rts) self.assertEqual(task4.status, self.status_rts) # now add a time log for task3 through create_time_log view request = testing.DummyRequest() # patch get_logged_in_user admins = Group.query.filter(Group.name == 'admins').first() self.user1.groups.append(admins) m = mocker.Mocker() obj = m.replace("stalker_pyramid.views.auth.get_logged_in_user") obj(request) m.result(self.user1) m.count(1, 1000000000) m.replay() request.route_url = lambda x, id=1: 'view_user' request.params['task_id'] = task3.id request.params['resource_id'] = self.user1.id request.params['start'] = "Fri, 19 Nov 2013 08:00:00 GMT" request.params['end'] = "Fri, 19 Nov 2013 17:00:00 GMT" response = time_log.create_time_log(request) self.assertEqual(response.status_int, 200) # now expect to have the status of task1 to be wip self.assertEqual(task3.status, self.status_wip) self.assertEqual(task2.status, self.status_rts) self.assertEqual(task1.status, self.status_wip) self.assertEqual(task0.status, self.status_wip) self.assertEqual(task4.status, self.status_rts) request.params['task_id'] = task2.id request.params['resource_id'] = self.user1.id request.params['start'] = "Fri, 18 Nov 2013 08:00:00 GMT" request.params['end'] = "Fri, 18 Nov 2013 17:00:00 GMT" response = time_log.create_time_log(request) self.assertEqual(response.status_int, 200) # now expect to have the status of task1 to be wip self.assertEqual(task3.status, self.status_wip) self.assertEqual(task2.status, self.status_wip) self.assertEqual(task1.status, self.status_wip) self.assertEqual(task0.status, self.status_wip) self.assertEqual(task4.status, self.status_rts) # now request a review and approve the task2 and task3 and expect the # task1 status is complete from stalker_pyramid.views.task import request_review, review_task #request = testing.DummyRequest() request.matchdict['id'] = task2.id request.params['send_email'] = 0 request.route_url = lambda x, id: 'localhost:6453/tasks/23/view' request.route_path = lambda x, id: '/tasks/23/view' response = request_review(request) self.assertEqual(response.status_int, 200) #request = testing.DummyRequest() request.matchdict['id'] = task3.id request.params['send_email'] = 0 response = request_review(request) print response.body self.assertEqual(response.status_int, 200) self.assertEqual(task3.status, self.status_prev) self.assertEqual(task2.status, self.status_prev) self.assertEqual(task1.status, self.status_wip) self.assertEqual(task0.status, self.status_wip) self.assertEqual(task4.status, self.status_rts) # approve the task2 request.matchdict['id'] = task2.id request.params['review'] = 'Approve' response = review_task(request) self.assertEqual(response.status_int, 200) # and except task1 is still wip self.assertEqual(task3.status, self.status_prev) self.assertEqual(task2.status, self.status_cmpl) self.assertEqual(task1.status, self.status_wip) self.assertEqual(task0.status, self.status_wip) self.assertEqual(task4.status, self.status_rts) # approve the task3 request.matchdict['id'] = task3.id request.params['review'] = 'Approve' response = review_task(request) self.assertEqual(response.status_int, 200) # now check the statuses self.assertEqual(task3.status, self.status_cmpl) self.assertEqual(task2.status, self.status_cmpl) self.assertEqual(task1.status, self.status_cmpl) self.assertEqual(task0.status, self.status_wip) self.assertEqual(task4.status, self.status_rts)