diff --git a/swh/deposit/api/checks.py b/swh/deposit/api/checks.py
index f76fba9c..dbf61404 100644
--- a/swh/deposit/api/checks.py
+++ b/swh/deposit/api/checks.py
@@ -1,129 +1,129 @@
 # 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 pkg_resources
 import xmlschema
 
 from swh.deposit.errors import FORBIDDEN, DepositError
 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"), 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, <detailed-error>) if metadata are ok but some suggestions are missing
           - (False, <detailed-error>) 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)}]}
 
     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:
             schemas().codemeta.validate(child)
         except xmlschema.exceptions.XMLSchemaException as e:
             detail.append({"fields": [schema_element.prefixed_name], "summary": str(e)})
 
     if detail:
-        return False, {"metadata": detail}
+        return False, {"metadata": detail + suggested_fields}
 
     if suggested_fields:  # it's fine but warn about missing suggested fields
         return True, {"metadata": suggested_fields}
 
     return True, None
 
 
 def check_url_match_provider(url: str, provider_url: str) -> None:
     """Check url matches the provider url.
 
     Raises DepositError in case of mismatch
 
     """
     provider_url = provider_url.rstrip("/") + "/"
     if not url.startswith(provider_url):
         raise DepositError(
             FORBIDDEN, f"URL mismatch: {url} must start with {provider_url}",
         )
