def get_or_create_episode(project_id, name):
episode_type = get_episode_type()
episode = Entity.get_by(entity_type_id=episode_type["id"],
project_id=project_id,
name=name)
if episode is None:
episode = Entity(entity_type_id=episode_type["id"],
project_id=project_id,
name=name)
episode.save()
return episode.serialize()
def test_get_project_and_type_assets(self):
entity_type = EntityType(name="VFX")
entity_type.save()
entity = Entity(name="Smoke",
entity_type_id=entity_type.id,
project_id=self.project.id)
entity.save()
path_ids = (self.project.id, self.entity_type.id)
path = "data/projects/%s/asset_types/%s/assets" % path_ids
assets = self.get(path)
self.assertEquals(len(assets), 1)
self.assertDictEqual(assets[0], self.entity_dict)
def get_or_create_sequence(project_id, episode_id, name):
sequence_type = get_sequence_type()
sequence = Entity.get_by(entity_type_id=sequence_type["id"],
parent_id=episode_id,
project_id=project_id,
name=name)
if sequence is None:
sequence = Entity(entity_type_id=sequence_type["id"],
parent_id=episode_id,
project_id=project_id,
name=name)
sequence.save()
return sequence.serialize()
def create_asset(project, asset_type, name, description):
name = name.capitalize()
asset = Entity(project_id=project.id,
entity_type_id=asset_type.id,
name=name,
description=description)
asset.save()
events.emit(
"asset:new", {
"asset": asset.serialize(),
"asset_type": asset_type.serialize(),
"project": project.serialize()
})
return asset
def get_or_create_episode(project_id, name):
"""
Retrieve episode matching given project and name or create it.
"""
episode_type = get_episode_type()
episode = Entity.get_by(
entity_type_id=episode_type["id"], project_id=project_id, name=name
)
if episode is None:
episode = Entity(
entity_type_id=episode_type["id"], project_id=project_id, name=name
)
episode.save()
return episode.serialize()
def save_entity(self, data):
entity = None
try:
entity = assets_service.get_raw_asset_by_shotgun_id(
data["shotgun_id"])
entity.update(data)
current_app.logger.info("Entity updated: %s" % entity)
except AssetNotFoundException:
if data.get("entity_type_id", None) is not None:
entity = Entity(**data)
entity.save()
current_app.logger.info("Entity created: %s" % entity)
else:
current_app.logger.info("Entity ignored: %s" % data["name"])
return entity
def import_entry(self, data):
episode = Entity.get_by(shotgun_id=data["shotgun_id"],
entity_type_id=self.episode_type["id"])
if episode is None:
episode = Entity(**data)
episode.save()
current_app.logger.info("Episode created: %s" % episode)
else:
episode.update(data)
episode.save()
current_app.logger.info("Episode updated: %s" % episode)
return episode
def import_entry(self, data):
sequence = Entity.get_by(shotgun_id=data["shotgun_id"],
entity_type_id=self.sequence_type["id"])
if sequence is None:
sequence = Entity(**data)
sequence.save()
current_app.logger.info("Sequence created: %s" % sequence)
else:
sequence.update(data)
sequence.save()
current_app.logger.info("Sequence updated: %s" % sequence)
return sequence
def save_entity(self, data):
entity = None
entities = asset_info.get_assets({"shotgun_id": data["shotgun_id"]})
if len(entities) > 0:
entity = entities[0]
if entity is None:
entity = Entity(**data)
entity.save()
current_app.logger.info("Entity created: %s" % entity)
else:
entity.update(data)
current_app.logger.info("Entity updated: %s" % entity)
return entity
def import_entry(self, data):
scene = Entity.get_by(
shotgun_id=data["shotgun_id"],
entity_type_id=shots_service.get_scene_type()["id"])
if scene is None:
scene = Entity(**data)
scene.save()
current_app.logger.info("Scene created: %s" % scene)
else:
scene.update(data)
scene.save()
current_app.logger.info("Scene updated: %s" % scene)
return scene
def get_or_create_sequence(project_id, episode_id, name):
"""
Retrieve sequence matching given project, episode and name or create it.
"""
sequence_type = get_sequence_type()
sequence = Entity.get_by(entity_type_id=sequence_type["id"],
parent_id=episode_id,
project_id=project_id,
name=name)
if sequence is None:
sequence = Entity(entity_type_id=sequence_type["id"],
parent_id=episode_id,
project_id=project_id,
name=name)
sequence.save()
return sequence.serialize()
def create_asset(project_id, asset_type_id, name, description, data):
project = projects_service.get_project_raw(project_id)
asset_type = get_asset_type_raw(asset_type_id)
asset = Entity(project_id=project_id,
entity_type_id=asset_type_id,
name=name,
description=description,
data=data)
asset.save()
asset_dict = asset.serialize(obj_type="Asset")
events.emit(
"asset:new", {
"asset": asset_dict,
"asset_type": asset_type.serialize(obj_type="AssetType"),
"project": project.serialize()
})
return asset_dict
def import_entry(self, data):
shot = Entity.get_by(shotgun_id=data["shotgun_id"],
entity_type_id=shot_info.get_shot_type().id)
if shot is None:
shot = Entity(**data)
shot.save()
current_app.logger.info("Shot created: %s" % shot)
else:
if shot.data is None:
shot.data = {}
shot.update(data)
shot.data.update(data["data"])
shot.save()
current_app.logger.info("Shot updated: %s" % shot)
return shot
def import_entry(self, data):
sequence = Entity.get_by(
shotgun_id=data["shotgun_id"],
entity_type_id=self.sequence_type["id"],
)
similar_sequence = Entity.get_by(
name=data["name"],
parent_id=data["parent_id"],
project_id=data["project_id"],
entity_type_id=self.sequence_type["id"],
)
if sequence is None and similar_sequence is None:
sequence = Entity(**data)
sequence.save()
current_app.logger.info("Sequence created: %s" % sequence)
elif sequence is not None:
if similar_sequence is None:
sequence.update(data)
sequence.save()
else:
sequence.update(
{
"description": data["description"],
"shotgun_id": data["shotgun_id"],
}
)
sequence.save()
current_app.logger.info("Sequence updated: %s" % sequence)
return sequence
def import_entry(self, data):
sequence = Entity.get_by(shotgun_id=data["shotgun_id"],
entity_type_id=self.sequence_type["id"])
if sequence is None:
sequence = Entity(**data)
sequence.save()
current_app.logger.info("Sequence created: %s" % sequence)
else:
# Little hack to avoid integrity errors due to
# duplicated data.
similar_sequence = Entity.get_by(
name=data["name"],
parent_id=data["parent_id"],
project_id=data["project_id"],
entity_type_id=self.sequence_type["id"])
if similar_sequence is None:
sequence.update(data)
sequence.save()
else:
sequence.update({
"description": data["description"],
"shotgun_id": data["shotgun_id"]
})
sequence.save()
current_app.logger.info("Sequence updated: %s" % sequence)
return sequence
class FileTreeTestCase(ApiDBTestCase):
def setUp(self):
super(FileTreeTestCase, self).setUp()
self.generate_fixture_project_status()
self.generate_fixture_project()
self.generate_fixture_project_standard()
self.generate_fixture_entity_type()
self.generate_fixture_entity()
self.generate_fixture_sequence()
self.generate_fixture_shot()
self.generate_fixture_sequence_standard()
self.generate_fixture_shot_standard()
self.generate_fixture_person()
self.generate_fixture_department()
self.generate_fixture_task_type()
self.generate_fixture_task_status()
self.generate_fixture_assigner()
self.generate_fixture_task()
self.generate_fixture_shot_task()
self.generate_fixture_shot_task_standard()
self.entity_standard = Entity(name='Car',
project_id=self.project_standard.id,
entity_type_id=self.entity_type.id)
self.entity_standard.save()
self.sequence_standard = Entity(name='Seq1',
project_id=self.project.id,
entity_type_id=self.sequence_type.id)
self.sequence_standard.save()
self.shot_standard = Entity(name='P001',
project_id=self.project_standard.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence_standard.id)
self.shot_standard.save()
def test_get_tree_from_file(self):
simple_tree = file_tree.get_tree_from_file("simple")
self.assertIsNotNone(simple_tree["working"])
def test_get_tree_from_project(self):
simple_tree = file_tree.get_tree_from_project(self.project)
self.assertIsNotNone(simple_tree["working"])
def test_join_path(self):
self.assertEqual(file_tree.join_path("", "PROD"), "PROD")
self.assertEqual(file_tree.join_path("ROOT", "PROD"), "ROOT/PROD")
self.assertEqual(file_tree.join_path("ROOT", "PROD", "\\"),
"ROOT\\PROD")
def test_get_root_path(self):
tree = file_tree.get_tree_from_file("simple")
path = file_tree.get_root_path(tree, "working", "/")
self.assertEqual(path, "/simple/productions/")
def test_get_file_name_root_standard(self):
tree = file_tree.get_tree_from_file("standard")
file_name = file_tree.get_file_name_root(tree, "working", self.shot,
self.shot_task)
self.assertEqual(file_name, "cosmos_landromat_s01_p01_animation")
def test_add_version_suffix_to_file_name(self):
file_name = "COSMOS_LANDROMAT_S01_P01"
file_name = file_tree.add_version_suffix_to_file_name(file_name, 3)
self.assertEqual(file_name, "COSMOS_LANDROMAT_S01_P01_v003")
def test_add_comment_suffix_to_file_name(self):
file_name = "COSMOS_LANDROMAT_S01_P01"
file_name = file_tree.add_comment_suffix_to_file_name(
file_name, "comment")
self.assertEqual(file_name, "COSMOS_LANDROMAT_S01_P01_comment")
def test_get_project(self):
project = file_tree.get_project(self.entity)
self.assertEqual(project, self.project)
def test_get_file_name_template(self):
tree = file_tree.get_tree_from_file("standard")
template = file_tree.get_file_name_template(tree, "working", self.shot)
self.assertEqual(template, tree["working"]["file_name"]["shot"])
template = file_tree.get_file_name_template(tree, "working",
self.entity)
self.assertEqual(template, tree["working"]["file_name"]["asset"])
def test_get_folder_path_template(self):
tree = file_tree.get_tree_from_file("simple")
template = file_tree.get_folder_path_template(tree, "working",
self.shot)
self.assertEqual(template, tree["working"]["folder_path"]["shot"])
template = file_tree.get_folder_path_template(tree, "working",
self.entity)
self.assertEqual(template, tree["working"]["folder_path"]["asset"])
def test_get_folder_from_datatype_project(self):
path = file_tree.get_folder_from_datatype("Project", self.shot,
self.shot_task)
self.assertEquals(path, self.project.name)
def test_get_folder_from_datatype_shot(self):
path = file_tree.get_folder_from_datatype("Shot", self.shot,
self.shot_task)
self.assertEquals(path, self.shot.name)
def test_get_folder_from_datatype_sequence(self):
path = file_tree.get_folder_from_datatype("Sequence", self.shot,
self.shot_task)
self.assertEquals(path, self.sequence.name)
def test_get_folder_from_datatype_asset(self):
path = file_tree.get_folder_from_datatype("Asset", self.entity,
self.task)
self.assertEquals(path, self.entity.name)
def test_get_folder_from_datatype_asset_type(self):
path = file_tree.get_folder_from_datatype("AssetType", self.entity,
self.task)
self.assertEquals(path, self.entity_type.name)
def test_get_folder_from_datatype_department(self):
path = file_tree.get_folder_from_datatype("Department", self.entity,
self.task)
self.assertEquals(path, self.department.name)
def test_get_folder_from_datatype_task(self):
path = file_tree.get_folder_from_datatype("Task", self.entity,
self.task)
self.assertEquals(path, self.task.name)
def test_get_folder_from_datatype_task_type(self):
path = file_tree.get_folder_from_datatype("TaskType", self.entity,
self.task)
self.assertEquals(path, self.task_type.name)
def test_get_folder_raise_exception(self):
self.assertRaises(MalformedFileTreeException,
file_tree.get_folder_from_datatype, "Unknown",
self.entity, self.task)
def test_get_folder_path_shot(self):
path = file_tree.get_folder_path(self.shot_task, mode="working")
self.assertEquals(
path,
"/simple/productions/cosmos_landromat/shots/s01/p01/animation")
def test_get_folder_path_with_separator(self):
path = file_tree.get_folder_path(self.shot_task,
mode="working",
sep="/")
self.assertEquals(
path,
"/simple/productions/cosmos_landromat/shots/s01/p01/animation")
def test_get_folder_path_asset(self):
path = file_tree.get_folder_path(self.task, mode="working")
self.assertEquals(
path,
"/simple/productions/cosmos_landromat/assets/props/tree/shaders")
def test_get_file_name_asset(self):
file_name = file_tree.get_file_name(self.task,
mode="working",
version=3)
self.assertEquals(file_name,
"cosmos_landromat_props_tree_shaders_v003")
def test_get_file_name_shot(self):
file_name = file_tree.get_file_name(self.shot_task,
mode="working",
version=3)
self.assertEquals(file_name, "cosmos_landromat_s01_p01_animation_v003")
def test_get_file_path_asset(self):
file_name = file_tree.get_file_path(self.task, version=3)
self.assertEquals(
file_name,
"/simple/productions/cosmos_landromat/assets/props/tree/shaders/"
"cosmos_landromat_props_tree_shaders_v003")
def test_get_file_name_comment(self):
file_name = file_tree.get_file_name(self.task,
mode="working",
version=3,
comment="My comment")
self.assertEquals(
file_name, "cosmos_landromat_props_tree_shaders_v003_my_comment")
def test_change_folder_path_separators(self):
result = file_tree.change_folder_path_separators(
"/simple/big_buck_bunny/props", "\\")
self.assertEqual(result, "\\simple\\big_buck_bunny\\props")
def test_update_variable(self):
name = file_tree.update_variable("<AssetType>_<Asset>", self.entity,
self.task)
self.assertEquals(name, "props_tree")
def test_apply_style(self):
file_name = "Shaders"
result = file_tree.apply_style(file_name, "uppercase")
self.assertEqual(result, "SHADERS")
result = file_tree.apply_style(file_name, "lowercase")
self.assertEqual(result, "shaders")
class ApiDBTestCase(ApiTestCase):
def setUp(self):
"""
Reset database before each test.
"""
super(ApiDBTestCase, self).setUp()
from zou.app.utils import dbhelpers
dbhelpers.drop_all()
dbhelpers.create_all()
self.log_in()
def log_in(self):
self.generate_fixture_user()
self.post("auth/login", {
"email": self.user.email,
"password": "******"
}, 200)
def tearDown(self):
"""
Delete database after each test.
"""
from zou.app.utils import dbhelpers
dbhelpers.drop_all()
def generate_data(self, cls, number, **kwargs):
"""
Generate random data for a given data model.
"""
mixer.init_app(self.flask_app)
return mixer.cycle(number).blend(cls, id=fields.gen_uuid, **kwargs)
def generate_fixture_project_status(self):
self.open_status = ProjectStatus(name="open", color="#FFFFFF")
self.open_status.save()
def generate_fixture_project_closed_status(self):
self.closed_status = ProjectStatus(name="closed", color="#FFFFFF")
self.closed_status.save()
def generate_fixture_project(self):
self.project = Project(name="Cosmos Landromat",
project_status_id=self.open_status.id)
self.project.save()
self.project.update(
{"file_tree": file_tree.get_tree_from_file("simple")})
def generate_fixture_project_closed(self):
self.project_closed = Project(name="Old Project",
project_status_id=self.closed_status.id)
self.project_closed.save()
def generate_fixture_project_standard(self):
self.project_standard = Project(name="Big Buck Bunny",
project_status_id=self.open_status.id)
self.project_standard.save()
self.project_standard.update(
{"file_tree": file_tree.get_tree_from_file("standard")})
def generate_fixture_entity(self):
self.entity = Entity(name="Tree",
description="Description Tree",
project_id=self.project.id,
entity_type_id=self.entity_type.id)
self.entity.save()
def generate_fixture_entity_standard(self):
self.entity_standard = Entity(name="Car",
project_id=self.project_standard.id,
entity_type_id=self.entity_type.id)
self.entity_standard.save()
def generate_fixture_sequence(self):
if hasattr(self, "episode"):
episode_id = self.episode.id
else:
episode_id = None
self.sequence = Entity(name="S01",
project_id=self.project.id,
entity_type_id=self.sequence_type.id,
parent_id=episode_id)
self.sequence.save()
def generate_fixture_sequence_standard(self):
self.sequence_standard = Entity(name="S01",
project_id=self.project_standard.id,
entity_type_id=self.sequence_type.id)
self.sequence_standard.save()
def generate_fixture_episode(self):
self.episode = Entity(name="E01",
project_id=self.project.id,
entity_type_id=self.episode_type.id)
self.episode.save()
def generate_fixture_shot(self):
self.shot = Entity(name="P01",
description="Description Shot 01",
data={
"fps": 25,
"frame_in": 0,
"frame_out": 100
},
project_id=self.project.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence.id)
self.shot.save()
self.shot_noseq = Entity(name="P01NOSEQ",
project_id=self.project.id,
entity_type_id=self.shot_type.id)
self.shot_noseq.save()
def generate_fixture_shot_standard(self):
self.shot_standard = Entity(name="P01",
description="Description Shot 01",
data={
"fps": 25,
"frame_in": 0,
"frame_out": 100
},
project_id=self.project_standard.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence_standard.id)
self.shot_standard.save()
def generate_fixture_user(self):
self.user = Person(first_name="John",
last_name="Did",
email=u"*****@*****.**",
password=auth.encrypt_password("mypassword"))
self.user.save()
def generate_fixture_person(self):
self.person = Person(first_name="John",
last_name="Doe",
email=u"*****@*****.**",
password=auth.encrypt_password("mypassword"))
self.person.save()
def generate_fixture_entity_type(self):
self.entity_type = EntityType(name="Props")
self.entity_type.save()
self.shot_type = EntityType(name="Shot")
self.shot_type.save()
self.sequence_type = EntityType(name="Sequence")
self.sequence_type.save()
self.episode_type = EntityType(name="Episode")
self.episode_type.save()
def generate_fixture_department(self):
self.department = Department(name="Modeling", color="#FFFFFF")
self.department.save()
self.department_animation = Department(name="Animation",
color="#FFFFFF")
self.department_animation.save()
def generate_fixture_task_type(self):
self.task_type = TaskType(name="Shaders",
color="#FFFFFF",
department_id=self.department.id)
self.task_type.save()
self.task_type_animation = TaskType(
name="Animation",
color="#FFFFFF",
department_id=self.department_animation.id)
self.task_type_animation.save()
def generate_fixture_task_status(self):
self.task_status = TaskStatus(name="Open",
short_name="opn",
color="#FFFFFF")
self.task_status.save()
def generate_fixture_task_status_wip(self):
self.task_status_wip = TaskStatus(name="WIP",
short_name="wip",
color="#FFFFFF")
self.task_status_wip.save()
def generate_fixture_task_status_to_review(self):
self.task_status_to_review = TaskStatus(name="To review",
short_name="pndng",
color="#FFFFFF")
self.task_status_to_review.save()
def generate_fixture_assigner(self):
self.assigner = Person(first_name="Ema", last_name="Peel")
self.assigner.save()
def generate_fixture_task(self):
start_date = fields.get_date_object("2017-02-20")
due_date = fields.get_date_object("2017-02-28")
real_start_date = fields.get_date_object("2017-02-22")
self.task = Task(name="Super modeling",
project_id=self.project.id,
task_type_id=self.task_type.id,
task_status_id=self.task_status.id,
entity_id=self.entity.id,
assignees=[self.person],
assigner_id=self.assigner.id,
duration=50,
estimation=40,
start_date=start_date,
due_date=due_date,
real_start_date=real_start_date)
self.task.save()
def generate_fixture_task_standard(self):
start_date = fields.get_date_object("2017-02-20")
due_date = fields.get_date_object("2017-02-28")
real_start_date = fields.get_date_object("2017-02-22")
self.task_standard = Task(name="Super modeling",
project_id=self.project_standard.id,
task_type_id=self.task_type.id,
task_status_id=self.task_status.id,
entity_id=self.entity_standard.id,
assignees=[self.person],
assigner_id=self.assigner.id,
duration=50,
estimation=40,
start_date=start_date,
due_date=due_date,
real_start_date=real_start_date)
self.task_standard.save()
def generate_fixture_shot_task(self):
self.shot_task = Task(
name="Super animation",
project_id=self.project.id,
task_type_id=self.task_type_animation.id,
task_status_id=self.task_status.id,
entity_id=self.shot.id,
assignees=[self.person],
assigner_id=self.assigner.id,
)
self.shot_task.save()
def generate_fixture_shot_task_standard(self):
self.shot_task_standard = Task(
name="Super animation",
project_id=self.project_standard.id,
task_type_id=self.task_type_animation.id,
task_status_id=self.task_status.id,
entity_id=self.shot_standard.id,
assignees=[self.person],
assigner_id=self.assigner.id)
self.shot_task_standard.save()
def generate_fixture_file_status(self):
self.file_status = FileStatus(name="To review", color="#FFFFFF")
self.file_status.save()
def generate_fixture_working_file(self):
self.working_file = WorkingFile(name="S01_P01_modeling",
comment="",
revision=1,
task_id=self.task.id,
entity_id=self.entity.id,
person_id=self.person.id)
self.working_file.save()
def generate_fixture_shot_working_file(self):
self.working_file = WorkingFile(name="S01_P01_animation",
comment="",
revision=1,
task_id=self.task.id,
entity_id=self.shot.id,
person_id=self.person.id)
self.working_file.save()
def generate_fixture_output_file(self):
self.output_file = OutputFile(comment="",
revision=1,
task_id=self.task.id,
entity_id=self.entity.id,
person_id=self.person.id,
file_status_id=self.file_status.id)
self.output_file.save()
def get_fixture_file_path(self, relative_path):
current_path = os.getcwd()
file_path_fixture = os.path.join(current_path, "test", "fixtures",
relative_path)
return file_path_fixture
class FileTreeTestCase(ApiDBTestCase):
def setUp(self):
super(FileTreeTestCase, self).setUp()
self.generate_fixture_project_status()
self.generate_fixture_project()
self.generate_fixture_project_standard()
self.generate_fixture_entity_type()
self.generate_fixture_entity()
self.generate_fixture_entity_standard()
self.generate_fixture_episode()
self.generate_fixture_sequence()
self.generate_fixture_shot()
self.generate_fixture_sequence_standard()
self.generate_fixture_shot_standard()
self.generate_fixture_person()
self.generate_fixture_department()
self.generate_fixture_task_type()
self.generate_fixture_task_status()
self.generate_fixture_assigner()
self.generate_fixture_task()
self.generate_fixture_task_standard()
self.generate_fixture_shot_task()
self.generate_fixture_shot_task_standard()
self.sequence_standard = Entity(name='Seq1',
project_id=self.project.id,
entity_type_id=self.sequence_type.id)
self.sequence_standard.save()
self.shot_standard = Entity(name='P001',
project_id=self.project_standard.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence_standard.id)
self.shot_standard.save()
def test_get_shot_path_template(self):
tree = file_tree.get_tree_from_project(self.project)
path = file_tree.get_shot_path_template(tree)
self.assertEqual(path, "<Project>/shots/<Sequence>/<Shot>/<TaskType>")
def test_get_shot_template_folders(self):
folders = file_tree.get_shot_template_folders(self.project)
self.assertEqual(
folders,
[u"<Project>", u"shots", u"<Sequence>", u"<Shot>", u"<TaskType>"])
def test_get_path_folders(self):
folders = file_tree.get_path_folders(
self.project,
"/simple/productions/the_crew/shots/s01/p01/animation")
self.assertEqual(folders,
["the_crew", "shots", "s01", "p01", "animation"])
def test_guess_shot(self):
shot = file_tree.guess_shot(self.project, "E01", "S01", "P01")
self.assertEqual(shot.id, self.shot.id)
def test_guess_asset(self):
asset = file_tree.guess_asset(self.project, "Props", "Tree")
self.assertEqual(asset.id, self.entity.id)
def test_guess_task_type(self):
task_type = file_tree.guess_task_type("Modeling", "Shaders")
self.assertEqual(task_type.id, self.task_type.id)
def test_guess_task(self):
task = file_tree.guess_task(self.entity, self.task_type,
"Super modeling")
self.assertEqual(task.id, self.task.id)
def test_get_task_from_shot_path(self):
file_path = file_tree.get_folder_path(self.shot_task_standard)
task = file_tree.get_shot_task_from_path(file_path,
self.project_standard)
self.assertTrue(task.id, self.shot_task_standard.id)
def test_get_task_from_asset_path(self):
file_path = file_tree.get_folder_path(self.task_standard)
task = file_tree.get_asset_task_from_path(file_path,
self.project_standard)
self.assertTrue(task.id, self.shot_task_standard.id)
class FileTreeTestCase(ApiDBTestCase):
def setUp(self):
super(FileTreeTestCase, self).setUp()
self.generate_fixture_project_status()
self.generate_fixture_project()
self.generate_fixture_project_standard()
self.generate_fixture_asset_type()
self.generate_fixture_asset()
self.generate_fixture_episode()
self.generate_fixture_sequence()
self.generate_fixture_shot()
self.generate_fixture_scene()
self.generate_fixture_sequence_standard()
self.generate_fixture_shot_standard()
self.generate_fixture_person()
self.generate_fixture_department()
self.generate_fixture_task_type()
self.generate_fixture_task_status()
self.generate_fixture_assigner()
self.generate_fixture_task()
self.generate_fixture_shot_task()
self.generate_fixture_shot_task_standard()
self.generate_fixture_software()
self.asset_standard = Entity(
name='Car',
project_id=self.project_standard.id,
entity_type_id=self.asset_type.id
)
self.asset_standard.save()
self.sequence_standard = Entity(
name='Seq1',
project_id=self.project.id,
entity_type_id=self.sequence_type.id
)
self.sequence_standard.save()
self.shot_standard = Entity(
name='P001',
project_id=self.project_standard.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence_standard.id
)
self.shot_standard.save()
self.output_type_materials = files_service.get_or_create_output_type(
"Materials")
self.output_type_cache = files_service.get_or_create_output_type(
"Cache")
self.output_type_image = files_service.get_or_create_output_type(
"Images")
def test_get_tree_from_file(self):
simple_tree = file_tree_service.get_tree_from_file("simple")
self.assertIsNotNone(simple_tree["working"])
def test_get_tree_from_project(self):
simple_tree = file_tree_service.get_tree_from_project(
self.project.serialize()
)
self.assertIsNotNone(simple_tree["working"])
def test_join_path(self):
self.assertEqual(file_tree_service.join_path("", "PROD"), "PROD")
self.assertEqual(
file_tree_service.join_path("ROOT", "PROD"), "ROOT/PROD")
self.assertEqual(
file_tree_service.join_path("ROOT", "PROD", "\\"), "ROOT\\PROD")
def test_get_root_path(self):
tree = file_tree_service.get_tree_from_file("simple")
path = file_tree_service.get_root_path(tree, "working", "/")
self.assertEqual(path, "/simple/productions/")
def test_get_project(self):
project = file_tree_service.get_project(self.asset.serialize())
self.assertEqual(project["name"], self.project.name)
def test_get_file_name_template(self):
tree = file_tree_service.get_tree_from_file("default")
template = file_tree_service.get_file_name_template(
tree,
"working",
self.shot.serialize()
)
self.assertEqual(template, tree["working"]["file_name"]["shot"])
template = file_tree_service.get_file_name_template(
tree,
"working",
self.asset.serialize()
)
self.assertEqual(template, tree["working"]["file_name"]["asset"])
template = file_tree_service.get_file_name_template(
tree,
"working",
self.sequence.serialize()
)
self.assertEqual(template, tree["working"]["file_name"]["sequence"])
def test_get_folder_path_template(self):
tree = file_tree_service.get_tree_from_file("simple")
template = file_tree_service.get_folder_path_template(
tree,
"working",
self.shot.serialize()
)
self.assertEqual(template, tree["working"]["folder_path"]["shot"])
template = file_tree_service.get_folder_path_template(
tree,
"working",
self.asset.serialize()
)
self.assertEqual(template, tree["working"]["folder_path"]["asset"])
template = file_tree_service.get_folder_path_template(
tree,
"working",
self.sequence.serialize()
)
self.assertEqual(template, tree["working"]["folder_path"]["sequence"])
def test_get_folder_from_datatype_project(self):
path = file_tree_service.get_folder_from_datatype(
"Project",
self.shot.serialize(),
self.shot_task.serialize()
)
self.assertEquals(path, self.project.name)
def test_get_folder_from_datatype_shot(self):
path = file_tree_service.get_folder_from_datatype(
"Shot",
self.shot.serialize(),
self.shot_task.serialize()
)
self.assertEquals(path, self.shot.name)
def test_get_folder_from_datatype_sequence_shot(self):
path = file_tree_service.get_folder_from_datatype(
"Sequence",
self.shot.serialize(),
self.shot_task.serialize()
)
self.assertEquals(path, self.sequence.name)
def test_get_folder_from_datatype_sequence_sequence(self):
path = file_tree_service.get_folder_from_datatype(
"Sequence",
self.sequence.serialize(),
self.shot_task.serialize()
)
self.assertEquals(path, self.sequence.name)
def test_get_folder_from_datatype_episode(self):
path = file_tree_service.get_folder_from_datatype(
"Episode",
self.shot.serialize(),
self.task.serialize()
)
self.assertEquals(path, "E01")
path = file_tree_service.get_folder_from_datatype(
"Episode",
self.sequence.serialize(),
self.task.serialize()
)
self.assertEquals(path, "E01")
def test_get_folder_from_datatype_entity(self):
path = file_tree_service.get_folder_from_datatype(
"Asset",
self.asset.serialize(),
self.task.serialize()
)
self.assertEquals(path, self.asset.name)
def test_get_folder_from_datatype_entity_type(self):
path = file_tree_service.get_folder_from_datatype(
"AssetType",
self.asset.serialize(),
self.task.serialize()
)
self.assertEquals(path, self.asset_type.name)
def test_get_folder_from_datatype_department(self):
path = file_tree_service.get_folder_from_datatype(
"Department",
self.asset.serialize(),
self.task.serialize()
)
self.assertEquals(path, self.department.name)
def test_get_folder_from_datatype_task(self):
path = file_tree_service.get_folder_from_datatype(
"Task",
self.asset.serialize(),
self.task.serialize()
)
self.assertEquals(path, self.task.name)
def test_get_folder_from_datatype_task_type(self):
path = file_tree_service.get_folder_from_datatype(
"TaskType",
self.asset.serialize(),
task=self.task.serialize()
)
self.assertEquals(path, self.task_type.name)
path = file_tree_service.get_folder_from_datatype(
"TaskType",
self.asset.serialize(),
task_type=self.task_type.serialize()
)
self.assertEquals(path, self.task_type.name)
def test_get_folder_from_datatype_software(self):
path = file_tree_service.get_folder_from_datatype(
"Software",
self.asset.serialize(),
self.task.serialize(),
software=self.software.serialize()
)
self.assertEquals(path, "Blender")
def test_get_folder_from_datatype_output_type(self):
path = file_tree_service.get_folder_from_datatype(
"OutputType",
self.asset.serialize(),
self.task.serialize(),
output_type=self.output_type_cache
)
self.assertEquals(path, "cache")
def test_get_folder_raise_exception(self):
self.assertRaises(
MalformedFileTreeException,
file_tree_service.get_folder_from_datatype,
"Unknown",
self.asset.serialize(),
self.task.serialize()
)
def test_get_working_folder_path_shot(self):
path = file_tree_service.get_working_folder_path(
self.shot_task.serialize(),
software=self.software_max.serialize()
)
self.assertEquals(
path,
"/simple/productions/cosmos_landromat/shots/s01/p01/animation/"
"3dsmax"
)
def test_get_working_folder_path_with_separator(self):
path = file_tree_service.get_working_folder_path(
self.shot_task.serialize(),
software=self.software_max.serialize(),
sep="\\"
)
self.assertEquals(
path,
"/simple\\productions\\cosmos_landromat\\shots\\s01\\p01\\"
"animation\\3dsmax"
)
def test_get_output_folder_path(self):
path = file_tree_service.get_output_folder_path(
self.shot.serialize(),
output_type=self.output_type_cache,
task_type=self.task_type_animation.serialize(),
sep="/"
)
self.assertEquals(
path,
"/simple/productions/export/cosmos_landromat/shots/s01/p01/"
"animation/cache"
)
def test_get_working_folder_path_with_software(self):
path = file_tree_service.get_working_folder_path(
self.task.serialize(),
software=self.software.serialize()
)
self.assertEquals(
path,
"/simple/productions/cosmos_landromat/assets/props/tree/shaders/"
"blender"
)
def test_get_working_file_name_asset(self):
file_name = file_tree_service.get_working_file_name(
self.task.serialize(),
revision=3
)
self.assertEquals(file_name, "cosmos_landromat_props_tree_shaders_v003")
def test_get_output_file_name_asset(self):
file_name = file_tree_service.get_output_file_name(
self.asset.serialize(),
name="main",
revision=3
)
self.assertEquals(
file_name,
"cosmos_landromat_props_tree_geometry_main_v003"
)
def test_get_output_file_name_shot_image_sequence(self):
file_name = file_tree_service.get_output_file_name(
self.shot.serialize(),
name="main",
revision=3,
output_type=self.output_type_image,
nb_elements=50
)
self.assertEquals(
file_name,
"cosmos_landromat_s01_p01_images_main_v003_[1-50]"
)
def test_get_working_file_name_shot(self):
file_name = file_tree_service.get_working_file_name(
self.shot_task.serialize(),
revision=3
)
self.assertEquals(file_name, "cosmos_landromat_s01_p01_animation_v003")
def test_get_working_file_path_asset(self):
file_name = file_tree_service.get_working_file_path(
self.task.serialize(),
software=self.software.serialize(),
revision=3
)
self.assertEquals(
file_name,
"/simple/productions/cosmos_landromat/assets/props/tree/shaders/"
"blender/"
"cosmos_landromat_props_tree_shaders_v003"
)
def test_get_file_path_scene(self):
scene_task = self.generate_fixture_scene_task()
file_name = file_tree_service.get_working_file_path(
scene_task.serialize(),
software=self.software_max.serialize(),
revision=3
)
self.assertEquals(
file_name,
"/simple/productions/cosmos_landromat/scenes/s01/sc01/animation/"
"3dsmax/"
"cosmos_landromat_sc01_animation_v003"
)
def test_get_folder_path_shot_asset_instance(self):
self.generate_fixture_scene_asset_instance()
self.generate_fixture_shot_asset_instance(
self.shot,
self.asset_instance
)
path = file_tree_service.get_instance_folder_path(
self.asset_instance.serialize(),
self.shot.serialize(),
output_type=self.output_type_cache,
task_type=self.task_type_animation.serialize(),
representation="abc"
)
self.assertEquals(
path,
"/simple/productions/export/cosmos_landromat/shot/s01/p01/"
"animation/cache/props/tree/instance_0001/abc"
)
def test_get_file_name_shot_asset_instance(self):
self.generate_fixture_scene_asset_instance()
self.generate_fixture_shot_asset_instance(
self.shot,
self.asset_instance
)
file_name = file_tree_service.get_instance_file_name(
self.asset_instance.serialize(),
self.shot.serialize(),
output_type=self.output_type_cache,
task_type=self.task_type_animation.serialize(),
name="main",
revision=3
)
self.assertEquals(
file_name,
"cosmos_landromat_s01_p01_animation_cache_main" +
"_tree_0001_v003"
)
def test_get_folder_path_scene_asset_instance(self):
self.generate_fixture_scene_asset_instance()
path = file_tree_service.get_instance_folder_path(
self.asset_instance.serialize(),
self.scene.serialize(),
task_type=self.task_type_animation.serialize(),
output_type=self.output_type_cache,
representation="abc"
)
self.assertEquals(
path,
"/simple/productions/export/cosmos_landromat/scene/s01/sc01/"
"animation/cache/props/tree/instance_0001/abc"
)
def test_get_file_name_scene_asset_instance(self):
self.generate_fixture_scene_asset_instance()
file_name = file_tree_service.get_instance_file_name(
self.asset_instance.serialize(),
self.scene.serialize(),
output_type=self.output_type_cache,
task_type=self.task_type_animation.serialize(),
name="main",
revision=3
)
self.assertEquals(
file_name,
"cosmos_landromat_s01_sc01_animation_cache_main_"
"tree_0001_v003"
)
def test_get_folder_path_asset_asset_instance(self):
self.generate_fixture_asset_types()
self.generate_fixture_asset_character()
self.generate_fixture_asset_asset_instance()
path = file_tree_service.get_instance_folder_path(
self.asset_instance.serialize(),
self.asset.serialize(),
task_type=self.task_type.serialize(),
output_type=self.output_type_materials,
representation="ml"
)
self.assertEquals(
path,
"/simple/productions/export/cosmos_landromat/assets/props/tree/"
"shaders/materials/character/rabbit/instance_0001/ml"
)
def test_get_file_name_asset_asset_instance(self):
self.generate_fixture_asset_types()
self.generate_fixture_asset_character()
self.generate_fixture_asset_asset_instance()
file_name = file_tree_service.get_instance_file_name(
self.asset_instance.serialize(),
self.asset.serialize(),
output_type=self.output_type_materials,
task_type=self.task_type.serialize(),
name="main",
revision=3
)
self.assertEquals(
file_name,
"cosmos_landromat_props_tree_shaders_materials_main_"
"rabbit_0001_v003"
)
def test_get_folder_path_representation(self):
self.generate_fixture_scene_asset_instance()
path = file_tree_service.get_instance_folder_path(
self.asset_instance.serialize(),
self.scene.serialize(),
task_type=self.task_type_animation.serialize(),
output_type=self.output_type_cache,
representation="abc"
)
self.assertEquals(
path,
"/simple/productions/export/cosmos_landromat/scene/s01/sc01/"
"animation/cache/props/tree/instance_0001/abc"
)
def test_change_folder_path_separators(self):
result = file_tree_service.change_folder_path_separators(
"/simple/big_buck_bunny/props", "\\")
self.assertEqual(result, "\\simple\\big_buck_bunny\\props")
def test_update_variable(self):
name = file_tree_service.update_variable(
"<AssetType>_<Asset>",
asset=self.asset.serialize(),
task=self.task.serialize()
)
self.assertEquals(name, "props_tree")
def test_apply_style(self):
file_name = "Shaders"
result = file_tree_service.apply_style(file_name, "uppercase")
self.assertEqual(result, "SHADERS")
result = file_tree_service.apply_style(file_name, "lowercase")
self.assertEqual(result, "shaders")
def test_update_variable_short_name(self):
name = file_tree_service.update_variable(
"<TaskType.short_name>",
asset=self.asset.serialize(),
task=self.task.serialize()
)
self.assertEquals(name, "shd")
class ApiDBTestCase(ApiTestCase):
def setUp(self):
"""
Reset database before each test.
"""
super(ApiDBTestCase, self).setUp()
from zou.app.utils import dbhelpers
dbhelpers.drop_all()
dbhelpers.create_all()
self.generate_fixture_user()
self.log_in_admin()
def tearDown(self):
"""
Delete database after each test.
"""
from zou.app.utils import dbhelpers
dbhelpers.drop_all()
def generate_data(self, cls, number, **kwargs):
"""
Generate random data for a given data model.
"""
mixer.init_app(self.flask_app)
return mixer.cycle(number).blend(cls, id=fields.gen_uuid, **kwargs)
def generate_fixture_project_status(self):
self.open_status = ProjectStatus(name="open", color="#FFFFFF")
self.open_status.save()
def generate_fixture_project_closed_status(self):
self.closed_status = ProjectStatus(name="closed", color="#FFFFFF")
self.closed_status.save()
def generate_fixture_project(self):
self.project = Project(name="Cosmos Landromat",
project_status_id=self.open_status.id)
self.project.save()
self.project.update(
{"file_tree": file_tree_service.get_tree_from_file("simple")})
def generate_fixture_project_closed(self):
self.project_closed = Project(name="Old Project",
project_status_id=self.closed_status.id)
self.project_closed.save()
def generate_fixture_project_standard(self):
self.project_standard = Project(name="Big Buck Bunny",
project_status_id=self.open_status.id)
self.project_standard.save()
self.project_standard.update(
{"file_tree": file_tree_service.get_tree_from_file("standard")})
def generate_fixture_project_no_preview_tree(self):
self.project_no_preview_tree = Project(
name="Agent 327", project_status_id=self.open_status.id)
self.project_no_preview_tree.save()
self.project_no_preview_tree.update(
{"file_tree": file_tree_service.get_tree_from_file("no_preview")})
def generate_fixture_entity(self):
self.entity = Entity(name="Tree",
description="Description Tree",
project_id=self.project.id,
entity_type_id=self.entity_type.id)
self.entity.save()
def generate_fixture_entity_character(self):
self.entity_character = Entity(
name="Rabbit",
description="Main character",
project_id=self.project.id,
entity_type_id=self.entity_type_character.id)
self.entity_character.save()
def generate_fixture_entity_camera(self):
self.entity_camera = Entity(name="Main camera",
description="Description Camera",
project_id=self.project.id,
entity_type_id=self.entity_type_camera.id)
self.entity_camera.save()
def generate_fixture_entity_standard(self):
self.entity_standard = Entity(name="Car",
project_id=self.project_standard.id,
entity_type_id=self.entity_type.id)
self.entity_standard.save()
def generate_fixture_sequence(self, name="S01"):
if hasattr(self, "episode"):
episode_id = self.episode.id
else:
episode_id = None
self.sequence = Entity(name=name,
project_id=self.project.id,
entity_type_id=self.sequence_type.id,
parent_id=episode_id)
self.sequence.save()
def generate_fixture_sequence_standard(self):
self.sequence_standard = Entity(name="S01",
project_id=self.project_standard.id,
entity_type_id=self.sequence_type.id)
self.sequence_standard.save()
def generate_fixture_episode(self, name="E01"):
self.episode = Entity(name=name,
project_id=self.project.id,
entity_type_id=self.episode_type.id)
self.episode.save()
def generate_fixture_shot(self, name="P01"):
self.shot = Entity(name=name,
description="Description Shot 01",
data={
"fps": 25,
"frame_in": 0,
"frame_out": 100
},
project_id=self.project.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence.id)
self.shot.save()
self.shot_noseq = Entity(name="P01NOSEQ",
project_id=self.project.id,
entity_type_id=self.shot_type.id)
self.shot_noseq.save()
def generate_fixture_scene(self,
name="SC01",
project_id=None,
sequence_id=None):
if project_id is None:
project_id = self.project.id
if sequence_id is None:
sequence_id = self.sequence.id
self.scene = Entity(name=name,
description="Description Scene 01",
data={},
project_id=project_id,
entity_type_id=self.scene_type.id,
parent_id=self.sequence.id)
self.scene.save()
def generate_fixture_shot_standard(self):
self.shot_standard = Entity(name="P01",
description="Description Shot 01",
data={
"fps": 25,
"frame_in": 0,
"frame_out": 100
},
project_id=self.project_standard.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence_standard.id)
self.shot_standard.save()
def generate_fixture_shot_asset_instance(self,
asset=None,
shot=None,
number=1):
if asset is None:
asset = self.entity
if shot is None:
shot = self.shot
self.asset_instance = AssetInstance.create(
asset_id=asset.id,
entity_id=shot.id,
entity_type_id=self.shot_type.id,
number=number,
description="Asset instance description")
def generate_fixture_scene_asset_instance(self,
asset=None,
scene=None,
number=1):
if asset is None:
asset = self.entity
if scene is None:
scene = self.scene
self.asset_instance = AssetInstance.create(
asset_id=asset.id,
entity_id=scene.id,
entity_type_id=self.scene_type.id,
number=number,
description="Asset instance description")
def generate_fixture_user(self):
self.user = Person.create(first_name="John",
last_name="Did",
role="admin",
email=u"*****@*****.**",
password=auth.encrypt_password("mypassword"))
return self.user
def generate_fixture_user_manager(self):
self.user_manager = Person.create(
first_name="John",
last_name="Did2",
role="manager",
email=u"*****@*****.**",
password=auth.encrypt_password("mypassword"))
return self.user_manager
def generate_fixture_user_cg_artist(self):
self.user_cg_artist = Person.create(
first_name="John",
last_name="Did3",
email=u"*****@*****.**",
role="user",
password=auth.encrypt_password("mypassword"))
return self.user_cg_artist
def generate_fixture_person(self):
self.person = Person(first_name="John",
last_name="Doe",
desktop_login="******",
email=u"*****@*****.**",
password=auth.encrypt_password("mypassword"))
self.person.save()
def generate_fixture_entity_type(self):
self.entity_type = EntityType.create(name="Props")
self.shot_type = EntityType.create(name="Shot")
self.sequence_type = EntityType.create(name="Sequence")
self.episode_type = EntityType.create(name="Episode")
self.scene_type = EntityType.create(name="Scene")
def generate_fixture_asset_types(self):
self.entity_type_character = EntityType.create(name="Character")
self.entity_type_environment = EntityType.create(name="Environment")
self.entity_type_camera = EntityType.create(name="Camera")
def generate_fixture_department(self):
self.department = Department(name="Modeling", color="#FFFFFF")
self.department.save()
self.department_animation = Department(name="Animation",
color="#FFFFFF")
self.department_animation.save()
def generate_fixture_task_type(self):
self.task_type = TaskType(name="Shaders",
color="#FFFFFF",
department_id=self.department.id)
self.task_type.save()
self.task_type_animation = TaskType(
name="Animation",
color="#FFFFFF",
department_id=self.department_animation.id)
self.task_type_animation.save()
def generate_fixture_task_status(self):
self.task_status = TaskStatus(name="Open",
short_name="opn",
color="#FFFFFF")
self.task_status.save()
def generate_fixture_task_status_wip(self):
self.task_status_wip = TaskStatus(name="WIP",
short_name="wip",
color="#FFFFFF")
self.task_status_wip.save()
def generate_fixture_task_status_to_review(self):
self.task_status_to_review = TaskStatus(name="To review",
short_name="pndng",
color="#FFFFFF")
self.task_status_to_review.save()
def generate_fixture_assigner(self):
self.assigner = Person(first_name="Ema", last_name="Peel")
self.assigner.save()
def generate_fixture_task(self, name="Master", entity_id=None):
if entity_id is None:
entity_id = self.entity.id
start_date = fields.get_date_object("2017-02-20")
due_date = fields.get_date_object("2017-02-28")
real_start_date = fields.get_date_object("2017-02-22")
self.task = Task(name=name,
project_id=self.project.id,
task_type_id=self.task_type.id,
task_status_id=self.task_status.id,
entity_id=entity_id,
assignees=[self.person],
assigner_id=self.assigner.id,
duration=50,
estimation=40,
start_date=start_date,
due_date=due_date,
real_start_date=real_start_date)
self.task.save()
def generate_fixture_task_standard(self):
start_date = fields.get_date_object("2017-02-20")
due_date = fields.get_date_object("2017-02-28")
real_start_date = fields.get_date_object("2017-02-22")
self.task_standard = Task(name="Super modeling",
project_id=self.project_standard.id,
task_type_id=self.task_type.id,
task_status_id=self.task_status.id,
entity_id=self.entity_standard.id,
assignees=[self.person],
assigner_id=self.assigner.id,
duration=50,
estimation=40,
start_date=start_date,
due_date=due_date,
real_start_date=real_start_date)
self.task_standard.save()
def generate_fixture_shot_task(self, name="Master"):
self.shot_task = Task(
name=name,
project_id=self.project.id,
task_type_id=self.task_type_animation.id,
task_status_id=self.task_status.id,
entity_id=self.shot.id,
assignees=[self.person],
assigner_id=self.assigner.id,
)
return self.shot_task.save()
def generate_fixture_scene_task(self, name="Master"):
self.scene_task = Task.create(
name=name,
project_id=self.project.id,
task_type_id=self.task_type_animation.id,
task_status_id=self.task_status.id,
entity_id=self.scene.id,
assignees=[self.person],
assigner_id=self.assigner.id,
)
return self.scene_task
def generate_fixture_sequence_task(self, name="Master"):
self.sequence_task = Task(
name=name,
project_id=self.project.id,
task_type_id=self.task_type_animation.id,
task_status_id=self.task_status.id,
entity_id=self.sequence.id,
assignees=[self.person],
assigner_id=self.assigner.id,
)
self.sequence_task.save()
def generate_fixture_shot_task_standard(self):
self.shot_task_standard = Task(
name="Super animation",
project_id=self.project_standard.id,
task_type_id=self.task_type_animation.id,
task_status_id=self.task_status.id,
entity_id=self.shot_standard.id,
assignees=[self.person],
assigner_id=self.assigner.id)
self.shot_task_standard.save()
def generate_fixture_file_status(self):
self.file_status = FileStatus(name="To review", color="#FFFFFF")
self.file_status.save()
def generate_fixture_working_file(self, name="main", revision=1):
self.working_file = WorkingFile(name=name,
comment="",
revision=revision,
task_id=self.task.id,
entity_id=self.entity.id,
person_id=self.person.id,
software_id=self.software.id)
self.working_file.save()
return self.working_file
def generate_fixture_shot_working_file(self):
self.working_file = WorkingFile(name="main",
comment="",
revision=1,
task_id=self.shot_task.id,
entity_id=self.shot.id,
person_id=self.person.id,
software_id=self.software.id)
self.working_file.save()
def generate_fixture_output_file(self,
output_type=None,
revision=1,
name="main",
task=None):
if output_type is None:
output_type = self.output_type
if task is None:
task_type_id = self.task_type.id
entity_id = self.entity.id
else:
task_type_id = task.task_type_id
entity_id = task.entity_id
self.output_file = OutputFile.create(
comment="",
revision=revision,
task_type_id=task_type_id,
entity_id=entity_id,
person_id=self.person.id,
file_status_id=self.file_status.id,
output_type_id=output_type.id,
name=name)
return self.output_file
def generate_fixture_output_type(self, name="Geometry", short_name="Geo"):
self.output_type = OutputType.create(name=name, short_name=short_name)
return self.output_type
def generate_fixture_software(self):
self.software = Software.create(name="Blender",
short_name="bdr",
file_extension=".blender")
self.software_max = Software.create(name="3dsMax",
short_name="max",
file_extension=".max")
def generate_fixture_preview_file(self, revision=1):
self.preview_file = PreviewFile.create(name="main",
revision=revision,
description="test description",
source="pytest",
task_id=self.task.id,
person_id=self.person.id)
return self.preview_file
def get_fixture_file_path(self, relative_path):
current_path = os.getcwd()
file_path_fixture = os.path.join(current_path, "tests", "fixtures",
relative_path)
return file_path_fixture
def generate_assigned_task(self):
self.generate_fixture_entity()
self.generate_fixture_department()
self.generate_fixture_task_type()
self.generate_fixture_task_status()
self.generate_fixture_person()
self.generate_fixture_assigner()
self.generate_fixture_task()
def generate_shot_suite(self):
self.generate_fixture_entity_type()
self.generate_fixture_project_status()
self.generate_fixture_project()
self.generate_fixture_episode()
self.generate_fixture_sequence()
self.generate_fixture_shot()
self.generate_fixture_scene()