def setUp(self):
"""set up the test
"""
super(ReviewTestDBCase, self).setUp()
from stalker import User
self.user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
from stalker.db.session import DBSession
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
from stalker import Status
with DBSession.no_autoflush:
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()
from stalker import Repository
self.repo = Repository(name='Test Repository',
code='TR',
linux_path='/mnt/T/',
windows_path='T:/',
osx_path='/Volumes/T/')
DBSession.add(self.repo)
from stalker import Structure
self.structure = Structure(name='Test Project Structure')
DBSession.add(self.structure)
from stalker import Project
self.project = Project(name='Test Project',
code='TP',
repository=self.repo)
DBSession.add(self.project)
from stalker import Task
self.task1 = Task(name='Test Task 1',
project=self.project,
resources=[self.user1],
responsible=[self.user2])
DBSession.add(self.task1)
self.task2 = Task(name='Test Task 2',
project=self.project,
responsible=[self.user1])
DBSession.add(self.task2)
self.task3 = Task(name='Test Task 3',
parent=self.task2,
resources=[self.user1])
DBSession.add(self.task3)
self.task4 = Task(name='Test Task 4',
project=self.project,
resources=[self.user1],
depends=[self.task3],
responsible=[self.user2],
schedule_timing=2,
schedule_unit='h')
DBSession.add(self.task4)
self.task5 = Task(name='Test Task 5',
project=self.project,
resources=[self.user2],
depends=[self.task3],
responsible=[self.user2],
schedule_timing=2,
schedule_unit='h')
DBSession.add(self.task5)
self.task6 = Task(name='Test Task 6',
project=self.project,
resources=[self.user3],
depends=[self.task3],
responsible=[self.user2],
schedule_timing=2,
schedule_unit='h')
DBSession.add(self.task6)
self.kwargs = {'task': self.task1, 'reviewer': self.user1}
# add everything to the db
DBSession.commit()
def setUp(self):
"""run once
"""
super(PaymentTestCase, self).setUp()
from stalker import Status
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_oh = Status(name='On Hold', code='OH')
self.status_stop = Status(name='Stopped', code='STOP')
self.status_cmpl = Status(name='Completed', code='CMPL')
self.status_new = Status(name='New', code='NEW')
self.status_app = Status(name='Approved', code='APP')
from stalker import StatusList
self.budget_status_list = StatusList(
name='Budget Statuses',
target_entity_type='Budget',
statuses=[self.status_new, self.status_prev, self.status_app])
self.task_status_list = StatusList(
name='Task Statses',
statuses=[
self.status_wfd, self.status_rts, self.status_wip,
self.status_prev, self.status_hrev, self.status_drev,
self.status_oh, self.status_stop, self.status_cmpl
],
target_entity_type='Task')
from stalker import Project
self.test_project_status_list = StatusList(
name="Project Statuses",
statuses=[self.status_wip, self.status_prev, self.status_cmpl],
target_entity_type=Project,
)
from stalker import Type
self.test_movie_project_type = Type(
name="Movie Project",
code='movie',
target_entity_type=Project,
)
from stalker import Repository
self.test_repository_type = Type(
name="Test Repository Type",
code='test',
target_entity_type=Repository,
)
self.test_repository = Repository(
name="Test Repository",
code='TR',
type=self.test_repository_type,
)
from stalker import User
self.test_user1 = User(name="User1",
login="******",
email="*****@*****.**",
password="******")
self.test_user2 = User(name="User2",
login="******",
email="*****@*****.**",
password="******")
self.test_user3 = User(name="User3",
login="******",
email="*****@*****.**",
password="******")
self.test_user4 = User(name="User4",
login="******",
email="*****@*****.**",
password="******")
self.test_user5 = User(name="User5",
login="******",
email="*****@*****.**",
password="******")
from stalker import Client
self.test_client = Client(name='Test Client', )
self.test_project = Project(name="Test Project1",
code='tp1',
type=self.test_movie_project_type,
status_list=self.test_project_status_list,
repository=self.test_repository,
clients=[self.test_client])
from stalker import Budget
self.test_budget = Budget(project=self.test_project,
name='Test Budget 1',
status_list=self.budget_status_list)
from stalker import Invoice
self.test_invoice = Invoice(budget=self.test_budget,
client=self.test_client,
amount=1500,
unit='TRY')
def setUp(self):
"""setup the test
"""
super(ProjectMixinTester, self).setUp()
# create a repository
from stalker import db, Type
self.repository_type = Type(
name="Test Repository Type",
code='testproj',
target_entity_type='Repository'
)
db.DBSession.add(self.repository_type)
from stalker import Repository
self.test_repository = Repository(
name="Test Repository",
type=self.repository_type,
)
db.DBSession.add(self.test_repository)
# statuses
from stalker import Status
self.status1 = Status(name="Status1", code="STS1")
self.status2 = Status(name="Status2", code="STS2")
self.status3 = Status(name="Status3", code="STS3")
db.DBSession.add_all([self.status1, self.status2, self.status3])
# project status list
from stalker import StatusList
self.project_status_list = StatusList(
name="Project Status List",
statuses=[
self.status1,
self.status2,
self.status3,
],
target_entity_type='Project'
)
db.DBSession.add(self.project_status_list)
# project type
self.test_project_type = Type(
name="Test Project Type",
code='testproj',
target_entity_type='Project',
)
db.DBSession.add(self.test_project_type)
# create projects
from stalker import Project
self.test_project1 = Project(
name="Test Project 1",
code='tp1',
type=self.test_project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
db.DBSession.add(self.test_project1)
self.test_project2 = Project(
name="Test Project 2",
code='tp2',
type=self.test_project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
db.DBSession.add(self.test_project2)
self.kwargs = {
"name": "Test Class",
"project": self.test_project1,
}
self.test_foo_obj = ProjMixClass(**self.kwargs)
db.DBSession.add(self.test_foo_obj)
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')
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 test_readme_tutorial_code(setup_sqlite3):
"""Tests the tutorial code in README.rst
"""
from stalker import db
db.setup()
db.init()
from stalker.db.session import DBSession
assert str(DBSession.connection().engine.url) == 'sqlite://'
from stalker import User
me = User(name='Erkan Ozgur Yilmaz',
login='******',
email='*****@*****.**',
password='******')
# Save the user to database
DBSession.save(me)
from stalker import Repository
repo = Repository(name='Commercial Projects Repository',
windows_path='Z:/Projects',
linux_path='/mnt/Z/Projects',
osx_path='/Volumes/Z/Projects')
from stalker import FilenameTemplate
task_template = FilenameTemplate(
name='Standard Task Filename Template',
target_entity_type='Task', # This is for files saved for Tasks
path='{{project.repository.path}}/{{project.code}}/'
'{%- for parent_task in parent_tasks -%}'
'{{parent_task.nice_name}}/'
'{%- endfor -%}', # This is Jinja2 template code
filename=
'{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}')
from stalker import Structure
standard_folder_structure = Structure(
name='Standard Project Folder Structure',
templates=[task_template],
custom_template=
'{{project.code}}/References' # If you need extra folders
)
from stalker import Project
new_project = Project(
name='Test Project',
code='TP',
structure=standard_folder_structure,
repositories=[repo
], # if you have more than one repository you can do it
)
from stalker import ImageFormat
hd1080 = ImageFormat(name='1080p', width=1920, height=1080)
new_project.image_format = hd1080
# Save the project and all the other data it is connected to it
DBSession.save(new_project)
from stalker import Task, Asset, Shot, Type
# define Character asset type
char_type = Type(name='Character', code='CHAR', target_entity_type='Asset')
character1 = Asset(name='Character 1',
code='CHAR1',
type=char_type,
project=new_project)
# Save the Asset
DBSession.save(character1)
model = Task(name='Model', parent=character1)
rigging = Task(
name='Rig',
parent=character1,
depends=[model
], # For project management, define that Rig can not start
# before Model ends.
)
# Save the new tasks
DBSession.save([model, rigging])
# A shot and some tasks for it
shot = Shot(name='SH001', code='SH001', project=new_project)
# Save the Shot
DBSession.save(shot)
animation = Task(
name='Animation',
parent=shot,
)
lighting = Task(
name='Lighting',
parent=shot,
depends=[animation], # Lighting can not start before Animation ends,
schedule_timing=1,
schedule_unit='d', # The task expected to take 1 day to complete
resources=[me])
DBSession.save([animation, lighting])
from stalker import Version
new_version = Version(task=animation)
new_version.update_paths() # to render the naming convention template
new_version.extension = '.ma' # let's say that we have created under Maya
assert new_version.absolute_full_path == \
"%sTP/SH001/Animation/SH001_Animation_Main_v001.ma" % \
repo.path
assert new_version.version_number == 1
new_version2 = Version(task=animation)
new_version2.update_paths() # to render the naming convention template
new_version2.extension = '.ma' # let's say that we have created under Maya
assert new_version2.version_number == 2
def setUp(self):
"""set up the test
"""
# we need a database
db.setup(self.config)
db.init()
# replace datetime now function
# create departments
self.test_dep1 = Department(name='Dep1')
self.test_dep2 = Department(name='Dep2')
# create resources
self.test_user1 = User(login='******',
name='User1',
email='*****@*****.**',
password='******',
departments=[self.test_dep1])
DBSession.add(self.test_user1)
self.test_user2 = User(login='******',
name='User2',
email='*****@*****.**',
password='******',
departments=[self.test_dep1])
DBSession.add(self.test_user2)
self.test_user3 = User(login='******',
name='User3',
email='*****@*****.**',
password='******',
departments=[self.test_dep2])
DBSession.add(self.test_user3)
self.test_user4 = User(login='******',
name='User4',
email='*****@*****.**',
password='******',
departments=[self.test_dep2])
DBSession.add(self.test_user4)
# user with two departments
self.test_user5 = User(login='******',
name='User5',
email='*****@*****.**',
password='******',
departments=[self.test_dep1, self.test_dep2])
DBSession.add(self.test_user5)
# user with no departments
self.test_user6 = User(login='******',
name='User6',
email='*****@*****.**',
password='******')
DBSession.add(self.test_user6)
# repository
self.test_repo = Repository(name='Test Repository',
linux_path='/mnt/T/',
windows_path='T:/',
osx_path='/Volumes/T/')
DBSession.add(self.test_repo)
# statuses
self.test_status1 = Status(name='Status 1', code='STS1')
self.test_status2 = Status(name='Status 2', code='STS2')
self.test_status3 = Status(name='Status 3', code='STS3')
self.test_status4 = Status(name='Status 4', code='STS4')
self.test_status5 = Status(name='Status 5', code='STS5')
DBSession.add_all([
self.test_status1, self.test_status2, self.test_status3,
self.test_status4, self.test_status5
])
# status lists
self.test_proj_status_list = StatusList(
name='Project Status List',
statuses=[self.test_status1, self.test_status2, self.test_status3],
target_entity_type='Project')
DBSession.add(self.test_proj_status_list)
# create one project
self.test_proj1 = Project(name='Test Project 1',
code='TP1',
repository=self.test_repo,
status_list=self.test_proj_status_list,
start=datetime.datetime(2013, 4, 4),
end=datetime.datetime(2013, 5, 4))
DBSession.add(self.test_proj1)
self.test_proj1.now = datetime.datetime(2013, 4, 4)
# create task status list
with DBSession.no_autoflush:
self.test_task_status_list = StatusList.query\
.filter_by(target_entity_type='Task').first()
# create two tasks with the same resources
self.test_task1 = Task(name='Task1',
project=self.test_proj1,
resources=[self.test_user1, self.test_user2],
alternative_resources=[
self.test_user3, self.test_user4,
self.test_user5
],
schedule_model=0,
schedule_timing=50,
schedule_unit='h',
status_list=self.test_task_status_list)
DBSession.add(self.test_task1)
self.test_task2 = Task(name='Task2',
project=self.test_proj1,
resources=[self.test_user1, self.test_user2],
alternative_resources=[
self.test_user3, self.test_user4,
self.test_user5
],
depends=[self.test_task1],
schedule_model=0,
schedule_timing=60,
schedule_unit='h',
status_list=self.test_task_status_list)
DBSession.add(self.test_task2)
DBSession.commit()
def setUp(self):
"""setting the test up
"""
super(TimeLogViewsFunctionalTestCase, self).setUp()
# get the admin
import datetime
from stalker import User
self.admin = User.query.filter(User.login == 'admin').first()
# update the date_created to a known value
self.admin.date_created = datetime.datetime(2016, 3, 29, 12, 0)
self.admin.date_updated = datetime.datetime(2016, 3, 29, 12, 0)
# create test users
self.test_user1 = User(
name='Test User 1',
login='******',
email='*****@*****.**',
password='******',
created_by=self.admin,
)
# update the date_created to a known value
self.test_user1.date_created = datetime.datetime(2016, 3, 29, 12, 0)
self.test_user1.date_updated = datetime.datetime(2016, 3, 29, 12, 0)
self.test_user2 = User(
name='Test User 2',
login='******',
email='*****@*****.**',
password='******',
created_by=self.admin,
)
# update the date_created to a known value
self.test_user2.date_created = datetime.datetime(2016, 3, 29, 12, 0)
self.test_user2.date_updated = datetime.datetime(2016, 3, 29, 12, 0)
self.test_user3 = User(
name='Test User 3',
login='******',
email='*****@*****.**',
password='******',
created_by=self.admin,
)
# update the date_created to a known value
self.test_user3.date_created = datetime.datetime(2016, 3, 29, 12, 0)
self.test_user3.date_updated = datetime.datetime(2016, 3, 29, 12, 0)
# create Projects
from stalker import Status, StatusList, Project, Repository
self.test_status1 = Status(name='Work In Progress', code='WIP')
self.test_status2 = Status(name='Completed', code='CMPL')
self.test_status_list = StatusList(
name='Project Status List',
target_entity_type='Project',
statuses=[self.test_status1, self.test_status2])
self.test_repo = Repository(name='Test Repository', )
self.test_project1 = Project(name='Test Project 1',
code='TP1',
status_list=self.test_status_list,
repositories=[self.test_repo])
self.test_project2 = Project(name='Test Project 2',
code='TP2',
status_list=self.test_status_list,
repositories=[self.test_repo])
# set user projects
self.test_user1.projects = [self.test_project1]
self.test_user2.projects = [self.test_project2]
self.test_user3.projects = [self.test_project1, self.test_project2]
from stalker import db
db.DBSession.add_all([
self.test_user1, self.test_user2, self.test_user3,
self.test_status1, self.test_status2, self.test_status_list,
self.test_repo, self.test_project1, self.test_project2
])
db.DBSession.flush()
db.DBSession.commit()
# create tasks
# tasks
# as resource
from stalker import Task
self.test_task1 = Task(name='T1',
project=self.test_project1,
resources=[self.test_user1],
responsible=[self.test_user2],
schedule_timing=10,
schedule_unit='h',
schedule_model='effort')
db.DBSession.add(self.test_task1)
self.test_task2 = Task(name='T2',
project=self.test_project1,
resources=[self.test_user1],
responsible=[self.test_user2])
db.DBSession.add(self.test_task2)
self.test_task3 = Task(name='T3',
project=self.test_project1,
resources=[self.test_user1],
responsible=[self.test_user2])
db.DBSession.add(self.test_task3)
# as responsible
self.test_task4 = Task(name='T4',
project=self.test_project1,
resources=[self.test_user2],
responsible=[self.test_user1])
db.DBSession.add(self.test_task4)
self.test_task5 = Task(name='T5',
project=self.test_project1,
resources=[self.test_user2],
responsible=[self.test_user1])
db.DBSession.add(self.test_task5)
self.test_task6 = Task(name='T6',
project=self.test_project1,
resources=[self.test_user2],
responsible=[self.test_user1])
db.DBSession.add(self.test_task6)
# non related
self.test_task7 = Task(name='T7',
project=self.test_project1,
resources=[self.test_user2],
responsible=[self.test_user3])
db.DBSession.add(self.test_task7)
self.test_task8 = Task(name='T8',
project=self.test_project1,
resources=[self.test_user2],
responsible=[self.test_user3])
db.DBSession.add(self.test_task8)
self.test_task9 = Task(name='T9',
project=self.test_project2,
resources=[self.test_user2],
responsible=[self.test_user3])
db.DBSession.add(self.test_task9)
self.test_task10 = Task(name='T10',
project=self.test_project2,
resources=[self.test_user2],
responsible=[self.test_user3])
db.DBSession.add(self.test_task10)
db.DBSession.flush()
db.DBSession.commit()
def setUp(self):
"""lets setup the tests
"""
# create a couple of test users
self.test_user1 = User(
name="User1",
login="******",
email="*****@*****.**",
password="******",
)
self.test_user2 = User(
name="User2",
login="******",
email="*****@*****.**",
password="******",
)
self.test_user3 = User(
name="User3",
login="******",
email="*****@*****.**",
password="******",
)
self.test_user4 = User(
name="User4",
login="******",
email="*****@*****.**",
password="******",
)
self.users_list = [
self.test_user1, self.test_user2, self.test_user3, self.test_user4
]
self.test_admin = User(
name="admin",
login="******",
email="*****@*****.**",
password="******",
)
self.status_new = Status(name="Test status 1", code="Status1")
self.status_wip = Status(name="Test status 2", code="Status2")
self.status_cmpl = Status(name="Test status 3", code="Status3")
self.project_statuses = StatusList(
name="Project Status List",
statuses=[self.status_new, self.status_wip, self.status_cmpl],
target_entity_type='Project')
self.test_repo = Repository(name="Test Repository")
self.test_project1 = Project(
name="Test Project 1",
code='proj1',
status_list=self.project_statuses,
repository=self.test_repo,
)
self.test_project2 = Project(
name="Test Project 1",
code='proj2',
status_list=self.project_statuses,
repository=self.test_repo,
)
self.test_project3 = Project(
name="Test Project 1",
code='proj3',
status_list=self.project_statuses,
repository=self.test_repo,
)
self.projects_list = [
self.test_project1, self.test_project2, self.test_project3
]
self.date_created = self.date_updated = datetime.datetime.now()
self.kwargs = {
"name": "Test Client",
"description": "This is a client for testing purposes",
"created_by": self.test_admin,
"updated_by": self.test_admin,
"date_created": self.date_created,
"date_updated": self.date_updated,
"users": self.users_list,
"projects": self.projects_list
}
# create a default client object
self.test_client = Client(**self.kwargs)
status_cmpl = Status.query.filter_by(code='CMPL').first()
# a status list which is suitable for Project instances
from stalker import StatusList, Project
project_statuses = StatusList(
name="Project Status List",
statuses=[status_new, status_wip, status_cmpl],
target_entity_type='Project' # you can also use Project which is the
# class itself
)
from stalker import Repository
# and the repository itself
commercial_repo = Repository(name="Commercial Repository")
new_project = Project(
name="Fancy Commercial",
code='FC',
status_list=project_statuses,
repositories=[commercial_repo],
)
import tzlocal
import datetime
from stalker import ImageFormat
new_project.description = \
"""The commercial is about this fancy product. The
client want us to have a shiny look with their
def test_generic_data_attribute_can_hold_a_wide_variety_of_object_types(
self):
"""testing if the generic_data attribute can hold any kind of object as
a list
"""
from stalker import db
db.setup()
new_simple_entity = SimpleEntity(**self.kwargs)
test_user = User(
name='email',
login='******',
email='*****@*****.**',
password='******',
)
from stalker import Department
test_department = Department(name='department1')
from stalker import Repository
test_repo = Repository(name='Test Repository')
from stalker import Structure
test_struct = Structure(name='Test Project Structure')
from stalker import Status, StatusList
test_project_status_list = StatusList(
name='Project Status List',
target_entity_type='Project',
statuses=[Status(name='Active', code='ACT')])
from stalker import Project
test_proj = Project(name='Test Project 1',
code='tp1',
repository=test_repo,
structure=test_struct,
status_list=test_project_status_list)
new_simple_entity.generic_data.extend([
test_proj, test_project_status_list, test_struct, test_repo,
test_department, test_user
])
DBSession.add(new_simple_entity)
DBSession.commit()
# now check if it is added to the database correctly
del new_simple_entity
new_simple_entity_db = SimpleEntity.query \
.filter_by(name=self.kwargs['name']) \
.first()
self.assertTrue(test_proj in new_simple_entity_db.generic_data)
self.assertTrue(
test_project_status_list in new_simple_entity_db.generic_data)
self.assertTrue(test_struct in new_simple_entity_db.generic_data)
self.assertTrue(test_repo in new_simple_entity_db.generic_data)
self.assertTrue(test_department in new_simple_entity_db.generic_data)
self.assertTrue(test_user in new_simple_entity_db.generic_data)
DBSession.remove()
def setUp(self):
"""set the test up
"""
super(EntityGroupTestCase, self).setUp()
from stalker import (Status, User, StatusList, Repository, Project,
Type, Asset, Task)
# create a couple of task
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.test_user1 = User(
name="User1",
login="******",
email="*****@*****.**",
password="******",
)
self.test_user2 = User(
name="User2",
login="******",
email="*****@*****.**",
password="******",
)
self.test_user3 = User(
name="User3",
login="******",
email="*****@*****.**",
password="******",
)
self.project_status_list = StatusList(
name="Project Status List",
statuses=[self.status_new, self.status_wip, self.status_cmpl],
target_entity_type="Project",
)
self.repo = Repository(
name='Test Repo',
code='TR',
linux_path='/mnt/M/JOBs',
windows_path='M:/JOBs',
osx_path='/Users/Shared/Servers/M',
)
self.project1 = Project(
name='Tests Project',
code='tp',
status_list=self.project_status_list,
repository=self.repo,
)
self.char_asset_type = Type(
name='Character Asset',
code='char',
target_entity_type="Asset"
)
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.asset_status_list = StatusList(
name='Asset 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='Asset'
)
self.asset1 = Asset(
name='Char1',
code='char1',
type=self.char_asset_type,
project=self.project1,
responsible=[self.test_user1],
status_list=self.asset_status_list
)
self.task1 = Task(
name="Test Task",
watchers=[self.test_user3],
parent=self.asset1,
schedule_timing=5,
schedule_unit='h',
bid_timing=52,
bid_unit='h',
status_list=self.task_status_list
)
self.child_task1 = Task(
name='Child Task 1',
resources=[self.test_user1, self.test_user2],
parent=self.task1,
status_list=self.task_status_list
)
self.child_task2 = Task(
name='Child Task 2',
resources=[self.test_user1, self.test_user2],
parent=self.task1,
status_list=self.task_status_list
)
self.task2 = Task(
name='Another Task',
project=self.project1,
resources=[self.test_user1],
responsible=[self.test_user2],
status_list=self.task_status_list
)
self.entity_group1 = EntityGroup(
name='My Tasks',
entities=[
self.task1, self.child_task2, self.task2
]
)
def setUp(self):
"""set up the test
"""
db.setup()
db.init()
self.user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
DBSession.add(self.user1)
self.user2 = User(name='Test User 2',
login='******',
email='*****@*****.**',
password='******')
DBSession.add(self.user2)
self.user3 = User(name='Test User 2',
login='******',
email='*****@*****.**',
password='******')
DBSession.add(self.user3)
# Review Statuses
self.status_new = Status.query.filter_by(code='NEW').first()
self.status_rrev = Status.query.filter_by(code='RREV').first()
self.status_app = Status.query.filter_by(code='APP').first()
# Task Statuses
self.status_wfd = Status.query.filter_by(code='WFD').first()
self.status_rts = Status.query.filter_by(code='RTS').first()
self.status_wip = Status.query.filter_by(code='WIP').first()
self.status_prev = Status.query.filter_by(code='PREV').first()
self.status_hrev = Status.query.filter_by(code='HREV').first()
self.status_drev = Status.query.filter_by(code='DREV').first()
self.status_cmpl = Status.query.filter_by(code='CMPL').first()
self.project_status_list = StatusList(
target_entity_type='Project',
statuses=[self.status_new, self.status_wip, self.status_cmpl])
DBSession.add(self.project_status_list)
self.temp_path = tempfile.mkdtemp()
self.repo = Repository(name='Test Repository',
linux_path=self.temp_path,
windows_path=self.temp_path,
osx_path=self.temp_path)
DBSession.add(self.repo)
self.structure = Structure(name='Test Project Structure')
DBSession.add(self.structure)
self.project = Project(name='Test Project',
code='TP',
status_list=self.project_status_list,
repository=self.repo)
DBSession.add(self.project)
self.task1 = Task(name='Test Task 1',
project=self.project,
resources=[self.user1],
responsible=[self.user2])
DBSession.add(self.task1)
self.task2 = Task(name='Test Task 2',
project=self.project,
responsible=[self.user1])
DBSession.add(self.task2)
self.task3 = Task(name='Test Task 3',
parent=self.task2,
resources=[self.user1])
DBSession.add(self.task3)
self.task4 = Task(name='Test Task 4',
project=self.project,
resources=[self.user1],
depends=[self.task3],
responsible=[self.user2],
schedule_timing=2,
schedule_unit='h')
DBSession.add(self.task4)
self.task5 = Task(name='Test Task 5',
project=self.project,
resources=[self.user2],
depends=[self.task3],
responsible=[self.user2],
schedule_timing=2,
schedule_unit='h')
DBSession.add(self.task5)
self.task6 = Task(name='Test Task 6',
project=self.project,
resources=[self.user3],
depends=[self.task3],
responsible=[self.user2],
schedule_timing=2,
schedule_unit='h')
DBSession.add(self.task6)
self.kwargs = {'task': self.task1, 'reviewer': self.user1}
#self.review = Review(**self.kwargs)
#DBSession.add(self.review)
# add everything to the db
DBSession.commit()
def setUp(self):
"""set up the test
"""
db.setup()
db.init()
# get statuses
self.status_new = Status.query.filter_by(code="NEW").first()
self.status_wfd = Status.query.filter_by(code="WFD").first()
self.status_rts = Status.query.filter_by(code="RTS").first()
self.status_wip = Status.query.filter_by(code="WIP").first()
self.status_prev = Status.query.filter_by(code="PREV").first()
self.status_hrev = Status.query.filter_by(code="HREV").first()
self.status_drev = Status.query.filter_by(code="DREV").first()
self.status_oh = Status.query.filter_by(code="OH").first()
self.status_stop = Status.query.filter_by(code="STOP").first()
self.status_cmpl = Status.query.filter_by(code="CMPL").first()
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
self.test_user2 = User(name='Test User 2',
login='******',
email='*****@*****.**',
password='******')
self.test_user3 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
self.test_repo = Repository(name='Test Repository')
self.test_structure = Structure(name='test structure')
# project status list
self.test_project_status_list = StatusList(
name='Project Statuses',
target_entity_type='Project',
statuses=[
self.status_new, self.status_wip, self.status_oh,
self.status_stop, self.status_cmpl
])
self.test_project1 = Project(name='Test Project 1',
code='TP1',
repository=self.test_repo,
structure=self.test_structure,
status_list=self.test_project_status_list)
# create three Tasks
self.test_task1 = Task(name='Test Task 1', project=self.test_project1)
self.test_task2 = Task(name='Test Task 2', project=self.test_project1)
self.test_task3 = Task(name='Test Task 3', project=self.test_project1)
# add everything to db
DBSession.add_all([
self.test_project1, self.test_project_status_list, self.test_repo,
self.test_structure, self.test_task1, self.test_task2,
self.test_task3, self.test_user1, self.test_user2
])
DBSession.commit()
self.kwargs = {
'task': self.test_task1,
'depends_to': self.test_task2,
'dependency_target': 'onend',
'gap_timing': 0,
'gap_unit': 'h',
'gap_model': 'length'
}
def setUp(self):
"""set up the test
"""
super(TaskDependencyTestDBCase, self).setUp()
from stalker.db.session import DBSession
from stalker import User
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
DBSession.add(self.test_user1)
self.test_user2 = User(name='Test User 2',
login='******',
email='*****@*****.**',
password='******')
DBSession.add(self.test_user2)
self.test_user3 = User(name='Test User 3',
login='******',
email='*****@*****.**',
password='******')
DBSession.add(self.test_user3)
from stalker import Repository
self.test_repo = Repository(name='Test Repository')
DBSession.add(self.test_repo)
from stalker import Structure
self.test_structure = Structure(name='test structure')
DBSession.add(self.test_structure)
from stalker import Project
self.test_project1 = Project(
name='Test Project 1',
code='TP1',
repository=self.test_repo,
structure=self.test_structure,
)
DBSession.add(self.test_project1)
DBSession.commit()
# create three Tasks
from stalker import Task
self.test_task1 = Task(name='Test Task 1', project=self.test_project1)
DBSession.add(self.test_task1)
self.test_task2 = Task(name='Test Task 2', project=self.test_project1)
DBSession.add(self.test_task2)
self.test_task3 = Task(name='Test Task 3', project=self.test_project1)
DBSession.add(self.test_task3)
DBSession.commit()
self.kwargs = {
'task': self.test_task1,
'depends_to': self.test_task2,
'dependency_target': 'onend',
'gap_timing': 0,
'gap_unit': 'h',
'gap_model': 'length'
}
def setUp(self):
"""setup the test
"""
super(SceneTester, self).setUp()
# create statuses
from stalker import db, Status, StatusList
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_status4 = Status(name="Status4", code="STS4")
self.test_status5 = Status(name="Status5", code="STS5")
# create a test project, user and a couple of shots
from stalker import Type
self.project_type = Type(
name="Test Project Type",
code='test',
target_entity_type='Project',
)
# create a status list for project
self.project_status_list = StatusList(
name="Project Statuses",
statuses=[
self.test_status1,
self.test_status2,
self.test_status3,
self.test_status4,
self.test_status5,
],
target_entity_type='Project',
)
# create a repository
self.repository_type = Type(name="Test Type",
code='test',
target_entity_type='Repository')
from stalker import Repository
self.test_repository = Repository(
name="Test Repository",
type=self.repository_type,
)
# create projects
from stalker import Project
self.test_project = Project(
name="Test Project 1",
code='tp1',
type=self.project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
self.test_project2 = Project(
name="Test Project 2",
code='tp2',
type=self.project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
# the parameters
self.kwargs = {
"name": "Test Scene",
'code': 'tsce',
"description": "A test scene",
"project": self.test_project,
}
# the test sequence
self.test_scene = Scene(**self.kwargs)
db.DBSession.add(self.test_scene)
db.DBSession.commit()
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):
"""set the test up
"""
from stalker import (db, defaults, Status, User, StatusList,
Repository, Project, Type, Asset, Task)
defaults.timing_resolution = datetime.timedelta(hours=1)
# # clean up test database
db.setup(self.config)
db.init()
# create a couple of task
self.status_new = Status.query.filter(Status.code == 'NEW').first()
self.status_wip = Status.query.filter(Status.code == 'WIP').first()
self.status_cmpl = \
Status.query.filter(Status.code == 'CMPL').first()
self.test_user1 = User(
name="User1",
login="******",
email="*****@*****.**",
password="******",
)
self.test_user2 = User(
name="User2",
login="******",
email="*****@*****.**",
password="******",
)
self.test_user3 = User(
name="User3",
login="******",
email="*****@*****.**",
password="******",
)
self.project_status_list = StatusList(
name="Project Status List",
statuses=[self.status_new, self.status_wip, self.status_cmpl],
target_entity_type="Project",
)
self.repo = Repository(
name='Test Repo',
linux_path='/mnt/M/JOBs',
windows_path='M:/JOBs',
osx_path='/Users/Shared/Servers/M',
)
self.project1 = Project(
name='Tests Project',
code='tp',
status_list=self.project_status_list,
repository=self.repo,
)
self.char_asset_type = Type(name='Character Asset',
code='char',
target_entity_type="Asset")
self.asset1 = Asset(name='Char1',
code='char1',
type=self.char_asset_type,
project=self.project1,
responsible=[self.test_user1])
self.task1 = Task(name="Test Task",
watchers=[self.test_user3],
parent=self.asset1,
schedule_timing=5,
schedule_unit='h',
bid_timing=52,
bid_unit='h')
self.child_task1 = Task(
name='Child Task 1',
resources=[self.test_user1, self.test_user2],
parent=self.task1,
)
self.child_task2 = Task(
name='Child Task 2',
resources=[self.test_user1, self.test_user2],
parent=self.task1,
)
self.task2 = Task(name='Another Task',
project=self.project1,
resources=[self.test_user1],
responsible=[self.test_user2])
self.entity_group1 = EntityGroup(
name='My Tasks',
entities=[self.task1, self.child_task2, self.task2])
db.DBSession.add_all([
self.task1, self.child_task1, self.child_task2, self.task2,
self.test_user1, self.test_user2, self.project1, self.status_cmpl,
self.status_new, self.status_wip, self.asset1
])
db.DBSession.commit()
def setUpClass(cls):
"""setup once
"""
# remove the transaction manager
db.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')
db.DBSession.add(cls.power_users_group)
db.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(
name='Project Statuses',
statuses=[cls.status_new, cls.status_wip, cls.status_cmpl],
target_entity_type=Project)
# 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='******')
db.DBSession.add(cls.test_user1)
db.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
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
])
db.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')
db.DBSession.add(cls.test_version1)
db.DBSession.commit()
cls.test_version2 = Version(cls.test_task1,
created_by=cls.admin,
created_with='Test',
description='Test Description')
db.DBSession.add(cls.test_version2)
db.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
db.DBSession.add(cls.test_version3)
db.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
db.DBSession.add(cls.test_version4)
db.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_creator.MainDialog()
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)
def setUp(self):
"""create the test data
"""
super(TaskViewUnitTestCase, self).setUp()
from stalker import db
from stalker import User
self.test_user1 = User(
name='Test User 1',
login='******',
email='*****@*****.**',
password='******'
)
db.DBSession.add(self.test_user1)
self.test_user2 = User(
name='Test User 2',
login='******',
email='*****@*****.**',
password='******'
)
db.DBSession.add(self.test_user2)
self.test_user3 = User(
name='Test User 3',
login='******',
email='*****@*****.**',
password='******'
)
db.DBSession.add(self.test_user3)
db.DBSession.commit()
from stalker import Status
self.status_rts = Status.query.filter(Status.code == 'RTS').first()
self.status_new = Status.query.filter(Status.code == 'NEW').first()
self.status_wip = Status.query.filter(Status.code == 'WIP').first()
self.status_cmpl = Status.query.filter(Status.code == 'CMPL').first()
from stalker import StatusList
self.test_project_status_list = StatusList(
name='Project Statuses',
statuses=[self.status_new, self.status_wip, self.status_cmpl],
target_entity_type='Project'
)
db.DBSession.add(self.test_project_status_list)
db.DBSession.commit()
from stalker import Repository
self.test_repo1 = Repository(
name='Test Repository',
linux_path='/mnt/T/',
windows_path='T:/',
osx_path='/Volumes/T'
)
db.DBSession.add(self.test_repo1)
from stalker import Project
self.test_project1 = Project(
name='Test Project 1',
code='TP1',
status_list=self.test_project_status_list,
repositories=[self.test_repo1]
)
db.DBSession.add(self.test_project1)
db.DBSession.commit()
from stalker import Task
self.test_task1 = Task(
name='Test Task 1',
project=self.test_project1,
responsible=[self.test_user3],
created_by=self.admin,
)
db.DBSession.add(self.test_task1)
self.test_task2 = Task(
name='Test Task 2',
parent=self.test_task1,
resources=[self.test_user1, self.test_user2],
schedule_timing=10,
schedule_unit='h',
created_by=self.admin,
)
db.DBSession.add(self.test_task2)
self.test_task3 = Task(
name='Test Task 3',
parent=self.test_task1,
resources=[self.test_user2],
schedule_timing=10,
schedule_unit='h',
created_by=self.admin,
)
db.DBSession.add(self.test_task3)
db.DBSession.commit()
def setUp(self):
"""set up the test
"""
# create the db
DBSession.remove()
db.setup()
# db.init()
# we just need statuses so create them instead of initializing the db
db.create_ticket_statuses()
db.create_entity_statuses(entity_type='Task',
status_names=defaults.task_status_names,
status_codes=defaults.task_status_codes)
db.create_entity_statuses(entity_type='Asset',
status_names=defaults.task_status_names,
status_codes=defaults.task_status_codes)
db.create_entity_statuses(entity_type='Shot',
status_names=defaults.task_status_names,
status_codes=defaults.task_status_codes)
db.create_entity_statuses(entity_type='Sequence',
status_names=defaults.task_status_names,
status_codes=defaults.task_status_codes)
db.create_entity_statuses(entity_type='Review',
status_names=defaults.review_status_names,
status_codes=defaults.review_status_codes)
# create statuses
self.test_status1 = Status(name='N', code='N')
self.test_status2 = Status(name='R', code='R')
# get the ticket types
ticket_types = Type.query \
.filter(Type.target_entity_type == 'Ticket').all()
self.ticket_type_1 = ticket_types[0]
self.ticket_type_2 = ticket_types[1]
# create a User
self.test_user = User(name='Test User',
login='******',
email='*****@*****.**',
password='******')
# create a Repository
self.test_repo = Repository(name="Test Repo")
# create a Project Type
self.test_project_type = Type(
name='Commercial Project',
code='comm',
target_entity_type=Project,
)
# create a Project StatusList
self.test_project_status1 = Status(name='PrjStat1', code='PrjStat1')
self.test_project_status2 = Status(name='PrjStat2', code='PrjStat2')
self.test_project_status_list = StatusList(
name="Project Status List",
target_entity_type=Project,
statuses=[
self.test_project_status1,
self.test_project_status2,
])
self.test_task_status_list = StatusList.query\
.filter_by(target_entity_type='Task').first()
# create a Project
self.test_project = Project(name="Test Project 1",
code="TEST_PROJECT_1",
type=self.test_project_type,
repository=self.test_repo,
status_list=self.test_project_status_list)
# create an Asset
self.test_asset_status_list = StatusList.query\
.filter_by(target_entity_type='Asset').first()
self.test_asset_type = Type(name='Character Asset',
code='char',
target_entity_type=Asset)
self.test_asset = Asset(name="Test Asset",
code='ta',
project=self.test_project,
status_list=self.test_asset_status_list,
type=self.test_asset_type)
# create a Task
self.test_task = Task(name="Modeling of Asset 1",
resources=[self.test_user],
status_list=self.test_task_status_list,
parent=self.test_asset)
# create a Version
self.test_version_status_list = StatusList(
name='Version Statuses',
target_entity_type=Version,
statuses=[self.test_status1, self.test_status2])
self.test_version = Version(name='Test Version',
task=self.test_task,
status_list=self.test_version_status_list,
version=1,
full_path='some/path')
# create the Ticket
self.kwargs = {
'project': self.test_project,
'links': [self.test_version],
'summary': 'This is a test ticket',
'description': 'This is the long description',
'priority': 'TRIVIAL',
'reported_by': self.test_user,
}
self.test_ticket = Ticket(**self.kwargs)
DBSession.add(self.test_ticket)
DBSession.commit()
# get the Ticket Statuses
self.status_new = Status.query.filter_by(name='New').first()
self.status_accepted = Status.query.filter_by(name='Accepted').first()
self.status_assigned = Status.query.filter_by(name='Assigned').first()
self.status_reopened = Status.query.filter_by(name='Reopened').first()
self.status_closed = Status.query.filter_by(name='Closed').first()
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',
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):
"""set up the test
"""
super(TicketTester, self).setUp()
# create statuses
from stalker import Status
self.test_status1 = Status(name='N', code='N')
self.test_status2 = Status(name='R', code='R')
# get the ticket types
from stalker import Type
ticket_types = Type.query \
.filter(Type.target_entity_type == 'Ticket').all()
self.ticket_type_1 = ticket_types[0]
self.ticket_type_2 = ticket_types[1]
# create a User
from stalker import User
self.test_user = User(
name='Test User',
login='******',
email='*****@*****.**',
password='******'
)
# create a Repository
from stalker import Repository
self.test_repo = Repository(name="Test Repo")
# create a Project Type
self.test_project_type = Type(
name='Commercial Project',
code='comm',
target_entity_type='Project',
)
# create a Project StatusList
self.test_project_status1 = Status(name='PrjStat1', code='PrjStat1')
self.test_project_status2 = Status(name='PrjStat2', code='PrjStat2')
# create a Project
from stalker import Project
self.test_project = Project(
name="Test Project 1",
code="TEST_PROJECT_1",
type=self.test_project_type,
repository=self.test_repo,
)
from stalker.db.session import DBSession
DBSession.add(self.test_project)
DBSession.commit()
self.test_asset_type = Type(
name='Character Asset',
code='char',
target_entity_type='Asset'
)
from stalker import Asset
self.test_asset = Asset(
name="Test Asset",
code='ta',
project=self.test_project,
type=self.test_asset_type
)
DBSession.add(self.test_asset)
DBSession.commit()
# create a Task
from stalker import Task
self.test_task = Task(
name="Modeling of Asset 1",
resources=[self.test_user],
parent=self.test_asset
)
DBSession.add(self.test_task)
DBSession.commit()
from stalker import Version
self.test_version = Version(
name='Test Version',
task=self.test_task,
version=1,
full_path='some/path'
)
# create the Ticket
self.kwargs = {
'project': self.test_project,
'links': [self.test_version],
'summary': 'This is a test ticket',
'description': 'This is the long description',
'priority': 'TRIVIAL',
'reported_by': self.test_user,
}
from stalker import Ticket
self.test_ticket = Ticket(**self.kwargs)
DBSession.add(self.test_ticket)
DBSession.commit()
# get the Ticket Statuses
self.status_new = Status.query.filter_by(name='New').first()
self.status_accepted = Status.query.filter_by(name='Accepted').first()
self.status_assigned = Status.query.filter_by(name='Assigned').first()
self.status_reopened = Status.query.filter_by(name='Reopened').first()
self.status_closed = Status.query.filter_by(name='Closed').first()
def setUp(self):
"""create test data
"""
database_url = 'sqlite:///:memory:'
db.setup({'sqlalchemy.url': database_url})
db.init()
self.temp_repo_path = tempfile.mkdtemp()
self.user1 = User(name='User 1',
login='******',
email='*****@*****.**',
password='******')
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)
# create task hierarchy
#
# ASSETS
#
self.assets = Task(name='Assets',
project=self.project,
responsible=[self.user1])
#
# SEQUENCES
#
self.sequences = Task(name='Sequences',
project=self.project,
responsible=[self.user1])
self.seq001 = Sequence(name='Seq001',
code='Seq001',
parent=self.sequences)
self.scene_task = Task(name='001_IST', parent=self.seq001)
self.scene_previs_type = Type(name='Scene Previs',
code='Scene Previs',
target_entity_type='Task')
self.scene_previs = Task(name='Scene Previs',
parent=self.scene_task,
type=self.scene_previs_type)
self.shots = Task(name='Shots', parent=self.scene_task)
self.shot1 = Shot(name='Seq001_001_IST_0010',
code='Seq001_001_IST_0010',
parent=self.shots)
# create shot tasks
self.previs = Task(name='Previs', parent=self.shot1)
self.camera = Task(name='Camera', parent=self.shot1)
self.animation = Task(name='Animation', parent=self.shot1)
self.scene_assembly = Task(name='SceneAssembly', parent=self.shot1)
self.lighting = Task(name='Lighting', parent=self.shot1)
self.comp = Task(name='Comp', parent=self.shot1)
# create maya files
self.maya_env = Maya()
pm.newFile(force=True)
sm = pm.PyNode('sequenceManager1')
seq1 = sm.create_sequence('001_IST')
# create 3 shots
shot1 = seq1.create_shot('shot1')
shot2 = seq1.create_shot('shot2')
shot3 = seq1.create_shot('shot3')
# set shot ranges
shot1.startFrame.set(1)
shot1.endFrame.set(100)
shot2.startFrame.set(101)
shot2.endFrame.set(200)
shot2.sequenceStartFrame.set(101)
shot3.startFrame.set(201)
shot3.endFrame.set(300)
shot3.sequenceStartFrame.set(201)
# save the file under scene previs
v = Version(task=self.scene_previs)
self.maya_env.save_as(v)
pm.newFile(force=1)
print(v.absolute_full_path)
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')
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()
