diff --git a/swh/deposit/api/checks.py b/swh/deposit/api/checks.py index 7da36cdd..2aeecb3a 100644 --- a/swh/deposit/api/checks.py +++ b/swh/deposit/api/checks.py @@ -1,119 +1,115 @@ # Copyright (C) 2017-2022 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information """Functional Metadata checks: Mandatory fields: - 'author' - 'name' or 'title' Suggested fields: - metadata-provenance """ import dataclasses import functools from typing import Dict, Optional, Tuple from xml.etree import ElementTree -import iso8601 import pkg_resources import xmlschema -from swh.deposit.utils import NAMESPACES, normalize_date, parse_swh_metadata_provenance +from swh.deposit.utils import NAMESPACES, parse_swh_metadata_provenance MANDATORY_FIELDS_MISSING = "Mandatory fields are missing" INVALID_DATE_FORMAT = "Invalid date format" SUGGESTED_FIELDS_MISSING = "Suggested fields are missing" METADATA_PROVENANCE_KEY = "swh:metadata-provenance" @dataclasses.dataclass class Schemas: swh: xmlschema.XMLSchema11 + codemeta: xmlschema.XMLSchema11 @functools.lru_cache(1) def schemas() -> Schemas: def load_xsd(name) -> xmlschema.XMLSchema11: return xmlschema.XMLSchema11( pkg_resources.resource_string("swh.deposit", f"xsd/{name}.xsd").decode() ) - return Schemas(swh=load_xsd("swh")) + return Schemas(swh=load_xsd("swh"), codemeta=load_xsd("codemeta")) def check_metadata(metadata: ElementTree.Element) -> Tuple[bool, Optional[Dict]]: """Check metadata for mandatory field presence and date format. Args: metadata: Metadata dictionary to check Returns: tuple (status, error_detail): - (True, None) if metadata are ok and suggested fields are also present - (True, ) if metadata are ok but some suggestions are missing - (False, ) otherwise. """ suggested_fields = [] # at least one value per couple below is mandatory alternate_fields = { ("atom:name", "atom:title", "codemeta:name"): False, ("atom:author", "codemeta:author"): False, } for possible_names in alternate_fields: for possible_name in possible_names: if metadata.find(possible_name, namespaces=NAMESPACES) is not None: alternate_fields[possible_names] = True continue mandatory_result = [" or ".join(k) for k, v in alternate_fields.items() if not v] # provenance metadata is optional provenance_meta = parse_swh_metadata_provenance(metadata) if provenance_meta is None: suggested_fields = [ {"summary": SUGGESTED_FIELDS_MISSING, "fields": [METADATA_PROVENANCE_KEY]} ] if mandatory_result: detail = [{"summary": MANDATORY_FIELDS_MISSING, "fields": mandatory_result}] return False, {"metadata": detail + suggested_fields} deposit_elt = metadata.find("swh:deposit", namespaces=NAMESPACES) if deposit_elt: try: schemas().swh.validate(deposit_elt) except xmlschema.exceptions.XMLSchemaException as e: return False, {"metadata": [{"fields": ["swh:deposit"], "summary": str(e)}]} - fields = [] - - for commit_date in metadata.findall( - "codemeta:datePublished", namespaces=NAMESPACES - ): - try: - normalize_date(commit_date.text) - except iso8601.iso8601.ParseError: - fields.append("codemeta:datePublished") - - for author_date in metadata.findall("codemeta:dateCreated", namespaces=NAMESPACES): + detail = [] + for child in metadata: + for schema_element in schemas().codemeta.root_elements: + if child.tag in schema_element.name: + break + else: + # Tag is not specified in the schema, don't validate it + continue try: - normalize_date(author_date.text) - except iso8601.iso8601.ParseError: - fields.append("codemeta:dateCreated") + schemas().codemeta.validate(child) + except xmlschema.exceptions.XMLSchemaException as e: + detail.append({"fields": [schema_element.prefixed_name], "summary": str(e)}) - if fields: - detail = [{"summary": INVALID_DATE_FORMAT, "fields": fields}] - return False, {"metadata": detail + suggested_fields} + if detail: + return False, {"metadata": detail} if suggested_fields: # it's fine but warn about missing suggested fields return True, {"metadata": suggested_fields} return True, None diff --git a/swh/deposit/tests/api/test_checks.py b/swh/deposit/tests/api/test_checks.py index 74c02fcd..0eeb75ee 100644 --- a/swh/deposit/tests/api/test_checks.py +++ b/swh/deposit/tests/api/test_checks.py @@ -1,524 +1,539 @@ # Copyright (C) 2017-2022 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information # disable flake8 on this file because of line length # flake8: noqa import re import textwrap from typing import Any, Dict from xml.etree import ElementTree import pytest from swh.deposit.api.checks import ( METADATA_PROVENANCE_KEY, SUGGESTED_FIELDS_MISSING, check_metadata, ) METADATA_PROVENANCE_DICT: Dict[str, Any] = { "swh:deposit": { METADATA_PROVENANCE_KEY: {"schema:url": "some-metadata-provenance-url"} } } XMLNS = """xmlns="http://www.w3.org/2005/Atom" xmlns:swh="https://www.softwareheritage.org/schema/2018/deposit" xmlns:codemeta="https://doi.org/10.5063/SCHEMA/CODEMETA-2.0" xmlns:schema="http://schema.org/" """ PROVENANCE_XML = """ some-metadata-provenance-url """ _parameters1 = [ textwrap.dedent(metadata_ok) for (metadata_ok,) in [ ( f"""\ something something-else foo someone {PROVENANCE_XML} """, ), ( f"""\ something something-else foo no one {PROVENANCE_XML} """, ), ( f"""\ some url bar no one {PROVENANCE_XML} """, ), ( f"""\ some url some id nar no one 2020-12-21 2020-12-21 {PROVENANCE_XML} """, ), ( f"""\ something something-else bar someone """, ), ( f"""\ something something-else bar someone some-metadata-provenance-url """, ), ( f"""\ something something-else bar someone some-metadata-provenance-url """, ), ( f"""\ something something-else bar someone some-metadata-provenance-url """, ), ] ] @pytest.mark.parametrize( "metadata_ok", _parameters1, ) def test_api_checks_check_metadata_ok(metadata_ok, swh_checks_deposit): actual_check, detail = check_metadata(ElementTree.fromstring(metadata_ok)) assert actual_check is True, f"Unexpected result: {detail}" if "swh:deposit" in metadata_ok: # no missing suggested field assert detail is None else: # missing suggested field assert detail == { "metadata": [ { "fields": [METADATA_PROVENANCE_KEY], "summary": SUGGESTED_FIELDS_MISSING, } ] } _parameters2 = [ (textwrap.dedent(metadata_ko), expected_summary) for (metadata_ko, expected_summary) in [ ( f"""\ something something-else someone {PROVENANCE_XML} """, { "summary": "Mandatory fields are missing", "fields": ["atom:name or atom:title or codemeta:name"], }, ), ( f"""\ something something-else foobar {PROVENANCE_XML} """, { "summary": "Mandatory fields are missing", "fields": ["atom:author or codemeta:author"], }, ), ( f"""\ something something-else bar someone {PROVENANCE_XML} """, { "summary": "Mandatory fields are missing", "fields": ["atom:name or atom:title or codemeta:name"], }, ), ( f"""\ something something-else foobar foo {PROVENANCE_XML} """, { "summary": "Mandatory fields are missing", "fields": ["atom:author or codemeta:author"], }, ), ( f"""\ something something-else bar someone {PROVENANCE_XML} """, { "summary": "Mandatory fields are missing", "fields": ["atom:author or codemeta:author"], }, ), - ( - f"""\ - - something - something-else - bar - someone - 2020-aa-21 - 2020-12-bb - {PROVENANCE_XML} - - """, - { - "summary": "Invalid date format", - "fields": ["codemeta:datePublished", "codemeta:dateCreated"], - }, - ), ] ] @pytest.mark.parametrize("metadata_ko,expected_summary", _parameters2) def test_api_checks_check_metadata_ko( metadata_ko, expected_summary, swh_checks_deposit ): actual_check, error_detail = check_metadata(ElementTree.fromstring(metadata_ko)) assert actual_check is False assert error_detail == {"metadata": [expected_summary]} _parameters3 = [ (textwrap.dedent(metadata_ko), expected_summary) for (metadata_ko, expected_summary) in [ + ( + f"""\ + + something + something-else + bar + someone + 2020-aa-21 + 2020-12-bb + {PROVENANCE_XML} + + """, + [ + { + "summary": ".*Reason: invalid value '2020-aa-21'.*", + "fields": ["codemeta:datePublished"], + }, + { + "summary": ".*Reason: invalid value '2020-12-bb'.*", + "fields": ["codemeta:dateCreated"], + }, + ], + ), ( f"""\ some url someid bar no one 2020-aa-21 2020-12-bb """, - { - "summary": "Invalid date format", - "fields": ["codemeta:datePublished", "codemeta:dateCreated"], - }, + [ + { + "summary": ".*Reason: invalid value '2020-aa-21'.*", + "fields": ["codemeta:datePublished"], + }, + { + "summary": ".*Reason: invalid value '2020-12-bb'.*", + "fields": ["codemeta:dateCreated"], + }, + ], ), - ] -] - - -@pytest.mark.parametrize("metadata_ko,expected_invalid_summary", _parameters3) -def test_api_checks_check_metadata_fields_ko_and_missing_suggested_fields( - metadata_ko, expected_invalid_summary, swh_checks_deposit -): - actual_check, error_detail = check_metadata(ElementTree.fromstring(metadata_ko)) - assert actual_check is False - assert error_detail == { - "metadata": [expected_invalid_summary] - + [{"fields": [METADATA_PROVENANCE_KEY], "summary": SUGGESTED_FIELDS_MISSING,}] - } - - -_parameters4 = [ - (textwrap.dedent(metadata_ko), expected_summary) - for (metadata_ko, expected_summary) in [ ( f"""\ something something-else bar someone """, - { - "summary": ( - r".*Reason: Unexpected child with tag 'swh:invalid'.*" - r"Instance:.*swh:invalid.*" - ), - "fields": ["swh:deposit"], - }, + [ + { + "summary": ( + r".*Reason: Unexpected child with tag 'swh:invalid'.*" + r"Instance:.*swh:invalid.*" + ), + "fields": ["swh:deposit"], + } + ], ), ( f"""\ something something-else bar someone """, - { - "summary": ( - r".*Reason: Unexpected child with tag 'swh:add_to_origin'.*" - ), - "fields": ["swh:deposit"], - }, + [ + { + "summary": ( + r".*Reason: Unexpected child with tag 'swh:add_to_origin'.*" + ), + "fields": ["swh:deposit"], + } + ], ), ( f"""\ something something-else bar someone """, - { - "summary": ( - r".*Reason: assertion test if false.*" - r"Schema:\n*" - r' *]+ id="swhdeposit-incompatible-create-and-add".*' - ), - "fields": ["swh:deposit"], - }, + [ + { + "summary": ( + r".*Reason: assertion test if false.*" + r"Schema:\n*" + r' *]+ id="swhdeposit-incompatible-create-and-add".*' + ), + "fields": ["swh:deposit"], + } + ], ), ( f"""\ something something-else bar someone """, - { - "summary": ( - r".*Reason: assertion test if false.*" - r"Schema:\n*" - r' *]+ id="swhdeposit-incompatible-create-and-reference".*' - ), - "fields": ["swh:deposit"], - }, + [ + { + "summary": ( + r".*Reason: assertion test if false.*" + r"Schema:\n*" + r' *]+ id="swhdeposit-incompatible-create-and-reference".*' + ), + "fields": ["swh:deposit"], + } + ], ), ( f"""\ something something-else bar someone """, - { - "summary": ( - r".*Reason: assertion test if false.*" - r"Schema:\n*" - r' *]+ id="swhdeposit-incompatible-add-and-reference".*' - ), - "fields": ["swh:deposit"], - }, + [ + { + "summary": ( + r".*Reason: assertion test if false.*" + r"Schema:\n*" + r' *]+ id="swhdeposit-incompatible-add-and-reference".*' + ), + "fields": ["swh:deposit"], + } + ], ), ( f"""\ something something-else bar someone """, - { - "summary": r".*Reason: Unexpected child with tag 'swh:origin'.*", - "fields": ["swh:deposit"], - }, + [ + { + "summary": r".*Reason: Unexpected child with tag 'swh:origin'.*", + "fields": ["swh:deposit"], + }, + ], ), ( f"""\ something something-else bar someone """, - { - "summary": r".*Reason: Unexpected child with tag 'swh:origin'.*", - "fields": ["swh:deposit"], - }, + [ + { + "summary": r".*Reason: Unexpected child with tag 'swh:origin'.*", + "fields": ["swh:deposit"], + }, + ], ), ( f"""\ something something-else bar someone """, - { - "summary": r".*Reason: Unexpected child with tag 'swh:object'.*", - "fields": ["swh:deposit"], - }, + [ + { + "summary": r".*Reason: Unexpected child with tag 'swh:object'.*", + "fields": ["swh:deposit"], + }, + ], ), ] ] -@pytest.mark.parametrize("metadata_ko,expected_summary", _parameters4) +@pytest.mark.parametrize("metadata_ko,expected_summaries", _parameters3) def test_api_checks_check_metadata_ko_schema( - metadata_ko, expected_summary, swh_checks_deposit + metadata_ko, expected_summaries, swh_checks_deposit ): actual_check, error_detail = check_metadata(ElementTree.fromstring(metadata_ko)) assert actual_check is False - assert len(error_detail["metadata"]) == 1, error_detail["metadata"] - assert error_detail["metadata"][0]["fields"] == expected_summary["fields"] + assert len(error_detail["metadata"]) == len(expected_summaries), error_detail[ + "metadata" + ] + + for (detail, expected_summary) in zip(error_detail["metadata"], expected_summaries): + assert detail["fields"] == expected_summary["fields"] - # xmlschema returns very detailed errors, we cannot reasonably test them - # for equality - summary = error_detail["metadata"][0]["summary"] - assert re.match(expected_summary["summary"], summary, re.DOTALL), summary + # xmlschema returns very detailed errors, we cannot reasonably test them + # for equality + summary = detail["summary"] + assert re.match( + expected_summary["summary"], summary, re.DOTALL + ), f"Failed to match {expected_summary['summary']!r} with:\n{summary}" diff --git a/swh/deposit/xsd/codemeta.xsd b/swh/deposit/xsd/codemeta.xsd new file mode 100644 index 00000000..6b117726 --- /dev/null +++ b/swh/deposit/xsd/codemeta.xsd @@ -0,0 +1,16 @@ + + + + + + + + + + +