def test_optional_values(self):
"""
Test that optional keys do not appear as missing.
"""
definition = "shots/[{Sequence}]/{Shot}/{Step}/work/{Shot}.{branch}[.v{version}][.{snapshot}].ma"
template = Template(definition, self.keys)
fields = {
"Shot": "shot value",
"Step": "step value",
"branch": "branch value"
}
# all optional fields skipped
result = template.missing_keys(fields)
self.assertEqual([], result)
# value allowed for optional field
fields["snapshot"] = "snapshot value"
result = template.missing_keys(fields)
self.assertEqual([], result)
# required field missing
del (fields["Shot"])
result = template.missing_keys(fields)
self.assertEqual(["Shot"], result)
def test_aliased_key(self):
key = StringKey("aliased_name")
self.keys["initial_name"] = key
definition = "something/{Shot}/{initial_name}"
template = Template(definition, self.keys)
fields = {"aliased_name": "some value", "Shot": "shot value"}
result = template.missing_keys(fields)
self.assertEqual([], result)
fields = {"initial_name": "some_value", "Shot": "shot value"}
result = template.missing_keys(fields)
self.assertEqual(["aliased_name"], result)
def test_aliased_key(self):
key = StringKey("aliased_name")
self.keys["initial_name"] = key
definition = "something/{Shot}/{initial_name}"
template = Template(definition, self.keys)
fields = {"aliased_name": "some value",
"Shot": "shot value"}
result = template.missing_keys(fields)
self.assertEquals([], result)
fields = {"initial_name": "some_value",
"Shot": "shot value"}
result = template.missing_keys(fields)
self.assertEquals(["aliased_name"], result)
def setUp(self):
super(TestTemplate, self).setUp()
# Make various types of keys(fields)
self.keys = {
"Sequence":
StringKey("Sequence"),
"Shot":
StringKey("Shot", default="s1", choices=["s1", "s2", "shot_1"]),
"Step":
StringKey("Step"),
"branch":
StringKey("branch", filter_by="alphanumeric"),
"name":
StringKey("name"),
"version":
IntegerKey("version", format_spec="03"),
"snapshot":
IntegerKey("snapshot", format_spec="03"),
"ext":
StringKey("ext"),
"seq_num":
SequenceKey("seq_num"),
"frame":
SequenceKey("frame", format_spec="04"),
"day_month_year":
TimestampKey("day_month_year", format_spec="%d_%m_%Y")
}
# Make a template
self.definition = "shots/{Sequence}/{Shot}/{Step}/work/{Shot}.{branch}.v{version}.{snapshot}.{day_month_year}.ma"
self.template = Template(self.definition, self.keys)
def test_key_alias(self):
"""
Test that key's aliased name is used in template.keys dict.
"""
key = StringKey("alias_name")
self.keys["not_alias_name"] = key
definition = "something/{not_alias_name}"
template = Template(definition, self.keys)
template_key = template.keys["alias_name"]
self.assertEqual(key, template_key)
self.assertEqual("something/{alias_name}", template.definition)
def test_optional_values(self):
"""
Test that optional keys do not appear as missing.
"""
definition = "shots/[{Sequence}]/{Shot}/{Step}/work/{Shot}.{branch}[.v{version}][.{snapshot}].ma"
template = Template(definition, self.keys)
fields = {"Shot": "shot value",
"Step": "step value",
"branch": "branch value"}
# all optional fields skipped
result = template.missing_keys(fields)
self.assertEquals([], result)
# value allowed for optional field
fields["snapshot"] = "snapshot value"
result = template.missing_keys(fields)
self.assertEquals([], result)
# required field missing
del(fields["Shot"])
result = template.missing_keys(fields)
self.assertEquals(["Shot"], result)
def test_default_enabled(self):
template = Template("{Shot}/{Step}", self.keys)
fields = {"Step": "Anm"}
expected = []
result = template.missing_keys(fields, skip_defaults=True)
self.assertEqual(expected, result)
def test_default_disabled(self):
template = Template("{Shot}/{Step}", self.keys)
fields = {"Step": "Anm"}
expected = ["Shot"]
result = template.missing_keys(fields)
self.assertEqual(expected, result)
def test_no_name(self):
template = Template(self.definition, self.keys, "")
expected = "<Sgtk Template %s>" % self.definition
self.assertEquals(expected, template.__repr__())
def test_default_period(self):
self.keys["S.hot"] = StringKey("S.hot")
template = Template("/something/{S.hot}/something", self.keys)
self.assertEqual(self.keys["S.hot"], template.keys["S.hot"])
def test_template(self):
template_name = "template_name"
template = Template(self.definition, self.keys, name=template_name)
expected = "<Sgtk Template %s: %s>" % (template_name, self.definition)
self.assertEqual(expected, template.__repr__())
def test_template(self):
template_name = "template_name"
template = Template(self.definition, self.keys, name=template_name)
expected = "<Sgtk Template %s: %s>" % (template_name, self.definition)
self.assertEquals(expected, template.__repr__())
def test_default_enabled(self):
template = Template("{Shot}/{Step}", self.keys)
fields = {"Step":"Anm"}
expected = []
result = template.missing_keys(fields, skip_defaults=True)
self.assertEquals(expected, result)
def test_default_disabled(self):
template = Template("{Shot}/{Step}", self.keys)
fields = {"Step":"Anm"}
expected = ["Shot"]
result = template.missing_keys(fields)
self.assertEquals(expected, result)
def test_definition_read_only(self):
template = Template("some/definition", self.keys)
self.assertRaises(AttributeError, setattr, template, "definition",
"other")
def test_default_enum_whitespace(self):
self.keys["S hot"] = StringKey("S hot")
template = Template("/something/{S hot}/something", self.keys)
self.assertEqual(self.keys["S hot"], template.keys["S hot"])
def test_optional(self):
template_name = "tempalte_name"
definition = "something/{Shot}[/{Step}]"
template = Template(definition, self.keys, name=template_name)
expected = "<Sgtk Template %s: %s>" % (template_name, definition)
self.assertEqual(expected, template.__repr__())
def test_no_name(self):
template = Template(self.definition, self.keys, "")
expected = "<Sgtk Template %s>" % self.definition
self.assertEqual(expected, template.__repr__())
def test_optional(self):
template_name = "tempalte_name"
definition = "something/{Shot}[/{Step}]"
template = Template(definition, self.keys, name=template_name)
expected = "<Sgtk Template %s: %s>" % (template_name, definition)
self.assertEquals(expected, template.__repr__())