diff --git a/swh/deposit/tests/api/test_checks.py b/swh/deposit/tests/api/test_checks.py
index 3cc96c0b..01ebd382 100644
--- a/swh/deposit/tests/api/test_checks.py
+++ b/swh/deposit/tests/api/test_checks.py
@@ -1,667 +1,712 @@
 # 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 = """
                 <swh:deposit>
                     <swh:metadata-provenance>
                         <schema:url>some-metadata-provenance-url</schema:url>
                     </swh:metadata-provenance>
                 </swh:deposit>"""
 
 _parameters1 = [
     textwrap.dedent(metadata_ok)
     for (metadata_ok,) in [
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <name>foo</name>
                 <author>someone</author>
                 {PROVENANCE_XML}
             </entry>
             """,
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <name>foo</name>
                 <author>no one</author>
                 {PROVENANCE_XML}
             </entry>
             """,
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <codemeta:name>bar</codemeta:name>
                 <codemeta:author>
                     <codemeta:name>no one</codemeta:name>
                 </codemeta:author>
                 {PROVENANCE_XML}
             </entry>
             """,
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <codemeta:name>bar</codemeta:name>
                 <codemeta:author>
                     <codemeta:name>someone</codemeta:name>
                     <schema:unknown-tag>should allow anything here</schema:unknown-tag>
                 </codemeta:author>
                 {PROVENANCE_XML}
             </entry>
             """,
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <codemeta:name>bar</codemeta:name>
                 <codemeta:author>
                     <schema:unknown-tag>should allow anything here</schema:unknown-tag>
                     <codemeta:name>someone</codemeta:name>
                 </codemeta:author>
                 {PROVENANCE_XML}
             </entry>
             """,
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <codemeta:name>bar</codemeta:name>
                 <codemeta:author>
                     <schema:unknown-tag>should allow anything here</schema:unknown-tag>
                     <codemeta:name>someone</codemeta:name>
                     <schema:unknown-tag>should allow anything here</schema:unknown-tag>
                 </codemeta:author>
                 {PROVENANCE_XML}
             </entry>
             """,
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <external_identifier>some id</external_identifier>
                 <name>nar</name>
                 <author>no one</author>
                 <codemeta:datePublished>2020-12-21</codemeta:datePublished>
                 <codemeta:dateCreated>2020-12-21</codemeta:dateCreated>
                 <codemeta:dateModified>2020-12-25</codemeta:dateModified>
                 {PROVENANCE_XML}
             </entry>
             """,
         ),
         (
             # technically, only Date is allowed for datePublished; but we allow DateTime
             # for backward compatibility with old swh-deposit versions
             f"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <external_identifier>some id</external_identifier>
                 <name>nar</name>
                 <author>no one</author>
                 <codemeta:datePublished>2020-12-21T12:00:00</codemeta:datePublished>
                 <codemeta:dateCreated>2020-12-21T12:00:00</codemeta:dateCreated>
                 <codemeta:dateModified>2020-12-25T12:00:00</codemeta:dateModified>
                 {PROVENANCE_XML}
             </entry>
             """,
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
             </entry>
             """,
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:add_to_origin>
                         <swh:origin url="http://example.org" />
                     </swh:add_to_origin>
                     <swh:metadata-provenance>
                         <schema:url>some-metadata-provenance-url</schema:url>
                     </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:reference>
                         <swh:origin url="http://example.org" />
                     </swh:reference>
                     <swh:metadata-provenance>
                         <schema:url>some-metadata-provenance-url</schema:url>
                     </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:reference>
                         <swh:object swhid="swh:1:dir:0000000000000000000000000000000000000000" />
                     </swh:reference>
                     <swh:metadata-provenance>
                         <schema:url>some-metadata-provenance-url</schema:url>
                     </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
         ),
     ]
 ]
 
 
 @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"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <author>someone</author>
                 {PROVENANCE_XML}
             </entry>
             """,
             {
                 "summary": "Mandatory fields are missing",
                 "fields": ["atom:name or atom:title or codemeta:name"],
             },
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>foobar</title>
                 {PROVENANCE_XML}
             </entry>
             """,
             {
                 "summary": "Mandatory fields are missing",
                 "fields": ["atom:author or codemeta:author"],
             },
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <codemeta:title>bar</codemeta:title>
                 <author>someone</author>
                 {PROVENANCE_XML}
             </entry>
             """,
             {
                 "summary": "Mandatory fields are missing",
                 "fields": ["atom:name or atom:title or codemeta:name"],
             },
         ),
         (
             f"""\
             <entry xmlns:atom="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/">
                 <atom:url>something</atom:url>
                 <atom:external_identifier>something-else</atom:external_identifier>
                 <atom:title>foobar</atom:title>
                 <author>foo</author>
                 {PROVENANCE_XML}
             </entry>
             """,
             {
                 "summary": "Mandatory fields are missing",
                 "fields": ["atom:author or codemeta:author"],
             },
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <authorblahblah>someone</authorblahblah>
                 {PROVENANCE_XML}
             </entry>
             """,
             {
                 "summary": "Mandatory fields are missing",
                 "fields": ["atom:author or codemeta:author"],
             },
         ),
     ]
 ]
 
 
 @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"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <codemeta:name>
                     <codemeta:name>bar</codemeta:name>
                 </codemeta:name>
                 <author>no one</author>
                 {PROVENANCE_XML}
             </entry>
             """,
             [
                 {
                     "summary": ".*Reason: a simple content element can't have child elements.*",
                     "fields": ["codemeta:name"],
                 },
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <codemeta:name>bar</codemeta:name>
                 <codemeta:author>no one</codemeta:author>
                 {PROVENANCE_XML}
             </entry>
             """,
             [
                 {
                     "summary": ".*Reason: character data between child elements.*",
                     "fields": ["codemeta:author"],
                 },
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <codemeta:name>bar</codemeta:name>
                 <codemeta:author>
                     <schema:unknown-tag>should allow anything here</schema:unknown-tag>
                 </codemeta:author>
                 {PROVENANCE_XML}
             </entry>
             """,
             [
                 {
                     "summary": ".*Tag '?codemeta:name'? expected.*",
                     "fields": ["codemeta:author"],
                 },
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <codemeta:datePublished>2020-aa-21</codemeta:datePublished>
                 <codemeta:dateCreated>2020-12-bb</codemeta:dateCreated>
                 {PROVENANCE_XML}
             </entry>
             """,
             [
                 {
                     "summary": ".*Reason: invalid value '2020-aa-21'.*",
                     "fields": ["codemeta:datePublished"],
                 },
                 {
                     "summary": ".*Reason: invalid value '2020-12-bb'.*",
                     "fields": ["codemeta:dateCreated"],
                 },
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <external_identifier>someid</external_identifier>
                 <title>bar</title>
                 <author>no one</author>
                 <codemeta:datePublished>2020-aa-21</codemeta:datePublished>
                 <codemeta:dateCreated>2020-12-bb</codemeta:dateCreated>
+                {PROVENANCE_XML}
             </entry>
             """,
             [
                 {
                     "summary": ".*Reason: invalid value '2020-aa-21'.*",
                     "fields": ["codemeta:datePublished"],
                 },
                 {
                     "summary": ".*Reason: invalid value '2020-12-bb'.*",
                     "fields": ["codemeta:dateCreated"],
                 },
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>some url</url>
                 <external_identifier>someid</external_identifier>
                 <title>bar</title>
                 <author>no one</author>
                 <codemeta:dateModified>2020-12-aa</codemeta:dateModified>
+                {PROVENANCE_XML}
             </entry>
             """,
             [
                 {
                     "summary": ".*Reason: invalid value '2020-12-aa'.*",
                     "fields": ["codemeta:dateModified"],
                 },
             ],
         ),
+        (
+            f"""\
+            <entry {XMLNS}>
+                <url>some url</url>
+                <codemeta:name>bar</codemeta:name>
+                <codemeta:author>no one</codemeta:author>
+            </entry>
+            """,
+            [
+                {
+                    "summary": ".*Reason: character data between child elements.*",
+                    "fields": ["codemeta:author"],
+                },
+                {
+                    "summary": "Suggested fields are missing",
+                    "fields": ["swh:metadata-provenance"],
+                },
+            ],
+        ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:invalid>
                         <swh:origin url="http://example.org" />
                     </swh:invalid>
+                    <swh:metadata-provenance>
+                        <schema:url>some-metadata-provenance-url</schema:url>
+                    </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
             [
                 {
                     "summary": (
                         r".*Reason: Unexpected child with tag 'swh:invalid'.*"
                         r"Instance:.*swh:invalid.*"
                     ),
                     "fields": ["swh:deposit"],
                 }
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:add_to_origin>
                         <swh:origin url="http://example.org" />
                     </swh:add_to_origin>
                     <swh:add_to_origin>
                         <swh:origin url="http://example.org" />
                     </swh:add_to_origin>
+                    <swh:metadata-provenance>
+                        <schema:url>some-metadata-provenance-url</schema:url>
+                    </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
             [
                 {
                     "summary": (
                         r".*Reason: Unexpected child with tag 'swh:add_to_origin'.*"
                     ),
                     "fields": ["swh:deposit"],
                 }
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:add_to_origin>
                         <swh:origin url="http://example.org" />
                     </swh:add_to_origin>
                     <swh:create_origin>
                         <swh:origin url="http://example.org" />
                     </swh:create_origin>
+                    <swh:metadata-provenance>
+                        <schema:url>some-metadata-provenance-url</schema:url>
+                    </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
             [
                 {
                     "summary": (
                         r".*Reason: assertion test if false.*"
                         r"Schema:\n*"
                         r' *<xsd:assert[^>]+ id="swhdeposit-incompatible-create-and-add".*'
                     ),
                     "fields": ["swh:deposit"],
                 }
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:create_origin>
                         <swh:origin url="http://example.org" />
                     </swh:create_origin>
                     <swh:reference>
                         <swh:origin url="http://example.org" />
                     </swh:reference>
+                    <swh:metadata-provenance>
+                        <schema:url>some-metadata-provenance-url</schema:url>
+                    </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
             [
                 {
                     "summary": (
                         r".*Reason: assertion test if false.*"
                         r"Schema:\n*"
                         r' *<xsd:assert[^>]+ id="swhdeposit-incompatible-create-and-reference".*'
                     ),
                     "fields": ["swh:deposit"],
                 }
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:add_to_origin>
                         <swh:origin url="http://example.org" />
                     </swh:add_to_origin>
                     <swh:reference>
                         <swh:origin url="http://example.org" />
                     </swh:reference>
+                    <swh:metadata-provenance>
+                        <schema:url>some-metadata-provenance-url</schema:url>
+                    </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
             [
                 {
                     "summary": (
                         r".*Reason: assertion test if false.*"
                         r"Schema:\n*"
                         r' *<xsd:assert[^>]+ id="swhdeposit-incompatible-add-and-reference".*'
                     ),
                     "fields": ["swh:deposit"],
                 }
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:reference>
                         <swh:object swhid="swh:1:dir:0000000000000000000000000000000000000000" />
                         <swh:origin url="http://example.org" />
                     </swh:reference>
+                    <swh:metadata-provenance>
+                        <schema:url>some-metadata-provenance-url</schema:url>
+                    </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
             [
                 {
                     "summary": r".*Reason: Unexpected child with tag 'swh:origin'.*",
                     "fields": ["swh:deposit"],
                 },
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:reference>
                         <swh:origin url="http://example.org" />
                         <swh:origin url="http://example.org" />
                     </swh:reference>
+                    <swh:metadata-provenance>
+                        <schema:url>some-metadata-provenance-url</schema:url>
+                    </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
             [
                 {
                     "summary": r".*Reason: Unexpected child with tag 'swh:origin'.*",
                     "fields": ["swh:deposit"],
                 },
             ],
         ),
         (
             f"""\
             <entry {XMLNS}>
                 <url>something</url>
                 <external_identifier>something-else</external_identifier>
                 <title>bar</title>
                 <author>someone</author>
                 <swh:deposit>
                     <swh:reference>
                         <swh:origin url="http://example.org" />
                         <swh:object swhid="swh:1:dir:0000000000000000000000000000000000000000" />
                     </swh:reference>
+                    <swh:metadata-provenance>
+                        <schema:url>some-metadata-provenance-url</schema:url>
+                    </swh:metadata-provenance>
                 </swh:deposit>
             </entry>
             """,
             [
                 {
                     "summary": r".*Reason: Unexpected child with tag 'swh:object'.*",
                     "fields": ["swh:deposit"],
                 },
             ],
         ),
     ]
 ]
 
 
 @pytest.mark.parametrize("metadata_ko,expected_summaries", _parameters3)
 def test_api_checks_check_metadata_ko_schema(
     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"]) == 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 = detail["summary"]
         assert re.match(
             expected_summary["summary"], summary, re.DOTALL
         ), f"Failed to match {expected_summary['summary']!r} with:\n{summary}"