def _get_target_namespace(xml_schema):
"""Get the target namespace.
Args:
xml_schema: XML representation of the schema.
Returns:
The target namespace.
"""
try:
xsd_tree = XSDTree.transform_to_xml(xml_schema)
except Exception as e:
raise exceptions.XMLError(str(e))
root = xsd_tree.find(".")
if "targetNamespace" in root.attrib:
target_namespace = root.attrib["targetNamespace"]
if target_namespace not in list(root.nsmap.values()):
message = "The use of a targetNamespace without an associated prefix is not supported."
raise oai_pmh_exceptions.OAIAPILabelledException(
message=message, status_code=status.HTTP_400_BAD_REQUEST)
else:
target_namespace = "http://www.w3.org/2001/XMLSchema"
return target_namespace
def test_generate_extension_with_single_child_attribute_returns_expected_json_dict(
self, ):
xsd_files = join("attribute", "single")
xsd_tree = self.extension_data_handler.get_xsd(xsd_files)
xsd_element = xsd_tree.xpath(
"/xs:schema/xs:element/xs:complexType/xs:simpleContent/xs:extension",
namespaces=self.namespaces,
)[0]
xml_tree = self.extension_data_handler.get_xml(xsd_files)
xml_data = XSDTree.tostring(xml_tree)
edit_data_tree = XSDTree.transform_to_xml(xml_data)
# Generate result dict
result_dict = self.parser.generate_extension(
xsd_element,
xsd_tree,
full_path="/root",
edit_data_tree=edit_data_tree,
default_value="entry0",
)
# Load expected dictionary and compare with result
expected_dict = self.extension_data_handler.get_json(xsd_files +
".reload")
self.assertDictEqual(expected_dict, result_dict)
def transform(self, xml_inputs):
""" Transforms the input to a json content
Args:
xml_inputs: xml files
Returns:
"""
results_transform = []
# loops on all xml input
for xml_item in xml_inputs:
# generate the title document with the sha
document_name_with_sha = AbstractExporter.get_title_document(
xml_item['title'], xml_item['xml_content'])
transform_result = TransformResult()
# set the document name to the collection
transform_result.source_document_name = document_name_with_sha
# for an XML transformation there is a list of one element
transform_result_content = TransformResultContent()
transform_result_content.file_name = document_name_with_sha
# sets the content and extension
dom = XSDTree.transform_to_xml(xml_item['xml_content'])
transform_result_content.content_converted = str(
self.transformation(dom))
transform_result_content.content_extension = self.extension
# add the content to the list of content
transform_result.transform_result_content.append(
transform_result_content)
# add the result to the list of result
results_transform.append(transform_result)
return results_transform
def get_xml_file(filename):
"""Get XML file
Args:
filename:
Returns:
"""
file_string = ""
is_in_tag = False
with open(filename, "r") as file_content:
file_lines = [
line.strip("\r\n\t ") for line in file_content.readlines()
]
for line in file_lines:
if is_in_tag: # Add space if we are in the tag
file_string += " "
file_string += line
# Leave the tag if we have one more closing that opening
if is_in_tag and line.count(">") == line.count("<") + 1:
is_in_tag = False
elif line.count("<") != line.count(
">"
): # In tag if opening and closing count are different
is_in_tag = True
# In any other cases the tag flag doesn't change
return XSDTree.transform_to_xml(file_string)
def test_reload_simple_content_basic(self):
xsd_files = join("simple_content", "basic")
xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files)
xsd_element = xsd_tree.xpath(
"/xs:schema/xs:complexType", namespaces=self.namespaces
)[0]
xml_tree = self.complex_type_data_handler.get_xml(xsd_files)
xml_data = XSDTree.tostring(xml_tree)
edit_data_tree = XSDTree.transform_to_xml(xml_data)
xml_value = xml_tree.xpath("/root", namespaces=self.namespaces)[0].text
# Generate result dict
result_string = self.parser.generate_complex_type(
xsd_element,
xsd_tree,
full_path="/root",
edit_data_tree=edit_data_tree,
default_value=xml_value,
)
# Load expected dictionary and compare with result
expected_dict = self.complex_type_data_handler.get_json("%s.reload" % xsd_files)
self.assertDictEqual(result_string, expected_dict)
def test_reload_complex_type_basic(self):
xsd_files = join("complex_type", "basic")
xsd_tree = self.element_data_handler.get_xsd(xsd_files)
xsd_element = xsd_tree.xpath(
"/xs:schema/xs:element", namespaces=self.namespaces
)[0]
xml_tree = self.element_data_handler.get_xml(xsd_files)
xml_data = XSDTree.tostring(xml_tree)
edit_data_tree = XSDTree.transform_to_xml(xml_data)
# Generate result dict
result_dict = self.parser.generate_element(
xsd_element, xsd_tree, full_path="", edit_data_tree=edit_data_tree
)
# Load expected dictionary and compare with result
expected_dict = self.element_data_handler.get_json(xsd_files + ".reload")
self.assertDictEqual(expected_dict, result_dict)
def test_reload_element_basic(self):
xsd_files = join("element", "basic")
xsd_tree = self.choice_data_handler.get_xsd(xsd_files)
xsd_element = xsd_tree.xpath("/xs:schema/xs:complexType/xs:choice",
namespaces=self.namespaces)[0]
xml_tree = self.choice_data_handler.get_xml(xsd_files)
xml_data = XSDTree.tostring(xml_tree)
edit_data_tree = XSDTree.transform_to_xml(xml_data)
result_string = self.parser.generate_choice(
xsd_element,
xsd_tree,
full_path="/root",
edit_data_tree=edit_data_tree)
expected_element = self.choice_data_handler.get_json(xsd_files +
".reload")
self.assertDictEqual(expected_element, result_string)
def _run_test(self, xsd_files):
xsd_tree = self.sequence_data_handler.get_xsd(xsd_files)
xsd_element = xsd_tree.xpath("/xs:schema/xs:complexType/xs:sequence",
namespaces=self.namespaces)[0]
xml_tree = self.sequence_data_handler.get_xml(xsd_files)
xml_data = XSDTree.tostring(xml_tree)
edit_data_tree = XSDTree.transform_to_xml(xml_data)
# Generate result dict
result_dict = self.parser.generate_sequence(
xsd_element,
xsd_tree,
full_path="/root",
edit_data_tree=edit_data_tree)
# Load expected dictionary and compare with result
expected_dict = self.sequence_data_handler.get_json(xsd_files +
".reload")
return result_dict, expected_dict
