def test_tasks_of_given_projects_are_correctly_scheduled(self): """testing if the tasks of given projects are correctly scheduled """ # create a dummy project # create a dummy Project to schedule dummy_project = Project(name='Dummy Project', code='DP', repository=self.test_repo) dt1 = Task(name='Dummy Task 1', project=dummy_project, schedule_timing=4, schedule_unit='h', resources=[self.test_user1]) dt2 = Task(name='Dummy Task 2', project=dummy_project, schedule_timing=4, schedule_unit='h', resources=[self.test_user2]) db.DBSession.add_all([dummy_project, dt1, dt2]) db.DBSession.commit() tjp_sched = TaskJugglerScheduler(compute_resources=True, projects=[dummy_project]) test_studio = Studio(name='Test Studio', now=datetime.datetime(2013, 4, 16, 0, 0)) test_studio.start = datetime.datetime(2013, 4, 16, 0, 0) test_studio.end = datetime.datetime(2013, 4, 30, 0, 0) test_studio.daily_working_hours = 9 DBSession.add(test_studio) db.DBSession.commit() tjp_sched.studio = test_studio tjp_sched.schedule() db.DBSession.commit() # check if the task and project timings are all adjusted self.assertEqual(self.test_proj1.computed_start, None) self.assertEqual(self.test_proj1.computed_end, None) self.assertEqual(self.test_task1.computed_start, None) self.assertEqual(self.test_task1.computed_end, None) self.assertEqual(self.test_task1.computed_resources, [self.test_user1, self.test_user2]) self.assertEqual(self.test_task2.computed_start, None) self.assertEqual(self.test_task2.computed_end, None) self.assertEqual(self.test_task2.computed_resources, [self.test_user1, self.test_user2]) self.assertEqual(dt1.computed_start, datetime.datetime(2013, 4, 16, 9, 0)) self.assertEqual(dt1.computed_end, datetime.datetime(2013, 4, 16, 13, 0)) self.assertEqual(dt2.computed_start, datetime.datetime(2013, 4, 16, 9, 0)) self.assertEqual(dt2.computed_end, datetime.datetime(2013, 4, 16, 13, 0))
def test_task_argument_is_not_a_leaf_task(self): """testing if a ValueError will be raised when the task given in task argument is not a leaf task """ task1 = Task(name='Task1', project=self.project) task2 = Task(name='Task2', parent=task1) self.kwargs['task'] = task1 self.assertRaises(ValueError, Review, **self.kwargs)
def test_time_log_creation_for_a_WFD_leaf_task(self): """testing if a StatusError will be raised when a TimeLog instance wanted to be created for a WFD leaf task """ new_task = Task(name='Test Task 2', project=self.test_project) new_task.depends = [self.test_task] self.kwargs['task'] = new_task self.assertRaises(StatusError, TimeLog, **self.kwargs)
def setUpClass(cls): """setup once """ db.setup() db.init() cls.status_new = Status.query.filter_by(code='NEW').first() cls.status_wip = Status.query.filter_by(code='WIP').first() cls.status_cmpl = Status.query.filter_by(code='CMPL').first() cls.test_project_status_list = StatusList( name='Project Statuses', target_entity_type='Project', statuses=[cls.status_new, cls.status_wip, cls.status_cmpl]) cls.test_repo = Repository(name='Test Repository') cls.test_project = Project(name='Test Project', code='TP', repository=cls.test_repo, status_list=cls.test_project_status_list) cls.test_task1 = Task(name='Test Task 1', project=cls.test_project) cls.test_task2 = Task(name='Test Task 2', project=cls.test_project) cls.test_task3 = Task(name='Test Task 3', project=cls.test_project) cls.test_version1 = Version(task=cls.test_task1) db.DBSession.add(cls.test_version1) db.DBSession.commit() cls.test_version2 = Version(task=cls.test_task1) db.DBSession.add(cls.test_version2) db.DBSession.commit() cls.test_version3 = Version(task=cls.test_task1) db.DBSession.add(cls.test_version3) db.DBSession.commit() cls.test_version4 = Version(task=cls.test_task2) db.DBSession.add(cls.test_version4) db.DBSession.commit() cls.test_link1 = Link(original_filename='test_render1.jpg') cls.test_link2 = Link(original_filename='test_render2.jpg') cls.test_link3 = Link(original_filename='test_render3.jpg') cls.test_link4 = Link(original_filename='test_render4.jpg') cls.test_version1.outputs = [ cls.test_link1, cls.test_link2, cls.test_link3 ] cls.test_version4.outputs = [cls.test_link4] db.DBSession.add_all([ cls.test_task1, cls.test_task2, cls.test_task3, cls.test_version1, cls.test_version2, cls.test_version3, cls.test_version4, cls.test_link1, cls.test_link2, cls.test_link3, cls.test_link4 ]) db.DBSession.commit()
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 test_time_log_creation_for_a_WFD_leaf_task(self): """testing if a StatusError will be raised when a TimeLog instance wanted to be created for a WFD leaf task """ new_task = Task( name='Test Task 2', project=self.test_project ) new_task.depends = [self.test_task] self.kwargs['task'] = new_task self.assertRaises(StatusError, TimeLog, **self.kwargs)
def test_creating_a_time_log_for_a_task_whose_dependending_tasks_already_has_time_logs(self): """testing if a HTTPServer error will be raised when a time log tried to be for a task whose depending tasks already has time logs created (This test should be in Stalker) """ # create a new task task2 = Task( name='Test Task 2', project=self.proj1, depends=[self.task1], resources=[self.user1], schedule_timing=4, schedule_unit= 'd', schedule_model='effort', status_list=self.task_status_list ) DBSession.add(task2) DBSession.flush() transaction.commit() # set the status of task1 to complete self.task1.status = self.status_cmpl # artificially update task2 status to rts task2.status = self.status_rts DBSession.flush() transaction.commit() # and now create time logs for task2 request = testing.DummyRequest() request.params['task_id'] = task2.id request.params['resource_id'] = self.user1.id request.params['start'] = "Fri, 01 Nov 2013 08:00:00 GMT" request.params['end'] = "Fri, 01 Nov 2013 17:00:00 GMT" response = time_log.create_time_log(request) self.assertEqual(response.status_int, 200) DBSession.add(task2) DBSession.flush() transaction.commit() # now because task2 is depending on to the task1 # and task2 has now started, entering any new time logs to task1 # is forbidden request = testing.DummyRequest() request.params['task_id'] = self.task1.id request.params['resource_id'] = self.user1.id request.params['start'] = "Fri, 02 Nov 2013 08:00:00 GMT" request.params['end'] = "Fri, 02 Nov 2013 17:00:00 GMT" response = time_log.create_time_log(request) self.assertEqual( response.status_int, 500 )
def test_TaskMixin_initialization(self): """testing if the TaskMixin part is initialized correctly """ from stalker import StatusList project_status_list = \ StatusList.query\ .filter(StatusList.target_entity_type=='Project').first() from stalker import Type project_type = Type( name="Commercial", code='comm', target_entity_type='Project' ) from stalker import Project new_project = Project( name="Commercial1", code='comm1', status_list=project_status_list, type=project_type, repository=self.test_repository, ) from stalker.db.session import DBSession DBSession.add(new_project) DBSession.commit() self.kwargs['project'] = new_project self.kwargs['code'] = "SH12314" from stalker import Task new_shot = Shot(**self.kwargs) task1 = Task( name="Modeling", status=0, project=new_project, parent=new_shot, ) task2 = Task( name="Lighting", status=0, project=new_project, parent=new_shot, ) tasks = [task1, task2] assert \ sorted(new_shot.tasks, key=lambda x: x.name) == \ sorted(tasks, key=lambda x: x.name)
def create_shot(self): """creates the related Stalker Shot entity with the current clip """ from stalker import Shot, Task from stalker.db.session import DBSession # create the shot logged_in_user = self.get_logged_in_user() # FP_001_001_0010 scene_code = self.shot_code.split("_")[2] scene_task = Task.query.filter(Task.parent == self.sequence).filter(Task.name.endswith(scene_code)).first() if not scene_task: # create the scene task scene_task = Task( project=self.project, name='SCN%s' % scene_code, type=self.get_type("Scene"), parent=self.sequence, description='Autocreated by Resolve', created_by=logged_in_user, updated_by=logged_in_user, ) DBSession.add(scene_task) DBSession.commit() shots_task = Task.query.filter(Task.parent == scene_task).filter(Task.name == 'Shots').first() if not shots_task: shots_task = Task( project=self.project, name='Shots', parent=scene_task, description='Autocreated by Resolve', created_by=logged_in_user, updated_by=logged_in_user, ) DBSession.add(shots_task) DBSession.commit() shot = Shot( name=self.shot_code, code=self.shot_code, project=self.project, parent=shots_task, sequences=[self.sequence], cut_in=1001, cut_out=int(self.clip.GetEnd() - self.clip.GetStart() + 1000), description='Autocreated by Resolve', created_by=logged_in_user, updated_by=logged_in_user, ) DBSession.add(shot) return shot
def test_task_argument_is_not_a_leaf_task(self): """testing if a ValueError will be raised when the task given in task argument is not a leaf task """ from stalker import Task task1 = Task(name='Task1', project=self.project) task2 = Task(name='Task2', parent=task1) self.kwargs['task'] = task1 with pytest.raises(ValueError) as cm: Review(**self.kwargs) assert str(cm.value) == \ 'It is only possible to create a review for a leaf tasks, and ' \ '<Task1 (Task)> is not a leaf task.'
def test_TaskableEntity_initialization(self): """testing if the TaskableEntity part is initialized correctly """ from stalker import Status, StatusList status1 = Status(name="On Hold", code="OH") project_status_list = StatusList( name="Project Statuses", statuses=[status1], target_entity_type='Project', ) from stalker import Type, Project, Sequence, Task project_type = Type( name="Commercial", code='comm', target_entity_type='Project' ) new_project = Project( name="Commercial", code='comm', status_list=project_status_list, type=project_type, repository=self.test_repository, ) self.kwargs["new_project"] = new_project new_sequence = Sequence(**self.kwargs) task1 = Task( name="Modeling", status=0, project=new_project, parent=new_sequence, ) task2 = Task( name="Lighting", status=0, project=new_project, parent=new_sequence, ) tasks = [task1, task2] self.assertEqual( sorted(new_sequence.tasks, key=lambda x: x.name), sorted(tasks, key=lambda x: x.name) )
def test_TaskMixin_initialization(self): """testing if the TaskMixin part is initialized correctly """ commercial_project_type = Type( name="Commercial", code='comm', target_entity_type=Project, ) new_project = Project( name="Commercial", code='COM', type=commercial_project_type, status_list=self.project_status_list, repository=self.repository, ) character_asset_type = Type( name="Character", code='char', target_entity_type=Asset ) new_asset = Asset( name="test asset", type=character_asset_type, code="tstasset", project=new_project, responsible=[self.test_user1] ) task1 = Task( name="Modeling", parent=new_asset ) task2 = Task( name="Lighting", parent=new_asset ) tasks = [task1, task2] self.assertEqual( sorted(new_asset.tasks, key=lambda x: x.name), sorted(tasks, key=lambda x: x.name) )
def test_time_log_creation_for_a_WFD_leaf_task(self): """testing if a StatusError will be raised when a TimeLog instance wanted to be created for a WFD leaf task """ new_task = Task(name='Test Task 2', project=self.test_project) new_task.depends = [self.test_task1] kwargs = copy.copy(self.kwargs) kwargs['task'] = new_task with self.assertRaises(StatusError) as cm: TimeLog(**kwargs) self.assertEqual( str(cm.exception), 'Test Task 2 is a WFD task, and it is not allowed to create ' 'TimeLogs for a WFD task, please supply a RTS, WIP, HREV or DREV ' 'task!')
def test_TaskMixin_initialization(self): """testing if the TaskMixin part is initialized correctly """ from stalker import Type, Project, Asset, Task commercial_project_type = Type( name="Commercial", code='comm', target_entity_type='Project', ) new_project = Project( name="Commercial", code='COM', type=commercial_project_type, repository=self.repository, ) character_asset_type = Type( name="Character", code='char', target_entity_type='Asset' ) new_asset = Asset( name="test asset", type=character_asset_type, code="tstasset", project=new_project, responsible=[self.test_user1] ) task1 = Task( name="Modeling", parent=new_asset ) task2 = Task( name="Lighting", parent=new_asset ) tasks = [task1, task2] assert \ sorted(new_asset.tasks, key=lambda x: x.name) == \ sorted(tasks, key=lambda x: x.name)
def test_time_log_creation_for_a_WFD_leaf_task(self): """testing if a StatusError will be raised when a TimeLog instance wanted to be created for a WFD leaf task """ from stalker import Task new_task = Task(name='Test Task 2', project=self.test_project) new_task.depends = [self.test_task1] kwargs = copy.copy(self.kwargs) kwargs['task'] = new_task from stalker.exceptions import StatusError with pytest.raises(StatusError) as cm: TimeLog(**kwargs) assert str(cm.value) == \ 'Test Task 2 is a WFD task, and it is not allowed to create ' \ 'TimeLogs for a WFD task, please supply a RTS, WIP, HREV or ' \ 'DREV task!'
def setUp(self): """setup the test """ # create a resource self.test_resource1 = User( name="User1", login="******", email="*****@*****.**", password="******", ) self.test_resource2 = User( name="User2", login="******", email="*****@*****.**", password="******" ) self.test_repo = Repository(name="test repository") # create a Project self.test_status1 = Status(name="Status1", code="STS1") self.test_status2 = Status(name="Status2", code="STS2") self.test_status3 = Status(name="Status3", code="STS3") self.test_project_status_list = StatusList( name="Project Statuses", statuses=[self.test_status1], target_entity_type=Project ) self.test_task_status_list = StatusList.query\ .filter_by(target_entity_type='Task').first() self.test_project = Project( name="test project", code='tp', repository=self.test_repo, status_list=self.test_project_status_list ) # create a Task self.test_task = Task( name="test task", project=self.test_project, status_list=self.test_task_status_list ) self.kwargs = { "task": self.test_task, "resource": self.test_resource1, "start": datetime.datetime(2013, 3, 22, 1, 0), "duration": datetime.timedelta(10) } # create a TimeLog # and test it self.test_time_log = TimeLog(**self.kwargs)
def setUp(self): """set up the test """ db.setup() db.init() 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 ) self.status_new = Status.query.filter_by(code='NEW').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_cmpl = Status.query.filter_by(code='CMPL').first() self.project_status_list = \ StatusList.query.filter_by(target_entity_type='Project').first() self.task_filename_template = FilenameTemplate( name='Task Filename Template', target_entity_type='Task', path='{{project.code}}/{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}{{extension}}' ) self.project_structure = Structure( name='Project Structure', templates=[self.task_filename_template] ) self.project = Project( name='Test Project', code='TP', status_list=self.project_status_list, repository=self.repo, structure=self.project_structure ) self.task = Task( name='Test Task', project=self.project ) from stalker.db.session import DBSession DBSession.add(self.task) DBSession.commit() self.version = Version( task=self.task ) self.kwargs = { 'name': 'Photoshop', 'extensions': ['psd'], 'structure': ['Outputs'] } self.external_env = ExternalEnv(**self.kwargs)
def test_TaskMixin_initialization(self): """testing if the TaskMixin part is initialized correctly """ status1 = Status(name="On Hold", code="OH") project_status_list = StatusList(name="Project Statuses", statuses=[status1], target_entity_type=Project) project_type = Type(name="Commercial", code='comm', target_entity_type=Project) new_project = Project( name="Commercial1", code='comm1', status_list=project_status_list, type=project_type, repository=self.test_repository, ) self.kwargs["code"] = "SH12314" new_shot = Shot(**self.kwargs) task1 = Task( name="Modeling", status=0, project=new_project, parent=new_shot, ) task2 = Task( name="Lighting", status=0, project=new_project, parent=new_shot, ) tasks = [task1, task2] self.assertEqual(sorted(new_shot.tasks, key=lambda x: x.name), sorted(tasks, key=lambda x: x.name))
def test_task_attribute_is_working_properly(self): """testing if the task attribute is working properly """ new_task = Task( name="Test task 2", project=self.test_project, status_list=self.test_task_status_list, resources=[self.test_resource1], ) self.assertNotEqual(self.test_time_log.task, new_task) self.test_time_log.task = new_task self.assertEqual(self.test_time_log.task, new_task)
def test_task_attribute_is_working_properly(self): """testing if the task attribute is working properly """ from stalker import Task new_task = Task( name="Test task 2", project=self.test_project, resources=[self.test_resource1], ) assert self.test_time_log.task != new_task self.test_time_log.task = new_task assert self.test_time_log.task == new_task
def test_initialization_of_task_part(self): """testing if the Task part is initialized correctly """ from stalker import Type, Project, Sequence, Task project_type = Type( name="Commercial", code='comm', target_entity_type='Project' ) new_project = Project( name="Commercial", code='comm', type=project_type, repository=self.test_repository, ) self.kwargs["project"] = new_project new_sequence = Sequence(**self.kwargs) task1 = Task( name="Modeling", status=0, project=new_project, parent=new_sequence, ) task2 = Task( name="Lighting", status=0, project=new_project, parent=new_sequence, ) tasks = [task1, task2] assert \ sorted(new_sequence.tasks, key=lambda x: x.name) == \ sorted(tasks, key=lambda x: x.name)
def test_task_attribute_updates_backref(self): """testing if the Task given with the task attribute is updated correctly with the current TimeLog instance is listed in the time_logs attribute of the Task """ new_task = Task( name="Test Task 3", project=self.test_project, status_list=self.test_task_status_list, resources=[self.test_resource1], ) self.test_time_log.task = new_task self.assertTrue(self.test_time_log in new_task.time_logs)
def test_time_log_creation_that_violates_dependency_condition_WIP_CMPL_onstart(self): """testing if a ValueError will be raised when the entered TimeLog will violate the dependency relation of the task +--------+ +-| Task 1 | | | CMPL | | +--------+ +--------+ +-------------------->| Task 2 | | WIP | +--------+ """ task = self.kwargs['task'] task.status = self.status_cmpl task.start = datetime.datetime(2014, 3, 16, 10, 0) task.end = datetime.datetime(2014, 3, 25, 19, 0) dep_task = Task( name="test task 2", project=self.test_project, status_list=self.test_task_status_list, schedule_timing=10, schedule_unit='d', depends=[task], resources=[self.test_resource2] ) # set the dependency target to onstart dep_task.task_depends_to[0].dependency_target = 'onstart' # entering a time log to the dates before 2014-03-16-10-0 should raise # a ValueError with self.assertRaises(DependencyViolationError) as cm: dep_task.create_time_log( self.test_resource2, datetime.datetime(2014, 3, 16, 9, 0), datetime.datetime(2014, 3, 16, 10, 0) ) self.assertEqual( '\'It is not possible to create a TimeLog before %s, which ' 'violates the dependency relation of "%s" to "%s"\'' % ( datetime.datetime(2014, 3, 16, 10, 0), dep_task.name, task.name ), str(cm.exception) ) # and creating a TimeLog after that is possible dep_task.create_time_log( self.test_resource2, datetime.datetime(2014, 3, 16, 10, 0), datetime.datetime(2014, 3, 16, 10, 0) )
def test_time_log_creation_that_violates_dependency_condition_WIP_CMPL_onend(self): """testing if a DependencyViolationError will be raised when the entered TimeLog will violate the dependency relation of the task +--------+ | Task 1 | ----+ | CMPL | | +--------+ | +--------+ +--->| Task 2 | | WIP | +--------+ """ kwargs = copy.copy(self.kwargs) task = kwargs['task'] task.status = self.status_cmpl task.start = datetime.datetime(2014, 3, 16, 10, 0, tzinfo=pytz.utc) task.end = datetime.datetime(2014, 3, 25, 19, 0, tzinfo=pytz.utc) from stalker import Task dep_task = Task( name="test task 2", project=self.test_project, schedule_timing=10, schedule_unit='d', depends=[task], resources=[self.test_resource2] ) # set the dependency target to onend dep_task.task_depends_to[0].dependency_target = 'onend' # entering a time log to the dates before 2014-03-25-19-0 should raise # a ValueError from stalker.exceptions import DependencyViolationError with pytest.raises(DependencyViolationError) as cm: dep_task.create_time_log( self.test_resource2, datetime.datetime(2014, 3, 25, 18, 0, tzinfo=pytz.utc), datetime.datetime(2014, 3, 25, 19, 0, tzinfo=pytz.utc) ) assert 'It is not possible to create a TimeLog before %s, which ' \ 'violates the dependency relation of "%s" to "%s"' % ( datetime.datetime(2014, 3, 25, 19, 0, tzinfo=pytz.utc), dep_task.name, task.name ) == str(cm.value) # and creating a TimeLog after that is possible dep_task.create_time_log( self.test_resource2, datetime.datetime(2014, 3, 25, 19, 0, tzinfo=pytz.utc), datetime.datetime(2014, 3, 25, 20, 0, tzinfo=pytz.utc) )
def test_task_argument_updates_backref(self): """testing if the Task given with the task argument is updated correctly with the current TimeLog instance is listed in the time_logs attribute of the Task """ new_task = Task( name="Test Task 3", project=self.test_project, status_list=self.test_task_status_list, resources=[self.test_resource1], ) # now create a new time_log for the new task self.kwargs["task"] = new_task self.kwargs["start"] = self.kwargs["start"] + \ self.kwargs["duration"] + \ datetime.timedelta(120) new_time_log = TimeLog(**self.kwargs) # now check if the new_time_log is in task.time_logs self.assertTrue(new_time_log in new_task.time_logs)
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()
wrong_shot.code = "SH004" # commit the changes to the database db.DBSession.commit() db.DBSession.delete(wrong_shot) db.DBSession.commit() wrong_shot = Shot.query.filter_by(code="SH005").first() print(wrong_shot) # should print None from stalker import Task previs = Task( name="Previs", parent=sh001 ) matchmove = Task( name="Matchmove", parent=sh001 ) anim = Task( name="Animation", parent=sh001 ) lighting = Task( name="Lighting", parent=sh001
def test_timeLog_creation_for_a_child_task(self): """testing TimeLog creation for a child task which has a couple of parent tasks """ dt = datetime.datetime td = datetime.timedelta parent_task1 = Task( name="Parent Task 1", project=self.test_project, status_list=self.test_task_status_list, ) parent_task2 = Task( name="Parent Task 2", project=self.test_project, status_list=self.test_task_status_list, ) child_task1 = Task( name="Child Task 1", project=self.test_project, status_list=self.test_task_status_list, resources=[self.test_resource1] ) child_task2 = Task( name="Child Task 1", project=self.test_project, status_list=self.test_task_status_list, resources=[self.test_resource2] ) # Task hierarchy # +-> p1 # | | # | +-> p2 # | | | # | | +-> c1 # | | # | +-> c2 # | # +-> self.test_task1 parent_task2.parent = parent_task1 child_task2.parent = parent_task1 child_task1.parent = parent_task2 from stalker.db.session import DBSession self.assertEqual(parent_task1.total_logged_seconds, 0) self.assertEqual(parent_task2.total_logged_seconds, 0) self.assertEqual(child_task1.total_logged_seconds, 0) self.assertEqual(child_task2.total_logged_seconds, 0) # now create a time log for child_task2 tlog1 = TimeLog( task=child_task2, resource=child_task2.resources[0], start=dt(2013, 7, 31, 10, 0), end=dt(2013, 7, 31, 19, 0) ) # before commit self.assertEqual(parent_task1.total_logged_seconds, 9 * 3600) self.assertEqual(parent_task2.total_logged_seconds, 0) self.assertEqual(child_task1.total_logged_seconds, 0) self.assertEqual(child_task2.total_logged_seconds, 9 * 3600) # commit changes DBSession.add(tlog1) DBSession.commit() # after commit it should not change self.assertEqual(parent_task1.total_logged_seconds, 9 * 3600) self.assertEqual(parent_task2.total_logged_seconds, 0) self.assertEqual(child_task1.total_logged_seconds, 0) self.assertEqual(child_task2.total_logged_seconds, 9 * 3600) # add a new tlog to child_task2 and commit it # now create a time log for child_task2 tlog2 = TimeLog( task=child_task2, resource=child_task2.resources[0], start=dt(2013, 7, 31, 19, 0), end=dt(2013, 7, 31, 22, 0) ) self.assertEqual(parent_task1.total_logged_seconds, 12 * 3600) self.assertEqual(parent_task2.total_logged_seconds, 0) self.assertEqual(child_task1.total_logged_seconds, 0) self.assertEqual(child_task2.total_logged_seconds, 12 * 3600) # commit changes DBSession.add(tlog2) DBSession.commit() self.assertEqual(parent_task1.total_logged_seconds, 12 * 3600) self.assertEqual(parent_task2.total_logged_seconds, 0) self.assertEqual(child_task1.total_logged_seconds, 0) self.assertEqual(child_task2.total_logged_seconds, 12 * 3600) # add a new time log to child_task1 and commit it tlog3 = TimeLog( task=child_task1, resource=child_task1.resources[0], start=dt(2013, 7, 31, 10, 0), end=dt(2013, 7, 31, 19, 0) ) self.assertEqual(parent_task1.total_logged_seconds, 21 * 3600) self.assertEqual(parent_task2.total_logged_seconds, 9 * 3600) self.assertEqual(child_task1.total_logged_seconds, 9 * 3600) self.assertEqual(child_task2.total_logged_seconds, 12 * 3600) # commit changes DBSession.add(tlog3) DBSession.commit() self.assertEqual(parent_task1.total_logged_seconds, 21 * 3600) self.assertEqual(parent_task2.total_logged_seconds, 9 * 3600) self.assertEqual(child_task1.total_logged_seconds, 9 * 3600) self.assertEqual(child_task2.total_logged_seconds, 12 * 3600)
def setUp(self): """set up the test """ # create an in memory database from stalker import db db.setup() db.init() 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() # create a resource self.test_resource1 = User( name="User1", login="******", email="*****@*****.**", password="******", ) self.test_resource2 = User( name="User2", login="******", email="*****@*****.**", password="******" ) self.test_repo = Repository(name="test repository") # create a Project self.test_status1 = Status(name="Status1", code="STS1") self.test_status2 = Status(name="Status2", code="STS2") self.test_status3 = Status(name="Status3", code="STS3") self.test_project_status_list = StatusList( name="Project Statuses", statuses=[self.test_status1], target_entity_type=Project ) self.test_task_status_list = StatusList.query\ .filter_by(target_entity_type='Task').first() self.test_project = Project( name="test project", code='tp', repository=self.test_repo, status_list=self.test_project_status_list ) # create a Task self.test_task = Task( name="test task", project=self.test_project, status_list=self.test_task_status_list, schedule_timing=10, schedule_unit='d', resources=[self.test_resource1] ) self.kwargs = { "name": "test time_log", "task": self.test_task, "resource": self.test_resource1, "start": datetime.datetime(2013, 3, 22, 1, 0), "duration": datetime.timedelta(10) }
def setUp(self): """setup the tests """ # ----------------------------------------------------------------- # start of the setUp # create the environment variable and point it to a temp directory db.setup() db.init() self.temp_repo_path = tempfile.mkdtemp() self.user1 = User(name='User 1', login='******', email='*****@*****.**', password='******') db.DBSession.add(self.user1) db.DBSession.commit() # login as self.user1 from stalker import LocalSession local_session = LocalSession() local_session.store_user(self.user1) local_session.save() self.repo1 = Repository(name='Test Project Repository', linux_path=self.temp_repo_path, windows_path=self.temp_repo_path, osx_path=self.temp_repo_path) self.status_new = Status.query.filter_by(code='NEW').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_comp = Status.query.filter_by(code='CMPL').first() self.task_template = FilenameTemplate( name='Task Template', target_entity_type='Task', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.asset_template = FilenameTemplate( name='Asset Template', target_entity_type='Asset', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.shot_template = FilenameTemplate( name='Shot Template', target_entity_type='Shot', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.sequence_template = FilenameTemplate( name='Sequence Template', target_entity_type='Sequence', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.structure = Structure(name='Project Struture', templates=[ self.task_template, self.asset_template, self.shot_template, self.sequence_template ]) self.project_status_list = StatusList( name='Project Statuses', target_entity_type='Project', statuses=[self.status_new, self.status_wip, self.status_comp]) self.image_format = ImageFormat(name='HD 1080', width=1920, height=1080, pixel_aspect=1.0) # create a test project self.project = Project(name='Test Project', code='TP', repository=self.repo1, status_list=self.project_status_list, structure=self.structure, image_format=self.image_format) self.task_status_list =\ StatusList.query.filter_by(target_entity_type='Task').first() self.asset_status_list =\ StatusList.query.filter_by(target_entity_type='Asset').first() self.shot_status_list =\ StatusList.query.filter_by(target_entity_type='Shot').first() self.sequence_status_list =\ StatusList.query.filter_by(target_entity_type='Sequence').first() self.character_type = Type(name='Character', code='CHAR', target_entity_type='Asset') # create a test series of root task self.task1 = Task(name='Test Task 1', project=self.project) self.task2 = Task(name='Test Task 2', project=self.project) self.task3 = Task(name='Test Task 3', project=self.project) # then a couple of child tasks self.task4 = Task(name='Test Task 4', parent=self.task1) self.task5 = Task(name='Test Task 5', parent=self.task1) self.task6 = Task(name='Test Task 6', parent=self.task1) # create a root asset self.asset1 = Asset(name='Asset 1', code='asset1', type=self.character_type, project=self.project) # create a child asset self.asset2 = Asset(name='Asset 2', code='asset2', type=self.character_type, parent=self.task4) # create a root Sequence self.sequence1 = Sequence(name='Sequence1', code='SEQ1', project=self.project) # create a child Sequence self.sequence2 = Sequence(name='Sequence2', code='SEQ2', parent=self.task2) # create a root Shot self.shot1 = Shot(name='SH001', code='SH001', project=self.project) # create a child Shot (child of a Sequence) self.shot2 = Shot(name='SH002', code='SH002', parent=self.sequence1) # create a child Shot (child of a child Sequence) self.shot3 = Shot(name='SH003', code='SH003', parent=self.sequence2) # commit everything db.DBSession.add_all([ self.repo1, self.status_new, self.status_wip, self.status_comp, self.project_status_list, self.project, self.task_status_list, self.asset_status_list, self.shot_status_list, self.sequence_status_list, self.task1, self.task2, self.task3, self.task4, self.task5, self.task6, self.asset1, self.asset2, self.shot1, self.shot2, self.shot3, self.sequence1, self.sequence2, self.task_template, self.asset_template, self.shot_template, self.sequence_template ]) db.DBSession.commit() # now create versions def create_version(task, take_name): """Creates a new version :param task: the task :param take_name: the take_name name :return: the version """ # just renew the scene #pymel.core.newFile(force=True) v = Version(task=task, take_name=take_name) v.update_paths() db.DBSession.add(v) db.DBSession.commit() #self.maya_env.save_as(v) return v # asset2 self.version1 = create_version(self.asset2, 'Main') self.version2 = create_version(self.asset2, 'Main') self.version3 = create_version(self.asset2, 'Main') self.version3.description = 'Test Description' self.version4 = create_version(self.asset2, 'Take1') self.version5 = create_version(self.asset2, 'Take1') self.version6 = create_version(self.asset2, 'Take1') # task5 self.version7 = create_version(self.task5, 'Main') self.version8 = create_version(self.task5, 'Main') self.version9 = create_version(self.task5, 'Main') self.version10 = create_version(self.task5, 'Take1') self.version11 = create_version(self.task5, 'Take1') self.version12 = create_version(self.task5, 'Take1') # task6 self.version13 = create_version(self.task6, 'Main') self.version14 = create_version(self.task6, 'Main') self.version15 = create_version(self.task6, 'Main') self.version16 = create_version(self.task6, 'Take1') self.version17 = create_version(self.task6, 'Take1') self.version18 = create_version(self.task6, 'Take1') # shot3 self.version19 = create_version(self.shot3, 'Main') self.version20 = create_version(self.shot3, 'Main') self.version21 = create_version(self.shot3, 'Main') self.version22 = create_version(self.shot3, 'Take1') self.version23 = create_version(self.shot3, 'Take1') self.version24 = create_version(self.shot3, 'Take1') # task3 self.version25 = create_version(self.task3, 'Main') self.version26 = create_version(self.task3, 'Main') self.version27 = create_version(self.task3, 'Main') self.version28 = create_version(self.task3, 'Take1') self.version29 = create_version(self.task3, 'Take1') self.version30 = create_version(self.task3, 'Take1') # asset1 self.version31 = create_version(self.asset1, 'Main') self.version32 = create_version(self.asset1, 'Main') self.version33 = create_version(self.asset1, 'Main') self.version34 = create_version(self.asset1, 'Take1') self.version35 = create_version(self.asset1, 'Take1') self.version36 = create_version(self.asset1, 'Take1') # shot2 self.version37 = create_version(self.shot2, 'Main') self.version38 = create_version(self.shot2, 'Main') self.version39 = create_version(self.shot2, 'Main') self.version40 = create_version(self.shot2, 'Take1') self.version41 = create_version(self.shot2, 'Take1') self.version42 = create_version(self.shot2, 'Take1') # shot1 self.version43 = create_version(self.shot1, 'Main') self.version44 = create_version(self.shot1, 'Main') self.version45 = create_version(self.shot1, 'Main') self.version46 = create_version(self.shot1, 'Take1') self.version47 = create_version(self.shot1, 'Take1') self.version48 = create_version(self.shot1, 'Take1') # +- task1 # | | # | +- task4 # | | | # | | +- asset2 # | | +- Main # | | | +- version1 # | | | +- version2 (P) # | | | +- version3 (P) # | | +- Take1 # | | +- version4 (P) # | | +- version5 # | | +- version6 (P) # | | # | +- task5 # | | +- Main # | | | +- version7 # | | | +- version8 # | | | +- version9 # | | +- Take1 # | | +- version10 # | | +- version11 # | | +- version12 (P) # | | # | +- task6 # | +- Main # | | +- version13 # | | +- version14 # | | +- version15 # | +- Take1 # | +- version16 (P) # | +- version17 # | +- version18 (P) # | # +- task2 # | | # | +- sequence2 # | | # | +- shot3 # | +- Main # | | +- version19 # | | +- version20 # | | +- version21 # | +- Take1 # | +- version22 # | +- version23 # | +- version24 # | # +- task3 # | +- Main # | | +- version25 # | | +- version26 # | | +- version27 # | +- Take1 # | +- version28 # | +- version29 # | +- version30 # | # +- asset1 # | +- Main # | | +- version31 # | | +- version32 # | | +- version33 # | +- Take1 # | +- version34 # | +- version35 # | +- version36 # | # +- sequence1 # | | # | +- shot2 # | +- Main # | | +- version37 # | | +- version38 # | | +- version39 # | +- Take1 # | +- version40 # | +- version41 # | +- version42 # | # +- shot1 # +- Main # | +- version43 # | +- version44 # | +- version45 # +- Take1 # +- version46 # +- version47 # +- version48 # Start Condition: # # version15 # version12 # version5 # version2 -> has new published version (version3) # version5 -> Referenced a second time # version2 -> has new published version (version3) # version12 -> Referenced a second time # version5 # version2 -> has new published version (version3) # version5 # version2 -> has new published version (version3) # version45 -> no change # version48 -> no change # # Expected Final Result # version15A -> Derived from version15 # version12A -> Derived from version12 # version5A -> Derived from version5 # version3 -> has new published version (version3) # version5A -> Derived from version5 # version3 -> has new published version (version3) # version12A -> Derived from version12 - The second reference # version5A -> Derived from version5 # version3 -> has new published version (version3) # version5A -> Derived from version5 # version3 -> has new published version (version3) # version45 -> no change # version48 -> no change # create a deep relation self.version2.is_published = True self.version3.is_published = True # new scene # version5 references version2 self.version5.inputs.append(self.version2) self.version5.is_published = True # version12 references version5 self.version12.inputs.append(self.version5) self.version12.is_published = True # version45 references version48 self.version45.is_published = True self.version48.is_published = True self.version45.inputs.append(self.version48) # version15 references version12 and version48 self.version15.inputs.append(self.version12) self.version15.inputs.append(self.version45) # reference_resolution self.reference_resolution = { 'root': [self.version12, self.version45], 'leave': [self.version48, self.version45], 'update': [self.version2], 'create': [self.version5, self.version12] } # create a buffer for extra created files, which are to be removed self.remove_these_files_buffer = [] self.test_environment = TestEnvironment(name='Test Environment') self.test_environment._version = self.version15 if not QtGui.QApplication.instance(): logger.debug('creating a new QApplication') self.app = QtGui.QApplication(sys.argv) else: logger.debug('using the present QApplication: %s' % QtGui.qApp) # self.app = QtGui.qApp self.app = QtGui.QApplication.instance() self.dialog = version_updater.MainDialog( environment=self.test_environment, reference_resolution=self.reference_resolution)
def setUp(self): super(DailyDBTestDBCase, self).setUp() from stalker import Status, StatusList 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_cmpl = Status.query.filter_by(code='CMPL').first() self.status_open = Status.query.filter_by(code='OPEN').first() self.status_cls = Status.query.filter_by(code='CLS').first() self.daily_status_list = \ StatusList.query.filter_by(target_entity_type='Daily').first() self.task_status_list = \ StatusList.query.filter_by(target_entity_type='Task').first() from stalker import Repository, Project self.test_repo = Repository(name='Test Repository', code='TR') from stalker.db.session import DBSession DBSession.add(self.test_repo) self.test_project = Project( name='Test Project', code='TP', repository=self.test_repo, ) DBSession.add(self.test_project) from stalker import Task self.test_task1 = Task(name='Test Task 1', project=self.test_project, status_list=self.task_status_list) DBSession.add(self.test_task1) self.test_task2 = Task(name='Test Task 2', project=self.test_project, status_list=self.task_status_list) DBSession.add(self.test_task2) self.test_task3 = Task(name='Test Task 3', project=self.test_project, status_list=self.task_status_list) DBSession.add(self.test_task3) DBSession.commit() from stalker import Version self.test_version1 = Version(task=self.test_task1) DBSession.add(self.test_version1) DBSession.commit() self.test_version2 = Version(task=self.test_task1) DBSession.add(self.test_version2) DBSession.commit() self.test_version3 = Version(task=self.test_task1) DBSession.add(self.test_version3) DBSession.commit() self.test_version4 = Version(task=self.test_task2) DBSession.add(self.test_version4) DBSession.commit() from stalker import Link self.test_link1 = Link(original_filename='test_render1.jpg') self.test_link2 = Link(original_filename='test_render2.jpg') self.test_link3 = Link(original_filename='test_render3.jpg') self.test_link4 = Link(original_filename='test_render4.jpg') DBSession.add_all([ self.test_link1, self.test_link2, self.test_link3, self.test_link4 ]) self.test_version1.outputs = [ self.test_link1, self.test_link2, self.test_link3 ] self.test_version4.outputs = [self.test_link4] DBSession.commit()
def setUp(self): super(DailyTestBase, self).setUp() from stalker import Status, StatusList self.status_new = Status(name='Mew', code='NEW') self.status_wfd = Status(name='Waiting For Dependency', code='WFD') self.status_rts = Status(name='Ready To Start', code='RTS') self.status_wip = Status(name='Work In Progress', code='WIP') self.status_prev = Status(name='Pending Review', code='PREV') self.status_hrev = Status(name='Has Revision', code='HREV') self.status_drev = Status(name='Dependency Has Revision', code='DREV') self.status_cmpl = Status(name='Completed', code='CMPL') self.status_open = Status(name='Open', code='OPEN') self.status_cls = Status(name='Closed', code='CLS') self.daily_status_list = StatusList( name='Daily Statuses', statuses=[self.status_open, self.status_cls], target_entity_type='Daily') self.task_status_list = StatusList( name='Task Statuses', statuses=[ self.status_wfd, self.status_rts, self.status_wip, self.status_prev, self.status_hrev, self.status_drev, self.status_cmpl ], target_entity_type='Task') self.test_project_status_list = StatusList( name='Project Statuses', target_entity_type='Project', statuses=[self.status_new, self.status_wip, self.status_cmpl]) from stalker import Repository, Project self.test_repo = Repository(name='Test Repository', code='TR') self.test_project = Project(name='Test Project', code='TP', repository=self.test_repo, status_list=self.test_project_status_list) from stalker import Task self.test_task1 = Task(name='Test Task 1', project=self.test_project, status_list=self.task_status_list) self.test_task2 = Task(name='Test Task 2', project=self.test_project, status_list=self.task_status_list) self.test_task3 = Task(name='Test Task 3', project=self.test_project, status_list=self.task_status_list) from stalker import Version self.test_version1 = Version(task=self.test_task1) self.test_version2 = Version(task=self.test_task1) self.test_version3 = Version(task=self.test_task1) self.test_version4 = Version(task=self.test_task2) from stalker import Link self.test_link1 = Link(original_filename='test_render1.jpg') self.test_link2 = Link(original_filename='test_render2.jpg') self.test_link3 = Link(original_filename='test_render3.jpg') self.test_link4 = Link(original_filename='test_render4.jpg') self.test_version1.outputs = [ self.test_link1, self.test_link2, self.test_link3 ] self.test_version4.outputs = [self.test_link4]
def setUp(self): """setup the test """ super(AssetTester, self).setUp() # users from stalker import User from stalker.db.session import DBSession self.test_user1 = User( name='User1', login='******', password='******', email='*****@*****.**' ) DBSession.add(self.test_user1) self.test_user2 = User( name='User2', login='******', password='******', email='*****@*****.**' ) DBSession.add(self.test_user2) DBSession.commit() # statuses from stalker import Status, Project self.status_wip = Status.query.filter_by(code='WIP').first() self.status_cmpl = Status.query.filter_by(code='CMPL').first() # types from stalker import Type self.commercial_project_type = Type( name="Commercial Project", code='commproj', target_entity_type='Project', ) DBSession.add(self.commercial_project_type) self.asset_type1 = Type( name="Character", code='char', target_entity_type='Asset' ) DBSession.add(self.asset_type1) self.asset_type2 = Type( name="Environment", code='env', target_entity_type='Asset' ) DBSession.add(self.asset_type2) self.repository_type = Type( name="Test Repository Type", code='testrepo', target_entity_type='Repository', ) DBSession.add(self.repository_type) # repository from stalker import Repository self.repository = Repository( name="Test Repository", type=self.repository_type, ) DBSession.add(self.repository) # project self.project1 = Project( name="Test Project1", code='tp1', type=self.commercial_project_type, repositories=[self.repository], ) DBSession.add(self.project1) DBSession.commit() # sequence from stalker import Sequence self.seq1 = Sequence( name="Test Sequence", code='tseq', project=self.project1, responsible=[self.test_user1] ) DBSession.add(self.seq1) # shots from stalker import Shot self.shot1 = Shot( code="TestSH001", project=self.project1, sequences=[self.seq1], responsible=[self.test_user1] ) DBSession.add(self.shot1) self.shot2 = Shot( code="TestSH002", project=self.project1, sequences=[self.seq1], responsible=[self.test_user1] ) DBSession.add(self.shot2) self.shot3 = Shot( code="TestSH003", project=self.project1, sequences=[self.seq1], responsible=[self.test_user1] ) DBSession.add(self.shot3) self.shot4 = Shot( code="TestSH004", project=self.project1, sequences=[self.seq1], responsible=[self.test_user1] ) DBSession.add(self.shot4) self.kwargs = { "name": "Test Asset", 'code': 'ta', "description": "This is a test Asset object", "project": self.project1, "type": self.asset_type1, "status": 0, 'responsible': [self.test_user1] } from stalker import Asset, Task self.asset1 = Asset(**self.kwargs) DBSession.add(self.asset1) # tasks self.task1 = Task( name="Task1", parent=self.asset1, ) DBSession.add(self.task1) self.task2 = Task( name="Task2", parent=self.asset1, ) DBSession.add(self.task2) self.task3 = Task( name="Task3", parent=self.asset1, ) DBSession.add(self.task3) DBSession.commit()
class ReviewTestCase(unittest2.TestCase): """tests the stalker.models.review.Review class """ 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 tearDown(self): """clean up test """ DBSession.remove() def test_task_argument_is_skipped(self): """testing if a TypeError will be raised when the task argument is skipped """ self.kwargs.pop('task') self.assertRaises(TypeError, Review, **self.kwargs) def test_task_argument_is_None(self): """testing if a TypeError will be raised when the task argument is None """ self.kwargs['task'] = None self.assertRaises(TypeError, Review, **self.kwargs) def test_task_argument_is_not_a_Task_instance(self): """testing if a TypeError will be raised when the task argument value is not a Task instance """ self.kwargs['task'] = 'not a Task instance' self.assertRaises(TypeError, Review, **self.kwargs) # def test_task_attribute_is_read_only(self): # """testing if a the task attribute is read only # """ # now = datetime.datetime.now() # self.task1.create_time_log( # resource=self.task1.resources[0], # start=now, # end=now + datetime.timedelta(hours=1) # ) # reviews = self.task1.request_review() # review = reviews[0] # self.assertRaises(AttributeError, setattr, review, 'task', self.task1) def test_task_argument_is_not_a_leaf_task(self): """testing if a ValueError will be raised when the task given in task argument is not a leaf task """ task1 = Task( name='Task1', project=self.project ) task2 = Task( name='Task2', parent=task1 ) self.kwargs['task'] = task1 self.assertRaises(ValueError, Review, **self.kwargs) def test_task_argument_is_working_properly(self): """testing if the task argument value is passed to the task argument properly """ now = datetime.datetime.now() self.task1.create_time_log( resource=self.task1.resources[0], start=now, end=now + datetime.timedelta(hours=1) ) reviews = self.task1.request_review() self.assertEqual(reviews[0].task, self.task1) def test_auto_name_is_true(self): """testing if review instances are named automatically """ self.assertTrue(Review.__auto_name__) def test_status_is_new_for_a_newly_created_review_instance(self): """testing if the status is NEW for a newly created review instance """ review = Review(**self.kwargs) self.assertEqual(review.status, self.status_new) def test_review_number_attribute_is_a_read_only_attribute(self): """testing if the review_number attribute is a read only attribute """ review = Review(**self.kwargs) self.assertRaises( AttributeError, setattr, review, 'review_number', 2 ) def test_review_number_attribute_is_initialized_to_the_task_review_number_plus_1(self): """testing if the review_number attribute is initialized with task.review_number + 1 """ review = Review(**self.kwargs) self.assertEqual(1, review.review_number) def test_review_number_for_multiple_responsible_task_is_equal_to_each_other(self): """testing if the review.review_number attribute for each review instance created for a task with multiple responsible are equal to each other """ self.task1.responsible = [self.user1, self.user2, self.user3] now = datetime.datetime.now() self.task1.create_time_log( resource=self.task1.resources[0], start=now, end=now + datetime.timedelta(hours=1) ) reviews = self.task1.request_review() expected_review_number = self.task1.review_number + 1 self.assertEqual(3, len(reviews)) self.assertEqual( expected_review_number, reviews[0].review_number ) self.assertEqual( expected_review_number, reviews[1].review_number ) self.assertEqual( expected_review_number, reviews[2].review_number ) def test_reviewer_argument_is_skipped(self): """testing if a TypeError will be raised when the reviewer argument is skipped """ self.kwargs.pop('reviewer') self.assertRaises(TypeError, Review, **self.kwargs) def test_reviewer_argument_is_None(self): """testing if a TypeError will be raised when the reviewer argument is None """ self.kwargs['reviewer'] = None self.assertRaises(TypeError, Review, **self.kwargs) def test_reviewer_attribute_is_set_to_None(self): """testing if a TypeError will be raised when the reviewer attribute is set to None """ review = Review(**self.kwargs) self.assertRaises(TypeError, setattr, review, 'reviewer', None) def test_reviewer_argument_is_not_a_User_instance(self): """testing if a TeypeError will be raised when the reviewer argument is not a User instance """ self.kwargs['reviewer'] = 'not a user instance' self.assertRaises(TypeError, Review, **self.kwargs) def test_reviewer_attribute_is_not_a_User_instance(self): """testing if a TypeError will be raised when the reviewer attribute is set to a value other than a User instance """ review = Review(**self.kwargs) self.assertRaises(TypeError, setattr, review, 'reviewer', 'not a user') def test_reviewer_argument_is_not_in_Task_responsible_list(self): """testing if it is possible to use some other user which is not in the Task.responsible list as the reviewer """ self.task1.responsible = [self.user1] self.kwargs['reviewer'] = self.user2 review = Review(**self.kwargs) self.assertEqual(review.reviewer, self.user2) def test_reviewer_attribute_is_not_in_Task_responsible_list(self): """testing if it is possible to use some other user which is not in the Task.responsible list as the reviewer """ self.task1.responsible = [self.user1] self.kwargs['reviewer'] = self.user1 review = Review(**self.kwargs) review.reviewer = self.user2 self.assertEqual(review.reviewer, self.user2) def test_reviewer_argument_is_working_properly(self): """testing if the reviewer argument value is correctly passed to reviewer attribute """ self.task1.responsible = [self.user1] self.kwargs['reviewer'] = self.user1 review = Review(**self.kwargs) self.assertEqual( self.user1, review.reviewer ) def test_reviewer_attribute_is_working_properly(self): """testing if the reviewer attribute is working properly """ self.task1.responsible = [self.user1, self.user2] self.kwargs['reviewer'] = self.user1 review = Review(**self.kwargs) review.reviewer = self.user2 self.assertEqual( self.user2, review.reviewer ) # TODO: add tests for the same user is being the reviewer for all reviews # at the same level with same task def test_approve_method_updates_task_status_correctly_for_a_single_responsible_task(self): """testing if the Review.approve() method will update the task status correctly for a task with only one responsible """ self.task1.responsible = [self.user1] self.kwargs['reviewer'] = self.user1 self.assertNotEqual( self.status_cmpl, self.task1.status ) review = Review(**self.kwargs) review.approve() self.assertEqual( self.status_cmpl, self.task1.status ) def test_approve_method_updates_task_status_correctly_for_a_multi_responsible_task_when_all_approve(self): """testing if the Review.approve() method will update the task status correctly for a task with multiple responsible """ self.task1.responsible = [self.user1, self.user2] now = datetime.datetime.now() self.task1.create_time_log( resource=self.user1, start=now, end=now + datetime.timedelta(hours=1) ) reviews = self.task1.request_review() review1 = reviews[0] review2 = reviews[1] review1.approve() # still pending review self.assertEqual( self.status_prev, self.task1.status ) # first reviewer review2.approve() self.assertEqual( self.status_cmpl, self.task1.status ) def test_approve_method_updates_task_parent_status(self): """testing if approve method will also update the task parent status """ self.task3.status = self.status_rts now = datetime.datetime.now() td = datetime.timedelta self.task3.create_time_log( resource=self.task3.resources[0], start=now, end=now + td(hours=1) ) reviews = self.task3.request_review() self.assertEqual( self.task3.status, self.status_prev ) review1 = reviews[0] review1.approve() self.assertEqual( self.task3.status, self.status_cmpl ) self.assertEqual( self.task2.status, self.status_cmpl ) def test_approve_method_updates_task_status_correctly_for_a_multi_responsible_task_when_one_approve(self): """testing if the Review.approve() method will update the task status correctly for a task with multiple responsible """ self.task1.responsible = [self.user1, self.user2] now = datetime.datetime.now() td = datetime.timedelta self.task1.create_time_log( resource=self.task1.resources[0], start=now, end=now + td(hours=1) ) reviews = self.task1.request_review() review1 = reviews[0] review2 = reviews[1] review1.request_revision() # one requst review should be enough to set the status to hrev, # note that this is another tests duty to check self.assertEqual( self.status_prev, self.task1.status ) # first reviewer review2.approve() self.assertEqual( self.status_hrev, self.task1.status ) def test_request_revision_method_updates_task_status_correctly_for_a_single_responsible_task(self): """testing if the Review.request_revision() method will update the task status correctly to HREV for a Task with only one responsible """ self.task1.responsible = [self.user1] now = datetime.datetime.now() self.task1.create_time_log( resource=self.task1.resources[0], start=now, end=now + datetime.timedelta(hours=1) ) reviews = self.task1.request_review() review = reviews[0] review.request_revision() self.assertEqual( self.status_hrev, self.task1.status ) def test_request_revision_method_updates_task_status_correctly_for_a_multi_responsible_task_when_one_request_revision(self): """testing if the Review.request_revision() method will update the task status correctly for a Task with multiple responsible """ self.task1.responsible = [self.user1, self.user2] now = datetime.datetime.now() self.task1.create_time_log( resource=self.task1.resources[0], start=now, end=now + datetime.timedelta(hours=1) ) # first reviewer requests a revision reviews = self.task1.request_review() review1 = reviews[0] review2 = reviews[1] review1.approve() self.assertEqual( self.status_prev, self.task1.status ) review2.request_revision() self.assertEqual( self.status_hrev, self.task1.status ) def test_request_revision_method_updates_task_status_correctly_for_a_multi_responsible_task_when_all_request_revision(self): """testing if the Review.request_revision() method will update the task status correctly for a Task with multiple responsible """ self.task1.responsible = [self.user1, self.user2] now = datetime.datetime.now() self.task1.create_time_log( resource=self.task1.resources[0], start=now, end=now + datetime.timedelta(hours=1) ) # first reviewer requests a revision reviews = self.task1.request_review() review1 = reviews[0] review2 = reviews[1] review1.request_revision() self.assertEqual( self.status_prev, self.task1.status ) # first reviewer review2.request_revision() self.assertEqual( self.status_hrev, self.task1.status ) def test_request_revision_method_updates_task_timing_correctly_for_a_multi_responsible_task_when_all_request_revision(self): """testing if the Review.request_revision() method will update the task timing values correctly for a Task with multiple responsible """ self.task1.responsible = [self.user1, self.user2] self.assertEqual( self.status_rts, self.task1.status ) dt = datetime.datetime td = datetime.timedelta now = dt.now() # create 1 hour time log self.task1.create_time_log( resource=self.user1, start=now, end=now + td(hours=1) ) # first reviewer requests a revision reviews = self.task1.request_review() self.assertEqual(len(reviews), 2) review1 = reviews[0] review2 = reviews[1] review1.request_revision( schedule_timing=2, schedule_unit='h', description='do some 2 hours extra work' ) self.assertEqual( self.status_prev, self.task1.status ) # first reviewer review2.request_revision( schedule_timing=5, schedule_unit='h', description='do some 5 hours extra work' ) self.assertEqual( self.status_hrev, self.task1.status ) # check the timing values self.assertEqual(self.task1.schedule_timing, 8) self.assertEqual(self.task1.schedule_unit, 'h') def test_review_set_property_return_all_the_revision_instances_with_same_review_number(self): """testing if review_set property returns all the Review instances of the same task with the same review_number """ self.task1.responsible = [self.user1, self.user2, self.user3] now = datetime.datetime.now() self.task1.create_time_log( resource=self.user1, start=now, end=now + datetime.timedelta(hours=1) ) self.task1.status = self.status_wip reviews = self.task1.request_review() review1 = reviews[0] review2 = reviews[1] review3 = reviews[2] self.assertEqual(review1.review_number, 1) self.assertEqual(review2.review_number, 1) self.assertEqual(review3.review_number, 1) self.task1.approve() review4 = self.task1.request_revision(reviewer=self.user1) self.task1.status = self.status_wip self.assertEqual(review4.review_number, 2) # enter new time log to turn it into WIP self.task1.create_time_log( resource=self.user1, start=now + datetime.timedelta(hours=1), end=now + datetime.timedelta(hours=2) ) review_set2 = self.task1.request_review() review5 = review_set2[0] review6 = review_set2[1] review7 = review_set2[2] self.assertEqual(review5.review_number, 3) self.assertEqual(review6.review_number, 3) self.assertEqual(review7.review_number, 3)
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()
login="******", email="*****@*****.**", password="******") test_user5 = User(name="User5", login="******", email="*****@*****.**", password="******") test_project1 = Project(name="Test Project1", code='tp1', type=test_movie_project_type, repositories=[test_repository]) test_dependent_task1 = Task(name="Dependent Task1", project=test_project1, status_list=task_status_list, responsible=[test_user1]) test_dependent_task2 = Task(name="Dependent Task2", project=test_project1, status_list=task_status_list, responsible=[test_user1]) kwargs = { 'name': 'Modeling', 'description': 'A Modeling Task', 'project': test_project1, 'priority': 500, 'responsible': [test_user1], 'resources': [test_user1, test_user2], 'alternative_resources': [test_user3, test_user4, test_user5],