499 lines
20 KiB
Python
499 lines
20 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Test the file_context module.
|
|
|
|
This was written well after I wrote the module, and starts out as a conversion
|
|
from the doctests I had in the module already.
|
|
"""
|
|
|
|
|
|
import unittest, os, textwrap
|
|
import yaml
|
|
|
|
import sys
|
|
print("__file__ = ", __file__)
|
|
sys.path.append(os.path.normpath(os.path.join(__file__, '..', '..')))
|
|
|
|
from abx import file_context
|
|
|
|
class FileContext_Utilities_Tests(unittest.TestCase):
|
|
"""
|
|
Test utility functions and classes that FileContext features depend on.
|
|
"""
|
|
|
|
def test_enum_class_basics(self):
|
|
my_enum = file_context.Enum('ZERO', 'ONE', 'TWO', 'THREE')
|
|
|
|
self.assertEqual(my_enum.number(my_enum.ZERO), 0)
|
|
self.assertEqual(my_enum.number(0), 0)
|
|
self.assertEqual(my_enum.number('ZERO'), 0)
|
|
|
|
self.assertEqual(my_enum.name(my_enum.ZERO), 'ZERO')
|
|
self.assertEqual(my_enum.name(0), 'ZERO')
|
|
self.assertEqual(my_enum.name('ZERO'), 'ZERO')
|
|
|
|
self.assertEqual(my_enum.ONE, 1)
|
|
self.assertEqual(my_enum.name(my_enum.TWO), 'TWO')
|
|
self.assertEqual(my_enum.name(2), 'TWO')
|
|
self.assertEqual(my_enum.number('THREE'), 3)
|
|
|
|
def test_enum_class_blender_enum_options(self):
|
|
my_options = file_context.Enum(
|
|
('ZP', 'ZeroPoint', 'Zero Point'),
|
|
('FP', 'FirstPoint', 'First Point'),
|
|
('LP', 'LastPoint', 'Last Point'))
|
|
|
|
#print("dir(my_options) = ", dir(my_options))
|
|
|
|
self.assertEqual(my_options.number(my_options.ZP), 0)
|
|
self.assertEqual(my_options.number(my_options.FP), 1)
|
|
|
|
self.assertEqual(my_options.name(my_options.ZP), 'ZP')
|
|
self.assertEqual(my_options.name(1), 'FP')
|
|
self.assertEqual(my_options.name('LP'), 'LP')
|
|
|
|
self.assertEqual(my_options[my_options.number('FP')],
|
|
('FP', 'FirstPoint', 'First Point'))
|
|
|
|
self.assertListEqual(my_options.options,
|
|
[('ZP', 'ZeroPoint', 'Zero Point'),
|
|
('FP', 'FirstPoint', 'First Point'),
|
|
('LP', 'LastPoint', 'Last Point')])
|
|
|
|
|
|
class FileContext_NameSchema_Interface_Tests(unittest.TestCase):
|
|
"""
|
|
Test the interfaces presented by FieldSchema.
|
|
|
|
FieldSchema is not really intended to be used from outside the
|
|
file_context module, but it is critical to the behavior of the
|
|
module, so I want to make sure it's working as expected.
|
|
"""
|
|
TESTDATA = os.path.abspath(
|
|
os.path.join(os.path.dirname(__file__), '..', 'testdata'))
|
|
|
|
TESTPROJECTYAML = os.path.join(TESTDATA, 'myproject', 'myproject.yaml')
|
|
|
|
TESTPATH = os.path.join(TESTDATA, 'myproject/Episodes/' +
|
|
'A.001-Pilot/Seq/LP-LastPoint/' +
|
|
'A.001-LP-1-BeginningOfEnd-anim.txt')
|
|
|
|
|
|
# Normally from 'project_schema' in YAML
|
|
TESTSCHEMA_LIST =[
|
|
{'rank': 'project', 'delimiter':'-', 'format':'{:s}', 'words':True},
|
|
{'rank': 'series', 'delimiter':'E', 'format':'{:2s}'},
|
|
{'rank': 'episode', 'delimiter':'-', 'format':'{!s:>02s}'},
|
|
{'rank': 'sequence','delimiter':'-', 'format':'{:2s}'},
|
|
{'rank': 'block', 'delimiter':'-', 'format':'{!s:1s}'},
|
|
{'rank': 'shot', 'delimiter':'-', 'format':'{!s:s}'},
|
|
{'rank': 'element', 'delimiter':'-', 'format':'{!s:s}'}]
|
|
|
|
|
|
|
|
|
|
class FileContext_Parser_UnitTests(unittest.TestCase):
|
|
TESTFILENAMES = ('S1E01-SF-4-SoyuzDMInt-cam.blend', 'S1E02-MM-MediaMontage-compos.blend',
|
|
'S1E01-PC-PressConference-edit.kdenlive',
|
|
'S1E01-LA-Launch.kdenlive')
|
|
|
|
# Collected by analyzing YAML control files ('project_unit').
|
|
TESTNAMEPATHS = (('Lunatics', 'S1', '1', 'SF', '4'),
|
|
('Lunatics', 'S1', '2', 'MM'),
|
|
('Lunatics', 'S1', '1', 'PC'),
|
|
('Lunatics', 'S1', '1', 'LA'))
|
|
|
|
# Normally from 'project_schema' in YAML
|
|
TESTSCHEMA_LIST =[
|
|
{'rank': 'project', 'delimiter':'-', 'format':'{:s}', 'words':True},
|
|
{'rank': 'series', 'delimiter':'E', 'format':'{:2s}'},
|
|
{'rank': 'episode', 'delimiter':'-', 'format':'{!s:>02s}'},
|
|
{'rank': 'sequence','delimiter':'-', 'format':'{:2s}'},
|
|
{'rank': 'block', 'delimiter':'-', 'format':'{!s:1s}'},
|
|
{'rank': 'shot', 'delimiter':'-', 'format':'{!s:s}'},
|
|
{'rank': 'element', 'delimiter':'-', 'format':'{!s:s}'}]
|
|
|
|
# Normally from 'definitions' in YAML
|
|
TESTDEFS = {
|
|
'filetypes':{
|
|
'blend': "Blender File",
|
|
'kdenlive': "Kdenlive Video Editor File",
|
|
'mlt': "Kdenlive Video Mix Script",
|
|
'svg': "Scalable Vector Graphics (Inkscape)",
|
|
'kra': "Krita Graphic File",
|
|
'xcf': "Gimp Graphic File",
|
|
'png': "Portable Network Graphics (PNG) Image",
|
|
'jpg': "Joint Photographic Experts Group (JPEG) Image",
|
|
'aup': "Audacity Project",
|
|
'ardour': "Ardour Project",
|
|
'flac': "Free Lossless Audio Codec (FLAC)",
|
|
'mp3': "MPEG Audio Layer III (MP3) Audio File",
|
|
'ogg': "Ogg Vorbis Audio File",
|
|
'avi': "Audio Video Interleave (AVI) Video Container",
|
|
'mkv': "Matroska Video Container",
|
|
'mp4': "Moving Picture Experts Group (MPEG) 4 Format}",
|
|
},
|
|
'roles':{
|
|
'extras': "Extras, crowds, auxillary animated movement",
|
|
'mech': "Mechanical animation",
|
|
'anim': "Character animation",
|
|
'cam': "Camera direction",
|
|
'vfx': "Visual special effects",
|
|
'compos': "Compositing",
|
|
'bkg': "Background 2D image",
|
|
'bb': "Billboard 2D image",
|
|
'tex': "Texture 2D image",
|
|
'foley': "Foley sound",
|
|
'voice': "Voice recording",
|
|
'fx': "Sound effects",
|
|
'music': "Music track",
|
|
'cue': "Musical cue",
|
|
'amb': "Ambient sound",
|
|
'loop': "Ambient sound loop",
|
|
'edit': "Video edit"
|
|
},
|
|
'roles_by_filetype': {
|
|
'kdenlive': 'edit',
|
|
'mlt': 'edit'
|
|
}
|
|
}
|
|
|
|
TESTDATA = os.path.abspath(
|
|
os.path.join(os.path.dirname(__file__), '..', 'testdata'))
|
|
|
|
TESTPATH = os.path.join(TESTDATA, 'myproject/Episodes/' +
|
|
'A.001-Pilot/Seq/LP-LastPoint/' +
|
|
'A.001-LP-1-BeginningOfEnd-anim.txt')
|
|
|
|
def setUp(self):
|
|
self.TESTSCHEMAS = [file_context.FieldSchema( #rank=s['rank'],
|
|
schema=s)
|
|
for s in self.TESTSCHEMA_LIST]
|
|
|
|
def test_parsing_filenames_w_episode_parser(self):
|
|
abx_episode_parser = file_context.NameParsers['abx_episode']()
|
|
|
|
data = abx_episode_parser('S1E01-SF-4-SoyuzDMInt-cam.blend', [])
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': 'blend',
|
|
'role': 'cam',
|
|
'hierarchy': 'episode',
|
|
'series': {'code': 'S1'},
|
|
'episode': {'code': 1},
|
|
'rank': 'block',
|
|
'seq': {'code': 'SF'},
|
|
'block': {'code': 4, 'title': 'Soyuz DMI nt'}})
|
|
|
|
data = abx_episode_parser('S1E02-MM-MediaMontage-compos.blend', [])
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': 'blend',
|
|
'role': 'compos',
|
|
'hierarchy': 'episode',
|
|
'series': {'code': 'S1'},
|
|
'episode': {'code': 2},
|
|
'rank': 'seq',
|
|
'seq': {'code': 'MM', 'title': 'Media Montage'}})
|
|
|
|
data = abx_episode_parser('S1E01-PC-PressConference-edit.kdenlive', [])
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': 'kdenlive',
|
|
'role': 'edit',
|
|
'hierarchy': 'episode',
|
|
'series': {'code': 'S1'},
|
|
'episode': {'code': 1},
|
|
'rank': 'seq',
|
|
'seq': {'code': 'PC', 'title': 'Press Conference'}})
|
|
|
|
data = abx_episode_parser('S1E01-LA-Launch.kdenlive', [])
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': 'kdenlive',
|
|
'role': 'edit',
|
|
'hierarchy': 'episode',
|
|
'series': {'code': 'S1'},
|
|
'episode': {'code': 1},
|
|
'rank': 'seq',
|
|
'seq': {'code': 'LA', 'title': 'Launch'}})
|
|
|
|
|
|
def test_parsing_filenames_w_schema_parser(self):
|
|
abx_schema_parser = file_context.NameParsers['abx_schema'](
|
|
schemas=self.TESTSCHEMAS, definitions=self.TESTDEFS)
|
|
|
|
data = abx_schema_parser('S1E01-SF-4-SoyuzDMInt-cam.blend',
|
|
namepath=self.TESTNAMEPATHS[0])
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': 'blend',
|
|
'comment': None,
|
|
'role': 'cam',
|
|
'title': 'SoyuzDMInt',
|
|
'series': {'code': 'S1'},
|
|
'episode': {'code': '01'},
|
|
'sequence': {'code': 'SF'},
|
|
'block': {'code': '4', 'title':'SoyuzDMInt'},
|
|
'rank': 'block'}
|
|
)
|
|
|
|
data = abx_schema_parser('S1E02-MM-MediaMontage-compos.blend',
|
|
namepath=self.TESTNAMEPATHS[1])
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': 'blend',
|
|
'comment': None,
|
|
'role': 'compos',
|
|
'title': 'MediaMontage',
|
|
'series': {'code': 'S1'},
|
|
'episode': {'code': '02'},
|
|
'sequence': {'code': 'MM', 'title':'MediaMontage'},
|
|
'rank': 'sequence'}
|
|
)
|
|
|
|
data = abx_schema_parser('S1E01-PC-PressConference-edit.kdenlive',
|
|
namepath=self.TESTNAMEPATHS[2])
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': 'kdenlive',
|
|
'comment': None,
|
|
'role': 'edit',
|
|
'title': 'PressConference',
|
|
'series': {'code': 'S1'},
|
|
'episode': {'code': '01'},
|
|
'sequence': {'code': 'PC', 'title':'PressConference'},
|
|
'rank': 'sequence'}
|
|
)
|
|
|
|
data = abx_schema_parser('S1E01-LA-Launch.kdenlive',
|
|
namepath=self.TESTNAMEPATHS[3])
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': 'kdenlive',
|
|
'comment': None,
|
|
'role': 'edit',
|
|
'title': 'Launch',
|
|
'series': {'code': 'S1'},
|
|
'episode': {'code': '01'},
|
|
'sequence': {'code': 'LA', 'title':'Launch'},
|
|
'rank': 'sequence'}
|
|
)
|
|
|
|
def test_parsing_filenames_w_fallback_parser(self):
|
|
abx_fallback_parser = file_context.NameParsers['abx_fallback']()
|
|
|
|
data = abx_fallback_parser('S1E01-SF-4-SoyuzDMInt-cam.blend', None)
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': 'blend',
|
|
'role': 'cam',
|
|
'comment': None,
|
|
'title': 'S1E01-SF-4-SoyuzDMInt',
|
|
'code': 'S1e01Sf4Soyuzdmint'
|
|
})
|
|
|
|
data = abx_fallback_parser('S1E01-SF-4-SoyuzDMInt-cam~~2021-01.blend', None)
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': 'blend',
|
|
'role': 'cam',
|
|
'comment': '2021-01',
|
|
'title': 'S1E01-SF-4-SoyuzDMInt',
|
|
'code': 'S1e01Sf4Soyuzdmint'
|
|
})
|
|
|
|
|
|
data = abx_fallback_parser('S1E02-MM-MediaMontage-compos.blend', None)
|
|
self.assertDictEqual(data[1],
|
|
{'filetype':'blend',
|
|
'role':'compos',
|
|
'comment': None,
|
|
'title': 'S1E02-MM-MediaMontage',
|
|
'code': 'S1e02MmMediamontage'
|
|
})
|
|
|
|
data = abx_fallback_parser('S1E01-PC-PressConference', None)
|
|
self.assertDictEqual(data[1],
|
|
{'filetype': None,
|
|
'role': None,
|
|
'comment': None,
|
|
'title': 'S1E01-PC-PressConference',
|
|
'code': 'S1e01PcPressconference'
|
|
})
|
|
|
|
|
|
class FileContext_Implementation_UnitTests(unittest.TestCase):
|
|
TESTDATA = os.path.abspath(
|
|
os.path.join(os.path.dirname(__file__), '..', 'testdata'))
|
|
|
|
TESTPATH = os.path.join(TESTDATA, 'myproject/Episodes/' +
|
|
'A.001-Pilot/Seq/LP-LastPoint/' +
|
|
'A.001-LP-1-BeginningOfEnd-anim.txt')
|
|
|
|
def test_filecontext_finds_and_loads_file(self):
|
|
fc = file_context.FileContext(self.TESTPATH)
|
|
|
|
# print('\ntest_filecontext_finds_and_loads_file')
|
|
# print(fc.get_log_text('INFO'))
|
|
# print(dir(self))
|
|
|
|
self.assertEqual(fc.filename, 'A.001-LP-1-BeginningOfEnd-anim.txt')
|
|
self.assertEqual(fc.root, os.path.join(self.TESTDATA, 'myproject'))
|
|
self.assertListEqual(fc.folders,
|
|
['myproject', 'Episodes', 'A.001-Pilot', 'Seq', 'LP-LastPoint'])
|
|
|
|
def test_filecontext_gets_correct_yaml_for_file(self):
|
|
fc = file_context.FileContext(self.TESTPATH)
|
|
# Look for data from three expected YAML files:
|
|
# From the project YAML file:
|
|
self.assertEqual(fc.provided_data['definitions']['omit_ranks']['scene'], 3)
|
|
# From the sequence directory YAML file:
|
|
self.assertEqual(fc.provided_data['project_unit'][-2]['name'], 'Last Point')
|
|
# From the sidecar YAML file:
|
|
self.assertEqual(fc.provided_data['project_unit'][-1]['code'], 1)
|
|
|
|
def test_filecontext_gets_correct_filename_info(self):
|
|
fc = file_context.FileContext(self.TESTPATH)
|
|
self.assertEqual(fc.filetype, 'txt')
|
|
self.assertEqual(fc.role, 'anim')
|
|
self.assertEqual(fc.title, 'BeginningOfEnd')
|
|
self.assertEqual(fc.comment, None)
|
|
|
|
def test_filecontext_abx_fields_include_default(self):
|
|
fc0 = file_context.FileContext()
|
|
fc1 = file_context.FileContext('')
|
|
fc2 = file_context.FileContext(self.TESTPATH)
|
|
|
|
for fc in (fc0, fc1, fc2):
|
|
self.assertIn('render_profiles', fc.abx_fields)
|
|
|
|
|
|
|
|
class FileContext_API_UnitTests(unittest.TestCase):
|
|
TESTDATA = os.path.abspath(
|
|
os.path.join(os.path.dirname(__file__), '..', 'testdata'))
|
|
|
|
TESTPATH = os.path.join(TESTDATA, 'myproject/Episodes/' +
|
|
'A.001-Pilot/Seq/LP-LastPoint/' +
|
|
'A.001-LP-1-BeginningOfEnd-anim.txt')
|
|
|
|
def setUp(self):
|
|
self.fc = file_context.FileContext(self.TESTPATH)
|
|
|
|
def test_filecontext_API_namepath(self):
|
|
self.assertListEqual( self.fc.namepath, ['myproject', 'A', 1, 'LP', 1])
|
|
|
|
def test_filecontext_API_rank(self):
|
|
self.assertEqual(self.fc.rank, 'block')
|
|
|
|
def test_filecontext_API_code(self):
|
|
self.assertEqual(self.fc.code, 1)
|
|
|
|
def test_filecontext_API_name(self):
|
|
self.assertEqual(self.fc.name, 'BeginningOfEnd')
|
|
|
|
def test_filecontext_API_designation(self):
|
|
self.assertEqual(self.fc.designation,
|
|
'myproject-A.001-LP-1')
|
|
|
|
def test_filecontext_API_fullname(self):
|
|
self.assertEqual(self.fc.fullname, 'myproject-A.001-LP-1-BeginningOfEnd')
|
|
|
|
def test_filecontext_API_shortname(self):
|
|
self.assertEqual(self.fc.shortname, 'A.001-LP-1-BeginningOfEnd')
|
|
|
|
def test_filecontext_API_scene_name(self):
|
|
self.assertEqual(self.fc.get_scene_name('Test'), 'LP-1 Test')
|
|
|
|
def test_filecontext_API_render_root(self):
|
|
self.assertEqual(os.path.abspath(self.fc.render_root),
|
|
os.path.abspath(os.path.join(self.TESTDATA,
|
|
'myproject/Episodes/A.001-Pilot/Renders')))
|
|
|
|
def test_filecontext_API_get_render_path(self):
|
|
self.assertEqual(os.path.abspath(self.fc.get_render_path(suffix='T')),
|
|
os.path.abspath(os.path.join(self.TESTDATA,
|
|
'myproject', 'Episodes', 'A.001-Pilot', 'Renders',
|
|
'T', 'A.001-LP-1', 'A.001-LP-1-T-f#####.png')))
|
|
|
|
def test_filecontext_API_new_name_context_explicit(self):
|
|
nc = self.fc.new_name_context(shot='A')
|
|
self.assertEqual(nc.get_scene_name('Exp'), 'LP-1-A Exp')
|
|
|
|
def test_filecontext_API_new_name_context_implicit(self):
|
|
nc = self.fc.new_name_context(rank='shot')
|
|
self.assertEqual(nc.get_scene_name('Imp'), 'LP-1-A Imp')
|
|
|
|
|
|
class NameContext_API_Tests(unittest.TestCase):
|
|
TESTDATA = os.path.abspath(
|
|
os.path.join(os.path.dirname(__file__), '..', 'testdata'))
|
|
|
|
TESTPATH = os.path.join(TESTDATA, 'myproject/Episodes/' +
|
|
'A.001-Pilot/Seq/LP-LastPoint/' +
|
|
'A.001-LP-1-BeginningOfEnd-anim.txt')
|
|
|
|
def setUp(self):
|
|
fc = file_context.FileContext(self.TESTPATH)
|
|
self.nc = fc.new_name_context(rank='shot', shot='A')
|
|
|
|
def test_namecontext_reports_correct_rank(self):
|
|
self.assertEqual(self.nc.rank, 'shot')
|
|
|
|
def test_namecontext_reports_correct_code(self):
|
|
self.assertEqual(self.nc.code, 'A')
|
|
|
|
def test_namecontext_reports_correct_namepath(self):
|
|
self.assertEqual(self.nc.namepath, ['myproject', 'A', 1, 'LP', 1, None, 'A'])
|
|
|
|
|
|
class FileContext_FailOver_Tests(unittest.TestCase):
|
|
"""
|
|
Tests of how well FileContext copes with imperfect data.
|
|
|
|
It's very likely that ABX will encounter projects that aren't
|
|
set up perfectly (or at all), and we don't want it to crash
|
|
in that situation, but rather fail gracefully or even work
|
|
around the problem.
|
|
"""
|
|
TESTDATA = os.path.abspath(
|
|
os.path.join(os.path.dirname(__file__), '..', 'testdata'))
|
|
|
|
TEST_EMPTY_PROJECT = os.path.join(TESTDATA, 'empty')
|
|
|
|
TEST_NONEXISTENT_PATH = os.path.join(TESTDATA,
|
|
'empty', 'Non', 'Existing', 'F', 'F-1-NonExisting-anim.blend')
|
|
|
|
TEST_NO_YAML = os.path.join(TESTDATA,
|
|
'yamlless', 'Episodes', 'Ae1-Void', 'Seq', 'VN-VagueName',
|
|
'Ae1-VN-1-VoidOfData-anim.txt')
|
|
|
|
TEST_MINIMAL_YAML = os.path.join(TESTDATA,
|
|
'yaminimal', 'Episodes', 'Ae1-Void', 'Seq', 'VN-VagueName',
|
|
'Ae1-VN-1-VoidOfData-anim.txt')
|
|
|
|
def test_filecontext_finds_default_yaml(self):
|
|
self.assertIn('abx_default', file_context.DEFAULT_YAML)
|
|
|
|
def test_filecontext_no_project_path(self):
|
|
fc = file_context.FileContext()
|
|
self.assertFalse(fc.file_exists)
|
|
self.assertFalse(fc.folder_exists)
|
|
self.assertIn('abx_default', fc.provided_data)
|
|
# What to test?
|
|
# The main thing is that it doesn't crash.
|
|
|
|
def test_filecontext_failover_empty_project(self):
|
|
fc = file_context.FileContext(self.TEST_EMPTY_PROJECT)
|
|
self.assertFalse(fc.file_exists)
|
|
self.assertTrue(fc.folder_exists)
|
|
self.assertIn('abx_default', fc.provided_data)
|
|
|
|
def test_filecontext_failover_nonexisting_file(self):
|
|
fc = file_context.FileContext(self.TEST_NONEXISTENT_PATH)
|
|
self.assertFalse(fc.file_exists)
|
|
self.assertFalse(fc.folder_exists)
|
|
self.assertIn('abx_default', fc.provided_data)
|
|
|
|
def test_filecontext_failover_no_yaml(self):
|
|
fc = file_context.FileContext(self.TEST_NO_YAML)
|
|
self.assertIn('abx_default', fc.provided_data)
|
|
# It finds the backstop root YAML in the testdata:
|
|
self.assertEqual(fc.root, self.TESTDATA)
|
|
|
|
def test_filecontext_failover_minimal_yaml(self):
|
|
fc = file_context.FileContext(self.TEST_MINIMAL_YAML)
|
|
self.assertIn('abx_default', fc.provided_data)
|
|
|