def setUp(self):
super(QueryTestCase, self).setUp()
self.generate_fixture_project_status()
self.generate_fixture_project()
self.project_id = self.project.id
project = Project(name='Kitchen',
project_status_id=self.open_status.id)
project.save()
self.project2_id = project.id
self.entity_type = EntityType(name='Shot Cosmos Landromat')
self.entity_type.save()
self.generate_data(Entity,
3,
entities_out=[],
entities_in=[],
project_id=self.project_id,
entity_type_id=self.entity_type.id)
self.generate_data(Entity,
2,
entities_out=[],
entities_in=[],
project_id=self.project2_id,
entity_type_id=self.entity_type.id)
class FolderPathTestCase(ApiDBTestCase):
def setUp(self):
super(FolderPathTestCase, self).setUp()
self.generate_fixture_project_status()
self.project_standard = Project(
name='Iris',
project_status_id=self.open_status.id
)
self.project_standard.save()
def test_set_file_tree(self):
tree = file_tree.get_tree_from_file('standard')
path = "project/%s/set-tree" % self.project_standard.id
project = self.post(path, {"tree_name": "standard"}, 200)
self.assertEquals(project["file_tree"], tree)
project = self.get("data/projects/%s" % self.project_standard.id)
self.assertEquals(project["file_tree"], tree)
def test_set_file_tree_400(self):
path = "project/%s/set-tree" % self.project_standard.id
self.post(path, {"name": "standard"}, 400)
self.post(path, {"tree_name": "not_exist"}, 400)
def test_set_file_tree_404(self):
path = "project/not-exist/set-tree"
self.post(path, {"tree_name": "standard"}, 404)
def test_project(self):
project_id = "d98a6269-e566-4e11-b29f-b3faa2039d79"
project_name = "Caminandes"
Project.create_from_import({
"team": [str(self.person.id)],
"id":
project_id,
"created_at":
"2019-06-20T12:28:16",
"updated_at":
"2019-08-30T12:48:09",
"name":
project_name,
"has_avatar":
True,
"fps":
"25",
"production_type":
"tvshow",
"start_date":
"2019-07-01",
"end_date":
"2021-12-31",
"project_status_id":
str(self.open_status.id),
"type":
"Project"
})
project = Project.get(project_id)
self.assertEqual(project.name, project_name)
def test_get_or_create_instance_by_name(self):
self.assertIsNone(Project.get_by(name="Test"))
project = \
base_service.get_or_create_instance_by_name(Project, name="Test")
self.assertIsNotNone(Project.get_by(name="Test"))
project_again = \
base_service.get_or_create_instance_by_name(Project, name="Test")
self.assertEquals(project["id"], project_again["id"])
def setUp(self):
super(FolderPathTestCase, self).setUp()
self.generate_fixture_project_status()
self.project_standard = Project(
name='Iris',
project_status_id=self.open_status.id
)
self.project_standard.save()
def get_or_create(name):
project = Project.get_by(name=name)
if project is None:
open_status = get_or_create_open_status()
project = Project(
name=name,
project_status_id=open_status.id
)
project.save()
return project
def test_sync_event(self):
sync_service.sync_event({
"name": "project:new",
"data": {
"project_id": self.new_project_id
}
})
self.assertIsNotNone(Project.get(self.new_project_id))
sync_service.sync_event({
"name": "project:delete",
"data": {
"project_id": self.new_project_id
}
})
self.assertIsNone(Project.get(self.new_project_id))
def get_full_asset(asset_id):
asset = get_asset(asset_id)
asset_type = get_asset_type_raw(asset["entity_type_id"])
project = Project.get(asset["project_id"])
asset["project_name"] = project.name
asset["asset_type_id"] = str(asset_type.id)
asset["asset_type_name"] = asset_type.name
tasks = Task.query \
.filter_by(entity_id=asset_id) \
.all()
task_dicts = []
for task in tasks:
task_dicts.append({
"id":
str(task.id),
"task_status_id":
str(task.task_status_id),
"task_type_id":
str(task.task_type_id),
"assignees": [str(assignee.id) for assignee in task.assignees]
})
asset["tasks"] = task_dicts
return asset
def task_to_review(task_id, person, comment, preview_path=""):
task = get_task_raw(task_id)
to_review_status = get_to_review_status()
task_dict_before = task.serialize()
task.update({"task_status_id": to_review_status["id"]})
task.save()
project = Project.get(task.project_id)
entity = Entity.get(task.entity_id)
entity_type = EntityType.get(entity.entity_type_id)
task_dict_after = task.serialize()
task_dict_after["project"] = project.serialize()
task_dict_after["entity"] = entity.serialize()
task_dict_after["entity_type"] = entity_type.serialize()
task_dict_after["person"] = person
task_dict_after["comment"] = comment
task_dict_after["preview_path"] = preview_path
events.emit("task:to-review", {
"task_before": task_dict_before,
"task_after": task_dict_after
})
return task_dict_after
def test_import_sequence(self):
self.load_fixture('projects')
sg_sequence = {
"project": {
"type": "Project",
"id": 1,
"name": "Cosmos Landromat"
},
"code": "S04",
"type": "Sequence",
"id": 4,
"description": "test description"
}
api_path = "data/import/shotgun/sequences"
self.sequences = self.post(api_path, [sg_sequence], 200)
self.assertEqual(len(self.sequences), 1)
self.sequences = self.get("data/sequences")
self.assertEqual(len(self.sequences), 1)
sequence = self.sequences[0]
project = Project.get_by(name="Cosmos Landromat")
self.assertEqual(sequence["name"], sg_sequence["code"])
self.assertEqual(sequence["description"], sg_sequence["description"])
self.assertEqual(sequence["shotgun_id"], sg_sequence["id"])
self.assertEqual(sequence["project_id"], str(project.id))
def task_to_review(task_id, person, comment, preview_path=""):
"""
Change the task status to "waiting for approval" if it is not already the
case. It emits a *task:to-review* event. Change the real start date time to
now.
"""
task = get_task_raw(task_id)
to_review_status = get_to_review_status()
task_dict_before = task.serialize()
task.update({"task_status_id": to_review_status["id"]})
task.save()
project = Project.get(task.project_id)
entity = Entity.get(task.entity_id)
entity_type = EntityType.get(entity.entity_type_id)
task_dict_after = task.serialize()
task_dict_after["project"] = project.serialize()
task_dict_after["entity"] = entity.serialize()
task_dict_after["entity_type"] = entity_type.serialize()
task_dict_after["person"] = person
task_dict_after["comment"] = comment
task_dict_after["preview_path"] = preview_path
events.emit("task:to-review", {
"task_before": task_dict_before,
"task_after": task_dict_after
})
return task_dict_after
def get_project_by_name(project_name):
project = Project.get_by(name=project_name)
if project is None:
raise ProjectNotFoundException()
return project
def to_review_task(task, output_file_dict):
to_review_status = get_to_review_status()
task_dict_before = task.serialize()
task.update({"task_status_id": to_review_status.id})
task.save()
project = Project.get(task.project_id)
entity = Entity.get(task.entity_id)
entity_type = EntityType.get(entity.entity_type_id)
person = Person.get(output_file_dict["person_id"])
task_dict_after = task.serialize()
task_dict_after["output_file"] = output_file_dict
task_dict_after["project"] = project.serialize()
task_dict_after["entity"] = entity.serialize()
task_dict_after["entity_type"] = entity_type.serialize()
task_dict_after["person"] = person.serialize()
events.emit("task:to-review", {
"task_before": task_dict_before,
"task_after": task_dict_after
})
return task
def test_import_asset(self):
self.load_fixture('projects')
sg_asset = {
"code": "Cake",
"description": "yellow cake",
"project": {
"type": "Project",
"id": 1,
"name": "Cosmos Landromat"
},
"sg_asset_type": "Props",
"type": "Asset",
"id": 3
}
api_path = "data/import/shotgun/assets"
self.assets = self.post(api_path, [sg_asset], 200)
self.assertEqual(len(self.assets), 1)
self.assets = self.get("data/entities")
self.assertEqual(len(self.assets), 1)
asset = self.assets[0]
project = Project.get_by(shotgun_id=sg_asset["project"]["id"])
self.assertEqual(asset["description"], sg_asset["description"])
self.assertEqual(asset["shotgun_id"], sg_asset["id"])
self.assertEqual(asset["project_id"], str(project.id))
def save(self):
self.generate_fixture_project_status()
project = self.generate_fixture_project()
project.name = "new name"
project.save()
project = Project.get(project.id)
self.assertEqual(project.name, "new name")
def test_import_shot(self):
self.load_fixture('projects')
self.load_fixture('sequences')
self.load_fixture('assets')
self.load_fixture('scenes')
api_path = "/import/shotgun/shots"
self.shots = self.post(api_path, [self.sg_shot], 200)
self.assertEqual(len(self.shots), 1)
self.shots = self.get("data/shots/all")
self.assertEqual(len(self.shots), 1)
shot = self.shots[0]
sequence = Entity.get_by(
shotgun_id=self.sg_shot["sg_sequence"]["id"],
entity_type_id=shots_service.get_sequence_type()["id"]
)
entity = Entity.get_by(name=self.sg_shot["assets"][0]["name"])
project = Project.get_by(name=self.sg_shot["project"]["name"])
scene = Entity.get_by(name=self.sg_shot["sg_scene"]["name"])
self.assertEqual(shot["name"], self.sg_shot["code"])
self.assertEqual(shot["data"]["frame_in"], 0)
self.assertEqual(shot["data"]["frame_out"], 122)
self.assertEqual(shot["data"]["sg_custom_field"], "test")
self.assertEqual(shot["parent_id"], str(sequence.id))
self.assertEqual(shot["entities_out"][0], str(entity.id))
self.assertEqual(shot["project_id"], str(project.id))
self.assertEqual(shot["source_id"], str(scene.id))
def related_projects():
projects = Project.query \
.join(Task) \
.filter(assignee_filter()) \
.filter(open_project_filter()) \
.all()
return Project.serialize_list(projects)
def generate_fixture_project(self, name="Cosmos Landromat"):
self.project = Project.create(name=name,
project_status_id=self.open_status.id)
self.project_id = self.project.id
self.project.update(
{"file_tree": file_tree_service.get_tree_from_file("simple")})
return self.project
def test_import_task(self):
self.load_task()
self.assertEqual(len(self.tasks), 1)
self.tasks = self.get("data/tasks")
self.assertEqual(len(self.tasks), 1)
task = self.tasks[0]
task = tasks_service.get_task_with_relations(task["id"])
project = Project.get_by(name=self.sg_task["project"]["name"])
task_type = \
TaskType.get_by(name=self.sg_task["step"]["name"])
task_status = TaskStatus.get_by(
short_name=self.sg_task["sg_status_list"])
assets = assets_service.get_assets(
{"shotgun_id": self.sg_task["entity"]["id"]})
entity = assets[0]
assigner = Person.get_by(
last_name=self.sg_task["created_by"]["name"].split(" ")[1])
assignee = Person.get_by(
last_name=self.sg_task["task_assignees"][0]["name"].split(" ")[1])
self.assertEqual(task["name"], self.sg_task["cached_display_name"])
self.assertEqual(task["duration"], self.sg_task["duration"])
self.assertEqual(task["shotgun_id"], self.sg_task["id"])
self.assertEqual(task["project_id"], str(project.id))
self.assertEqual(task["task_type_id"], str(task_type.id))
self.assertEqual(task["task_status_id"], str(task_status.id))
self.assertEqual(task["entity_id"], entity["id"])
self.assertEqual(task["assigner_id"], str(assigner.id))
self.assertEqual(task["assignees"][0], str(assignee.id))
def get_full_shot(shot_id):
shot = get_shot(shot_id)
sequence = Entity.get(shot["parent_id"])
project = Project.get(shot["project_id"])
shot["project_name"] = project.name
shot["sequence_id"] = str(sequence.id)
shot["sequence_name"] = sequence.name
if sequence.parent_id is not None:
episode = Entity.get(sequence.parent_id)
shot["episode_id"] = str(episode.id)
shot["episode_name"] = episode.name
tasks = Task.query \
.filter_by(entity_id=shot_id) \
.all()
task_dicts = []
for task in tasks:
task_dicts.append({
"id":
str(task.id),
"task_status_id":
str(task.task_status_id),
"task_type_id":
str(task.task_type_id),
"assignees": [str(assignee.id) for assignee in task.assignees]
})
shot["tasks"] = task_dicts
return shot
def prepare_import(self):
self.project_ids = Project.get_id_map()
self.person_ids = Person.get_id_map()
self.task_type_ids = TaskType.get_id_map(field="name")
self.task_status_ids = TaskStatus.get_id_map(field="short_name")
self.asset_ids = self.get_asset_map()
self.shot_ids = self.get_shot_map()
def generate_fixture_project_no_preview_tree(self):
self.project_no_preview_tree = Project.create(
name="Agent 327", project_status_id=self.open_status.id
)
self.project_no_preview_tree.update(
{"file_tree": file_tree_service.get_tree_from_file("no_preview")}
)
def test_import_sequence(self):
self.load_fixture("projects")
self.load_fixture("episodes")
sg_sequence = {
"project": {"type": "Project", "id": 1, "name": "Agent327"},
"episode": {"type": "Episode", "id": 1, "name": "E01"},
"code": "S04",
"type": "Sequence",
"id": 4,
"description": "test description",
}
api_path = "/import/shotgun/sequences"
self.sequences = self.post(api_path, [sg_sequence], 200)
self.assertEqual(len(self.sequences), 1)
self.sequences = self.get("data/sequences")
self.assertEqual(len(self.sequences), 1)
sequence = self.sequences[0]
project = Project.get_by(name="Agent327")
episode = Entity.get_by(name="E01")
self.assertEqual(sequence["name"], sg_sequence["code"])
self.assertEqual(sequence["description"], sg_sequence["description"])
self.assertEqual(sequence["shotgun_id"], sg_sequence["id"])
self.assertEqual(sequence["project_id"], str(project.id))
self.assertEqual(sequence["parent_id"], str(episode.id))
def generate_fixture_project_standard(self):
self.project_standard = Project.create(
name="Big Buck Bunny", project_status_id=self.open_status.id
)
self.project_standard.update(
{"file_tree": file_tree_service.get_tree_from_file("default")}
)
def test_import_episode(self):
self.load_fixture('projects')
sg_episode = {
"project": {
"type": "Project",
"id": 4,
"name": "Agent327"
},
"code": "E04",
"type": "Episode",
"id": 4,
"description": "test description"
}
api_path = "/import/shotgun/episodes"
self.episodes = self.post(api_path, [sg_episode], 200)
self.assertEqual(len(self.episodes), 1)
self.episodes = self.get("data/episodes")
self.assertEqual(len(self.episodes), 1)
episode = self.episodes[0]
project = Project.get_by(name="Agent327")
self.assertEqual(episode["name"], sg_episode["code"])
self.assertEqual(episode["description"], sg_episode["description"])
self.assertEqual(episode["shotgun_id"], sg_episode["id"])
self.assertEqual(episode["project_id"], str(project.id))
def get_full_asset(asset_id):
"""
Return asset matching given id with additional information (project name,
asset type name and tasks).
"""
asset = get_asset(asset_id)
asset_type = get_asset_type(asset["entity_type_id"])
project = Project.get(asset["project_id"])
asset["project_name"] = project.name
asset["asset_type_id"] = asset_type["id"]
asset["asset_type_name"] = asset_type["name"]
tasks = Task.query \
.filter_by(entity_id=asset_id) \
.all()
task_dicts = []
for task in tasks:
task_dicts.append({
"id":
str(task.id),
"task_status_id":
str(task.task_status_id),
"task_type_id":
str(task.task_type_id),
"assignees": [str(assignee.id) for assignee in task.assignees]
})
asset["tasks"] = task_dicts
return asset
def get_project_from_preview_file(preview_file_id):
"""
Get project dict of related preview file.
"""
preview_file = files_service.get_preview_file_raw(preview_file_id)
task = Task.get(preview_file.task_id)
project = Project.get(task.project_id)
return project.serialize()
def test_get_id_map(self):
self.generate_fixture_project_status()
self.generate_fixture_project()
project_id = self.generate_fixture_project("Second project").id
project_map = Project.get_id_map(field="name")
self.assertTrue("Second project" in project_map)
project_id_again = project_map["Second project"]
self.assertEqual(project_id_again, project_id)
def test_get_open_projects(self):
projects = self.get("data/user/projects/open")
self.assertEquals(len(projects), 0)
project = Project.get(self.project_id)
project.team.append(self.user)
project.save()
projects = self.get("data/user/projects/open")
self.assertEquals(len(projects), 1)
project = Project.get(self.project_id)
project.team[:] = []
project.save()
projects = self.get("data/user/projects/open")
self.assertEquals(len(projects), 0)
def update(self):
self.generate_fixture_project_status()
project = self.generate_fixture_project()
project.update({
"name": "new name"
})
project = Project.get(project.id)
self.assertEqual(project.name, "new name")
