def test_document_validate_api(self): self.assertIsNone(xmlschema.validate(self.vh_xml_file)) self.assertIsNone( xmlschema.validate(self.vh_xml_file, use_defaults=False)) vh_2_file = self.casepath('examples/vehicles/vehicles-2_errors.xml') self.assertRaises(XMLSchemaValidationError, xmlschema.validate, vh_2_file) try: xmlschema.validate( vh_2_file, namespaces={'vhx': "http://example.com/vehicles"}) except XMLSchemaValidationError as err: path_line = str(err).splitlines()[-1] else: path_line = '' if sys.version_info >= (3, 6): self.assertEqual('Path: /vhx:vehicles/vhx:cars', path_line) else: self.assertTrue('Path: /vh:vehicles/vh:cars' == path_line or 'Path: /vhx:vehicles/vhx:cars', path_line) # Due to unordered dicts # Issue #80 vh_2_xt = ElementTree.parse(vh_2_file) self.assertRaises(XMLSchemaValidationError, xmlschema.validate, vh_2_xt, self.vh_xsd_file) # Issue #145 with open(self.vh_xml_file) as f: self.assertIsNone(xmlschema.validate(f, schema=self.vh_xsd_file))
def oscal_validator(oscal_schema, oscal_data): schema, stype = read_file(oscal_schema, _get_oscal_file_type(oscal_schema)) data, ftype = read_file(oscal_data, _get_oscal_file_type(oscal_data)) if ftype is 'json': validate(data, schema) if ftype is 'xml': xmlschema.validate(data, schema)
def oscal_validator(oscal_schema, oscal_data): schema, stype = read_file(oscal_schema, _get_oscal_file_type(oscal_schema)) data, ftype = read_file(oscal_data, _get_oscal_file_type(oscal_data)) if ftype == 'json' or ftype == 'yaml': # Yaml files are validated using the json schema validate(data, schema) if ftype == 'xml': xmlschema.validate(data, schema)
def cli(xml_file, schema_file, verbose): """Validate an XML against an XSD SCHEMA.""" xml_from_url = False try: xml_file, requested_url = xmlFromURL(xml_file, 'XML_FILE') if not xml_file.startswith('/'): xml_from_url = True xsd_resp, _ = xmlFromURL(schema_file, 'SCHEMA_FILE') if xsd_resp: schema_file = str(xsd_resp) except Exception as error: click.echo(error) return None try: xmlschema.validate(xml_file, schema=schema_file) # When validation succeeds if xml_from_url: click.echo(f"The XML from the URL:\n{requested_url}") click.secho("is valid.\n", fg='green') else: click.echo("The XML file: " + click.format_filename(str(xml_file), shorten=True)) click.secho("is valid.\n", fg='green') except xmlschema.validators.exceptions.XMLSchemaValidationError as err: # When validation does not succeed if xml_from_url: click.echo(f"The XML from the URL:\n{requested_url}") click.secho("is invalid.\n", fg='red') else: click.echo("The XML file: " + click.format_filename(str(xml_file), shorten=True)) click.secho("is invalid.\n", fg='red') if verbose: click.secho("Error:", bold=True) click.echo(err) except xmlschema.etree.ParseError as err: # If there is a syntax error with either file click.echo("Faulty XML or XSD file was given.\n") if verbose: click.echo(f"Error: {err}") except xmlschema.exceptions.XMLSchemaException as err: if not verbose: click.echo("\nValidation ran into an unexpected error." + " Run command with --verbose option for more details\n") else: click.echo(f"Error: {err}")
def test_xml_instances(self): if group_tests[0]['source'].endswith('.xsd'): schema = group_tests[0]['source'] schemas = group_tests[0]['sources'] else: schema = None schemas = [] for item in filter(lambda x: not x['source'].endswith('.xsd'), group_tests): source = item['source'] rel_path = os.path.relpath(source) for version, expected in sorted(filter(lambda x: x[0] != 'source', item.items())): schema_class = XMLSchema11 if version == '1.1' else XMLSchema10 if expected == 'invalid': message = "instance %s should be invalid with XSD %s" % (rel_path, version) with self.assertRaises((XMLSchemaException, ElementTree.ParseError), msg=message): with warnings.catch_warnings(): warnings.simplefilter('ignore') if not schemas: validate(source, schema=schema, cls=schema_class) else: xs = schema_class(schemas[0], use_meta=use_meta, use_fallback=use_fallback, build=False) for other in schemas[1:]: schema_class(other, global_maps=xs.maps, use_fallback=use_fallback, build=False) xs.build() xs.validate(source) else: try: with warnings.catch_warnings(): warnings.simplefilter('ignore') if len(schemas) <= 1 and use_meta and use_fallback: validate(source, schema=schema, cls=schema_class) else: xs = schema_class(schemas[0], use_meta=use_meta, use_fallback=use_fallback, build=False) for other in schemas[1:]: schema_class(other, global_maps=xs.maps, build=False) xs.build() xs.validate(source) except (XMLSchemaException, ElementTree.ParseError) as err: error = "instance %s should be valid with XSD %s, but an error " \ "is raised:\n\n%s" % (rel_path, version, str(err)) else: error = None self.assertIsNone(error)
def test_can_create_xml_docs_from_csv(): csv_file = "./test_data/metadata.csv" xsd_file = cvs_to_xsd(csv_file, xml_namespace="https://metadata.com", root_element="oai_dc") for xml_file in cvs_to_xml(csv_file, xml_namespace="https://metadata.com", root_element="oai_dc", file_name_column="Identifier"): print(xmlschema.validate(xml_file, xsd_file)) cmis_schema = "./test_data/CmisMetadata.xsd" cmis_file = cvs_to_cmis_xslt(csv_file, xml_namespace="https://metadata.com", root_element="oai_dc") search_schema = "./test_data/custom-indexer.xsd" search_file = csv_to_search_xml(csv_file, xml_namespace="https://metadata.com", root_element="oai_dc") xmlschema.validate(search_file, search_schema)
def test_create_simple_package_with_parent(): folder = client.folder(FOLDER_ID) package = simple_asset_package(preservation_file=file, parent_folder=folder) io_ref = os.path.basename(package).replace(".zip", "") with zipfile.ZipFile(package, "r") as zip_ref: zip_ref.extractall("./test_data/") folder = f"./test_data/{io_ref}" assert os.path.exists(folder) metadata = f"{folder}/metadata.xml" assert os.path.exists(metadata) xml_document = xml.etree.ElementTree.parse(metadata) ref = xml_document.find(f'.//{{{NS}}}InformationObject/{{{NS}}}Ref') assert ref.text == io_ref xmlschema.validate(metadata, './test_data/XIP-V6.0.xsd') shutil.rmtree(folder)
def test_xml_instances(self): if group_tests[0]['source'].endswith('.xsd'): schema = group_tests[0]['source'] else: schema = None for item in filter(lambda x: not x['source'].endswith('.xsd'), group_tests): source = item['source'] rel_path = os.path.relpath(source) for version, expected in sorted( filter(lambda x: x[0] != 'source', item.items())): schema_class = XMLSchema11 if version == '1.1' else XMLSchema10 if expected == 'invalid': message = "instance %s should be invalid with XSD %s" % ( rel_path, version) with self.assertRaises( (XMLSchemaException, ElementTree.ParseError), msg=message): with warnings.catch_warnings(): warnings.simplefilter('ignore') validate(source, schema=schema, cls=schema_class) else: try: with warnings.catch_warnings(): warnings.simplefilter('ignore') validate(source, schema=schema, cls=schema_class) except (XMLSchemaException, ElementTree.ParseError) as err: error = "instance %s should be valid with XSD %s, but an error " \ "is raised:\n\n%s" % (rel_path, version, str(err)) else: error = None self.assertIsNone(error)
def validate_XSD_file(self, xml_fileinput): """| Usage | This keyword is used to validate am xml file against the XSD | Arguments | 'xml_fileinput' = Output xml file path. |XSD Validator | ${xml_fileinput} """ if not os.path.exists(xml_fileinput): raise AssertionError("File not found error :" + xml_fileinput + " doesnot exist") pprint(xmlschema.to_dict(xml_fileinput)) print(xmlschema.validate(xml_fileinput))
def test_document_validate_api_lazy(self): source = xmlschema.XMLResource(self.col_xml_file, lazy=False) namespaces = source.get_namespaces() source.root[0].clear() # Drop internal elements source.root[1].clear() xsd_element = self.col_schema.elements['collection'] self.assertRaises(XMLSchemaValidationError, xsd_element.decode, source.root, namespaces=namespaces) for _ in xsd_element.iter_decode(source.root, 'strict', namespaces=namespaces, source=source, max_depth=1): del _ self.assertIsNone(xmlschema.validate(self.col_xml_file, lazy=True))
def Validate(xml_filepath, xsd_path): xmlschema_doc = etree.parse(xsd_path) xmlschema = etree.XMLSchema(xmlschema_doc) log_text = """<div class="jumbotron"> <h1>Validation Result</h1> </div> """ # parse xml try: xml_doc = etree.parse(xml_filepath) log_text += """<h3>XML Syntax validation : </h3> <div class="alert alert-success"> Okay </div>""" # check for file IO error except IOError: log_text += """<div class="alert alert-danger"> Invalid XML file </div>""" # check for XML syntax errors except etree.XMLSyntaxError as err: log_text += """<h2>XML Syntax Error</h2> <ul class="list-group">""" for error in err.error_log: log_text += "<li class=\"list-group-item\">" + "ERROR ON LINE " + str( error.line) + " " + str( error.message.encode("utf-8")) + "</li>" log_text += "</ul>" except: log_text += 'Unknown error occurred .\n' # validate against schema try: xmlschema.assertValid(xml_doc) log_text += """<h3>XML Schema validation : </h3> <div class="alert alert-success"> Okay </div>""" except etree.DocumentInvalid as err: log_text += "<h3>XML Validation Error :</h3> <ul class=\"list-group\">" for error in err.error_log: log_text += "<li class=\"list-group-item\">" + "ERROR ON LINE " + str( error.line) + " " + str( error.message.encode("utf-8")) + "</li>" log_text += "</ul>" except: log_text += 'Unknown error occurred .\n' result = xmlschema.validate(xml_doc) if (result): log_text += """<div class="alert alert-success"> <strong> Instance is valid :)</strong> </div> <div class="input-group-prepend"> <span class="input-group-text" id="basic-addon1">Patient ID</span> <input id="patient_id" type="text" class="form-control" placeholder="Patient ID" aria-label="Username" aria-describedby="basic-addon1" required="true" name="patient_id" pattern="[a-zA-Z0-9]{6,}$"title="Patient ID must have atleast 6 characters(only letters/numbers allowed)"> </div> <br> <input type="submit" name="Save" value="Save" /> <br><br> """ else: log_text += """<div class="alert alert-danger"> <strong> Instance is invalid :(</strong> </div>""" log_text += "</form>" htmlheadString = """<!DOCTYPE html> <html> <head> <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous"> <title>Validator Response</title> </head> <body style="margin-left: 30px;margin-right:30px"> <form action="" method="post"> {% csrf_token %} """ buttonString = """<div> <form action="" method="post"> {% csrf_token %} <input type="submit" name="Home" value="Home" /> </form> </div> </body> </html> """ source_code = htmlheadString + "\n" + log_text + "\n" + buttonString newfilepath = os.path.join(BASE_DIR, 'templates') newfilepath = os.path.join(newfilepath, 'validator_response.html') newfileobject = open(newfilepath, "w+") newfileobject.write(source_code) newfileobject.close()
def __compare_with_xml_schema(cls, xml_header_path): xsd_file_path = os.path.join(str(path), os.pardir, os.pardir, os.pardir, 'rec_to_nwb', 'data', 'header_schema.xsd') xsd_schema = xmlschema.XMLSchema(xsd_file_path) xmlschema.validate(xml_header_path, xsd_schema)
for xml_file in args.xml_file: print("\nValidate XML file {!r} ...".format(xml_file)) start_dt = datetime.datetime.now() try: if cert is not None: signed_xml_data = lxml.etree.parse(xml_file).getroot() signxml.XMLVerifier().verify(signed_xml_data, x509_cert=cert) elapsed_time = datetime.datetime.now() - start_dt print("XML signature validation: OK (elapsed time: {})".format( elapsed_time)) start_dt = datetime.datetime.now() xml_file = signed_xml_data xmlschema.validate(xml_file, schema=schema, lazy=args.lazy) except xmlschema.XMLSchemaValidationError as err: exit_code = 1 print("XML schema validation: FAIL") if args.verbosity >= 2: print(err) except (signxml.InvalidDigest, signxml.InvalidSignature) as err: exit_code = 1 print("XML signature validation: FAIL") if args.verbosity >= 2: print(err) else: elapsed_time = datetime.datetime.now() - start_dt print("XML schema validation: OK (elapsed time: {})".format(
def validateXMLFiles(): xmlschema.validate(article_training_data_loc, training_data_schema) xmlschema.validate(article_ground_truth_data_loc, ground_truth_schema)
def __compare_with_xml_schema(cls, xml_header_path): xsd_file_path = str( path) + '/../../../rec_to_nwb/data/header_schema.xsd' xsd_schema = xmlschema.XMLSchema(xsd_file_path) xmlschema.validate(xml_header_path, xsd_schema)