def setUp(self):
"""setup the test
"""
super(SequenceTester, self).setUp()
# 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',
)
from stalker.db.session import DBSession
DBSession.add(self.project_type)
# create a repository
self.repository_type = Type(
name="Test Type",
code='test',
target_entity_type='Repository'
)
DBSession.add(self.repository_type)
from stalker import Repository
self.test_repository = Repository(
name="Test Repository",
type=self.repository_type,
)
DBSession.add(self.test_repository)
# create projects
from stalker import Project
self.test_project = Project(
name="Test Project 1",
code='tp1',
type=self.project_type,
repository=self.test_repository,
)
DBSession.add(self.test_project)
self.test_project2 = Project(
name="Test Project 2",
code='tp2',
type=self.project_type,
repository=self.test_repository,
)
DBSession.add(self.test_project2)
# the parameters
self.kwargs = {
"name": "Test Sequence",
'code': 'tseq',
"description": "A test sequence",
"project": self.test_project,
}
# the test sequence
from stalker import Sequence
self.test_sequence = Sequence(**self.kwargs)
DBSession.commit()
def test_number_attribute_is_not_created_per_project(self):
"""testing if the number attribute is not created per project and
continues to increase for every created ticket
"""
from stalker import Project
proj1 = Project(name='Test Project 1',
code='TP1',
repository=self.test_repo,
status_list=self.test_project_status_list)
proj2 = Project(name='Test Project 2',
code='TP2',
repository=self.test_repo,
status_list=self.test_project_status_list)
proj3 = Project(name='Test Project 3',
code='TP3',
repository=self.test_repo,
status_list=self.test_project_status_list)
from stalker import db, Ticket
p1_t1 = Ticket(project=proj1)
db.DBSession.add(p1_t1)
db.DBSession.commit()
self.assertEqual(p1_t1.number, 2)
p1_t2 = Ticket(project=proj1)
db.DBSession.add(p1_t2)
db.DBSession.commit()
self.assertEqual(p1_t2.number, 3)
p2_t1 = Ticket(project=proj2)
db.DBSession.add(p2_t1)
db.DBSession.commit()
self.assertEqual(p2_t1.number, 4)
p1_t3 = Ticket(project=proj1)
db.DBSession.add(p1_t3)
db.DBSession.commit()
self.assertEqual(p1_t3.number, 5)
p3_t1 = Ticket(project=proj3)
db.DBSession.add(p3_t1)
db.DBSession.commit()
self.assertEqual(p3_t1.number, 6)
p2_t2 = Ticket(project=proj2)
db.DBSession.add(p2_t2)
db.DBSession.commit()
self.assertEqual(p2_t2.number, 7)
p3_t2 = Ticket(project=proj3)
db.DBSession.add(p3_t2)
db.DBSession.commit()
self.assertEqual(p3_t2.number, 8)
p2_t3 = Ticket(project=proj2)
db.DBSession.add(p2_t3)
db.DBSession.commit()
self.assertEqual(p2_t3.number, 9)
def setUp(self):
"""setup the test
"""
# create a repository
self.repository_type = Type(name="Test Repository Type",
code='testproj',
target_entity_type=Repository)
self.test_repository = Repository(
name="Test Repository",
type=self.repository_type,
)
# statuses
self.status1 = Status(name="Status1", code="STS1")
self.status2 = Status(name="Status2", code="STS2")
self.status3 = Status(name="Status3", code="STS3")
# project status list
self.project_status_list = StatusList(name="Project Status List",
statuses=[
self.status1,
self.status2,
self.status3,
],
target_entity_type=Project)
# project type
self.test_project_type = Type(
name="Test Project Type",
code='testproj',
target_entity_type=Project,
)
# create projects
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,
)
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,
)
self.kwargs = {
"name": "Test Class",
"project": self.test_project1,
}
self.test_foo_obj = ProjMixClass(**self.kwargs)
def test_projects_attribute_is_working_properly(self):
"""testing if the projects attribute is working properly
"""
dp1 = Project(name='Dummy Project',
code='DP',
repository=self.test_repo)
dp2 = Project(name='Dummy Project',
code='DP',
repository=self.test_repo)
tjp = TaskJugglerScheduler(compute_resources=True)
tjp.projects = [dp1, dp2]
self.assertEqual(tjp.projects, [dp1, dp2])
def test_projects_argument_is_working_properly(self):
"""testing if the projects argument value is correctly passed to the
projects attribute
"""
dp1 = Project(name='Dummy Project',
code='DP',
repository=self.test_repo)
dp2 = Project(name='Dummy Project',
code='DP',
repository=self.test_repo)
tjp = TaskJugglerScheduler(compute_resources=True, projects=[dp1, dp2])
self.assertEqual(tjp.projects, [dp1, dp2])
def setUp(self):
"""set the test up
"""
from stalker import Status, StatusList, Repository
self.test_repo = Repository(name='Test Repo')
self.status_new = Status(name='New', code='NEW')
self.status_wip = Status(name='Work In Progress', code='WIP')
self.status_cmpl = Status(name='Completed', code='CMPL')
self.project_statuses = StatusList(
name='Project Status List',
statuses=[self.status_new, self.status_wip, self.status_cmpl],
target_entity_type='Project')
from stalker import User
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
from stalker import Project
self.test_project = Project(name='Test Project 1',
code='TP1',
repositories=[self.test_repo],
status_list=self.project_statuses)
from stalker import Role
self.test_role = Role(name='Test User')
def test_tasks_of_given_projects_are_correctly_scheduled(self):
"""testing if the tasks of given projects are correctly scheduled
"""
# create a dummy project
# create a dummy Project to schedule
dummy_project = Project(name='Dummy Project',
code='DP',
repository=self.test_repo)
dt1 = Task(name='Dummy Task 1',
project=dummy_project,
schedule_timing=4,
schedule_unit='h',
resources=[self.test_user1])
dt2 = Task(name='Dummy Task 2',
project=dummy_project,
schedule_timing=4,
schedule_unit='h',
resources=[self.test_user2])
db.DBSession.add_all([dummy_project, dt1, dt2])
db.DBSession.commit()
tjp_sched = TaskJugglerScheduler(compute_resources=True,
projects=[dummy_project])
test_studio = Studio(name='Test Studio',
now=datetime.datetime(2013, 4, 16, 0, 0))
test_studio.start = datetime.datetime(2013, 4, 16, 0, 0)
test_studio.end = datetime.datetime(2013, 4, 30, 0, 0)
test_studio.daily_working_hours = 9
DBSession.add(test_studio)
db.DBSession.commit()
tjp_sched.studio = test_studio
tjp_sched.schedule()
db.DBSession.commit()
# check if the task and project timings are all adjusted
self.assertEqual(self.test_proj1.computed_start, None)
self.assertEqual(self.test_proj1.computed_end, None)
self.assertEqual(self.test_task1.computed_start, None)
self.assertEqual(self.test_task1.computed_end, None)
self.assertEqual(self.test_task1.computed_resources,
[self.test_user1, self.test_user2])
self.assertEqual(self.test_task2.computed_start, None)
self.assertEqual(self.test_task2.computed_end, None)
self.assertEqual(self.test_task2.computed_resources,
[self.test_user1, self.test_user2])
self.assertEqual(dt1.computed_start,
datetime.datetime(2013, 4, 16, 9, 0))
self.assertEqual(dt1.computed_end,
datetime.datetime(2013, 4, 16, 13, 0))
self.assertEqual(dt2.computed_start,
datetime.datetime(2013, 4, 16, 9, 0))
self.assertEqual(dt2.computed_end,
datetime.datetime(2013, 4, 16, 13, 0))
def setUp(self):
"""set the test up
"""
super(ProjectUserTestDBCase, self).setUp()
from stalker import Repository
self.test_repo = Repository(name='Test Repo')
from stalker.db.session import DBSession
DBSession.add(self.test_repo)
DBSession.commit()
from stalker import User
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
DBSession.add(self.test_user1)
from stalker import Project
self.test_project = Project(
name='Test Project 1',
code='TP1',
repositories=[self.test_repo],
)
DBSession.add(self.test_project)
from stalker import Role
self.test_role = Role(name='Test User')
DBSession.add(self.test_role)
DBSession.commit()
def setUp(self):
"""set the test up
"""
super(ProjectClientTestDBCase, self).setUp()
from stalker import Status, Repository
self.test_repo = Repository(name='Test Repo')
self.status_new = Status(name='New', code='NEW')
self.status_wip = Status(name='Work In Progress', code='WIP')
self.status_cmpl = Status(name='Completed', code='CMPL')
from stalker import User
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
from stalker import Client
self.test_client = Client(name='Test Client')
from stalker import Project
self.test_project = Project(
name='Test Project 1',
code='TP1',
repositories=[self.test_repo],
)
from stalker import Role
self.test_role = Role(name='Test Client')
def test_ProjectMixin_initialization(self):
"""testing if the ProjectMixin part is initialized correctly
"""
from stalker import Status, StatusList
status1 = Status(name="On Hold", code="OH")
project_status_list = StatusList(
name="Project Statuses", statuses=[status1],
target_entity_type='Project'
)
from stalker import Type
project_type = Type(
name="Commercial",
code='comm',
target_entity_type='Project'
)
from stalker import Project
new_project = Project(
name="Test Project",
code='tp',
status=project_status_list[0],
status_list=project_status_list,
type=project_type,
repository=self.test_repository
)
from stalker import Sequence
self.kwargs["project"] = new_project
new_sequence = Sequence(**self.kwargs)
self.assertEqual(new_sequence.project, new_project)
def setUp(self):
"""setting up the test
"""
super(PageTester, self).setUp()
# create a repository
from stalker import Type
self.repository_type = Type(name="Test Repository Type",
code='test_repo',
target_entity_type='Repository')
from stalker import Repository
self.test_repository = Repository(
name="Test Repository",
code="TR",
type=self.repository_type,
)
# 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")
# 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')
# project type
self.test_project_type = Type(
name="Test Project Type",
code='testproj',
target_entity_type='Project',
)
# 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,
)
self.kwargs = {
'title': 'Test Page Title',
'content': 'Test content',
'project': self.test_project1
}
self.test_page = Page(**self.kwargs)
def setUp(self):
"""set up the test
"""
db.setup()
db.init()
self.temp_path = tempfile.mkdtemp()
self.repo = Repository(
name='Test Repository',
linux_path=self.temp_path,
windows_path=self.temp_path,
osx_path=self.temp_path
)
self.status_new = Status.query.filter_by(code='NEW').first()
self.status_wip = Status.query.filter_by(code='WIP').first()
self.status_cmpl = Status.query.filter_by(code='CMPL').first()
self.project_status_list = \
StatusList.query.filter_by(target_entity_type='Project').first()
self.task_filename_template = FilenameTemplate(
name='Task Filename Template',
target_entity_type='Task',
path='{{project.code}}/{%- for parent_task in parent_tasks -%}'
'{{parent_task.nice_name}}/{%- endfor -%}',
filename='{{version.nice_name}}'
'_v{{"%03d"|format(version.version_number)}}{{extension}}'
)
self.project_structure = Structure(
name='Project Structure',
templates=[self.task_filename_template]
)
self.project = Project(
name='Test Project',
code='TP',
status_list=self.project_status_list,
repository=self.repo,
structure=self.project_structure
)
self.task = Task(
name='Test Task',
project=self.project
)
from stalker.db.session import DBSession
DBSession.add(self.task)
DBSession.commit()
self.version = Version(
task=self.task
)
self.kwargs = {
'name': 'Photoshop',
'extensions': ['psd'],
'structure': ['Outputs']
}
self.external_env = ExternalEnv(**self.kwargs)
def setUp(self):
"""setup the test
"""
# create a resource
self.test_resource1 = User(
name="User1",
login="******",
email="*****@*****.**",
password="******",
)
self.test_resource2 = User(
name="User2",
login="******",
email="*****@*****.**",
password="******"
)
self.test_repo = Repository(name="test repository")
# create a Project
self.test_status1 = Status(name="Status1", code="STS1")
self.test_status2 = Status(name="Status2", code="STS2")
self.test_status3 = Status(name="Status3", code="STS3")
self.test_project_status_list = StatusList(
name="Project Statuses",
statuses=[self.test_status1],
target_entity_type=Project
)
self.test_task_status_list = StatusList.query\
.filter_by(target_entity_type='Task').first()
self.test_project = Project(
name="test project",
code='tp',
repository=self.test_repo,
status_list=self.test_project_status_list
)
# create a Task
self.test_task = Task(
name="test task",
project=self.test_project,
status_list=self.test_task_status_list
)
self.kwargs = {
"task": self.test_task,
"resource": self.test_resource1,
"start": datetime.datetime(2013, 3, 22, 1, 0),
"duration": datetime.timedelta(10)
}
# create a TimeLog
# and test it
self.test_time_log = TimeLog(**self.kwargs)
def setUpClass(cls):
"""setup once
"""
db.setup()
db.init()
cls.status_new = Status.query.filter_by(code='NEW').first()
cls.status_wip = Status.query.filter_by(code='WIP').first()
cls.status_cmpl = Status.query.filter_by(code='CMPL').first()
cls.test_project_status_list = StatusList(
name='Project Statuses',
target_entity_type='Project',
statuses=[cls.status_new, cls.status_wip, cls.status_cmpl])
cls.test_repo = Repository(name='Test Repository')
cls.test_project = Project(name='Test Project',
code='TP',
repository=cls.test_repo,
status_list=cls.test_project_status_list)
cls.test_task1 = Task(name='Test Task 1', project=cls.test_project)
cls.test_task2 = Task(name='Test Task 2', project=cls.test_project)
cls.test_task3 = Task(name='Test Task 3', project=cls.test_project)
cls.test_version1 = Version(task=cls.test_task1)
db.DBSession.add(cls.test_version1)
db.DBSession.commit()
cls.test_version2 = Version(task=cls.test_task1)
db.DBSession.add(cls.test_version2)
db.DBSession.commit()
cls.test_version3 = Version(task=cls.test_task1)
db.DBSession.add(cls.test_version3)
db.DBSession.commit()
cls.test_version4 = Version(task=cls.test_task2)
db.DBSession.add(cls.test_version4)
db.DBSession.commit()
cls.test_link1 = Link(original_filename='test_render1.jpg')
cls.test_link2 = Link(original_filename='test_render2.jpg')
cls.test_link3 = Link(original_filename='test_render3.jpg')
cls.test_link4 = Link(original_filename='test_render4.jpg')
cls.test_version1.outputs = [
cls.test_link1, cls.test_link2, cls.test_link3
]
cls.test_version4.outputs = [cls.test_link4]
db.DBSession.add_all([
cls.test_task1, cls.test_task2, cls.test_task3, cls.test_version1,
cls.test_version2, cls.test_version3, cls.test_version4,
cls.test_link1, cls.test_link2, cls.test_link3, cls.test_link4
])
db.DBSession.commit()
def test_projects_argument_is_not_iterable(self):
"""testing if a TypeError will be raised when the given projects
argument is not an instance of list
"""
from stalker import Project
self.kwargs["projects"] = "a project"
with self.assertRaises(TypeError) as cm:
Project(**self.kwargs)
self.assertEqual(str(cm.exception), 'Project.code cannot be None')
def create_project():
"""creates test data
"""
from stalker import Repository, Project
repo = Repository(name='Test Repository',
windows_path='T:/',
linux_path='/mnt/T/',
osx_path='/Volumes/T/')
project = Project(name='Test Project', code='TP', repository=repo)
yield project
def test_TaskMixin_initialization(self):
"""testing if the TaskMixin part is initialized correctly
"""
from stalker import StatusList
project_status_list = \
StatusList.query\
.filter(StatusList.target_entity_type=='Project').first()
from stalker import Type
project_type = Type(
name="Commercial",
code='comm',
target_entity_type='Project'
)
from stalker import Project
new_project = Project(
name="Commercial1",
code='comm1',
status_list=project_status_list,
type=project_type,
repository=self.test_repository,
)
from stalker.db.session import DBSession
DBSession.add(new_project)
DBSession.commit()
self.kwargs['project'] = new_project
self.kwargs['code'] = "SH12314"
from stalker import Task
new_shot = Shot(**self.kwargs)
task1 = Task(
name="Modeling", status=0,
project=new_project,
parent=new_shot,
)
task2 = Task(
name="Lighting",
status=0,
project=new_project,
parent=new_shot,
)
tasks = [task1, task2]
assert \
sorted(new_shot.tasks, key=lambda x: x.name) == \
sorted(tasks, key=lambda x: x.name)
def test_TaskableEntity_initialization(self):
"""testing if the TaskableEntity part is initialized correctly
"""
from stalker import Status, StatusList
status1 = Status(name="On Hold", code="OH")
project_status_list = StatusList(
name="Project Statuses", statuses=[status1],
target_entity_type='Project',
)
from stalker import Type, Project, Sequence, Task
project_type = Type(
name="Commercial",
code='comm',
target_entity_type='Project'
)
new_project = Project(
name="Commercial",
code='comm',
status_list=project_status_list,
type=project_type,
repository=self.test_repository,
)
self.kwargs["new_project"] = new_project
new_sequence = Sequence(**self.kwargs)
task1 = Task(
name="Modeling",
status=0,
project=new_project,
parent=new_sequence,
)
task2 = Task(
name="Lighting",
status=0,
project=new_project,
parent=new_sequence,
)
tasks = [task1, task2]
self.assertEqual(
sorted(new_sequence.tasks, key=lambda x: x.name),
sorted(tasks, key=lambda x: x.name)
)
def test_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
"""
new_simple_entity = SimpleEntity(**self.kwargs)
from stalker import User
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',
code='TR',
)
from stalker import Structure
test_struct = Structure(name='Test Project Structure')
from stalker import Project
test_proj = Project(
name='Test Project 1',
code='tp1',
repository=test_repo,
structure=test_struct,
)
new_simple_entity.generic_data.extend(
[test_proj, test_struct, test_repo, test_department, test_user])
# 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()
assert test_proj in new_simple_entity_db.generic_data
assert test_struct in new_simple_entity_db.generic_data
assert test_repo in new_simple_entity_db.generic_data
assert test_department in new_simple_entity_db.generic_data
assert test_user in new_simple_entity_db.generic_data
def test_TaskMixin_initialization(self):
"""testing if the TaskMixin part is initialized correctly
"""
commercial_project_type = Type(
name="Commercial",
code='comm',
target_entity_type=Project,
)
new_project = Project(
name="Commercial",
code='COM',
type=commercial_project_type,
status_list=self.project_status_list,
repository=self.repository,
)
character_asset_type = Type(
name="Character",
code='char',
target_entity_type=Asset
)
new_asset = Asset(
name="test asset",
type=character_asset_type,
code="tstasset",
project=new_project,
responsible=[self.test_user1]
)
task1 = Task(
name="Modeling",
parent=new_asset
)
task2 = Task(
name="Lighting",
parent=new_asset
)
tasks = [task1, task2]
self.assertEqual(
sorted(new_asset.tasks, key=lambda x: x.name),
sorted(tasks, key=lambda x: x.name)
)
def test_ProjectMixin_initialization(self):
"""testing if the ProjectMixin part is initialized correctly
"""
from stalker import Type
project_type = Type(name="Commercial",
code='comm',
target_entity_type='Project')
from stalker import Project
new_project = Project(name="Test Project",
code='tp',
type=project_type,
repository=self.test_repository)
self.kwargs["project"] = new_project
new_scene = Scene(**self.kwargs)
assert new_scene.project == new_project
def test_TaskMixin_initialization(self):
"""testing if the TaskMixin part is initialized correctly
"""
from stalker import Type, Project, Asset, Task
commercial_project_type = Type(
name="Commercial",
code='comm',
target_entity_type='Project',
)
new_project = Project(
name="Commercial",
code='COM',
type=commercial_project_type,
repository=self.repository,
)
character_asset_type = Type(
name="Character",
code='char',
target_entity_type='Asset'
)
new_asset = Asset(
name="test asset",
type=character_asset_type,
code="tstasset",
project=new_project,
responsible=[self.test_user1]
)
task1 = Task(
name="Modeling",
parent=new_asset
)
task2 = Task(
name="Lighting",
parent=new_asset
)
tasks = [task1, task2]
assert \
sorted(new_asset.tasks, key=lambda x: x.name) == \
sorted(tasks, key=lambda x: x.name)
def test_TaskMixin_initialization(self):
"""testing if the TaskMixin part is initialized correctly
"""
status1 = Status(name="On Hold", code="OH")
project_status_list = StatusList(name="Project Statuses",
statuses=[status1],
target_entity_type=Project)
project_type = Type(name="Commercial",
code='comm',
target_entity_type=Project)
new_project = Project(
name="Commercial1",
code='comm1',
status_list=project_status_list,
type=project_type,
repository=self.test_repository,
)
self.kwargs["code"] = "SH12314"
new_shot = Shot(**self.kwargs)
task1 = Task(
name="Modeling",
status=0,
project=new_project,
parent=new_shot,
)
task2 = Task(
name="Lighting",
status=0,
project=new_project,
parent=new_shot,
)
tasks = [task1, task2]
self.assertEqual(sorted(new_shot.tasks, key=lambda x: x.name),
sorted(tasks, key=lambda x: x.name))
def test_initialization_of_task_part(self):
"""testing if the Task part is initialized correctly
"""
from stalker import Type, Project, Sequence, Task
project_type = Type(
name="Commercial",
code='comm',
target_entity_type='Project'
)
new_project = Project(
name="Commercial",
code='comm',
type=project_type,
repository=self.test_repository,
)
self.kwargs["project"] = new_project
new_sequence = Sequence(**self.kwargs)
task1 = Task(
name="Modeling",
status=0,
project=new_project,
parent=new_sequence,
)
task2 = Task(
name="Lighting",
status=0,
project=new_project,
parent=new_sequence,
)
tasks = [task1, task2]
assert \
sorted(new_sequence.tasks, key=lambda x: x.name) == \
sorted(tasks, key=lambda x: x.name)
def setUp(self):
"""set the test up
"""
super(ProjectUserTestCase, self).setUp()
from stalker import Status, StatusList, Repository
self.test_repo = Repository(name='Test Repo')
from stalker import db
db.DBSession.add(self.test_repo)
db.DBSession.commit()
self.status_new = Status.query.filter_by(code='NEW').first()
self.status_wip = Status.query.filter_by(code='WIP').first()
self.status_cmpl = Status.query.filter_by(code='CMPL').first()
self.project_statuses = StatusList(
name='Project Status List',
statuses=[self.status_new, self.status_wip, self.status_cmpl],
target_entity_type='Project')
db.DBSession.add(self.project_statuses)
from stalker import User
self.test_user1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(self.test_user1)
from stalker import Project
self.test_project = Project(name='Test Project 1',
code='TP1',
repositories=[self.test_repo],
status_list=self.project_statuses)
db.DBSession.add(self.test_project)
from stalker import Role
self.test_role = Role(name='Test User')
db.DBSession.add(self.test_role)
db.DBSession.commit()
status_wip,
status_cmpl
],
target_entity_type=Project # you can also use "Project" which is a str
)
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 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
product bla bla bla..."""
new_project.image_format = ImageFormat(
name="HD 1080",
width=1920,
height=1080
def setUp(self):
"""setup the test
"""
super(AssetTester, self).setUp()
# users
from stalker import User
from stalker.db.session import DBSession
self.test_user1 = User(
name='User1',
login='******',
password='******',
email='*****@*****.**'
)
DBSession.add(self.test_user1)
self.test_user2 = User(
name='User2',
login='******',
password='******',
email='*****@*****.**'
)
DBSession.add(self.test_user2)
DBSession.commit()
# statuses
from stalker import Status, Project
self.status_wip = Status.query.filter_by(code='WIP').first()
self.status_cmpl = Status.query.filter_by(code='CMPL').first()
# types
from stalker import Type
self.commercial_project_type = Type(
name="Commercial Project",
code='commproj',
target_entity_type='Project',
)
DBSession.add(self.commercial_project_type)
self.asset_type1 = Type(
name="Character",
code='char',
target_entity_type='Asset'
)
DBSession.add(self.asset_type1)
self.asset_type2 = Type(
name="Environment",
code='env',
target_entity_type='Asset'
)
DBSession.add(self.asset_type2)
self.repository_type = Type(
name="Test Repository Type",
code='testrepo',
target_entity_type='Repository',
)
DBSession.add(self.repository_type)
# repository
from stalker import Repository
self.repository = Repository(
name="Test Repository",
type=self.repository_type,
)
DBSession.add(self.repository)
# project
self.project1 = Project(
name="Test Project1",
code='tp1',
type=self.commercial_project_type,
repositories=[self.repository],
)
DBSession.add(self.project1)
DBSession.commit()
# sequence
from stalker import Sequence
self.seq1 = Sequence(
name="Test Sequence",
code='tseq',
project=self.project1,
responsible=[self.test_user1]
)
DBSession.add(self.seq1)
# shots
from stalker import Shot
self.shot1 = Shot(
code="TestSH001",
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
DBSession.add(self.shot1)
self.shot2 = Shot(
code="TestSH002",
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
DBSession.add(self.shot2)
self.shot3 = Shot(
code="TestSH003",
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
DBSession.add(self.shot3)
self.shot4 = Shot(
code="TestSH004",
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
DBSession.add(self.shot4)
self.kwargs = {
"name": "Test Asset",
'code': 'ta',
"description": "This is a test Asset object",
"project": self.project1,
"type": self.asset_type1,
"status": 0,
'responsible': [self.test_user1]
}
from stalker import Asset, Task
self.asset1 = Asset(**self.kwargs)
DBSession.add(self.asset1)
# tasks
self.task1 = Task(
name="Task1",
parent=self.asset1,
)
DBSession.add(self.task1)
self.task2 = Task(
name="Task2",
parent=self.asset1,
)
DBSession.add(self.task2)
self.task3 = Task(
name="Task3",
parent=self.asset1,
)
DBSession.add(self.task3)
DBSession.commit()
def setUp(self):
"""set up the test
"""
# create an in memory database
from stalker import db
db.setup()
db.init()
self.status_wfd = Status.query.filter_by(code='WFD').first()
self.status_rts = Status.query.filter_by(code='RTS').first()
self.status_wip = Status.query.filter_by(code='WIP').first()
self.status_prev = Status.query.filter_by(code='PREV').first()
self.status_hrev = Status.query.filter_by(code='HREV').first()
self.status_drev = Status.query.filter_by(code='DREV').first()
self.status_oh = Status.query.filter_by(code='OH').first()
self.status_stop = Status.query.filter_by(code='STOP').first()
self.status_cmpl = Status.query.filter_by(code='CMPL').first()
# create a resource
self.test_resource1 = User(
name="User1",
login="******",
email="*****@*****.**",
password="******",
)
self.test_resource2 = User(
name="User2",
login="******",
email="*****@*****.**",
password="******"
)
self.test_repo = Repository(name="test repository")
# create a Project
self.test_status1 = Status(name="Status1", code="STS1")
self.test_status2 = Status(name="Status2", code="STS2")
self.test_status3 = Status(name="Status3", code="STS3")
self.test_project_status_list = StatusList(
name="Project Statuses",
statuses=[self.test_status1],
target_entity_type=Project
)
self.test_task_status_list = StatusList.query\
.filter_by(target_entity_type='Task').first()
self.test_project = Project(
name="test project",
code='tp',
repository=self.test_repo,
status_list=self.test_project_status_list
)
# create a Task
self.test_task = Task(
name="test task",
project=self.test_project,
status_list=self.test_task_status_list,
schedule_timing=10,
schedule_unit='d',
resources=[self.test_resource1]
)
self.kwargs = {
"name": "test time_log",
"task": self.test_task,
"resource": self.test_resource1,
"start": datetime.datetime(2013, 3, 22, 1, 0),
"duration": datetime.timedelta(10)
}
tds_department = Department(
name="TDs",
description="This is the TDs department"
)
tds_department.users.append(myUser)
all_departments = Department.query.all()
all_members_of_dep = all_departments[0].members
print all_members_of_dep[0].first_name
session.add(myUser)
session.add(tds_department)
new_project = Project(name="Fancy Commercial")
new_project.description = """The commercial is about this fancy product. The
client want us to have a shinny look with their
product bla bla bla..."""
new_project.image_format = ImageFormat(name="HD 1080", width=1920, height=1080)
new_project.fps = 25
new_project.due = datetime(2011,2,15)
new_project.lead = myUser
from stalker import Type
commercial_project_type = Type(name="Commercial")
new_project.type = commercial_project_type
session.add(new_project)
login="******",
email="*****@*****.**",
password="******")
test_user4 = User(name="User4",
login="******",
email="*****@*****.**",
password="******")
test_user5 = User(name="User5",
login="******",
email="*****@*****.**",
password="******")
test_project1 = Project(name="Test Project1",
code='tp1',
type=test_movie_project_type,
repositories=[test_repository])
test_dependent_task1 = Task(name="Dependent Task1",
project=test_project1,
status_list=task_status_list,
responsible=[test_user1])
test_dependent_task2 = Task(name="Dependent Task2",
project=test_project1,
status_list=task_status_list,
responsible=[test_user1])
kwargs = {
'name': 'Modeling',
'description': 'A Modeling Task',
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):
super(DailyTestBase, self).setUp()
from stalker import Status, StatusList
self.status_new = Status(name='Mew', code='NEW')
self.status_wfd = Status(name='Waiting For Dependency', code='WFD')
self.status_rts = Status(name='Ready To Start', code='RTS')
self.status_wip = Status(name='Work In Progress', code='WIP')
self.status_prev = Status(name='Pending Review', code='PREV')
self.status_hrev = Status(name='Has Revision', code='HREV')
self.status_drev = Status(name='Dependency Has Revision', code='DREV')
self.status_cmpl = Status(name='Completed', code='CMPL')
self.status_open = Status(name='Open', code='OPEN')
self.status_cls = Status(name='Closed', code='CLS')
self.daily_status_list = StatusList(
name='Daily Statuses',
statuses=[self.status_open, self.status_cls],
target_entity_type='Daily')
self.task_status_list = StatusList(
name='Task Statuses',
statuses=[
self.status_wfd, self.status_rts, self.status_wip,
self.status_prev, self.status_hrev, self.status_drev,
self.status_cmpl
],
target_entity_type='Task')
self.test_project_status_list = StatusList(
name='Project Statuses',
target_entity_type='Project',
statuses=[self.status_new, self.status_wip, self.status_cmpl])
from stalker import Repository, Project
self.test_repo = Repository(name='Test Repository', code='TR')
self.test_project = Project(name='Test Project',
code='TP',
repository=self.test_repo,
status_list=self.test_project_status_list)
from stalker import Task
self.test_task1 = Task(name='Test Task 1',
project=self.test_project,
status_list=self.task_status_list)
self.test_task2 = Task(name='Test Task 2',
project=self.test_project,
status_list=self.task_status_list)
self.test_task3 = Task(name='Test Task 3',
project=self.test_project,
status_list=self.task_status_list)
from stalker import Version
self.test_version1 = Version(task=self.test_task1)
self.test_version2 = Version(task=self.test_task1)
self.test_version3 = Version(task=self.test_task1)
self.test_version4 = Version(task=self.test_task2)
from stalker import Link
self.test_link1 = Link(original_filename='test_render1.jpg')
self.test_link2 = Link(original_filename='test_render2.jpg')
self.test_link3 = Link(original_filename='test_render3.jpg')
self.test_link4 = Link(original_filename='test_render4.jpg')
self.test_version1.outputs = [
self.test_link1, self.test_link2, self.test_link3
]
self.test_version4.outputs = [self.test_link4]
