def make_test_cases(path: Path, group: TestGroup):
schema_href = None
schema_is_valid = False
if (group.schema_test and group.schema_test.schema_document
and group.schema_test.schema_document[0].href):
schema_doc = group.schema_test.schema_document[0].href
schema_validity = validity(group.schema_test.expected)
if (group.name in ("wildZ003", "ctZ007")
and len(group.schema_test.schema_document) > 0
and group.schema_test.schema_document[1].href):
schema_doc = group.schema_test.schema_document[1].href
schema_href = path.joinpath(schema_doc).resolve().relative_to(w3c)
schema_is_valid = schema_validity.validity == ExpectedOutcome.VALID
schema_name = text.snake_case(group.name)
documentation = make_docstring(group)
structure_style = "filenames"
if group.name in ("schD5", "schD7", "xsd003b", "over015"):
structure_style = "namespaces"
elif group.name in ("addB132", "ctZ007"):
structure_style = "single-package"
for instance in group.instance_test:
if not instance.instance_document or not instance.instance_document.href:
raise ValueError("Missing instance document!")
instance_path = path.joinpath(
instance.instance_document.href).resolve()
instance_href = instance_path.relative_to(w3c)
instance_validity = validity(instance.expected)
class_name = read_root_name(instance_path)
version = pick_version(group.version)
instance_is_valid = instance_validity.validity == ExpectedOutcome.VALID
schema_path = str(schema_href) or ""
if schema_path and instance_is_valid and schema_is_valid:
yield TestCase(
path=path,
version=version,
documentation=documentation,
schema_name=schema_name,
schema_path=schema_path,
instance_name=text.snake_case(instance.name),
instance_path=str(instance_href),
class_name=class_name,
structure_style=structure_style,
)
def rename_attributes_with_index(cls, attrs: List[Attr],
rename: List[Attr]):
"""Append the next available index number to all the rename attributes
names."""
for index in range(1, len(rename)):
num = 1
name = text.snake_case(rename[index].name)
while any(
text.snake_case(attr.name) == text.snake_case(
f"{name}_{num}") for attr in attrs):
num += 1
rename[index].name = f"{rename[index].name}_{num}"
def package_name(cls, package: str) -> str:
"""Convert the given package name to safe snake case."""
return ".".join(
map(
lambda x: text.snake_case(utils.safe_snake(x, default="pkg")),
package.split("."),
))
def test_snake_case(self):
self.assertEqual("p00p", snake_case("p00p"))
self.assertEqual("username", snake_case("USERName"))
self.assertEqual("user_name", snake_case("UserNAME"))
self.assertEqual("user_name", snake_case("USER_name"))
self.assertEqual("user_name", snake_case("USER-NAME"))
self.assertEqual("user_name", snake_case("User_Name"))
self.assertEqual("user_name", snake_case("user_name"))
self.assertEqual("suser_name", snake_case("SUserNAME"))
def enumeration_name(cls, name: str) -> str:
"""
Strip reference prefix and turn to snake case.
If the name is one of the python reserved words append the
prefix _value
"""
return text.snake_case(safe_snake(name)).upper()
def attribute_name(cls, name: str) -> str:
"""
Strip reference prefix and turn to snake case.
If the name is one of the python reserved words append the
prefix _value
"""
local_name = text.suffix(name)
return text.snake_case(safe_snake(local_name))
def emit_event(self, event: str, name: str, **kwargs: Any):
"""Call if exist the parser's hook for the given element and event."""
if name not in self.event_names:
self.event_names[name] = text.snake_case(QName(name).localname)
method_name = f"{event}_{self.event_names[name]}"
if hasattr(self, method_name):
getattr(self, method_name)(**kwargs)
def process_duplicate_attribute_names(cls, attrs: List[Attr]) -> None:
"""Sanitize duplicate attribute names that might exist by applying
rename strategies."""
grouped = group_by(attrs, lambda attr: text.snake_case(attr.name))
for items in grouped.values():
total = len(items)
if total == 2 and not items[0].is_enumeration:
cls.rename_attribute_by_preference(*items)
elif total > 1:
cls.rename_attributes_with_index(attrs, items)
def create(cls: Type[T], **kwargs) -> T:
if not kwargs.get("ns_map"):
kwargs.update({"ns_map": {"xs": Namespace.XS.uri}})
kwargs = {
text.snake_case(etree.QName(key).localname): value
for key, value in kwargs.items() if value is not None
}
data = {
attr.name: kwargs[attr.name]
for attr in fields(cls) if attr.name in kwargs
}
return cls(**data)
def package_name(cls, name):
return text.snake_case(name)
def module_name(cls, name):
return text.snake_case(name)
def module_name(cls, module: str) -> str:
"""Convert the given module name to safe snake case."""
return text.snake_case(utils.safe_snake(text.clean_uri(module), default="mod"))
def test_build_with_no_meta_name_and_name_generator(self, *args):
inspect = XmlContext(name_generator=lambda x: text.snake_case(x))
result = inspect.build(ItemsType)
self.assertEqual(QName("items_type"), str(result.qname))
def module_name(cls, name: str) -> str:
return text.snake_case(name)
def emit_event(self, event: str, name: str, **kwargs):
"""Call if exist the parser's hook for the given element and event."""
local_name = text.snake_case(QName(name).localname)
method_name = f"{event}_{local_name}"
if hasattr(self, method_name):
getattr(self, method_name)(**kwargs)
def test_class_meta_with_no_meta_name_and_name_generator(self, *args):
inspect = ModelInspect(name_generator=lambda x: text.snake_case(x))
result = inspect.class_meta(ItemsType)
self.assertEqual(QName("items_type"), str(result.qname))
def real_name(self) -> str:
if self.test:
return text.snake_case(self.test)
if self.id:
return self.id
return "value"
def package_name(cls, name: str) -> str:
return ".".join(
map(
lambda x: text.snake_case(safe_snake(x, default="pkg")), name.split(".")
)
)
def module_name(cls, name: str) -> str:
return text.snake_case(safe_snake(name, default="mod"))
def constant_name(name: str) -> str:
"""Apply python conventions for constant names."""
return text.snake_case(utils.safe_snake(name)).upper()
def attribute_name(name: str) -> str:
"""Apply python conventions for instance variable names."""
return text.snake_case(utils.safe_snake(name))
def test_snake_case(self):
self.assertEqual("user_name", snake_case("userName"))
self.assertEqual("user_name", snake_case("User.Name"))
self.assertEqual("user_name", snake_case("UserName"))
self.assertEqual("user_name", snake_case("USER_NAME"))
self.assertEqual("user_name", snake_case("user_name"))
self.assertEqual("common_v48_0", snake_case("common_v48_0"))
self.assertEqual("user", snake_case("user"))
self.assertEqual("user", snake_case("User"))
self.assertEqual("user", snake_case("USER"))
self.assertEqual("user", snake_case("_user"))
self.assertEqual("user", snake_case("_User"))
self.assertEqual("user", snake_case("__user"))
self.assertEqual("user_name", snake_case("user__name"))
def real_name(self) -> str:
if self.test:
return text.snake_case(self.test)
if self.id:
return self.id
return DEFAULT_ATTR_NAME
