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