def test_committing_data(self):
"""testing committing and retrieving data back
"""
kwargs = copy.copy(self.kwargs)
d1 = DAGMixinFooMixedInClass(**kwargs)
d2 = DAGMixinFooMixedInClass(**kwargs)
d3 = DAGMixinFooMixedInClass(**kwargs)
d4 = DAGMixinFooMixedInClass(**kwargs)
d1.children = [d2, d3]
d2.children = [d4]
from stalker.db.session import DBSession
DBSession.add_all([d1, d2, d3, d4])
DBSession.commit()
del d1, d2, d3, d4
all_data = DAGMixinFooMixedInClass.query.all()
assert len(all_data) == 4
assert isinstance(all_data[0], DAGMixinFooMixedInClass)
assert isinstance(all_data[1], DAGMixinFooMixedInClass)
assert isinstance(all_data[2], DAGMixinFooMixedInClass)
assert isinstance(all_data[3], DAGMixinFooMixedInClass)
def create_statuses_and_status_lists():
"""Creates the statuses needed for Project, Task, Asset, Shot and Sequence
entities
"""
# Also create basic Status and status lists for
# Project, Asset, Shot, Sequence
# Project
project_status_list = StatusList.query\
.filter_by(target_entity_type='Project').first()
if not project_status_list:
project_status_list = StatusList(name='Project Statuses',
target_entity_type='Project')
new = Status.query.filter_by(code='NEW').first()
wip = Status.query.filter_by(code='WIP').first()
cmpl = Status.query.filter_by(code='CMPL').first()
# now use them in status lists
project_status_list.statuses = [new, wip, cmpl]
# Warning! Not using scoped_session here, it is the plain old session
DBSession.add_all([
project_status_list,
])
DBSession.commit()
def setUpClass(cls):
"""setup once
"""
# create a test database
db.setup()
db.init()
# create test repositories
cls.repo1 = Repository(
name='Test Repo 1',
linux_path='/test/repo/1/linux/path',
windows_path='T:/test/repo/1/windows/path',
osx_path='/test/repo/1/osx/path',
)
cls.repo2 = Repository(
name='Test Repo 2',
linux_path='/test/repo/2/linux/path',
windows_path='T:/test/repo/2/windows/path',
osx_path='/test/repo/2/osx/path',
)
cls.repo3 = Repository(
name='Test Repo 3',
linux_path='/test/repo/3/linux/path',
windows_path='T:/test/repo/3/windows/path',
osx_path='/test/repo/3/osx/path',
)
cls.repo4 = Repository(
name='Test Repo 4',
linux_path='/test/repo/4/linux/path',
windows_path='T:/test/repo/4/windows/path',
osx_path='/test/repo/4/osx/path',
)
cls.repo5 = Repository(
name='Test Repo 5',
linux_path='/test/repo/5/linux/path',
windows_path='T:/test/repo/5/windows/path',
osx_path='/test/repo/5/osx/path',
)
cls.all_repos = [cls.repo1, cls.repo2, cls.repo3, cls.repo4, cls.repo5]
DBSession.add_all(cls.all_repos)
DBSession.commit()
def test_nice_name_attribute_is_working_properly(self):
"""testing if the nice_name attribute is working properly
"""
# for self.test_version
self.assertEqual(self.test_version.naming_parents, [self.test_shot1, self.test_task1])
# for a new version of a task
task1 = Task(name="Test Task 1", project=self.test_project, status_list=self.test_task_status_list)
task2 = Task(name="Test Task 2", parent=task1, status_list=self.test_task_status_list)
task3 = Task(name="Test Task 3", parent=task2, status_list=self.test_task_status_list)
DBSession.add_all([task1, task2, task3])
DBSession.commit()
version1 = Version(task=task3, take_name="Take1")
DBSession.add(version1)
DBSession.commit()
self.assertEqual(
version1.nice_name, "%s_%s_%s_%s" % (task1.nice_name, task2.nice_name, task3.nice_name, version1.take_name)
)
# for a an asset version
asset_statuses = StatusList(
target_entity_type="Asset", statuses=[self.test_status1, self.test_status2, self.test_status3]
)
character_type = Type(target_entity_type="Asset", name="Character", code="Char")
asset1 = Asset(name="Asset1", code="Asset1", parent=task1, status_list=asset_statuses, type=character_type)
version2 = Version(task=asset1)
self.assertEqual(version2.nice_name, "%s_%s" % (asset1.nice_name, version2.take_name))
# for a version of a task of a shot
shot2 = Shot(name="SH002", code="SH002", parent=task3, status_list=self.test_shot_status_list)
task4 = Task(name="Test Task 4", parent=shot2, status_list=self.test_task_status_list)
version3 = Version(task=task4)
self.assertEqual(version3.nice_name, "%s_%s_%s" % (shot2.nice_name, task4.nice_name, version3.take_name))
# for an asset of a shot
asset2 = Asset(name="Asset2", code="Asset2", parent=shot2, status_list=asset_statuses, type=character_type)
version4 = Version(task=asset2)
self.assertEqual(version4.nice_name, "%s_%s" % (asset2.nice_name, version4.take_name))
def test_deleting_data(self):
"""testing deleting data
"""
d1 = DAGMixinFooMixedInClass(**self.kwargs)
d2 = DAGMixinFooMixedInClass(**self.kwargs)
d3 = DAGMixinFooMixedInClass(**self.kwargs)
d4 = DAGMixinFooMixedInClass(**self.kwargs)
d1.children = [d2, d3]
d2.children = [d4]
from stalker.db.session import DBSession
DBSession.add_all([d1, d2, d3, d4])
DBSession.commit()
DBSession.delete(d1)
DBSession.commit()
all_data = DAGMixinFooMixedInClass.query.all()
assert len(all_data) == 0
def setUp(self):
"""setup the test
"""
# setup a test database
self.TEST_DATABASE_URI = "sqlite:///:memory:"
db.setup()
db.init()
# need to have some test object for
# a department
self.test_department1 = Department(name="Test Department 1")
self.test_department2 = Department(name="Test Department 2")
self.test_department3 = Department(name="Test Department 3")
DBSession.add_all([self.test_department1, self.test_department2, self.test_department3])
# a couple of groups
self.test_group1 = Group(name="Test Group 1")
self.test_group2 = Group(name="Test Group 2")
self.test_group3 = Group(name="Test Group 3")
DBSession.add_all([self.test_group1, self.test_group2, self.test_group3])
# a couple of statuses
self.test_status1 = Status(name="Completed", code="CMPLT")
self.test_status2 = Status(name="Work In Progress", code="WIP")
self.test_status3 = Status(name="Waiting To Start", code="WTS")
self.test_status4 = Status(name="Pending Review", code="PRev")
DBSession.add_all([self.test_status1, self.test_status2, self.test_status3, self.test_status4])
# a project status list
self.project_status_list = StatusList(
name="Project Status List",
statuses=[self.test_status1, self.test_status2, self.test_status3, self.test_status4],
target_entity_type=Project,
)
# a repository type
self.test_repository_type = Type(name="Test", code="test", target_entity_type=Repository)
# a repository
self.test_repository = Repository(name="Test Repository", type=self.test_repository_type)
# a project type
self.commercial_project_type = Type(name="Commercial Project", code="comm", target_entity_type=Project)
# a couple of projects
self.test_project1 = Project(
name="Test Project 1",
code="tp1",
status_list=self.project_status_list,
type=self.commercial_project_type,
repository=self.test_repository,
)
self.test_project2 = Project(
name="Test Project 2",
code="tp2",
status_list=self.project_status_list,
type=self.commercial_project_type,
repository=self.test_repository,
)
self.test_project3 = Project(
name="Test Project 3",
code="tp3",
status_list=self.project_status_list,
type=self.commercial_project_type,
repository=self.test_repository,
)
DBSession.add_all([self.test_project1, self.test_project2, self.test_project3])
# a task status list
self.task_status_list = StatusList.query.filter_by(target_entity_type="Task").first()
# a couple of tasks
self.test_task1 = Task(name="Test Task 1", status_list=self.task_status_list, project=self.test_project1)
self.test_task2 = Task(name="Test Task 2", status_list=self.task_status_list, project=self.test_project1)
self.test_task3 = Task(name="Test Task 3", status_list=self.task_status_list, project=self.test_project2)
self.test_task4 = Task(name="Test Task 4", status_list=self.task_status_list, project=self.test_project3)
DBSession.add_all([self.test_task1, self.test_task2, self.test_task3, self.test_task4])
# for task1
self.test_version1 = Version(task=self.test_task1, full_path="some/path")
DBSession.add(self.test_version1)
self.test_version2 = Version(task=self.test_task1, full_path="some/path")
DBSession.add(self.test_version2)
self.test_version3 = Version(task=self.test_task1, full_path="some/path")
DBSession.add(self.test_version3)
# for task2
self.test_version4 = Version(task=self.test_task2, full_path="some/path")
DBSession.add(self.test_version4)
self.test_version5 = Version(task=self.test_task2, full_path="some/path")
DBSession.add(self.test_version5)
self.test_version6 = Version(task=self.test_task2, full_path="some/path")
DBSession.add(self.test_version6)
# for task3
self.test_version7 = Version(task=self.test_task3, full_path="some/path")
DBSession.add(self.test_version7)
self.test_version8 = Version(task=self.test_task3, full_path="some/path")
DBSession.add(self.test_version8)
self.test_version9 = Version(task=self.test_task3, full_path="some/path")
DBSession.add(self.test_version9)
# for task4
self.test_version10 = Version(task=self.test_task4, full_path="some/path")
DBSession.add(self.test_version10)
self.test_version11 = Version(task=self.test_task4, full_path="some/path")
DBSession.add(self.test_version11)
self.test_version12 = Version(task=self.test_task4, full_path="some/path")
DBSession.add(self.test_version12)
# *********************************************************************
# Tickets
# *********************************************************************
# no need to create status list for tickets cause we have a database
# set up an running so it will be automatically linked
# tickets for version1
self.test_ticket1 = Ticket(project=self.test_project1, links=[self.test_version1])
DBSession.add(self.test_ticket1)
# set it to closed
self.test_ticket1.resolve()
# create a new ticket and leave it open
self.test_ticket2 = Ticket(project=self.test_project1, links=[self.test_version1])
DBSession.add(self.test_ticket2)
# create a new ticket and close and then reopen it
self.test_ticket3 = Ticket(project=self.test_project1, links=[self.test_version1])
DBSession.add(self.test_ticket3)
self.test_ticket3.resolve()
self.test_ticket3.reopen()
# *********************************************************************
# tickets for version2
# create a new ticket and leave it open
self.test_ticket4 = Ticket(project=self.test_project1, links=[self.test_version2])
DBSession.add(self.test_ticket4)
# create a new Ticket and close it
self.test_ticket5 = Ticket(project=self.test_project1, links=[self.test_version2])
DBSession.add(self.test_ticket5)
self.test_ticket5.resolve()
# create a new Ticket and close it
self.test_ticket6 = Ticket(project=self.test_project1, links=[self.test_version3])
DBSession.add(self.test_ticket6)
self.test_ticket6.resolve()
# *********************************************************************
# tickets for version3
# create a new ticket and close it
self.test_ticket7 = Ticket(project=self.test_project1, links=[self.test_version3])
DBSession.add(self.test_ticket7)
self.test_ticket7.resolve()
# create a new ticket and close it
self.test_ticket8 = Ticket(project=self.test_project1, links=[self.test_version3])
DBSession.add(self.test_ticket8)
self.test_ticket8.resolve()
# *********************************************************************
# tickets for version4
# create a new ticket and close it
self.test_ticket9 = Ticket(project=self.test_project1, links=[self.test_version4])
DBSession.add(self.test_ticket9)
self.test_ticket9.resolve()
# no tickets for any other version
# *********************************************************************
# a status list for sequence
self.sequence_status_list = StatusList.query.filter_by(target_entity_type="Sequence").first()
# a couple of sequences
self.test_sequence1 = Sequence(
name="Test Seq 1", code="ts1", project=self.test_project1, status_list=self.sequence_status_list
)
self.test_sequence2 = Sequence(
name="Test Seq 2", code="ts2", project=self.test_project1, status_list=self.sequence_status_list
)
self.test_sequence3 = Sequence(
name="Test Seq 3", code="ts3", project=self.test_project1, status_list=self.sequence_status_list
)
self.test_sequence4 = Sequence(
name="Test Seq 4", code="ts4", project=self.test_project1, status_list=self.sequence_status_list
)
DBSession.add_all([self.test_sequence1, self.test_sequence2, self.test_sequence3, self.test_sequence4])
# a test admin
# self.test_admin = User(
# name='Admin',
# login='******',
# email='*****@*****.**',
# password='******'
# )
self.test_admin = User.query.filter_by(name=defaults.admin_name).first()
self.assertIsNotNone(self.test_admin)
# create the default values for parameters
self.kwargs = {
"name": "Erkan Ozgur Yilmaz",
"login": "******",
"description": "this is a test user",
"password": "******",
"email": "*****@*****.**",
"departments": [self.test_department1],
"groups": [self.test_group1, self.test_group2],
"created_by": self.test_admin,
"updated_by": self.test_admin,
}
# create a proper user object
self.test_user = User(**self.kwargs)
DBSession.add(self.test_user)
DBSession.commit()
# just change the kwargs for other tests
self.kwargs["name"] = "some other name"
self.kwargs["email"] = "*****@*****.**"
def accept(self):
"""overridden accept method
"""
# get the info
task = self.tasks_combo_box.currentTask()
resource = self.get_current_resource()
# war the user if the resource is not the logged_in_user
if resource != self.logged_in_user:
msg_box = QtWidgets.QMessageBox(self)
msg_box.setWindowTitle(
'Entering TimeLog On Behalf of Somebody Else'
)
msg_box.setText(
"You're entering a TimeLog on behalf of somebody else???"
)
accept_button = msg_box.addButton(
'Accept the responsibility',
QtWidgets.QMessageBox.AcceptRole
)
cancel_button = msg_box.addButton(
'Cancel',
QtWidgets.QMessageBox.RejectRole
)
msg_box.setDefaultButton(cancel_button)
msg_box.exec_()
clicked_button = msg_box.clickedButton()
msg_box.deleteLater()
if clicked_button == cancel_button:
return
description = self.description_plain_text_edit.toPlainText()
revision_cause_text = \
self.revision_type_combo_box.currentText().replace(' ', '_')
is_complete = self.set_as_complete_radio_button.isChecked()
submit_to_final_review = \
self.submit_for_final_review_radio_button.isChecked()
# get the revision Types
from stalker import Type
revision_type = Type.query\
.filter(Type.target_entity_type == 'Note')\
.filter(Type.name == revision_cause_text)\
.first()
date = self.calendar_widget.selectedDate()
start = self.start_time_edit.time()
end = self.end_time_edit.time()
# construct proper datetime.DateTime instances
import datetime
start_date = datetime.datetime(
date.year(), date.month(), date.day(),
start.hour(), start.minute()
)
end_date = datetime.datetime(
date.year(), date.month(), date.day(),
end.hour(), end.minute()
)
today_midnight = datetime.datetime.now().replace(
hour=23, minute=59, second=59, microsecond=999
)
# raise an error if the user is trying to enter a TimeLog to the future
if start_date > today_midnight or end_date > today_midnight:
QtWidgets.QMessageBox.critical(
self,
'Error',
'Gelecege TimeLog giremezsiniz!!!',
)
return
# convert them to utc
from anima.utils import local_to_utc
utc_start_date = local_to_utc(start_date)
utc_end_date = local_to_utc(end_date)
# create a TimeLog
# print('Task : %s' % task.name)
# print('Resource : %s' % resource.name)
# print('utc_start_date: %s' % utc_start_date)
# print('utc_end_date : %s' % utc_end_date)
# now if we are not using extra time just create the TimeLog
from stalker import TimeLog
from stalker.db.session import DBSession
from stalker.exceptions import (OverBookedError,
DependencyViolationError)
utc_now = local_to_utc(datetime.datetime.now())
# TODO: Remove this in a later version
import stalker
from distutils.version import LooseVersion
if LooseVersion(stalker.__version__) >= LooseVersion('0.2.18'):
# inject timezone info
import pytz
utc_start_date = utc_start_date.replace(tzinfo=pytz.utc)
utc_end_date = utc_end_date.replace(tzinfo=pytz.utc)
utc_now = utc_now.replace(tzinfo=pytz.utc)
from sqlalchemy.exc import IntegrityError
if not self.timelog:
try:
new_time_log = TimeLog(
task=task,
resource=resource,
start=utc_start_date,
end=utc_end_date,
description=description,
date_created=utc_now
)
except (OverBookedError, DependencyViolationError) as e:
# inform the user that it can not do that
QtWidgets.QMessageBox.critical(
self,
'Error',
'%s' % e
)
DBSession.rollback()
return
try:
DBSession.add(new_time_log)
DBSession.commit()
self.timelog_created = True
except IntegrityError as e:
DBSession.rollback()
QtWidgets.QMessageBox.critical(
self,
'Error',
'Database Error!!!'
'<br>'
'%s' % e
)
return
else:
# just update the date values
self.timelog.start = utc_start_date
self.timelog.end = utc_end_date
self.timelog.date_updated = utc_now
DBSession.add(self.timelog)
DBSession.commit()
if self.no_time_left:
# we have no time left so automatically extend the task
from stalker import Task
schedule_timing, schedule_unit = \
task.least_meaningful_time_unit(
task.total_logged_seconds
)
if schedule_timing != 0:
task.schedule_timing = schedule_timing
task.schedule_unit = schedule_unit
# also create a Note
from stalker import Note
new_note = Note(
content='Extending timing of the task <b>%s h %s min.</b>' % (
self.extended_hours,
self.extended_minutes
),
type=revision_type,
created_by=self.logged_in_user,
date_created=utc_now
)
DBSession.add(new_note)
task.notes.append(new_note)
try:
DBSession.commit()
except IntegrityError as e:
QtWidgets.QMessageBox.critical(
self,
'Error',
'Database Error!!!'
'<br>'
'%s' % e
)
DBSession.rollback()
return
if is_complete:
# set the status to complete
from stalker import Type, Status
status_cmpl = Status.query.filter(Status.code == 'CMPL').first()
forced_status_type = \
Type.query.filter(Type.name == 'Forced Status').first()
# also create a Note
from stalker import Note
new_note = Note(
content='%s has changed this task status to Completed' %
resource.name,
type=forced_status_type,
created_by=self.logged_in_user,
date_created=utc_now
)
DBSession.add(new_note)
task.notes.append(new_note)
task.status = status_cmpl
DBSession.commit()
elif submit_to_final_review:
# clip the Task timing to current time logs
from stalker import Task
schedule_timing, schedule_unit = \
task.least_meaningful_time_unit(
task.total_logged_seconds
)
task.schedule_timing = schedule_timing
task.schedule_unit = schedule_unit
DBSession.add(task)
try:
DBSession.commit()
except IntegrityError as e:
QtWidgets.QMessageBox.critical(
self,
'Error',
'Database Error!!!'
'<br>'
'%s' % e
)
DBSession.rollback()
return
# request a review
reviews = task.request_review()
for review in reviews:
review.created_by = review.updated_by = self.logged_in_user
review.date_created = utc_now
review.date_updated = utc_now
DBSession.add_all(reviews)
# and create a Note for the Task
request_review_note_type = \
Type.query\
.filter(Type.target_entity_type == 'Note')\
.filter(Type.name == 'Request Review')\
.first()
from stalker import Note
request_review_note = Note(
type=request_review_note_type,
created_by=self.logged_in_user,
date_created=utc_now
)
DBSession.add(request_review_note)
DBSession.add(task)
task.notes.append(request_review_note)
try:
DBSession.commit()
except IntegrityError as e:
DBSession.rollback()
QtWidgets.QMessageBox.critical(
self,
'Error',
'Database Error!!!'
'<br>'
'%s' % e
)
return
# Fix statuses
from anima import utils
utils.fix_task_statuses(task)
try:
DBSession.commit()
except IntegrityError as e:
DBSession.rollback()
QtWidgets.QMessageBox.critical(
self,
'Error',
'Database Error!!!'
'<br>'
'%s' % e
)
return
# if nothing bad happens close the dialog
super(MainDialog, self).accept()
def create_empty_project():
"""creates empty project test data
"""
from stalker.db.session import DBSession
from stalker import (Task, Asset, Type, Sequence, Shot, Version,
FilenameTemplate, Repository, Project, Structure)
repo = Repository(name='Test Repository',
code='TR',
windows_path='T:/',
linux_path='/mnt/T/',
osx_path='/Volumes/T/')
task_filename_template = FilenameTemplate(
name='Task Filename Template',
path='$REPO{{project.repository.code}}/{{project.code}}/'
'{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}'
'/{%- endfor -%}',
filename=
'{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}',
target_entity_type='Task')
asset_filename_template = FilenameTemplate(
name='Asset Filename Template',
path='$REPO{{project.repository.code}}/{{project.code}}/'
'{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}'
'/{%- endfor -%}',
filename=
'{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}',
target_entity_type='Asset')
shot_filename_template = FilenameTemplate(
name='Shot Filename Template',
path='$REPO{{project.repository.code}}/{{project.code}}/'
'{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}'
'/{%- endfor -%}',
filename=
'{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}',
target_entity_type='Shot')
sequence_filename_template = FilenameTemplate(
name='Sequence Filename Template',
path='$REPO{{project.repository.code}}/{{project.code}}/'
'{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}'
'/{%- endfor -%}',
filename=
'{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}',
target_entity_type='Sequence')
structure = Structure(name='Default Project Structure',
templates=[
task_filename_template, asset_filename_template,
shot_filename_template,
sequence_filename_template
])
DBSession.add_all([
structure, task_filename_template, asset_filename_template,
shot_filename_template, sequence_filename_template
])
DBSession.commit()
project = Project(
name='Test Project',
code='TP',
repository=repo,
structure=structure,
)
DBSession.add(project)
DBSession.commit()
yield project
def setUp(self):
"""setup the test
"""
super(self.__class__, self).setUp()
from stalker import Status
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
from stalker.db.session import DBSession
from stalker import User
self.test_resource1 = User(
name="User1",
login="******",
email="*****@*****.**",
password="******",
)
DBSession.add(self.test_resource1)
self.test_resource2 = User(name="User2",
login="******",
email="*****@*****.**",
password="******")
DBSession.add(self.test_resource2)
from stalker import Repository
self.test_repo = Repository(name="test repository", code="tr")
DBSession.add(self.test_repo)
# 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")
DBSession.add_all(
[self.test_status1, self.test_status2, self.test_status3])
from stalker import Project
self.test_project = Project(
name="test project",
code='tp',
repository=self.test_repo,
)
DBSession.add(self.test_project)
# create Tasks
from stalker import Task
self.test_task1 = Task(name="test task 1",
project=self.test_project,
schedule_timing=10,
schedule_unit='d',
resources=[self.test_resource1])
DBSession.add(self.test_task1)
self.test_task2 = Task(name="test task 2",
project=self.test_project,
schedule_timing=10,
schedule_unit='d',
resources=[self.test_resource1])
DBSession.add(self.test_task2)
self.kwargs = {
"task": self.test_task1,
"resource": self.test_resource1,
"start": datetime.datetime(2013, 3, 22, 1, 0, tzinfo=pytz.utc),
"duration": datetime.timedelta(10)
}
# create a TimeLog
# and test it
self.test_time_log = TimeLog(**self.kwargs)
DBSession.add(self.test_time_log)
DBSession.commit()
type=character_asset_type,
project=new_project2,
status_list=asset_status_list,
responsible=[new_user1])
task_status_list = StatusList(name="Task Statuses",
statuses=[status1, status2],
target_entity_type=Task)
new_task = Task(name="Task 1",
resources=[new_user1],
parent=new_asset1,
status_list=task_status_list)
new_task2 = Task(name="Task 2",
resources=[new_user2],
parent=new_asset2,
status_list=task_status_list)
#new_project.assets
#new_asset.project
#new_project
#new_project.assets.append(new_asset)
#new_project.assets
DBSession.add_all([new_project1, new_project2])
DBSession.commit()
# uses are now assigned to projects
assert new_project1.users == []
def create_project():
"""creates test data
"""
from stalker.db.session import DBSession
from stalker import (Task, Asset, Type, Sequence, Shot, Version,
FilenameTemplate, Repository, Project, Structure)
repo = Repository(name='Test Repository',
code='TR',
windows_path='T:/',
linux_path='/mnt/T/',
osx_path='/Volumes/T/')
task_filename_template = FilenameTemplate(
name='Task Filename Template',
path='$REPO{{project.repository.code}}/{{project.code}}/'
'{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}'
'/{%- endfor -%}',
filename=
'{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}',
target_entity_type='Task')
asset_filename_template = FilenameTemplate(
name='Asset Filename Template',
path='$REPO{{project.repository.code}}/{{project.code}}/'
'{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}'
'/{%- endfor -%}',
filename=
'{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}',
target_entity_type='Asset')
shot_filename_template = FilenameTemplate(
name='Shot Filename Template',
path='$REPO{{project.repository.code}}/{{project.code}}/'
'{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}'
'/{%- endfor -%}',
filename=
'{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}',
target_entity_type='Shot')
sequence_filename_template = FilenameTemplate(
name='Sequence Filename Template',
path='$REPO{{project.repository.code}}/{{project.code}}/'
'{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}'
'/{%- endfor -%}',
filename=
'{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}',
target_entity_type='Sequence')
structure = Structure(name='Default Project Structure',
templates=[
task_filename_template, asset_filename_template,
shot_filename_template,
sequence_filename_template
])
DBSession.add_all([
structure, task_filename_template, asset_filename_template,
shot_filename_template, sequence_filename_template
])
DBSession.commit()
project = Project(
name='Test Project',
code='TP',
repository=repo,
structure=structure,
)
DBSession.add(project)
DBSession.commit()
assets_task = Task(name='Assets', project=project)
characters_task = Task(name='Characters', parent=assets_task)
props_task = Task(name='Props', parent=assets_task)
environments_task = Task(name='Environments', parent=assets_task)
sequences_task = Task(name='Sequences', project=project)
# Asset Types
char_type = Type(name='Character', code='Char', target_entity_type='Asset')
prop_type = Type(name='Prop', code='Prop', target_entity_type='Asset')
exterior_type = Type(name='Exterior',
code='Exterior',
target_entity_type='Asset')
interior_type = Type(name='Interior',
code='Interior',
target_entity_type='Asset')
# Task Types
model_type = Type(name='Model', code='Model', target_entity_type='Task')
look_dev_type = Type(name='Look Development',
code='LookDev',
target_entity_type='Task')
rig_type = Type(name='Rig', code='Rig', target_entity_type='Task')
layout_type = Type(name='Layout', code='Layout', target_entity_type='Task')
anim_type = \
Type(name='Animation', code='Animation', target_entity_type='Task')
camera_type = Type(name='Camera', code='Camera', target_entity_type='Task')
plate_type = Type(name='Plate', code='Plate', target_entity_type='Task')
fx_type = Type(name='FX', code='FX', target_entity_type='Task')
lighting_type = \
Type(name='Lighting', code='Lighting', target_entity_type='Task')
comp_type = Type(name='Comp', code='Comp', target_entity_type='Task')
DBSession.add_all([
char_type, prop_type, exterior_type, interior_type, model_type,
look_dev_type, rig_type, layout_type, anim_type, camera_type,
plate_type, fx_type, lighting_type, comp_type
])
DBSession.commit()
# char1
char1 = Asset(name='Char1',
code='Char1',
parent=characters_task,
type=char_type)
model = Task(name='Model', type=model_type, parent=char1)
look_dev_task = Task(name='LookDev', type=look_dev_type, parent=char1)
rig = Task(name='Rig', type=rig_type, parent=char1)
DBSession.add_all([char1, model, look_dev_task, rig])
DBSession.commit()
# char2
char2 = Asset(name='Char2',
code='Char2',
parent=characters_task,
type=char_type)
model = Task(name='Model', type=model_type, parent=char2)
look_dev_task = Task(name='LookDev', type=look_dev_type, parent=char2)
rig = Task(name='Rig', type=rig_type, parent=char2)
DBSession.add_all([char2, model, look_dev_task, rig])
DBSession.commit()
# prop1
prop1 = \
Asset(name='Prop2', code='Prop2', parent=props_task, type=prop_type)
model = Task(name='Model', type=model_type, parent=prop1)
look_dev_task = Task(name='LookDev', type=look_dev_type, parent=prop1)
DBSession.add_all([prop1, model, look_dev_task])
DBSession.commit()
# prop2
prop2 = \
Asset(name='Prop2', code='Prop2', parent=props_task, type=prop_type)
model = Task(name='Model', type=model_type, parent=prop2)
look_dev_task = Task(name='LookDev', type=look_dev_type, parent=prop2)
DBSession.add_all([prop2, model, look_dev_task])
DBSession.commit()
# environments
# env1
env1 = Asset(name='Env1',
code='Env1',
type=exterior_type,
parent=environments_task)
layout_task = Task(name='Layout', type=layout_type, parent=env1)
props_task = Task(name='Props', parent=env1)
yapi1_asset = \
Asset(name='Yapi1', code='Yapi1', type=prop_type, parent=props_task)
model_task = Task(name='Model', type=model_type, parent=yapi1_asset)
look_dev_task = \
Task(name='LookDev', type=look_dev_type, parent=yapi1_asset)
DBSession.add_all([
env1, layout_task, props_task, yapi1_asset, model_task, look_dev_task
])
DBSession.commit()
# env2
env2 = Asset(name='Env2',
code='Env2',
type=exterior_type,
parent=environments_task)
layout_task = Task(name='Layout', type=layout_type, parent=env2)
props_task = Task(name='Props', parent=env2)
yapi1_asset = \
Asset(name='Yapi2', code='Yapi2', type=prop_type, parent=props_task)
model_task = Task(name='Model', type=model_type, parent=yapi1_asset)
look_dev_task = \
Task(name='LookDev', type=look_dev_type, parent=yapi1_asset)
DBSession.add_all([
env2, layout_task, props_task, yapi1_asset, model_task, look_dev_task
])
DBSession.commit()
# sequences and shots
seq1 = Sequence(name='Seq1', code='Seq1', parent=sequences_task)
edit_task = Task(name='Edit', parent=seq1)
shots_task = Task(name='Shots', parent=seq1)
DBSession.add_all([seq1, edit_task, shots_task])
DBSession.commit()
# shot1
shot1 = Shot(name='Seq001_001_0010',
code='Seq001_001_0010',
sequences=[seq1],
parent=shots_task)
anim_task = Task(name='Anim', type=anim_type, parent=shot1)
camera_task = Task(name='Camera', type=camera_type, parent=shot1)
plate_task = Task(name='Plate', type=plate_type, parent=shot1)
fx_task = Task(name='FX', type=fx_type, parent=shot1)
lighting_task = Task(name='Lighting', type=lighting_type, parent=shot1)
comp_task = Task(name='Comp', type=comp_type, parent=shot1)
DBSession.add_all([
shot1, anim_task, camera_task, plate_task, fx_task, lighting_task,
comp_task
])
DBSession.commit()
# shot2
shot2 = Shot(name='Seq001_001_0020',
code='Seq001_001_0020',
sequences=[seq1],
parent=shots_task)
anim_task = Task(name='Anim', type=anim_type, parent=shot2)
camera_task = Task(name='Camera', type=camera_type, parent=shot2)
plate_task = Task(name='Plate', type=plate_type, parent=shot2)
fx_task = Task(name='FX', type=fx_type, parent=shot2)
lighting_task = Task(name='Lighting', type=lighting_type, parent=shot2)
comp_task = Task(name='Comp', type=comp_type, parent=shot2)
DBSession.add_all([
shot2, anim_task, camera_task, plate_task, fx_task, lighting_task,
comp_task
])
DBSession.commit()
# shot3
shot3 = Shot(name='Seq001_001_0030',
code='Seq001_001_0030',
sequences=[seq1],
parent=shots_task)
anim_task = Task(name='Anim', type=anim_type, parent=shot3)
camera_task = Task(name='Camera', type=camera_type, parent=shot3)
plate_task = Task(name='Plate', type=plate_type, parent=shot3)
fx_task = Task(name='FX', type=fx_type, parent=shot3)
lighting_task = Task(name='Lighting', type=lighting_type, parent=shot3)
comp_task = Task(name='Comp', type=comp_type, parent=shot3)
DBSession.add_all([
shot3, anim_task, camera_task, plate_task, fx_task, lighting_task,
comp_task
])
DBSession.commit()
# Seq2
# sequences and shots
seq2 = Sequence(name='Seq2', code='Seq2', parent=sequences_task)
edit_task = Task(name='Edit', parent=seq2)
shots_task = Task(name='Shots', parent=seq2)
DBSession.add_all([seq2, edit_task, shots_task])
DBSession.commit()
# shot1
shot1 = Shot(name='Seq002_001_0010',
code='Seq002_001_0010',
sequences=[seq2],
parent=shots_task)
anim_task = Task(name='Anim', type=anim_type, parent=shot1)
camera_task = Task(name='Camera', type=camera_type, parent=shot1)
plate_task = Task(name='Plate', type=plate_type, parent=shot1)
fx_task = Task(name='FX', type=fx_type, parent=shot1)
lighting_task = Task(name='Lighting', type=lighting_type, parent=shot1)
comp_task = Task(name='Comp', type=comp_type, parent=shot1)
DBSession.add_all([
shot1, anim_task, camera_task, plate_task, fx_task, lighting_task,
comp_task
])
DBSession.commit()
# shot2
shot2 = Shot(name='Seq002_001_0020',
code='Seq002_001_0020',
sequences=[seq2],
parent=shots_task)
anim_task = Task(name='Anim', type=anim_type, parent=shot2)
camera_task = Task(name='Camera', type=camera_type, parent=shot2)
plate_task = Task(name='Plate', type=plate_type, parent=shot2)
fx_task = Task(name='FX', type=fx_type, parent=shot2)
lighting_task = Task(name='Lighting', type=lighting_type, parent=shot2)
comp_task = Task(name='Comp', type=comp_type, parent=shot2)
DBSession.add_all([
shot2, anim_task, camera_task, plate_task, fx_task, lighting_task,
comp_task
])
DBSession.commit()
# shot3
shot3 = Shot(name='Seq002_001_0030',
code='Seq002_001_0030',
sequences=[seq2],
parent=shots_task)
anim_task = Task(name='Anim', type=anim_type, parent=shot3)
camera_task = Task(name='Camera', type=camera_type, parent=shot3)
plate_task = Task(name='Plate', type=plate_type, parent=shot3)
fx_task = Task(name='FX', type=fx_type, parent=shot3)
lighting_task = Task(name='Lighting', type=lighting_type, parent=shot3)
comp_task = Task(name='Comp', type=comp_type, parent=shot3)
DBSession.add_all([
shot3, anim_task, camera_task, plate_task, fx_task, lighting_task,
comp_task
])
DBSession.commit()
yield project
def setUpClass(cls):
"""setup test
"""
# -----------------------------------------------------------------
# start of the setUp
# create the environment variable and point it to a temp directory
from stalker import db
database_url = "sqlite:///:memory:"
db.setup({'sqlalchemy.url': database_url})
db.init()
cls.temp_repo_path = tempfile.mkdtemp()
from stalker import User
cls.user1 = User(name='User 1',
login='******',
email='*****@*****.**',
password='******')
from stalker import Repository
cls.repo1 = Repository(name='Test Project Repository',
linux_path=cls.temp_repo_path,
windows_path=cls.temp_repo_path,
osx_path=cls.temp_repo_path)
from stalker import Status
cls.status_new = Status.query.filter_by(code='NEW').first()
cls.status_wip = Status.query.filter_by(code='WIP').first()
cls.status_comp = Status.query.filter_by(code='CMPL').first()
from stalker import FilenameTemplate
cls.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)}}',
)
from stalker import Structure
cls.structure = Structure(name='Project Struture',
templates=[cls.task_template])
from stalker import StatusList
cls.project_status_list = \
StatusList.query.filter_by(target_entity_type='Project').first()
from stalker import ImageFormat
cls.image_format = ImageFormat(name='HD 1080',
width=1920,
height=1080,
pixel_aspect=1.0)
# create a test project
from stalker import Project
cls.project = Project(name='Test Project',
code='TP',
repository=cls.repo1,
status_list=cls.project_status_list,
structure=cls.structure,
image_format=cls.image_format)
cls.task_status_list =\
StatusList.query.filter_by(target_entity_type='Task').first()
from stalker import Type
cls.character_type = Type(name='Character',
code='CHAR',
target_entity_type='Asset')
from stalker import Task
# create a test series of root task
cls.task1 = Task(name='Test Task 1', project=cls.project)
cls.task2 = Task(name='Test Task 2', project=cls.project)
# commit everything
from stalker.db.session import DBSession
DBSession.add_all([
cls.repo1, cls.status_new, cls.status_wip, cls.status_comp,
cls.project_status_list, cls.project, cls.task_status_list,
cls.task1, cls.task2, cls.task_template
])
DBSession.commit()
cls.version1 = cls.create_version(cls.task1, 'Main')
cls.version2 = cls.create_version(cls.task1, 'Main')
cls.version3 = cls.create_version(cls.task1, 'Main')
# create other reprs
# BBOX
cls.version4 = cls.create_version(cls.task1, 'Main@BBox')
cls.version5 = cls.create_version(cls.task1, 'Main@BBox')
cls.version5.is_published = True
DBSession.commit()
# ASS
cls.version6 = cls.create_version(cls.task1, 'Main@ASS')
cls.version7 = cls.create_version(cls.task1, 'Main@ASS')
cls.version7.is_published = True
DBSession.commit()
# GPU
cls.version8 = cls.create_version(cls.task1, 'Main@GPU')
cls.version9 = cls.create_version(cls.task1, 'Main@GPU')
# Non default take name
cls.version10 = cls.create_version(cls.task1, 'alt1')
cls.version11 = cls.create_version(cls.task1, 'alt1')
# Hires
cls.version12 = cls.create_version(cls.task1, 'alt1@Hires')
cls.version13 = cls.create_version(cls.task1, 'alt1@Hires')
# Midres
cls.version14 = cls.create_version(cls.task1, 'alt1@Midres')
cls.version15 = cls.create_version(cls.task1, 'alt1@Midres')
# Lores
cls.version16 = cls.create_version(cls.task1, 'alt1@Lores')
cls.version17 = cls.create_version(cls.task1, 'alt1@Lores')
cls.version17.is_published = True
# No Repr
cls.version18 = cls.create_version(cls.task1, 'NoRepr')
cls.version19 = cls.create_version(cls.task1, 'NoRepr')
DBSession.commit()
# create a buffer for extra created files, which are to be removed
cls.remove_these_files_buffer = []
def setUpClass(cls):
"""setup once
"""
# remove the transaction manager
DBSession.remove()
cls.repo_path = tempfile.mkdtemp()
from anima import defaults
defaults.local_storage_path = tempfile.mktemp()
db.setup({
'sqlalchemy.url': 'sqlite:///:memory:',
'sqlalchemy.echo': 'false'
})
db.init()
# create Power Users Group
cls.power_users_group = Group(name='Power Users')
DBSession.add(cls.power_users_group)
DBSession.commit()
# create a LocalSession first
cls.admin = User.query.all()[0]
cls.lsession = LocalSession()
cls.lsession.store_user(cls.admin)
cls.lsession.save()
# create a repository
cls.test_repo1 = Repository(name='Test Repository',
windows_path='T:/TestRepo/',
linux_path='/mnt/T/TestRepo/',
osx_path='/Volumes/T/TestRepo/')
cls.test_structure1 = Structure(name='Test Project Structure',
templates=[],
custom_template='')
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.project_status_list = \
StatusList.query.filter_by(target_entity_type=Project).first()
# create a couple of projects
cls.test_project1 = Project(name='Project 1',
code='P1',
repository=cls.test_repo1,
structure=cls.test_structure1,
status_list=cls.project_status_list)
cls.test_project2 = Project(name='Project 2',
code='P2',
repository=cls.test_repo1,
structure=cls.test_structure1,
status_list=cls.project_status_list)
cls.test_project3 = Project(name='Project 3',
code='P3',
repository=cls.test_repo1,
structure=cls.test_structure1,
status_list=cls.project_status_list)
cls.projects = [
cls.test_project1, cls.test_project2, cls.test_project3
]
cls.test_user1 = User(
name='Test User',
# groups=[self.power_users_group],
login='******',
email='*****@*****.**',
password='******')
DBSession.add(cls.test_user1)
DBSession.commit()
cls.admin.projects.append(cls.test_project1)
cls.admin.projects.append(cls.test_project2)
cls.admin.projects.append(cls.test_project3)
cls.test_user1.projects.append(cls.test_project1)
cls.test_user1.projects.append(cls.test_project2)
cls.test_user1.projects.append(cls.test_project3)
# project 1
cls.test_task1 = Task(
name='Test Task 1',
project=cls.test_project1,
resources=[cls.admin],
)
cls.test_task2 = Task(
name='Test Task 2',
project=cls.test_project1,
resources=[cls.admin],
)
cls.test_task3 = Task(
name='Test Task 2',
project=cls.test_project1,
resources=[cls.admin],
)
# project 2
cls.test_task4 = Task(
name='Test Task 4',
project=cls.test_project2,
resources=[cls.admin],
)
cls.test_task5 = Task(
name='Test Task 5',
project=cls.test_project2,
resources=[cls.admin],
)
cls.test_task6 = Task(
name='Test Task 6',
parent=cls.test_task5,
resources=[cls.admin],
)
cls.test_task7 = Task(
name='Test Task 7',
parent=cls.test_task5,
resources=[],
)
cls.test_task8 = Task(
name='Test Task 8',
parent=cls.test_task5,
resources=[],
)
cls.test_task9 = Task(
name='Test Task 9',
parent=cls.test_task5,
resources=[],
)
# +-> Project 1
# | |
# | +-> Task1
# | |
# | +-> Task2
# | |
# | +-> Task3
# |
# +-> Project 2
# | |
# | +-> Task4
# | |
# | +-> Task5
# | |
# | +-> Task6
# | |
# | +-> Task7 (no resource)
# | |
# | +-> Task8 (no resource)
# | |
# | +-> Task9 (no resource)
# |
# +-> Project 3
# record them all to the db
DBSession.add_all([
cls.admin, cls.test_project1, cls.test_project2, cls.test_project3,
cls.test_task1, cls.test_task2, cls.test_task3, cls.test_task4,
cls.test_task5, cls.test_task6, cls.test_task7, cls.test_task8,
cls.test_task9
])
DBSession.commit()
cls.all_tasks = [
cls.test_task1, cls.test_task2, cls.test_task3, cls.test_task4,
cls.test_task5, cls.test_task6, cls.test_task7, cls.test_task8,
cls.test_task9
]
# create versions
cls.test_version1 = Version(cls.test_task1,
created_by=cls.admin,
created_with='Test',
description='Test Description')
DBSession.add(cls.test_version1)
DBSession.commit()
cls.test_version2 = Version(cls.test_task1,
created_by=cls.admin,
created_with='Test',
description='Test Description')
DBSession.add(cls.test_version2)
DBSession.commit()
cls.test_version3 = Version(cls.test_task1,
created_by=cls.admin,
created_with='Test',
description='Test Description')
cls.test_version3.is_published = True
DBSession.add(cls.test_version3)
DBSession.commit()
cls.test_version4 = Version(cls.test_task1,
take_name='Main@GPU',
created_by=cls.admin,
created_with='Test',
description='Test Description')
cls.test_version4.is_published = True
DBSession.add(cls.test_version4)
DBSession.commit()
if not QtGui.QApplication.instance():
logger.debug('creating a new QApplication')
cls.app = QtGui.QApplication(sys.argv)
else:
logger.debug('using the present QApplication: %s' % QtGui.qApp)
# self.app = QtGui.qApp
cls.app = QtGui.QApplication.instance()
# cls.test_environment = TestEnvironment()
cls.dialog = version_dialog.MainDialog()
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):
"""set up the test
"""
super(self.__class__, self).setUp()
# create departments
from stalker import Department
self.test_dep1 = Department(name='Dep1')
self.test_dep2 = Department(name='Dep2')
# create resources
from stalker import User
self.test_user1 = User(login='******',
name='User1',
email='*****@*****.**',
password='******',
departments=[self.test_dep1])
from stalker.db.session import DBSession
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
from stalker import Repository
self.test_repo = Repository(name='Test Repository',
code='TR',
linux_path='/mnt/T/',
windows_path='T:/',
osx_path='/Volumes/T/')
DBSession.add(self.test_repo)
# statuses
from stalker import Status
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
])
# create one project
from stalker import Project
self.test_proj1 = Project(name='Test Project 1',
code='TP1',
repository=self.test_repo,
start=datetime.datetime(2013,
4,
4,
tzinfo=pytz.utc),
end=datetime.datetime(2013,
5,
4,
tzinfo=pytz.utc))
DBSession.add(self.test_proj1)
self.test_proj1.now = datetime.datetime(2013, 4, 4, tzinfo=pytz.utc)
# create two tasks with the same resources
from stalker import Task
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',
)
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',
priority=800)
DBSession.save(self.test_task2)
def setUp(self):
"""sets up the test
"""
db.setup()
db.init()
self.test_repo_path = tempfile.mkdtemp()
# create test data
self.test_repo = Repository(name='Test Repository',
linux_path=self.test_repo_path,
windows_path=self.test_repo_path,
osx_path=self.test_repo_path)
self.test_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.test_structure = Structure(name='Test Project Structure',
templates=[self.test_task_template])
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.test_project_status_list = \
StatusList.query.filter(target_entity_type='Project').first()
self.test_project1 = Project(name='Test Project 1',
code='TP1',
repository=self.test_repo,
structure=self.test_structure,
status_list=self.test_project_status_list)
DBSession.add(self.test_project1)
DBSession.commit()
# now create tasks
# root tasks
self.test_task1 = Task(name='Task1', project=self.test_project1)
self.test_task2 = Task(name='Task2', project=self.test_project1)
self.test_task3 = Task(name='Task3', project=self.test_project1)
# child of Task1
self.test_task4 = Task(name='Task4', parent=self.test_task1)
self.test_task5 = Task(name='Task5', parent=self.test_task1)
self.test_task6 = Task(name='Task6', parent=self.test_task1)
# child of Task2
self.test_task7 = Task(name='Task7', parent=self.test_task2)
self.test_task8 = Task(name='Task8', parent=self.test_task2)
self.test_task9 = Task(name='Task9', parent=self.test_task2)
# child of Task10
self.test_task10 = Task(name='Task10', parent=self.test_task3)
self.test_task11 = Task(name='Task11', parent=self.test_task3)
self.test_task12 = Task(name='Task12', parent=self.test_task3)
DBSession.add_all([
self.test_task1, self.test_task2, self.test_task3, self.test_task4,
self.test_task5, self.test_task6, self.test_task7, self.test_task8,
self.test_task9, self.test_task10, self.test_task11,
self.test_task12
])
# now create versions for each of leaf tasks
# Task4
# Main
self.test_version1 = self.create_version(self.test_task4,
take_name='Main')
self.test_version2 = self.create_version(self.test_task4,
take_name='Main')
self.test_version3 = self.create_version(self.test_task4,
take_name='Main')
# Take1
self.test_version4 = self.create_version(self.test_task4,
take_name='Take1')
self.test_version5 = self.create_version(self.test_task4,
take_name='Take1')
self.test_version6 = self.create_version(self.test_task4,
take_name='Take1')
# Take2
self.test_version7 = self.create_version(self.test_task4,
take_name='Take2')
self.test_version8 = self.create_version(self.test_task4,
take_name='Take2')
self.test_version9 = self.create_version(self.test_task4,
take_name='Take2')
# Task5
# Main
self.test_version10 = self.create_version(self.test_task5,
take_name='Main')
self.test_version11 = self.create_version(self.test_task5,
take_name='Main')
self.test_version12 = self.create_version(self.test_task5,
take_name='Main')
# Take1
self.test_version13 = self.create_version(self.test_task5,
take_name='Take1')
self.test_version14 = self.create_version(self.test_task5,
take_name='Take1')
self.test_version15 = self.create_version(self.test_task5,
take_name='Take1')
# Take2
self.test_version16 = self.create_version(self.test_task5,
take_name='Take2')
self.test_version17 = self.create_version(self.test_task5,
take_name='Take2')
self.test_version18 = self.create_version(self.test_task5,
take_name='Take2')
# Task6
# Main
self.test_version19 = self.create_version(self.test_task6,
take_name='Main')
self.test_version20 = self.create_version(self.test_task6,
take_name='Main')
self.test_version21 = self.create_version(self.test_task6,
take_name='Main')
# Take1
self.test_version22 = self.create_version(self.test_task6,
take_name='Take1')
self.test_version23 = self.create_version(self.test_task6,
take_name='Take1')
self.test_version24 = self.create_version(self.test_task6,
take_name='Take1')
# Take2
self.test_version25 = self.create_version(self.test_task6,
take_name='Take2')
self.test_version26 = self.create_version(self.test_task6,
take_name='Take2')
self.test_version27 = self.create_version(self.test_task6,
take_name='Take2')
# Task7
# Main
self.test_version28 = self.create_version(self.test_task7,
take_name='Main')
self.test_version29 = self.create_version(self.test_task7,
take_name='Main')
self.test_version30 = self.create_version(self.test_task7,
take_name='Main')
# Take1
self.test_version31 = self.create_version(self.test_task7,
take_name='Take1')
self.test_version32 = self.create_version(self.test_task7,
take_name='Take1')
self.test_version33 = self.create_version(self.test_task7,
take_name='Take1')
# Take2
self.test_version34 = self.create_version(self.test_task7,
take_name='Take2')
self.test_version35 = self.create_version(self.test_task7,
take_name='Take2')
self.test_version36 = self.create_version(self.test_task7,
take_name='Take2')
# Task8 - will have no versions
# Task9 - it is a destination task with versions
# Main
self.test_version37 = self.create_version(self.test_task9,
take_name='Main')
self.test_version38 = self.create_version(self.test_task9,
take_name='Main')
self.test_version39 = self.create_version(self.test_task9,
take_name='Main')
# Take1 - an existing take
self.test_version40 = self.create_version(self.test_task9,
take_name='Take1')
self.test_version41 = self.create_version(self.test_task9,
take_name='Take1')
self.test_version42 = self.create_version(self.test_task9,
take_name='Take1')
# Take3 - a non existing take
self.test_version43 = self.create_version(self.test_task9,
take_name='Take1')
self.test_version44 = self.create_version(self.test_task9,
take_name='Take1')
self.test_version45 = self.create_version(self.test_task9,
take_name='Take1')
if not QtGui.QApplication.instance():
self.app = QtGui.QApplication(sys.argv)
else:
# self.app = QtGui.qApp
self.app = QtGui.QApplication.instance()
self.dialog = VersionMover()
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='******')
DBSession.add(self.user1)
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.query.filter_by(target_entity_type='Project').first()
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
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
])
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()
DBSession.add(v)
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)
from stalker import Sequence
seq1 = Sequence(
name="Sequence 1",
code="SEQ1",
project=new_project,
)
from stalker import Shot
sh001 = Shot(name='SH001', code='SH001', project=new_project, sequences=[seq1])
sh002 = Shot(code='SH002', project=new_project, sequences=[seq1])
sh003 = Shot(code='SH003', project=new_project, sequences=[seq1])
DBSession.add_all([sh001, sh002, sh003])
DBSession.commit()
sh004 = Shot(code='SH004', project=new_project, sequences=[seq1])
DBSession.add(sh004)
DBSession.commit()
sh004.code = "SH005"
DBSession.commit()
# first find the data
wrong_shot = Shot.query.filter_by(code="SH005").first()
# now update it
wrong_shot.code = "SH004"
def setUp(self):
"""setup the test
"""
self.config = testing.setUp()
db.setup({'sqlalchemy.url': 'sqlite:///:memory:'})
DBSession.configure(extension=ZopeTransactionExtension())
with transaction.manager:
self.test_repo = Repository(
name='Test Repository',
linux_path=tempfile.mkdtemp(),
windows_path=tempfile.mkdtemp(),
osx_path=tempfile.mkdtemp()
)
DBSession.add(self.test_repo)
self.status1 = Status(name='Status1', code='STS1')
self.status2 = Status(name='Status2', code='STS2')
self.status3 = Status(name='Status3', code='STS3')
self.status4 = Status(name='Status4', code='STS4')
self.status5 = Status(name='Status5', code='STS5')
DBSession.add_all([self.status1, self.status2, self.status3,
self.status4, self.status5])
self.test_project_status_list = StatusList(
name='Project Statuses',
statuses=[self.status1, self.status2, self.status3, self.status4,
self.status5],
target_entity_type='Project'
)
DBSession.add(self.test_project_status_list)
self.test_task_status_list = StatusList(
name='Task Statuses',
statuses=[self.status1, self.status2, self.status3, self.status4,
self.status5],
target_entity_type='Task'
)
DBSession.add(self.test_task_status_list)
self.test_version_status_list = StatusList(
name='Version Statuses',
statuses=[self.status1, self.status2, self.status3, self.status4,
self.status5],
target_entity_type='Version'
)
DBSession.add(self.test_task_status_list)
# create a project
self.test_project = Project(
name='Test Project',
code='TP',
repository=self.test_repo,
status_list=self.test_project_status_list
)
DBSession.add(self.test_project)
# create a task
self.test_task = Task(
project=self.test_project,
name='Test Task',
status_list=self.test_task_status_list
)
DBSession.add(self.test_task)
# create a test version
self.test_version = Version(
task=self.test_task,
status_list=self.test_version_status_list
)
DBSession.add(self.test_version)
DBSession.add_all([
self.test_project, self.test_project_status_list,
self.test_repo, self.test_task, self.test_task_status_list,
self.test_version
])
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
from stalker import Project
dummy_project = Project(name='Dummy Project',
code='DP',
repository=self.test_repo)
from stalker import Task
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])
from stalker.db.session import DBSession
DBSession.add_all([dummy_project, dt1, dt2])
DBSession.commit()
tjp_sched = TaskJugglerScheduler(compute_resources=True,
projects=[dummy_project])
from stalker import Studio
test_studio = Studio(name='Test Studio',
now=datetime.datetime(2013,
4,
16,
0,
0,
tzinfo=pytz.utc))
test_studio.start = \
datetime.datetime(2013, 4, 16, 0, 0, tzinfo=pytz.utc)
test_studio.end = datetime.datetime(2013, 4, 30, 0, 0, tzinfo=pytz.utc)
test_studio.daily_working_hours = 9
DBSession.add(test_studio)
DBSession.commit()
tjp_sched.studio = test_studio
tjp_sched.schedule()
DBSession.commit()
# check if the task and project timings are all adjusted
assert self.test_proj1.computed_start is None
assert self.test_proj1.computed_end is None
assert self.test_task1.computed_start is None
assert self.test_task1.computed_end is None
assert self.test_task1.computed_resources == \
[self.test_user1, self.test_user2]
assert self.test_task2.computed_start is None
assert self.test_task2.computed_end is None
assert self.test_task2.computed_resources == \
[self.test_user1, self.test_user2]
assert \
dt1.computed_start == \
datetime.datetime(2013, 4, 16, 9, 0, tzinfo=pytz.utc)
assert \
dt1.computed_end == \
datetime.datetime(2013, 4, 16, 13, 0, tzinfo=pytz.utc)
assert \
dt2.computed_start == \
datetime.datetime(2013, 4, 16, 9, 0, tzinfo=pytz.utc)
assert \
dt2.computed_end == \
datetime.datetime(2013, 4, 16, 13, 0, tzinfo=pytz.utc)
'depends': [test_dependent_task1, test_dependent_task2],
'time_logs': [],
'versions': [],
'is_milestone': False,
'status': 0,
'status_list': task_status_list,
}
from stalker.db.session import DBSession
DBSession.add_all([
test_project_status_list,
test_movie_project_type,
test_repository_type,
test_repository,
test_user1,
test_user2,
test_user3,
test_user4,
test_user5,
test_project1,
test_dependent_task1,
test_dependent_task2,
])
DBSession.commit()
kwargs['depends'] = []
dt = datetime.datetime
td = datetime.timedelta
now = dt(2017, 3, 15, 0, 30, tzinfo=pytz.utc)
kwargs['schedule_model'] = 'effort'
name="Task Statuses",
statuses=[status1, status2],
target_entity_type=Task
)
new_task = Task(
name="Task 1",
resources=[new_user1],
parent=new_asset1,
status_list=task_status_list
)
new_task = Task(
name="Task 2",
resources=[new_user2],
parent=new_asset2,
status_list=task_status_list
)
#new_project.assets
#new_asset.project
#new_project
#new_project.assets.append(new_asset)
#new_project.assets
DBSession.add_all([new_project1, new_project2])
DBSession.commit()
# uses are now assigned to projects
assert new_project1.users == []
