diff --git a/swh/indexer/metadata.py b/swh/indexer/metadata.py
index 9f1e870..7d9e3b1 100644
--- a/swh/indexer/metadata.py
+++ b/swh/indexer/metadata.py
@@ -1,385 +1,389 @@
 # Copyright (C) 2017-2020  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
 
 from copy import deepcopy
-from typing import Any, Callable, Dict, Iterator, List, Tuple
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
 
 from swh.core.config import merge_configs
 from swh.core.utils import grouper
 from swh.indexer.codemeta import merge_documents
 from swh.indexer.indexer import ContentIndexer, OriginIndexer, RevisionIndexer
 from swh.indexer.metadata_detector import detect_metadata
 from swh.indexer.metadata_dictionary import MAPPINGS
 from swh.indexer.origin_head import OriginHeadIndexer
 from swh.indexer.storage import INDEXER_CFG_KEY
+from swh.indexer.storage.model import ContentMetadataRow
 from swh.model import hashutil
 
 REVISION_GET_BATCH_SIZE = 10
 ORIGIN_GET_BATCH_SIZE = 10
 
 
 def call_with_batches(
     f: Callable[[List[Dict[str, Any]]], Dict["str", Any]],
     args: List[Dict[str, str]],
     batch_size: int,
 ) -> Iterator[str]:
     """Calls a function with batches of args, and concatenates the results.
     """
     groups = grouper(args, batch_size)
     for group in groups:
         yield from f(list(group))
 
 
-class ContentMetadataIndexer(ContentIndexer[Dict]):
+class ContentMetadataIndexer(ContentIndexer[ContentMetadataRow]):
     """Content-level indexer
 
     This indexer is in charge of:
 
     - filtering out content already indexed in content_metadata
     - reading content from objstorage with the content's id sha1
     - computing metadata by given context
     - using the metadata_dictionary as the 'swh-metadata-translator' tool
     - store result in content_metadata table
 
     """
 
     def filter(self, ids):
         """Filter out known sha1s and return only missing ones.
         """
         yield from self.idx_storage.content_metadata_missing(
             ({"id": sha1, "indexer_configuration_id": self.tool["id"],} for sha1 in ids)
         )
 
-    def index(self, id, data, log_suffix="unknown revision"):
+    def index(
+        self, id, data: Optional[bytes] = None, log_suffix="unknown revision", **kwargs
+    ) -> List[ContentMetadataRow]:
         """Index sha1s' content and store result.
 
         Args:
             id (bytes): content's identifier
             data (bytes): raw content in bytes
 
         Returns:
             dict: dictionary representing a content_metadata. If the
             translation wasn't successful the metadata keys will
             be returned as None
 
         """
-        result = {
-            "id": id,
-            "indexer_configuration_id": self.tool["id"],
-            "metadata": None,
-        }
+        assert isinstance(id, bytes)
+        assert data is not None
         try:
             mapping_name = self.tool["tool_configuration"]["context"]
             log_suffix += ", content_id=%s" % hashutil.hash_to_hex(id)
-            result["metadata"] = MAPPINGS[mapping_name](log_suffix).translate(data)
+            metadata = MAPPINGS[mapping_name](log_suffix).translate(data)
         except Exception:
             self.log.exception(
                 "Problem during metadata translation "
                 "for content %s" % hashutil.hash_to_hex(id)
             )
-        if result["metadata"] is None:
+        if metadata is None:
             return []
-        return [result]
+        return [
+            ContentMetadataRow(
+                id=id, indexer_configuration_id=self.tool["id"], metadata=metadata,
+            )
+        ]
 
     def persist_index_computations(
-        self, results: List[Dict], policy_update: str
+        self, results: List[ContentMetadataRow], policy_update: str
     ) -> Dict[str, int]:
         """Persist the results in storage.
 
         Args:
             results: list of content_metadata, dict with the
               following keys:
               - id (bytes): content's identifier (sha1)
               - metadata (jsonb): detected metadata
             policy_update: either 'update-dups' or 'ignore-dups' to
               respectively update duplicates or ignore them
 
         """
         return self.idx_storage.content_metadata_add(
             results, conflict_update=(policy_update == "update-dups")
         )
 
 
 DEFAULT_CONFIG: Dict[str, Any] = {
     "tools": {
         "name": "swh-metadata-detector",
         "version": "0.0.2",
         "configuration": {},
     },
 }
 
 
 class RevisionMetadataIndexer(RevisionIndexer[Dict]):
     """Revision-level indexer
 
     This indexer is in charge of:
 
     - filtering revisions already indexed in revision_intrinsic_metadata table
       with defined computation tool
     - retrieve all entry_files in root directory
     - use metadata_detector for file_names containing metadata
     - compute metadata translation if necessary and possible (depends on tool)
     - send sha1s to content indexing if possible
     - store the results for revision
 
     """
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.config = merge_configs(DEFAULT_CONFIG, self.config)
 
     def filter(self, sha1_gits):
         """Filter out known sha1s and return only missing ones.
 
         """
         yield from self.idx_storage.revision_intrinsic_metadata_missing(
             (
                 {"id": sha1_git, "indexer_configuration_id": self.tool["id"],}
                 for sha1_git in sha1_gits
             )
         )
 
     def index(self, rev):
         """Index rev by processing it and organizing result.
 
         use metadata_detector to iterate on filenames
 
         - if one filename detected -> sends file to content indexer
         - if multiple file detected -> translation needed at revision level
 
         Args:
           rev: revision model object from storage
 
         Returns:
             dict: dictionary representing a revision_intrinsic_metadata, with
             keys:
 
             - id (str): rev's identifier (sha1_git)
             - indexer_configuration_id (bytes): tool used
             - metadata: dict of retrieved metadata
 
         """
         result = {
             "id": rev.id,
             "indexer_configuration_id": self.tool["id"],
             "mappings": None,
             "metadata": None,
         }
 
         try:
             root_dir = rev.directory
             dir_ls = list(self.storage.directory_ls(root_dir, recursive=False))
             if [entry["type"] for entry in dir_ls] == ["dir"]:
                 # If the root is just a single directory, recurse into it
                 # eg. PyPI packages, GNU tarballs
                 subdir = dir_ls[0]["target"]
                 dir_ls = self.storage.directory_ls(subdir, recursive=False)
             files = [entry for entry in dir_ls if entry["type"] == "file"]
             detected_files = detect_metadata(files)
             (mappings, metadata) = self.translate_revision_intrinsic_metadata(
                 detected_files, log_suffix="revision=%s" % hashutil.hash_to_hex(rev.id),
             )
             result["mappings"] = mappings
             result["metadata"] = metadata
         except Exception as e:
             self.log.exception("Problem when indexing rev: %r", e)
         return [result]
 
     def persist_index_computations(
         self, results: List[Dict], policy_update: str
     ) -> Dict[str, int]:
         """Persist the results in storage.
 
         Args:
             results: list of content_mimetype, dict with the
               following keys:
               - id (bytes): content's identifier (sha1)
               - mimetype (bytes): mimetype in bytes
               - encoding (bytes): encoding in bytes
             policy_update: either 'update-dups' or 'ignore-dups' to
               respectively update duplicates or ignore them
 
         """
         # TODO: add functions in storage to keep data in
         # revision_intrinsic_metadata
         return self.idx_storage.revision_intrinsic_metadata_add(
             results, conflict_update=(policy_update == "update-dups")
         )
 
     def translate_revision_intrinsic_metadata(
         self, detected_files: Dict[str, List[Any]], log_suffix: str
     ) -> Tuple[List[Any], List[Any]]:
         """
         Determine plan of action to translate metadata when containing
         one or multiple detected files:
 
         Args:
             detected_files: dictionary mapping context names (e.g.,
               "npm", "authors") to list of sha1
 
         Returns:
             (List[str], dict): list of mappings used and dict with
             translated metadata according to the CodeMeta vocabulary
 
         """
         used_mappings = [MAPPINGS[context].name for context in detected_files]
         metadata = []
         tool = {
             "name": "swh-metadata-translator",
             "version": "0.0.2",
             "configuration": {},
         }
         # TODO: iterate on each context, on each file
         # -> get raw_contents
         # -> translate each content
         config = {k: self.config[k] for k in [INDEXER_CFG_KEY, "objstorage", "storage"]}
         config["tools"] = [tool]
         for context in detected_files.keys():
             cfg = deepcopy(config)
             cfg["tools"][0]["configuration"]["context"] = context
             c_metadata_indexer = ContentMetadataIndexer(config=cfg)
             # sha1s that are in content_metadata table
             sha1s_in_storage = []
             metadata_generator = self.idx_storage.content_metadata_get(
                 detected_files[context]
             )
             for c in metadata_generator:
                 # extracting metadata
-                sha1 = c["id"]
+                sha1 = c.id
                 sha1s_in_storage.append(sha1)
-                local_metadata = c["metadata"]
+                local_metadata = c.metadata
                 # local metadata is aggregated
                 if local_metadata:
                     metadata.append(local_metadata)
 
             sha1s_filtered = [
                 item for item in detected_files[context] if item not in sha1s_in_storage
             ]
 
             if sha1s_filtered:
                 # content indexing
                 try:
                     c_metadata_indexer.run(
                         sha1s_filtered,
                         policy_update="ignore-dups",
                         log_suffix=log_suffix,
                     )
                     # on the fly possibility:
                     for result in c_metadata_indexer.results:
-                        local_metadata = result["metadata"]
+                        local_metadata = result.metadata
                         metadata.append(local_metadata)
 
                 except Exception:
                     self.log.exception("Exception while indexing metadata on contents")
 
         metadata = merge_documents(metadata)
         return (used_mappings, metadata)
 
 
 class OriginMetadataIndexer(OriginIndexer[Dict]):
     USE_TOOLS = False
 
     def __init__(self, config=None, **kwargs) -> None:
         super().__init__(config=config, **kwargs)
         self.origin_head_indexer = OriginHeadIndexer(config=config)
         self.revision_metadata_indexer = RevisionMetadataIndexer(config=config)
 
     def index_list(self, origin_urls, **kwargs):
         head_rev_ids = []
         origins_with_head = []
         origins = list(
             call_with_batches(
                 self.storage.origin_get, origin_urls, ORIGIN_GET_BATCH_SIZE,
             )
         )
         for origin in origins:
             if origin is None:
                 continue
             head_results = self.origin_head_indexer.index(origin.url)
             if head_results:
                 (head_result,) = head_results
                 origins_with_head.append(origin)
                 head_rev_ids.append(head_result["revision_id"])
 
         head_revs = list(
             call_with_batches(
                 self.storage.revision_get, head_rev_ids, REVISION_GET_BATCH_SIZE
             )
         )
         assert len(head_revs) == len(head_rev_ids)
 
         results = []
         for (origin, rev) in zip(origins_with_head, head_revs):
             if not rev:
                 self.log.warning("Missing head revision of origin %r", origin.url)
                 continue
 
             for rev_metadata in self.revision_metadata_indexer.index(rev):
                 # There is at most one rev_metadata
                 orig_metadata = {
                     "from_revision": rev_metadata["id"],
                     "id": origin.url,
                     "metadata": rev_metadata["metadata"],
                     "mappings": rev_metadata["mappings"],
                     "indexer_configuration_id": rev_metadata[
                         "indexer_configuration_id"
                     ],
                 }
                 results.append((orig_metadata, rev_metadata))
         return results
 
     def persist_index_computations(
         self, results: List[Dict], policy_update: str
     ) -> Dict[str, int]:
         conflict_update = policy_update == "update-dups"
 
         # Deduplicate revisions
         rev_metadata: List[Any] = []
         orig_metadata: List[Any] = []
         revs_to_delete: List[Any] = []
         origs_to_delete: List[Any] = []
         summary: Dict = {}
         for (orig_item, rev_item) in results:
             assert rev_item["metadata"] == orig_item["metadata"]
             if not rev_item["metadata"] or rev_item["metadata"].keys() <= {"@context"}:
                 # If we didn't find any metadata, don't store a DB record
                 # (and delete existing ones, if any)
                 if rev_item not in revs_to_delete:
                     revs_to_delete.append(rev_item)
                 if orig_item not in origs_to_delete:
                     origs_to_delete.append(orig_item)
             else:
                 if rev_item not in rev_metadata:
                     rev_metadata.append(rev_item)
                 if orig_item not in orig_metadata:
                     orig_metadata.append(orig_item)
 
         if rev_metadata:
             summary_rev = self.idx_storage.revision_intrinsic_metadata_add(
                 rev_metadata, conflict_update=conflict_update
             )
             summary.update(summary_rev)
         if orig_metadata:
             summary_ori = self.idx_storage.origin_intrinsic_metadata_add(
                 orig_metadata, conflict_update=conflict_update
             )
             summary.update(summary_ori)
 
         # revs_to_delete should always be empty unless we changed a mapping
         # to detect less files or less content.
         # However, origs_to_delete may be empty whenever an upstream deletes
         # a metadata file.
         if origs_to_delete:
             summary_ori = self.idx_storage.origin_intrinsic_metadata_delete(
                 origs_to_delete
             )
             summary.update(summary_ori)
         if revs_to_delete:
             summary_rev = self.idx_storage.revision_intrinsic_metadata_delete(
                 revs_to_delete
             )
             summary.update(summary_rev)
 
         return summary
diff --git a/swh/indexer/metadata_dictionary/base.py b/swh/indexer/metadata_dictionary/base.py
index a0d63fc..0ddd975 100644
--- a/swh/indexer/metadata_dictionary/base.py
+++ b/swh/indexer/metadata_dictionary/base.py
@@ -1,183 +1,177 @@
 # Copyright (C) 2017-2019  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
 
-import abc
 import json
 import logging
 from typing import List
 
 from swh.indexer.codemeta import SCHEMA_URI, compact, merge_values
 
 
-class BaseMapping(metaclass=abc.ABCMeta):
+class BaseMapping:
     """Base class for mappings to inherit from
 
     To implement a new mapping:
 
     - inherit this class
     - override translate function
     """
 
     def __init__(self, log_suffix=""):
         self.log_suffix = log_suffix
         self.log = logging.getLogger(
             "%s.%s" % (self.__class__.__module__, self.__class__.__name__)
         )
 
     @property
-    @abc.abstractmethod
     def name(self):
         """A name of this mapping, used as an identifier in the
         indexer storage."""
-        pass
+        raise NotImplementedError(f"{self.__class__.__name__}.name")
 
     @classmethod
-    @abc.abstractmethod
     def detect_metadata_files(cls, files):
         """
         Detects files potentially containing metadata
 
         Args:
             file_entries (list): list of files
 
         Returns:
             list: list of sha1 (possibly empty)
         """
-        pass
+        raise NotImplementedError(f"{cls.__name__}.detect_metadata_files")
 
-    @abc.abstractmethod
     def translate(self, file_content):
-        pass
+        raise NotImplementedError(f"{self.__class__.__name__}.translate")
 
     def normalize_translation(self, metadata):
         return compact(metadata)
 
 
 class SingleFileMapping(BaseMapping):
     """Base class for all mappings that use a single file as input."""
 
     @property
-    @abc.abstractmethod
     def filename(self):
         """The .json file to extract metadata from."""
-        pass
+        raise NotImplementedError(f"{self.__class__.__name__}.filename")
 
     @classmethod
     def detect_metadata_files(cls, file_entries):
         for entry in file_entries:
             if entry["name"] == cls.filename:
                 return [entry["sha1"]]
         return []
 
 
 class DictMapping(BaseMapping):
     """Base class for mappings that take as input a file that is mostly
     a key-value store (eg. a shallow JSON dict)."""
 
     string_fields = []  # type: List[str]
     """List of fields that are simple strings, and don't need any
     normalization."""
 
     @property
-    @abc.abstractmethod
     def mapping(self):
         """A translation dict to map dict keys into a canonical name."""
-        pass
+        raise NotImplementedError(f"{self.__class__.__name__}.mapping")
 
     @staticmethod
     def _normalize_method_name(name):
         return name.replace("-", "_")
 
     @classmethod
     def supported_terms(cls):
         return {
             term
             for (key, term) in cls.mapping.items()
             if key in cls.string_fields
             or hasattr(cls, "translate_" + cls._normalize_method_name(key))
             or hasattr(cls, "normalize_" + cls._normalize_method_name(key))
         }
 
     def _translate_dict(self, content_dict, *, normalize=True):
         """
         Translates content  by parsing content from a dict object
         and translating with the appropriate mapping
 
         Args:
             content_dict (dict): content dict to translate
 
         Returns:
             dict: translated metadata in json-friendly form needed for
             the indexer
 
         """
         translated_metadata = {"@type": SCHEMA_URI + "SoftwareSourceCode"}
         for k, v in content_dict.items():
             # First, check if there is a specific translation
             # method for this key
             translation_method = getattr(
                 self, "translate_" + self._normalize_method_name(k), None
             )
             if translation_method:
                 translation_method(translated_metadata, v)
             elif k in self.mapping:
                 # if there is no method, but the key is known from the
                 # crosswalk table
                 codemeta_key = self.mapping[k]
 
                 # if there is a normalization method, use it on the value
                 normalization_method = getattr(
                     self, "normalize_" + self._normalize_method_name(k), None
                 )
                 if normalization_method:
                     v = normalization_method(v)
                 elif k in self.string_fields and isinstance(v, str):
                     pass
                 elif k in self.string_fields and isinstance(v, list):
                     v = [x for x in v if isinstance(x, str)]
                 else:
                     continue
 
                 # set the translation metadata with the normalized value
                 if codemeta_key in translated_metadata:
                     translated_metadata[codemeta_key] = merge_values(
                         translated_metadata[codemeta_key], v
                     )
                 else:
                     translated_metadata[codemeta_key] = v
         if normalize:
             return self.normalize_translation(translated_metadata)
         else:
             return translated_metadata
 
 
 class JsonMapping(DictMapping, SingleFileMapping):
     """Base class for all mappings that use a JSON file as input."""
 
     def translate(self, raw_content):
         """
         Translates content by parsing content from a bytestring containing
         json data and translating with the appropriate mapping
 
         Args:
             raw_content (bytes): raw content to translate
 
         Returns:
             dict: translated metadata in json-friendly form needed for
             the indexer
 
         """
         try:
             raw_content = raw_content.decode()
         except UnicodeDecodeError:
             self.log.warning("Error unidecoding from %s", self.log_suffix)
             return
         try:
             content_dict = json.loads(raw_content)
         except json.JSONDecodeError:
             self.log.warning("Error unjsoning from %s", self.log_suffix)
             return
         if isinstance(content_dict, dict):
             return self._translate_dict(content_dict)
diff --git a/swh/indexer/storage/__init__.py b/swh/indexer/storage/__init__.py
index d1aaa16..d27b154 100644
--- a/swh/indexer/storage/__init__.py
+++ b/swh/indexer/storage/__init__.py
@@ -1,684 +1,694 @@
 # Copyright (C) 2015-2020  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
 
 
 from collections import Counter
 import json
 from typing import Dict, Iterable, List, Optional, Tuple
 
 import psycopg2
 import psycopg2.pool
 
 from swh.core.db.common import db_transaction
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.model import SHA1_SIZE
 from swh.storage.exc import StorageDBError
 from swh.storage.utils import get_partition_bounds_bytes
 
 from . import converters
 from .db import Db
 from .exc import DuplicateId, IndexerStorageArgumentException
 from .interface import PagedResult, Sha1
 from .metrics import process_metrics, send_metric, timed
 from .model import (
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
     ContentMetadataRow,
     ContentMimetypeRow,
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 
 INDEXER_CFG_KEY = "indexer_storage"
 
 
 MAPPING_NAMES = ["codemeta", "gemspec", "maven", "npm", "pkg-info"]
 
 
 def get_indexer_storage(cls, args):
     """Get an indexer storage object of class `storage_class` with
     arguments `storage_args`.
 
     Args:
         cls (str): storage's class, either 'local' or 'remote'
         args (dict): dictionary of arguments passed to the
             storage class constructor
 
     Returns:
         an instance of swh.indexer's storage (either local or remote)
 
     Raises:
         ValueError if passed an unknown storage class.
 
     """
     if cls == "remote":
         from .api.client import RemoteStorage as IndexerStorage
     elif cls == "local":
         from . import IndexerStorage
     elif cls == "memory":
         from .in_memory import IndexerStorage
     else:
         raise ValueError("Unknown indexer storage class `%s`" % cls)
 
     return IndexerStorage(**args)
 
 
 def check_id_duplicates(data):
     """
     If any two row models in `data` have the same unique key, raises
     a `ValueError`.
 
     Values associated to the key must be hashable.
 
     Args:
         data (List[dict]): List of dictionaries to be inserted
 
     >>> check_id_duplicates([
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=42, lang="python"),
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=32, lang="python"),
     ... ])
     >>> check_id_duplicates([
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=42, lang="python"),
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=42, lang="python"),
     ... ])
     Traceback (most recent call last):
       ...
     swh.indexer.storage.exc.DuplicateId: [{'id': b'foo', 'indexer_configuration_id': 42}]
     """  # noqa
     counter = Counter(tuple(sorted(item.unique_key().items())) for item in data)
     duplicates = [id_ for (id_, count) in counter.items() if count >= 2]
     if duplicates:
         raise DuplicateId(list(map(dict, duplicates)))
 
 
 class IndexerStorage:
     """SWH Indexer Storage
 
     """
 
     def __init__(self, db, min_pool_conns=1, max_pool_conns=10):
         """
         Args:
             db_conn: either a libpq connection string, or a psycopg2 connection
 
         """
         try:
             if isinstance(db, psycopg2.extensions.connection):
                 self._pool = None
                 self._db = Db(db)
             else:
                 self._pool = psycopg2.pool.ThreadedConnectionPool(
                     min_pool_conns, max_pool_conns, db
                 )
                 self._db = None
         except psycopg2.OperationalError as e:
             raise StorageDBError(e)
 
     def get_db(self):
         if self._db:
             return self._db
         return Db.from_pool(self._pool)
 
     def put_db(self, db):
         if db is not self._db:
             db.put_conn()
 
     @timed
     @db_transaction()
     def check_config(self, *, check_write, db=None, cur=None):
         # Check permissions on one of the tables
         if check_write:
             check = "INSERT"
         else:
             check = "SELECT"
 
         cur.execute(
             "select has_table_privilege(current_user, 'content_mimetype', %s)",  # noqa
             (check,),
         )
         return cur.fetchone()[0]
 
     @timed
     @db_transaction()
     def content_mimetype_missing(
         self, mimetypes: Iterable[Dict], db=None, cur=None
     ) -> List[Tuple[Sha1, int]]:
         return [obj[0] for obj in db.content_mimetype_missing_from_list(mimetypes, cur)]
 
     @timed
     @db_transaction()
     def get_partition(
         self,
         indexer_type: str,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
         with_textual_data=False,
         db=None,
         cur=None,
     ) -> PagedResult[Sha1]:
         """Retrieve ids of content with `indexer_type` within within partition partition_id
         bound by limit.
 
         Args:
             **indexer_type**: Type of data content to index (mimetype, language, etc...)
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
             **with_textual_data** (bool): Deal with only textual content (True) or all
                 content (all contents by defaults, False)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns:
             PagedResult of Sha1. If next_page_token is None, there is no more data to
             fetch
 
         """
         if limit is None:
             raise IndexerStorageArgumentException("limit should not be None")
         if indexer_type not in db.content_indexer_names:
             err = f"Wrong type. Should be one of [{','.join(db.content_indexer_names)}]"
             raise IndexerStorageArgumentException(err)
 
         start, end = get_partition_bounds_bytes(partition_id, nb_partitions, SHA1_SIZE)
         if page_token is not None:
             start = hash_to_bytes(page_token)
         if end is None:
             end = b"\xff" * SHA1_SIZE
 
         next_page_token: Optional[str] = None
         ids = [
             row[0]
             for row in db.content_get_range(
                 indexer_type,
                 start,
                 end,
                 indexer_configuration_id,
                 limit=limit + 1,
                 with_textual_data=with_textual_data,
                 cur=cur,
             )
         ]
 
         if len(ids) >= limit:
             next_page_token = hash_to_hex(ids[-1])
             ids = ids[:limit]
 
         assert len(ids) <= limit
         return PagedResult(results=ids, next_page_token=next_page_token)
 
     @timed
     @db_transaction()
     def content_mimetype_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
         db=None,
         cur=None,
     ) -> PagedResult[Sha1]:
         return self.get_partition(
             "mimetype",
             indexer_configuration_id,
             partition_id,
             nb_partitions,
             page_token=page_token,
             limit=limit,
             db=db,
             cur=cur,
         )
 
     @timed
     @process_metrics
     @db_transaction()
     def content_mimetype_add(
         self,
         mimetypes: List[ContentMimetypeRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(mimetypes)
         mimetypes.sort(key=lambda m: m.id)
         db.mktemp_content_mimetype(cur)
         db.copy_to(
             [m.to_dict() for m in mimetypes],
             "tmp_content_mimetype",
             ["id", "mimetype", "encoding", "indexer_configuration_id"],
             cur,
         )
         count = db.content_mimetype_add_from_temp(conflict_update, cur)
         return {"content_mimetype:add": count}
 
     @timed
     @db_transaction()
     def content_mimetype_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> List[ContentMimetypeRow]:
         return [
             ContentMimetypeRow.from_dict(
                 converters.db_to_mimetype(dict(zip(db.content_mimetype_cols, c)))
             )
             for c in db.content_mimetype_get_from_list(ids, cur)
         ]
 
     @timed
     @db_transaction()
     def content_language_missing(
         self, languages: Iterable[Dict], db=None, cur=None
     ) -> List[Tuple[Sha1, int]]:
         return [obj[0] for obj in db.content_language_missing_from_list(languages, cur)]
 
     @timed
     @db_transaction()
     def content_language_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> List[ContentLanguageRow]:
         return [
             ContentLanguageRow.from_dict(
                 converters.db_to_language(dict(zip(db.content_language_cols, c)))
             )
             for c in db.content_language_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def content_language_add(
         self,
         languages: List[ContentLanguageRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(languages)
         languages.sort(key=lambda m: m.id)
         db.mktemp_content_language(cur)
         # empty language is mapped to 'unknown'
         db.copy_to(
             (
                 {
                     "id": lang.id,
                     "lang": lang.lang or "unknown",
                     "indexer_configuration_id": lang.indexer_configuration_id,
                 }
                 for lang in languages
             ),
             "tmp_content_language",
             ["id", "lang", "indexer_configuration_id"],
             cur,
         )
 
         count = db.content_language_add_from_temp(conflict_update, cur)
         return {"content_language:add": count}
 
     @timed
     @db_transaction()
     def content_ctags_missing(
         self, ctags: Iterable[Dict], db=None, cur=None
     ) -> List[Tuple[Sha1, int]]:
         return [obj[0] for obj in db.content_ctags_missing_from_list(ctags, cur)]
 
     @timed
     @db_transaction()
     def content_ctags_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> List[ContentCtagsRow]:
         return [
             ContentCtagsRow.from_dict(
                 converters.db_to_ctags(dict(zip(db.content_ctags_cols, c)))
             )
             for c in db.content_ctags_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def content_ctags_add(
         self,
         ctags: List[ContentCtagsRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(ctags)
         ctags.sort(key=lambda m: m.id)
 
         db.mktemp_content_ctags(cur)
         db.copy_to(
             [ctag.to_dict() for ctag in ctags],
             tblname="tmp_content_ctags",
             columns=["id", "name", "kind", "line", "lang", "indexer_configuration_id"],
             cur=cur,
         )
 
         count = db.content_ctags_add_from_temp(conflict_update, cur)
         return {"content_ctags:add": count}
 
     @timed
     @db_transaction()
     def content_ctags_search(
         self,
         expression: str,
         limit: int = 10,
         last_sha1: Optional[Sha1] = None,
         db=None,
         cur=None,
     ) -> List[ContentCtagsRow]:
         return [
             ContentCtagsRow.from_dict(
                 converters.db_to_ctags(dict(zip(db.content_ctags_cols, obj)))
             )
             for obj in db.content_ctags_search(expression, last_sha1, limit, cur=cur)
         ]
 
     @timed
     @db_transaction()
     def content_fossology_license_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> List[ContentLicenseRow]:
         return [
             ContentLicenseRow.from_dict(
                 converters.db_to_fossology_license(
                     dict(zip(db.content_fossology_license_cols, c))
                 )
             )
             for c in db.content_fossology_license_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def content_fossology_license_add(
         self,
         licenses: List[ContentLicenseRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(licenses)
         licenses.sort(key=lambda m: m.id)
         db.mktemp_content_fossology_license(cur)
         db.copy_to(
             [license.to_dict() for license in licenses],
             tblname="tmp_content_fossology_license",
             columns=["id", "license", "indexer_configuration_id"],
             cur=cur,
         )
         count = db.content_fossology_license_add_from_temp(conflict_update, cur)
         return {"content_fossology_license:add": count}
 
     @timed
     @db_transaction()
     def content_fossology_license_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
         db=None,
         cur=None,
     ) -> PagedResult[Sha1]:
         return self.get_partition(
             "fossology_license",
             indexer_configuration_id,
             partition_id,
             nb_partitions,
             page_token=page_token,
             limit=limit,
             with_textual_data=True,
             db=db,
             cur=cur,
         )
 
     @timed
     @db_transaction()
-    def content_metadata_missing(self, metadata, db=None, cur=None):
+    def content_metadata_missing(
+        self, metadata: Iterable[Dict], db=None, cur=None
+    ) -> List[Tuple[Sha1, int]]:
         return [obj[0] for obj in db.content_metadata_missing_from_list(metadata, cur)]
 
     @timed
     @db_transaction()
-    def content_metadata_get(self, ids, db=None, cur=None):
+    def content_metadata_get(
+        self, ids: Iterable[Sha1], db=None, cur=None
+    ) -> List[ContentMetadataRow]:
         return [
-            converters.db_to_metadata(dict(zip(db.content_metadata_cols, c)))
+            ContentMetadataRow.from_dict(
+                converters.db_to_metadata(dict(zip(db.content_metadata_cols, c)))
+            )
             for c in db.content_metadata_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def content_metadata_add(
-        self, metadata: List[Dict], conflict_update: bool = False, db=None, cur=None
+        self,
+        metadata: List[ContentMetadataRow],
+        conflict_update: bool = False,
+        db=None,
+        cur=None,
     ) -> Dict[str, int]:
-        check_id_duplicates(map(ContentMetadataRow.from_dict, metadata))
-        metadata.sort(key=lambda m: m["id"])
+        check_id_duplicates(metadata)
+        metadata.sort(key=lambda m: m.id)
 
         db.mktemp_content_metadata(cur)
 
         db.copy_to(
-            metadata,
+            [m.to_dict() for m in metadata],
             "tmp_content_metadata",
             ["id", "metadata", "indexer_configuration_id"],
             cur,
         )
         count = db.content_metadata_add_from_temp(conflict_update, cur)
         return {
             "content_metadata:add": count,
         }
 
     @timed
     @db_transaction()
     def revision_intrinsic_metadata_missing(self, metadata, db=None, cur=None):
         return [
             obj[0]
             for obj in db.revision_intrinsic_metadata_missing_from_list(metadata, cur)
         ]
 
     @timed
     @db_transaction()
     def revision_intrinsic_metadata_get(self, ids, db=None, cur=None):
         return [
             converters.db_to_metadata(dict(zip(db.revision_intrinsic_metadata_cols, c)))
             for c in db.revision_intrinsic_metadata_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def revision_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False, db=None, cur=None
     ) -> Dict[str, int]:
         check_id_duplicates(map(RevisionIntrinsicMetadataRow.from_dict, metadata))
         metadata.sort(key=lambda m: m["id"])
 
         db.mktemp_revision_intrinsic_metadata(cur)
 
         db.copy_to(
             metadata,
             "tmp_revision_intrinsic_metadata",
             ["id", "metadata", "mappings", "indexer_configuration_id"],
             cur,
         )
         count = db.revision_intrinsic_metadata_add_from_temp(conflict_update, cur)
         return {
             "revision_intrinsic_metadata:add": count,
         }
 
     @timed
     @process_metrics
     @db_transaction()
     def revision_intrinsic_metadata_delete(
         self, entries: List[Dict], db=None, cur=None
     ) -> Dict:
         count = db.revision_intrinsic_metadata_delete(entries, cur)
         return {"revision_intrinsic_metadata:del": count}
 
     @timed
     @db_transaction()
     def origin_intrinsic_metadata_get(self, ids, db=None, cur=None):
         return [
             converters.db_to_metadata(dict(zip(db.origin_intrinsic_metadata_cols, c)))
             for c in db.origin_intrinsic_metadata_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def origin_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False, db=None, cur=None
     ) -> Dict[str, int]:
         check_id_duplicates(map(OriginIntrinsicMetadataRow.from_dict, metadata))
         metadata.sort(key=lambda m: m["id"])
 
         db.mktemp_origin_intrinsic_metadata(cur)
 
         db.copy_to(
             metadata,
             "tmp_origin_intrinsic_metadata",
             ["id", "metadata", "indexer_configuration_id", "from_revision", "mappings"],
             cur,
         )
         count = db.origin_intrinsic_metadata_add_from_temp(conflict_update, cur)
         return {
             "origin_intrinsic_metadata:add": count,
         }
 
     @timed
     @process_metrics
     @db_transaction()
     def origin_intrinsic_metadata_delete(
         self, entries: List[Dict], db=None, cur=None
     ) -> Dict:
         count = db.origin_intrinsic_metadata_delete(entries, cur)
         return {
             "origin_intrinsic_metadata:del": count,
         }
 
     @timed
     @db_transaction()
     def origin_intrinsic_metadata_search_fulltext(
         self, conjunction, limit=100, db=None, cur=None
     ):
         return [
             converters.db_to_metadata(dict(zip(db.origin_intrinsic_metadata_cols, c)))
             for c in db.origin_intrinsic_metadata_search_fulltext(
                 conjunction, limit=limit, cur=cur
             )
         ]
 
     @timed
     @db_transaction()
     def origin_intrinsic_metadata_search_by_producer(
         self,
         page_token="",
         limit=100,
         ids_only=False,
         mappings=None,
         tool_ids=None,
         db=None,
         cur=None,
     ):
         assert isinstance(page_token, str)
         # we go to limit+1 to check whether we should add next_page_token in
         # the response
         res = db.origin_intrinsic_metadata_search_by_producer(
             page_token, limit + 1, ids_only, mappings, tool_ids, cur
         )
         result = {}
         if ids_only:
             result["origins"] = [origin for (origin,) in res]
             if len(result["origins"]) > limit:
                 result["origins"][limit:] = []
                 result["next_page_token"] = result["origins"][-1]
         else:
             result["origins"] = [
                 converters.db_to_metadata(
                     dict(zip(db.origin_intrinsic_metadata_cols, c))
                 )
                 for c in res
             ]
             if len(result["origins"]) > limit:
                 result["origins"][limit:] = []
                 result["next_page_token"] = result["origins"][-1]["id"]
         return result
 
     @timed
     @db_transaction()
     def origin_intrinsic_metadata_stats(self, db=None, cur=None):
         mapping_names = [m for m in MAPPING_NAMES]
         select_parts = []
 
         # Count rows for each mapping
         for mapping_name in mapping_names:
             select_parts.append(
                 (
                     "sum(case when (mappings @> ARRAY['%s']) "
                     "         then 1 else 0 end)"
                 )
                 % mapping_name
             )
 
         # Total
         select_parts.append("sum(1)")
 
         # Rows whose metadata has at least one key that is not '@context'
         select_parts.append(
             "sum(case when ('{}'::jsonb @> (metadata - '@context')) "
             "         then 0 else 1 end)"
         )
         cur.execute(
             "select " + ", ".join(select_parts) + " from origin_intrinsic_metadata"
         )
         results = dict(zip(mapping_names + ["total", "non_empty"], cur.fetchone()))
         return {
             "total": results.pop("total"),
             "non_empty": results.pop("non_empty"),
             "per_mapping": results,
         }
 
     @timed
     @db_transaction()
     def indexer_configuration_add(self, tools, db=None, cur=None):
         db.mktemp_indexer_configuration(cur)
         db.copy_to(
             tools,
             "tmp_indexer_configuration",
             ["tool_name", "tool_version", "tool_configuration"],
             cur,
         )
 
         tools = db.indexer_configuration_add_from_temp(cur)
         results = [dict(zip(db.indexer_configuration_cols, line)) for line in tools]
         send_metric(
             "indexer_configuration:add",
             len(results),
             method_name="indexer_configuration_add",
         )
         return results
 
     @timed
     @db_transaction()
     def indexer_configuration_get(self, tool, db=None, cur=None):
         tool_conf = tool["tool_configuration"]
         if isinstance(tool_conf, dict):
             tool_conf = json.dumps(tool_conf)
         idx = db.indexer_configuration_get(
             tool["tool_name"], tool["tool_version"], tool_conf
         )
         if not idx:
             return None
         return dict(zip(db.indexer_configuration_cols, idx))
diff --git a/swh/indexer/storage/in_memory.py b/swh/indexer/storage/in_memory.py
index 9675a90..80dbb0e 100644
--- a/swh/indexer/storage/in_memory.py
+++ b/swh/indexer/storage/in_memory.py
@@ -1,510 +1,509 @@
 # Copyright (C) 2018-2020  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
 
 from collections import Counter, defaultdict
 import itertools
 import json
 import math
 import operator
 import re
 from typing import (
     Any,
     Dict,
     Generic,
     Iterable,
     List,
     Optional,
     Set,
     Tuple,
     Type,
     TypeVar,
 )
 
 from swh.core.collections import SortedList
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.model import SHA1_SIZE, Sha1Git
 from swh.storage.utils import get_partition_bounds_bytes
 
 from . import MAPPING_NAMES, check_id_duplicates
 from .exc import IndexerStorageArgumentException
 from .interface import PagedResult, Sha1
 from .model import (
     BaseRow,
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
     ContentMetadataRow,
     ContentMimetypeRow,
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 
 SHA1_DIGEST_SIZE = 160
 
 
 def _transform_tool(tool):
     return {
         "id": tool["id"],
         "name": tool["tool_name"],
         "version": tool["tool_version"],
         "configuration": tool["tool_configuration"],
     }
 
 
 def check_id_types(data: List[Dict[str, Any]]):
     """Checks all elements of the list have an 'id' whose type is 'bytes'."""
     if not all(isinstance(item.get("id"), bytes) for item in data):
         raise IndexerStorageArgumentException("identifiers must be bytes.")
 
 
 def _key_from_dict(d):
     return tuple(sorted(d.items()))
 
 
 ToolId = int
 TValue = TypeVar("TValue", bound=BaseRow)
 
 
 class SubStorage(Generic[TValue]):
     """Implements common missing/get/add logic for each indexer type."""
 
     _data: Dict[Sha1, Dict[Tuple, Dict[str, Any]]]
     _tools_per_id: Dict[Sha1, Set[ToolId]]
 
     def __init__(self, row_class: Type[TValue], tools):
         self.row_class = row_class
         self._tools = tools
         self._sorted_ids = SortedList[bytes, Sha1]()
         self._data = defaultdict(dict)
         self._tools_per_id = defaultdict(set)
 
     def _key_from_dict(self, d) -> Tuple:
         """Like the global _key_from_dict, but filters out dict keys that don't
         belong in the unique key."""
         return _key_from_dict({k: d[k] for k in self.row_class.UNIQUE_KEY_FIELDS})
 
     def missing(self, keys: Iterable[Dict]) -> List[Sha1]:
         """List data missing from storage.
 
         Args:
             data (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Yields:
             missing sha1s
 
         """
         results = []
         for key in keys:
             tool_id = key["indexer_configuration_id"]
             id_ = key["id"]
             if tool_id not in self._tools_per_id.get(id_, set()):
                 results.append(id_)
         return results
 
     def get(self, ids: Iterable[Sha1]) -> List[TValue]:
         """Retrieve data per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Yields:
             dict: dictionaries with the following keys:
 
               - **id** (bytes)
               - **tool** (dict): tool used to compute metadata
               - arbitrary data (as provided to `add`)
 
         """
         results = []
         for id_ in ids:
             for entry in self._data[id_].values():
                 entry = entry.copy()
                 tool_id = entry.pop("indexer_configuration_id")
                 results.append(
                     self.row_class(
                         id=id_, tool=_transform_tool(self._tools[tool_id]), **entry,
                     )
                 )
         return results
 
     def get_all(self) -> List[TValue]:
         return self.get(self._sorted_ids)
 
     def get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         """Retrieve ids of content with `indexer_type` within partition partition_id
         bound by limit.
 
         Args:
             **indexer_type**: Type of data content to index (mimetype, language, etc...)
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
             **with_textual_data** (bool): Deal with only textual content (True) or all
                 content (all contents by defaults, False)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns:
             PagedResult of Sha1. If next_page_token is None, there is no more data to
             fetch
 
         """
         if limit is None:
             raise IndexerStorageArgumentException("limit should not be None")
         (start, end) = get_partition_bounds_bytes(
             partition_id, nb_partitions, SHA1_SIZE
         )
 
         if page_token:
             start = hash_to_bytes(page_token)
         if end is None:
             end = b"\xff" * SHA1_SIZE
 
         next_page_token: Optional[str] = None
         ids: List[Sha1] = []
         sha1s = (sha1 for sha1 in self._sorted_ids.iter_from(start))
         for counter, sha1 in enumerate(sha1s):
             if sha1 > end:
                 break
             if counter >= limit:
                 next_page_token = hash_to_hex(sha1)
                 break
             ids.append(sha1)
 
         assert len(ids) <= limit
         return PagedResult(results=ids, next_page_token=next_page_token)
 
     def add(self, data: Iterable[TValue], conflict_update: bool) -> int:
         """Add data not present in storage.
 
         Args:
             data (iterable): dictionaries with keys:
 
               - **id**: sha1
               - **indexer_configuration_id**: tool used to compute the
                 results
               - arbitrary data
 
             conflict_update (bool): Flag to determine if we want to overwrite
               (true) or skip duplicates (false)
 
         """
         data = list(data)
         check_id_duplicates(data)
         count = 0
         for obj in data:
             item = obj.to_dict()
             id_ = item.pop("id")
             tool_id = item["indexer_configuration_id"]
             key = _key_from_dict(obj.unique_key())
             if not conflict_update and key in self._data[id_]:
                 # Duplicate, should not be updated
                 continue
             self._data[id_][key] = item
             self._tools_per_id[id_].add(tool_id)
             count += 1
             if id_ not in self._sorted_ids:
                 self._sorted_ids.add(id_)
         return count
 
     def delete(self, entries: List[Dict]) -> int:
         """Delete entries and return the number of entries deleted.
 
         """
         deleted = 0
         for entry in entries:
             (id_, tool_id) = (entry["id"], entry["indexer_configuration_id"])
             if tool_id in self._tools_per_id[id_]:
                 self._tools_per_id[id_].remove(tool_id)
             if id_ in self._data:
                 key = self._key_from_dict(entry)
                 if key in self._data[id_]:
                     deleted += 1
                     del self._data[id_][key]
         return deleted
 
 
 class IndexerStorage:
     """In-memory SWH indexer storage."""
 
     def __init__(self):
         self._tools = {}
         self._mimetypes = SubStorage(ContentMimetypeRow, self._tools)
         self._languages = SubStorage(ContentLanguageRow, self._tools)
         self._content_ctags = SubStorage(ContentCtagsRow, self._tools)
         self._licenses = SubStorage(ContentLicenseRow, self._tools)
         self._content_metadata = SubStorage(ContentMetadataRow, self._tools)
         self._revision_intrinsic_metadata = SubStorage(
             RevisionIntrinsicMetadataRow, self._tools
         )
         self._origin_intrinsic_metadata = SubStorage(
             OriginIntrinsicMetadataRow, self._tools
         )
 
     def check_config(self, *, check_write):
         return True
 
     def content_mimetype_missing(
         self, mimetypes: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         return self._mimetypes.missing(mimetypes)
 
     def content_mimetype_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         return self._mimetypes.get_partition(
             indexer_configuration_id, partition_id, nb_partitions, page_token, limit
         )
 
     def content_mimetype_add(
         self, mimetypes: List[ContentMimetypeRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._mimetypes.add(mimetypes, conflict_update)
         return {"content_mimetype:add": added}
 
     def content_mimetype_get(self, ids: Iterable[Sha1]) -> List[ContentMimetypeRow]:
         return self._mimetypes.get(ids)
 
     def content_language_missing(
         self, languages: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         return self._languages.missing(languages)
 
     def content_language_get(self, ids: Iterable[Sha1]) -> List[ContentLanguageRow]:
         return self._languages.get(ids)
 
     def content_language_add(
         self, languages: List[ContentLanguageRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._languages.add(languages, conflict_update)
         return {"content_language:add": added}
 
     def content_ctags_missing(self, ctags: Iterable[Dict]) -> List[Tuple[Sha1, int]]:
         return self._content_ctags.missing(ctags)
 
     def content_ctags_get(self, ids: Iterable[Sha1]) -> List[ContentCtagsRow]:
         return self._content_ctags.get(ids)
 
     def content_ctags_add(
         self, ctags: List[ContentCtagsRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._content_ctags.add(ctags, conflict_update,)
         return {"content_ctags:add": added}
 
     def content_ctags_search(
         self, expression: str, limit: int = 10, last_sha1: Optional[Sha1] = None
     ) -> List[ContentCtagsRow]:
         nb_matches = 0
         items_per_id: Dict[Tuple[Sha1Git, ToolId], List[ContentCtagsRow]] = {}
         for item in sorted(self._content_ctags.get_all()):
             if item.id <= (last_sha1 or bytes(0 for _ in range(SHA1_DIGEST_SIZE))):
                 continue
             items_per_id.setdefault(
                 (item.id, item.indexer_configuration_id), []
             ).append(item)
 
         results = []
         for items in items_per_id.values():
             for item in items:
                 if item.name != expression:
                     continue
                 nb_matches += 1
                 if nb_matches > limit:
                     break
                 results.append(item)
 
         return results
 
     def content_fossology_license_get(
         self, ids: Iterable[Sha1]
     ) -> List[ContentLicenseRow]:
         return self._licenses.get(ids)
 
     def content_fossology_license_add(
         self, licenses: List[ContentLicenseRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._licenses.add(licenses, conflict_update)
         return {"content_fossology_license:add": added}
 
     def content_fossology_license_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         return self._licenses.get_partition(
             indexer_configuration_id, partition_id, nb_partitions, page_token, limit
         )
 
-    def content_metadata_missing(self, metadata):
+    def content_metadata_missing(
+        self, metadata: Iterable[Dict]
+    ) -> List[Tuple[Sha1, int]]:
         return self._content_metadata.missing(metadata)
 
-    def content_metadata_get(self, ids):
-        return [obj.to_dict() for obj in self._content_metadata.get(ids)]
+    def content_metadata_get(self, ids: Iterable[Sha1]) -> List[ContentMetadataRow]:
+        return self._content_metadata.get(ids)
 
     def content_metadata_add(
-        self, metadata: List[Dict], conflict_update: bool = False
+        self, metadata: List[ContentMetadataRow], conflict_update: bool = False
     ) -> Dict[str, int]:
-        check_id_types(metadata)
-        added = self._content_metadata.add(
-            map(ContentMetadataRow.from_dict, metadata), conflict_update
-        )
+        added = self._content_metadata.add(metadata, conflict_update)
         return {"content_metadata:add": added}
 
     def revision_intrinsic_metadata_missing(self, metadata):
         return self._revision_intrinsic_metadata.missing(metadata)
 
     def revision_intrinsic_metadata_get(self, ids):
         return [obj.to_dict() for obj in self._revision_intrinsic_metadata.get(ids)]
 
     def revision_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         check_id_types(metadata)
         added = self._revision_intrinsic_metadata.add(
             map(RevisionIntrinsicMetadataRow.from_dict, metadata), conflict_update
         )
         return {"revision_intrinsic_metadata:add": added}
 
     def revision_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
         deleted = self._revision_intrinsic_metadata.delete(entries)
         return {"revision_intrinsic_metadata:del": deleted}
 
     def origin_intrinsic_metadata_get(self, ids):
         return [obj.to_dict() for obj in self._origin_intrinsic_metadata.get(ids)]
 
     def origin_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._origin_intrinsic_metadata.add(
             map(OriginIntrinsicMetadataRow.from_dict, metadata), conflict_update
         )
         return {"origin_intrinsic_metadata:add": added}
 
     def origin_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
         deleted = self._origin_intrinsic_metadata.delete(entries)
         return {"origin_intrinsic_metadata:del": deleted}
 
     def origin_intrinsic_metadata_search_fulltext(self, conjunction, limit=100):
         # A very crude fulltext search implementation, but that's enough
         # to work on English metadata
         tokens_re = re.compile("[a-zA-Z0-9]+")
         search_tokens = list(itertools.chain(*map(tokens_re.findall, conjunction)))
 
         def rank(data):
             # Tokenize the metadata
             text = json.dumps(data.metadata)
             text_tokens = tokens_re.findall(text)
             text_token_occurences = Counter(text_tokens)
 
             # Count the number of occurrences of search tokens in the text
             score = 0
             for search_token in search_tokens:
                 if text_token_occurences[search_token] == 0:
                     # Search token is not in the text.
                     return 0
                 score += text_token_occurences[search_token]
 
             # Normalize according to the text's length
             return score / math.log(len(text_tokens))
 
         results = [
             (rank(data), data) for data in self._origin_intrinsic_metadata.get_all()
         ]
         results = [(rank_, data) for (rank_, data) in results if rank_ > 0]
         results.sort(
             key=operator.itemgetter(0), reverse=True  # Don't try to order 'data'
         )
         return [result.to_dict() for (rank_, result) in results[:limit]]
 
     def origin_intrinsic_metadata_search_by_producer(
         self, page_token="", limit=100, ids_only=False, mappings=None, tool_ids=None
     ):
         assert isinstance(page_token, str)
         nb_results = 0
         if mappings is not None:
             mappings = frozenset(mappings)
         if tool_ids is not None:
             tool_ids = frozenset(tool_ids)
         origins = []
 
         # we go to limit+1 to check whether we should add next_page_token in
         # the response
         for entry in self._origin_intrinsic_metadata.get_all():
             if entry.id <= page_token:
                 continue
             if nb_results >= (limit + 1):
                 break
             if mappings is not None and mappings.isdisjoint(entry.mappings):
                 continue
             if tool_ids is not None and entry.tool["id"] not in tool_ids:
                 continue
             origins.append(entry.to_dict())
             nb_results += 1
 
         result = {}
         if len(origins) > limit:
             origins = origins[:limit]
             result["next_page_token"] = origins[-1]["id"]
         if ids_only:
             origins = [origin["id"] for origin in origins]
         result["origins"] = origins
         return result
 
     def origin_intrinsic_metadata_stats(self):
         mapping_count = {m: 0 for m in MAPPING_NAMES}
         total = non_empty = 0
         for data in self._origin_intrinsic_metadata.get_all():
             total += 1
             if set(data.metadata) - {"@context"}:
                 non_empty += 1
             for mapping in data.mappings:
                 mapping_count[mapping] += 1
         return {"per_mapping": mapping_count, "total": total, "non_empty": non_empty}
 
     def indexer_configuration_add(self, tools):
         inserted = []
         for tool in tools:
             tool = tool.copy()
             id_ = self._tool_key(tool)
             tool["id"] = id_
             self._tools[id_] = tool
             inserted.append(tool)
         return inserted
 
     def indexer_configuration_get(self, tool):
         return self._tools.get(self._tool_key(tool))
 
     def _tool_key(self, tool):
         return hash(
             (
                 tool["tool_name"],
                 tool["tool_version"],
                 json.dumps(tool["tool_configuration"], sort_keys=True),
             )
         )
diff --git a/swh/indexer/storage/interface.py b/swh/indexer/storage/interface.py
index 8645990..561d4e9 100644
--- a/swh/indexer/storage/interface.py
+++ b/swh/indexer/storage/interface.py
@@ -1,600 +1,603 @@
 # Copyright (C) 2015-2020  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
 
 from typing import Dict, Iterable, List, Optional, Tuple, TypeVar
 
 from swh.core.api import remote_api_endpoint
 from swh.core.api.classes import PagedResult as CorePagedResult
 from swh.indexer.storage.model import (
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
+    ContentMetadataRow,
     ContentMimetypeRow,
 )
 
 TResult = TypeVar("TResult")
 PagedResult = CorePagedResult[TResult, str]
 
 
 Sha1 = bytes
 
 
 class IndexerStorageInterface:
     @remote_api_endpoint("check_config")
     def check_config(self, *, check_write):
         """Check that the storage is configured and ready to go."""
         ...
 
     @remote_api_endpoint("content_mimetype/missing")
     def content_mimetype_missing(
         self, mimetypes: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         """Generate mimetypes missing from storage.
 
         Args:
             mimetypes (iterable): iterable of dict with keys:
 
               - **id** (bytes): sha1 identifier
               - **indexer_configuration_id** (int): tool used to compute the
                 results
 
         Returns:
             list of tuple (id, indexer_configuration_id) missing
 
         """
         ...
 
     @remote_api_endpoint("content_mimetype/range")
     def content_mimetype_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         """Retrieve mimetypes within partition partition_id bound by limit.
 
         Args:
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns:
             PagedResult of Sha1. If next_page_token is None, there is no more data
             to fetch
 
         """
         ...
 
     @remote_api_endpoint("content_mimetype/add")
     def content_mimetype_add(
         self, mimetypes: List[ContentMimetypeRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add mimetypes not present in storage.
 
         Args:
             mimetypes: mimetype rows to be added, with their `tool` attribute set to
             None.
             conflict_update: Flag to determine if we want to
             overwrite (``True``) or skip duplicates (``False``, the
             default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content_mimetype")
     def content_mimetype_get(self, ids: Iterable[Sha1]) -> List[ContentMimetypeRow]:
         """Retrieve full content mimetype per ids.
 
         Args:
             ids: sha1 identifiers
 
         Returns:
             mimetype row objects
 
         """
         ...
 
     @remote_api_endpoint("content_language/missing")
     def content_language_missing(
         self, languages: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         """List languages missing from storage.
 
         Args:
             languages (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Returns:
             list of tuple (id, indexer_configuration_id) missing
 
         """
         ...
 
     @remote_api_endpoint("content_language")
     def content_language_get(self, ids: Iterable[Sha1]) -> List[ContentLanguageRow]:
         """Retrieve full content language per ids.
 
         Args:
             ids (iterable): sha1 identifier
 
         Returns:
             language row objects
 
         """
         ...
 
     @remote_api_endpoint("content_language/add")
     def content_language_add(
         self, languages: List[ContentLanguageRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add languages not present in storage.
 
         Args:
             languages: language row objects
 
             conflict_update (bool): Flag to determine if we want to
                 overwrite (true) or skip duplicates (false, the
                 default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content/ctags/missing")
     def content_ctags_missing(self, ctags: Iterable[Dict]) -> List[Tuple[Sha1, int]]:
         """List ctags missing from storage.
 
         Args:
             ctags (iterable): dicts with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Returns:
             list of missing id for the tuple (id,
             indexer_configuration_id)
 
         """
         ...
 
     @remote_api_endpoint("content/ctags")
     def content_ctags_get(self, ids: Iterable[Sha1]) -> List[ContentCtagsRow]:
         """Retrieve ctags per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Returns:
             list of language rows
 
 
         """
         ...
 
     @remote_api_endpoint("content/ctags/add")
     def content_ctags_add(
         self, ctags: List[ContentCtagsRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add ctags not present in storage
 
         Args:
             ctags (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1
                 - **ctags** ([list): List of dictionary with keys: name, kind,
                   line, lang
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content/ctags/search")
     def content_ctags_search(
         self, expression: str, limit: int = 10, last_sha1: Optional[Sha1] = None
     ) -> List[ContentCtagsRow]:
         """Search through content's raw ctags symbols.
 
         Args:
             expression (str): Expression to search for
             limit (int): Number of rows to return (default to 10).
             last_sha1 (str): Offset from which retrieving data (default to '').
 
         Returns:
             rows of ctags including id, name, lang, kind, line, etc...
 
         """
         ...
 
     @remote_api_endpoint("content/fossology_license")
     def content_fossology_license_get(
         self, ids: Iterable[Sha1]
     ) -> List[ContentLicenseRow]:
         """Retrieve licenses per id.
 
         Args:
             ids: sha1 identifiers
 
         Yields:
             license rows; possibly more than one per (sha1, tool_id) if there
             are multiple licenses.
 
         """
         ...
 
     @remote_api_endpoint("content/fossology_license/add")
     def content_fossology_license_add(
         self, licenses: List[ContentLicenseRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add licenses not present in storage.
 
         Args:
             license: license rows to be added, with their `tool` attribute set to
             None.
 
             conflict_update: Flag to determine if we want to overwrite (true)
                 or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content/fossology_license/range")
     def content_fossology_license_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         """Retrieve licenses within the partition partition_id bound by limit.
 
         Args:
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns: PagedResult of Sha1. If next_page_token is None, there is no more data
             to fetch
 
         """
         ...
 
     @remote_api_endpoint("content_metadata/missing")
-    def content_metadata_missing(self, metadata):
+    def content_metadata_missing(
+        self, metadata: Iterable[Dict]
+    ) -> List[Tuple[Sha1, int]]:
         """List metadata missing from storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Yields:
             missing sha1s
 
         """
         ...
 
     @remote_api_endpoint("content_metadata")
-    def content_metadata_get(self, ids):
+    def content_metadata_get(self, ids: Iterable[Sha1]) -> List[ContentMetadataRow]:
         """Retrieve metadata per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Yields:
             dictionaries with the following keys:
 
                 id (bytes)
                 metadata (str): associated metadata
                 tool (dict): tool used to compute metadata
 
         """
         ...
 
     @remote_api_endpoint("content_metadata/add")
     def content_metadata_add(
-        self, metadata: List[Dict], conflict_update: bool = False
+        self, metadata: List[ContentMetadataRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add metadata not present in storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                 - **id**: sha1
                 - **metadata**: arbitrary dict
 
             conflict_update: Flag to determine if we want to overwrite (true)
                 or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata/missing")
     def revision_intrinsic_metadata_missing(self, metadata):
         """List metadata missing from storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                - **id** (bytes): sha1_git revision identifier
                - **indexer_configuration_id** (int): tool used to compute
                  the results
 
         Yields:
             missing ids
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata")
     def revision_intrinsic_metadata_get(self, ids):
         """Retrieve revision metadata per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Yields:
             : dictionaries with the following keys:
 
                 - **id** (bytes)
                 - **metadata** (str): associated metadata
                 - **tool** (dict): tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata/add")
     def revision_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add metadata not present in storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                 - **id**: sha1_git of revision
                 - **metadata**: arbitrary dict
                 - **indexer_configuration_id**: tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
             conflict_update: Flag to determine if we want to overwrite (true)
               or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata/delete")
     def revision_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
         """Remove revision metadata from the storage.
 
         Args:
             entries (dict): dictionaries with the following keys:
 
                 - **id** (bytes): revision identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   metadata
 
         Returns:
             Summary of number of rows deleted
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata")
     def origin_intrinsic_metadata_get(self, ids):
         """Retrieve origin metadata per id.
 
         Args:
             ids (iterable): origin identifiers
 
         Yields:
             list: dictionaries with the following keys:
 
                 - **id** (str): origin url
                 - **from_revision** (bytes): which revision this metadata
                   was extracted from
                 - **metadata** (str): associated metadata
                 - **tool** (dict): tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/add")
     def origin_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add origin metadata not present in storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                 - **id**: origin urls
                 - **from_revision**: sha1 id of the revision used to generate
                   these metadata.
                 - **metadata**: arbitrary dict
                 - **indexer_configuration_id**: tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
             conflict_update: Flag to determine if we want to overwrite (true)
               or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/delete")
     def origin_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
         """Remove origin metadata from the storage.
 
         Args:
             entries (dict): dictionaries with the following keys:
 
                 - **id** (str): origin urls
                 - **indexer_configuration_id** (int): tool used to compute
                   metadata
 
         Returns:
             Summary of number of rows deleted
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/search/fulltext")
     def origin_intrinsic_metadata_search_fulltext(self, conjunction, limit=100):
         """Returns the list of origins whose metadata contain all the terms.
 
         Args:
             conjunction (List[str]): List of terms to be searched for.
             limit (int): The maximum number of results to return
 
         Yields:
             list: dictionaries with the following keys:
 
                 - **id** (str): origin urls
                 - **from_revision**: sha1 id of the revision used to generate
                   these metadata.
                 - **metadata** (str): associated metadata
                 - **tool** (dict): tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/search/by_producer")
     def origin_intrinsic_metadata_search_by_producer(
         self, page_token="", limit=100, ids_only=False, mappings=None, tool_ids=None
     ):
         """Returns the list of origins whose metadata contain all the terms.
 
         Args:
             page_token (str): Opaque token used for pagination.
             limit (int): The maximum number of results to return
             ids_only (bool): Determines whether only origin urls are
                 returned or the content as well
             mappings (List[str]): Returns origins whose intrinsic metadata
                 were generated using at least one of these mappings.
 
         Returns:
             dict: dict with the following keys:
               - **next_page_token** (str, optional): opaque token to be used as
                 `page_token` for retrieving the next page. If absent, there is
                 no more pages to gather.
               - **origins** (list): list of origin url (str) if `ids_only=True`
                 else dictionaries with the following keys:
 
                 - **id** (str): origin urls
                 - **from_revision**: sha1 id of the revision used to generate
                   these metadata.
                 - **metadata** (str): associated metadata
                 - **tool** (dict): tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/stats")
     def origin_intrinsic_metadata_stats(self):
         """Returns counts of indexed metadata per origins, broken down
         into metadata types.
 
         Returns:
             dict: dictionary with keys:
 
                 - total (int): total number of origins that were indexed
                   (possibly yielding an empty metadata dictionary)
                 - non_empty (int): total number of origins that we extracted
                   a non-empty metadata dictionary from
                 - per_mapping (dict): a dictionary with mapping names as
                   keys and number of origins whose indexing used this
                   mapping. Note that indexing a given origin may use
                   0, 1, or many mappings.
         """
         ...
 
     @remote_api_endpoint("indexer_configuration/add")
     def indexer_configuration_add(self, tools):
         """Add new tools to the storage.
 
         Args:
             tools ([dict]): List of dictionary representing tool to
                 insert in the db. Dictionary with the following keys:
 
                 - **tool_name** (str): tool's name
                 - **tool_version** (str): tool's version
                 - **tool_configuration** (dict): tool's configuration
                   (free form dict)
 
         Returns:
             List of dict inserted in the db (holding the id key as
             well).  The order of the list is not guaranteed to match
             the order of the initial list.
 
         """
         ...
 
     @remote_api_endpoint("indexer_configuration/data")
     def indexer_configuration_get(self, tool):
         """Retrieve tool information.
 
         Args:
             tool (dict): Dictionary representing a tool with the
                 following keys:
 
                 - **tool_name** (str): tool's name
                 - **tool_version** (str): tool's version
                 - **tool_configuration** (dict): tool's configuration
                   (free form dict)
 
         Returns:
             The same dictionary with an `id` key, None otherwise.
 
         """
         ...
diff --git a/swh/indexer/tests/storage/test_storage.py b/swh/indexer/tests/storage/test_storage.py
index 1cd5e16..3ad46c8 100644
--- a/swh/indexer/tests/storage/test_storage.py
+++ b/swh/indexer/tests/storage/test_storage.py
@@ -1,1935 +1,1938 @@
 # Copyright (C) 2015-2020  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
 
 import inspect
 import math
 import threading
 from typing import Any, Dict, List, Tuple, Union
 
 import attr
 import pytest
 
 from swh.indexer.storage.exc import DuplicateId, IndexerStorageArgumentException
 from swh.indexer.storage.interface import IndexerStorageInterface
 from swh.indexer.storage.model import (
     BaseRow,
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
+    ContentMetadataRow,
     ContentMimetypeRow,
 )
 from swh.model.hashutil import hash_to_bytes
 
 
 def prepare_mimetypes_from_licenses(
     fossology_licenses: List[ContentLicenseRow],
 ) -> List[ContentMimetypeRow]:
     """Fossology license needs some consistent data in db to run.
 
     """
     mimetypes = []
     for c in fossology_licenses:
         mimetypes.append(
             ContentMimetypeRow(
                 id=c.id,
                 mimetype="text/plain",  # for filtering on textual data to work
                 encoding="utf-8",
                 indexer_configuration_id=c.indexer_configuration_id,
             )
         )
     return mimetypes
 
 
 def endpoint_name(etype: str, ename: str) -> str:
     """Compute the storage's endpoint's name
 
     >>> endpoint_name('content_mimetype', 'add')
     'content_mimetype_add'
     >>> endpoint_name('content_fosso_license', 'delete')
     'content_fosso_license_delete'
 
     """
     return f"{etype}_{ename}"
 
 
 def endpoint(storage, etype: str, ename: str):
     return getattr(storage, endpoint_name(etype, ename))
 
 
 def expected_summary(count: int, etype: str, ename: str = "add") -> Dict[str, int]:
     """Compute the expected summary
 
     The key is determine according to etype and ename
 
         >>> expected_summary(10, 'content_mimetype', 'add')
         {'content_mimetype:add': 10}
         >>> expected_summary(9, 'origin_intrinsic_metadata', 'delete')
         {'origin_intrinsic_metadata:del': 9}
 
     """
     pattern = ename[0:3]
     key = endpoint_name(etype, ename).replace(f"_{ename}", f":{pattern}")
     return {key: count}
 
 
 def test_check_config(swh_indexer_storage) -> None:
     assert swh_indexer_storage.check_config(check_write=True)
     assert swh_indexer_storage.check_config(check_write=False)
 
 
 def test_types(swh_indexer_storage) -> None:
     """Checks all methods of StorageInterface are implemented by this
     backend, and that they have the same signature."""
     # Create an instance of the protocol (which cannot be instantiated
     # directly, so this creates a subclass, then instantiates it)
     interface = type("_", (IndexerStorageInterface,), {})()
 
     assert "content_mimetype_add" in dir(interface)
 
     missing_methods = []
 
     for meth_name in dir(interface):
         if meth_name.startswith("_"):
             continue
         interface_meth = getattr(interface, meth_name)
         try:
             concrete_meth = getattr(swh_indexer_storage, meth_name)
         except AttributeError:
             missing_methods.append(meth_name)
             continue
 
         expected_signature = inspect.signature(interface_meth)
         actual_signature = inspect.signature(concrete_meth)
 
         assert expected_signature == actual_signature, meth_name
 
     assert missing_methods == []
 
 
 class StorageETypeTester:
     """Base class for testing a series of common behaviour between a bunch of
     endpoint types supported by an IndexerStorage.
 
     This is supposed to be inherited with the following class attributes:
     - endpoint_type
     - tool_name
     - example_data
 
     See below for example usage.
     """
 
     endpoint_type: str
     tool_name: str
     example_data: List[Dict]
 
     # For old endpoints (which use dicts), this is just the identity function.
     # For new endpoints, it returns a BaseRow instance.
     @staticmethod
     def row_from_dict(d: Dict) -> Union[Dict, BaseRow]:
         return d
 
     # Inverse function of row_from_dict
     # TODO: remove this once all endpoints are migrated to rows
     @staticmethod
     def dict_from_row(r: Union[Dict, BaseRow]) -> Dict:
         assert isinstance(r, Dict)
         return r
 
     def test_missing(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool_id = data.tools[self.tool_name]["id"]
 
         # given 2 (hopefully) unknown objects
         query = [
             {"id": data.sha1_1, "indexer_configuration_id": tool_id,},
             {"id": data.sha1_2, "indexer_configuration_id": tool_id,},
         ]
 
         # we expect these are both returned by the xxx_missing endpoint
         actual_missing = endpoint(storage, etype, "missing")(query)
         assert list(actual_missing) == [
             data.sha1_1,
             data.sha1_2,
         ]
 
         # now, when we add one of them
         summary = endpoint(storage, etype, "add")(
             [
                 self.row_from_dict(
                     {
                         "id": data.sha1_2,
                         **self.example_data[0],
                         "indexer_configuration_id": tool_id,
                     }
                 )
             ]
         )
 
         assert summary == expected_summary(1, etype)
 
         # we expect only the other one returned
         actual_missing = endpoint(storage, etype, "missing")(query)
         assert list(actual_missing) == [data.sha1_1]
 
     def test_add__drop_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool_id = data.tools[self.tool_name]["id"]
 
         # add the first object
         data_v1 = {
             "id": data.sha1_2,
             **self.example_data[0],
             "indexer_configuration_id": tool_id,
         }
         summary = endpoint(storage, etype, "add")([self.row_from_dict(data_v1)])
         assert summary == expected_summary(1, etype)
 
         # should be able to retrieve it
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
         expected_data_v1 = [
             self.row_from_dict(
                 {
                     "id": data.sha1_2,
                     **self.example_data[0],
                     "tool": data.tools[self.tool_name],
                 }
             )
         ]
         assert actual_data == expected_data_v1
 
         # now if we add a modified version of the same object (same id)
         data_v2 = data_v1.copy()
         data_v2.update(self.example_data[1])
         summary2 = endpoint(storage, etype, "add")([self.row_from_dict(data_v2)])
         assert summary2 == expected_summary(0, etype)  # not added
 
         # we expect to retrieve the original data, not the modified one
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
         assert actual_data == expected_data_v1
 
     def test_add__update_in_place_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         data_v1 = {
             "id": data.sha1_2,
             **self.example_data[0],
             "indexer_configuration_id": tool["id"],
         }
 
         # given
         summary = endpoint(storage, etype, "add")([self.row_from_dict(data_v1)])
         assert summary == expected_summary(1, etype)  # not added
 
         # when
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         expected_data_v1 = [
             self.row_from_dict(
                 {"id": data.sha1_2, **self.example_data[0], "tool": tool}
             )
         ]
 
         # then
         assert actual_data == expected_data_v1
 
         # given
         data_v2 = data_v1.copy()
         data_v2.update(self.example_data[1])
 
         endpoint(storage, etype, "add")(
             [self.row_from_dict(data_v2)], conflict_update=True
         )
         assert summary == expected_summary(1, etype)  # modified so counted
 
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         expected_data_v2 = [
             self.row_from_dict(
                 {"id": data.sha1_2, **self.example_data[1], "tool": tool,}
             )
         ]
 
         # data did change as the v2 was used to overwrite v1
         assert actual_data == expected_data_v2
 
     def test_add__update_in_place_deadlock(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         hashes = [
             hash_to_bytes("34973274ccef6ab4dfaaf86599792fa9c3fe4{:03d}".format(i))
             for i in range(1000)
         ]
 
         data_v1 = [
             self.row_from_dict(
                 {
                     "id": hash_,
                     **self.example_data[0],
                     "indexer_configuration_id": tool["id"],
                 }
             )
             for hash_ in hashes
         ]
         data_v2 = [
             self.row_from_dict(
                 {
                     "id": hash_,
                     **self.example_data[1],
                     "indexer_configuration_id": tool["id"],
                 }
             )
             for hash_ in hashes
         ]
 
         # Remove one item from each, so that both queries have to succeed for
         # all items to be in the DB.
         data_v2a = data_v2[1:]
         data_v2b = list(reversed(data_v2[0:-1]))
 
         # given
         endpoint(storage, etype, "add")(data_v1)
 
         # when
         actual_data = list(endpoint(storage, etype, "get")(hashes))
 
         expected_data_v1 = [
             self.row_from_dict({"id": hash_, **self.example_data[0], "tool": tool})
             for hash_ in hashes
         ]
 
         # then
         assert actual_data == expected_data_v1
 
         # given
         def f1() -> None:
             endpoint(storage, etype, "add")(data_v2a, conflict_update=True)
 
         def f2() -> None:
             endpoint(storage, etype, "add")(data_v2b, conflict_update=True)
 
         t1 = threading.Thread(target=f1)
         t2 = threading.Thread(target=f2)
         t2.start()
         t1.start()
 
         t1.join()
         t2.join()
 
         actual_data = sorted(
             map(self.dict_from_row, endpoint(storage, etype, "get")(hashes)),
             key=lambda x: x["id"],
         )
 
         expected_data_v2 = [
             {"id": hash_, **self.example_data[1], "tool": tool} for hash_ in hashes
         ]
 
         assert actual_data == expected_data_v2
 
     def test_add__duplicate_twice(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         data_rev1 = self.row_from_dict(
             {
                 "id": data.revision_id_2,
                 **self.example_data[0],
                 "indexer_configuration_id": tool["id"],
             }
         )
 
         data_rev2 = self.row_from_dict(
             {
                 "id": data.revision_id_2,
                 **self.example_data[1],
                 "indexer_configuration_id": tool["id"],
             }
         )
 
         # when
         summary = endpoint(storage, etype, "add")([data_rev1])
         assert summary == expected_summary(1, etype)
 
         with pytest.raises(DuplicateId):
             endpoint(storage, etype, "add")(
                 [data_rev2, data_rev2], conflict_update=True
             )
 
         # then
         actual_data = list(
             endpoint(storage, etype, "get")([data.revision_id_2, data.revision_id_1])
         )
 
         expected_data = [
             self.row_from_dict(
                 {"id": data.revision_id_2, **self.example_data[0], "tool": tool}
             )
         ]
         assert actual_data == expected_data
 
     def test_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         query = [data.sha1_2, data.sha1_1]
         data1 = self.row_from_dict(
             {
                 "id": data.sha1_2,
                 **self.example_data[0],
                 "indexer_configuration_id": tool["id"],
             }
         )
 
         # when
         summary = endpoint(storage, etype, "add")([data1])
         assert summary == expected_summary(1, etype)
 
         # then
         actual_data = list(endpoint(storage, etype, "get")(query))
 
         # then
         expected_data = [
             self.row_from_dict(
                 {"id": data.sha1_2, **self.example_data[0], "tool": tool}
             )
         ]
 
         assert actual_data == expected_data
 
 
 class TestIndexerStorageContentMimetypes(StorageETypeTester):
     """Test Indexer Storage content_mimetype related methods
     """
 
     endpoint_type = "content_mimetype"
     tool_name = "file"
     example_data = [
         {"mimetype": "text/plain", "encoding": "utf-8",},
         {"mimetype": "text/html", "encoding": "us-ascii",},
     ]
     row_from_dict = ContentMimetypeRow.from_dict
     dict_from_row = staticmethod(lambda x: x.to_dict())  # type: ignore
 
     def test_generate_content_mimetype_get_partition_failure(
         self, swh_indexer_storage: IndexerStorageInterface
     ) -> None:
         """get_partition call with wrong limit input should fail"""
         storage = swh_indexer_storage
         indexer_configuration_id = 42
         with pytest.raises(
             IndexerStorageArgumentException, match="limit should not be None"
         ):
             storage.content_mimetype_get_partition(
                 indexer_configuration_id, 0, 3, limit=None  # type: ignore
             )
 
     def test_generate_content_mimetype_get_partition_no_limit(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition should return result"""
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
 
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         assert len(mimetypes) == 16
         nb_partitions = 16
 
         actual_ids = []
         for partition_id in range(nb_partitions):
             actual_result = storage.content_mimetype_get_partition(
                 indexer_configuration_id, partition_id, nb_partitions
             )
             assert actual_result.next_page_token is None
             actual_ids.extend(actual_result.results)
 
         assert len(actual_ids) == len(expected_ids)
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_generate_content_mimetype_get_partition_full(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition for a single partition should return available ids
 
         """
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         actual_result = storage.content_mimetype_get_partition(
             indexer_configuration_id, 0, 1
         )
         assert actual_result.next_page_token is None
         actual_ids = actual_result.results
         assert len(actual_ids) == len(expected_ids)
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_generate_content_mimetype_get_partition_empty(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition when at least one of the partitions is empty"""
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         # nb_partitions = smallest power of 2 such that at least one of
         # the partitions is empty
         nb_mimetypes = len(mimetypes)
         nb_partitions = 1 << math.floor(math.log2(nb_mimetypes) + 1)
 
         seen_ids = []
 
         for partition_id in range(nb_partitions):
             actual_result = storage.content_mimetype_get_partition(
                 indexer_configuration_id,
                 partition_id,
                 nb_partitions,
                 limit=nb_mimetypes + 1,
             )
 
             for actual_id in actual_result.results:
                 seen_ids.append(actual_id)
 
             # Limit is higher than the max number of results
             assert actual_result.next_page_token is None
 
         assert set(seen_ids) == expected_ids
 
     def test_generate_content_mimetype_get_partition_with_pagination(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition should return ids provided with pagination
 
         """
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         nb_partitions = 4
 
         actual_ids = []
         for partition_id in range(nb_partitions):
             next_page_token = None
             while True:
                 actual_result = storage.content_mimetype_get_partition(
                     indexer_configuration_id,
                     partition_id,
                     nb_partitions,
                     limit=2,
                     page_token=next_page_token,
                 )
                 actual_ids.extend(actual_result.results)
                 next_page_token = actual_result.next_page_token
                 if next_page_token is None:
                     break
 
         assert len(set(actual_ids)) == len(set(expected_ids))
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
 
 class TestIndexerStorageContentLanguage(StorageETypeTester):
     """Test Indexer Storage content_language related methods
     """
 
     endpoint_type = "content_language"
     tool_name = "pygments"
     example_data = [
         {"lang": "haskell",},
         {"lang": "common-lisp",},
     ]
     row_from_dict = ContentLanguageRow.from_dict
     dict_from_row = staticmethod(lambda x: x.to_dict())  # type: ignore
 
 
 class TestIndexerStorageContentCTags(StorageETypeTester):
     """Test Indexer Storage content_ctags related methods
     """
 
     endpoint_type = "content_ctags"
     tool_name = "universal-ctags"
     example_data = [
         {"name": "done", "kind": "variable", "line": 119, "lang": "OCaml",},
         {"name": "done", "kind": "variable", "line": 100, "lang": "Python",},
         {"name": "main", "kind": "function", "line": 119, "lang": "Python",},
     ]
     row_from_dict = ContentCtagsRow.from_dict
     dict_from_row = staticmethod(lambda x: x.to_dict())  # type: ignore
 
     # the following tests are disabled because CTAGS behaves differently
     @pytest.mark.skip
     def test_add__drop_duplicate(self):
         pass
 
     @pytest.mark.skip
     def test_add__update_in_place_duplicate(self):
         pass
 
     @pytest.mark.skip
     def test_add__update_in_place_deadlock(self):
         pass
 
     @pytest.mark.skip
     def test_add__duplicate_twice(self):
         pass
 
     @pytest.mark.skip
     def test_get(self):
         pass
 
     def test_content_ctags_search(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # 1. given
         tool = data.tools["universal-ctags"]
         tool_id = tool["id"]
 
         ctags1 = [
             ContentCtagsRow(
                 id=data.sha1_1,
                 indexer_configuration_id=tool_id,
                 **kwargs,  # type: ignore
             )
             for kwargs in [
                 {"name": "hello", "kind": "function", "line": 133, "lang": "Python",},
                 {"name": "counter", "kind": "variable", "line": 119, "lang": "Python",},
                 {"name": "hello", "kind": "variable", "line": 210, "lang": "Python",},
             ]
         ]
         ctags1_with_tool = [
             attr.evolve(ctag, indexer_configuration_id=None, tool=tool)
             for ctag in ctags1
         ]
 
         ctags2 = [
             ContentCtagsRow(
                 id=data.sha1_2,
                 indexer_configuration_id=tool_id,
                 **kwargs,  # type: ignore
             )
             for kwargs in [
                 {"name": "hello", "kind": "variable", "line": 100, "lang": "C",},
                 {"name": "result", "kind": "variable", "line": 120, "lang": "C",},
             ]
         ]
         ctags2_with_tool = [
             attr.evolve(ctag, indexer_configuration_id=None, tool=tool)
             for ctag in ctags2
         ]
 
         storage.content_ctags_add(ctags1 + ctags2)
 
         # 1. when
         actual_ctags = list(storage.content_ctags_search("hello", limit=1))
 
         # 1. then
         assert actual_ctags == [ctags1_with_tool[0]]
 
         # 2. when
         actual_ctags = list(
             storage.content_ctags_search("hello", limit=1, last_sha1=data.sha1_1)
         )
 
         # 2. then
         assert actual_ctags == [ctags2_with_tool[0]]
 
         # 3. when
         actual_ctags = list(storage.content_ctags_search("hello"))
 
         # 3. then
         assert actual_ctags == [
             ctags1_with_tool[0],
             ctags1_with_tool[2],
             ctags2_with_tool[0],
         ]
 
         # 4. when
         actual_ctags = list(storage.content_ctags_search("counter"))
 
         # then
         assert actual_ctags == [ctags1_with_tool[1]]
 
         # 5. when
         actual_ctags = list(storage.content_ctags_search("result", limit=1))
 
         # then
         assert actual_ctags == [ctags2_with_tool[1]]
 
     def test_content_ctags_search_no_result(
         self, swh_indexer_storage: IndexerStorageInterface
     ) -> None:
         storage = swh_indexer_storage
         actual_ctags = list(storage.content_ctags_search("counter"))
 
         assert not actual_ctags
 
     def test_content_ctags_add__add_new_ctags_added(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
 
         # given
         tool = data.tools["universal-ctags"]
         tool_id = tool["id"]
 
         ctag1 = ContentCtagsRow(
             id=data.sha1_2,
             indexer_configuration_id=tool_id,
             name="done",
             kind="variable",
             line=100,
             lang="Scheme",
         )
         ctag1_with_tool = attr.evolve(ctag1, indexer_configuration_id=None, tool=tool)
 
         # given
         storage.content_ctags_add([ctag1])
         storage.content_ctags_add([ctag1])  # conflict does nothing
 
         # when
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         # then
         assert actual_ctags == [ctag1_with_tool]
 
         # given
         ctag2 = ContentCtagsRow(
             id=data.sha1_2,
             indexer_configuration_id=tool_id,
             name="defn",
             kind="function",
             line=120,
             lang="Scheme",
         )
         ctag2_with_tool = attr.evolve(ctag2, indexer_configuration_id=None, tool=tool)
 
         storage.content_ctags_add([ctag2])
 
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         assert actual_ctags == [ctag1_with_tool, ctag2_with_tool]
 
     def test_content_ctags_add__update_in_place(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool = data.tools["universal-ctags"]
         tool_id = tool["id"]
 
         ctag1 = ContentCtagsRow(
             id=data.sha1_2,
             indexer_configuration_id=tool_id,
             name="done",
             kind="variable",
             line=100,
             lang="Scheme",
         )
         ctag1_with_tool = attr.evolve(ctag1, indexer_configuration_id=None, tool=tool)
 
         # given
         storage.content_ctags_add([ctag1])
 
         # when
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         # then
         assert actual_ctags == [ctag1_with_tool]
 
         # given
         ctag2 = ContentCtagsRow(
             id=data.sha1_2,
             indexer_configuration_id=tool_id,
             name="defn",
             kind="function",
             line=120,
             lang="Scheme",
         )
         ctag2_with_tool = attr.evolve(ctag2, indexer_configuration_id=None, tool=tool)
 
         storage.content_ctags_add([ctag1, ctag2], conflict_update=True)
 
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         assert actual_ctags == [ctag1_with_tool, ctag2_with_tool]
 
     def test_add_empty(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         (storage, data) = swh_indexer_storage_with_data
         etype = self.endpoint_type
 
         summary = endpoint(storage, etype, "add")([])
         assert summary == {"content_ctags:add": 0}
 
         actual_ctags = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         assert actual_ctags == []
 
     def test_get_unknown(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         (storage, data) = swh_indexer_storage_with_data
         etype = self.endpoint_type
 
         actual_ctags = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         assert actual_ctags == []
 
 
 class TestIndexerStorageContentMetadata(StorageETypeTester):
     """Test Indexer Storage content_metadata related methods
     """
 
     tool_name = "swh-metadata-detector"
     endpoint_type = "content_metadata"
     example_data = [
         {
             "metadata": {
                 "other": {},
                 "codeRepository": {
                     "type": "git",
                     "url": "https://github.com/moranegg/metadata_test",
                 },
                 "description": "Simple package.json test for indexer",
                 "name": "test_metadata",
                 "version": "0.0.1",
             },
         },
         {"metadata": {"other": {}, "name": "test_metadata", "version": "0.0.1"},},
     ]
+    row_from_dict = ContentMetadataRow.from_dict
+    dict_from_row = staticmethod(lambda x: x.to_dict())  # type: ignore
 
 
 class TestIndexerStorageRevisionIntrinsicMetadata(StorageETypeTester):
     """Test Indexer Storage revision_intrinsic_metadata related methods
     """
 
     tool_name = "swh-metadata-detector"
     endpoint_type = "revision_intrinsic_metadata"
     example_data = [
         {
             "metadata": {
                 "other": {},
                 "codeRepository": {
                     "type": "git",
                     "url": "https://github.com/moranegg/metadata_test",
                 },
                 "description": "Simple package.json test for indexer",
                 "name": "test_metadata",
                 "version": "0.0.1",
             },
             "mappings": ["mapping1"],
         },
         {
             "metadata": {"other": {}, "name": "test_metadata", "version": "0.0.1"},
             "mappings": ["mapping2"],
         },
     ]
 
     def test_revision_intrinsic_metadata_delete(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         query = [data.sha1_2, data.sha1_1]
         data1 = {
             "id": data.sha1_2,
             **self.example_data[0],
             "indexer_configuration_id": tool["id"],
         }
 
         # when
         summary = endpoint(storage, etype, "add")([data1])
         assert summary == expected_summary(1, etype)
 
         summary2 = endpoint(storage, etype, "delete")(
             [{"id": data.sha1_2, "indexer_configuration_id": tool["id"],}]
         )
         assert summary2 == expected_summary(1, etype, "del")
 
         # then
         actual_data = list(endpoint(storage, etype, "get")(query))
 
         # then
         assert not actual_data
 
     def test_revision_intrinsic_metadata_delete_nonexisting(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
         endpoint(storage, etype, "delete")(
             [{"id": data.sha1_2, "indexer_configuration_id": tool["id"],}]
         )
 
 
 class TestIndexerStorageContentFossologyLicense:
     endpoint_type = "content_fossology_license"
     tool_name = "nomos"
 
     row_from_dict = ContentLicenseRow.from_dict
     dict_from_row = staticmethod(lambda x: x.to_dict())
 
     def test_content_fossology_license_add__new_license_added(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool = data.tools["nomos"]
         tool_id = tool["id"]
 
         license1 = ContentLicenseRow(
             id=data.sha1_1, license="Apache-2.0", indexer_configuration_id=tool_id,
         )
 
         # given
         storage.content_fossology_license_add([license1])
         # conflict does nothing
         storage.content_fossology_license_add([license1])
 
         # when
         actual_licenses = list(storage.content_fossology_license_get([data.sha1_1]))
 
         # then
         expected_licenses = [
             ContentLicenseRow(id=data.sha1_1, license="Apache-2.0", tool=tool,)
         ]
         assert actual_licenses == expected_licenses
 
         # given
         license2 = ContentLicenseRow(
             id=data.sha1_1, license="BSD-2-Clause", indexer_configuration_id=tool_id,
         )
 
         storage.content_fossology_license_add([license2])
 
         actual_licenses = list(storage.content_fossology_license_get([data.sha1_1]))
 
         expected_licenses.append(
             ContentLicenseRow(id=data.sha1_1, license="BSD-2-Clause", tool=tool,)
         )
 
         # first license was not removed when the second one was added
         assert sorted(actual_licenses) == sorted(expected_licenses)
 
     def test_generate_content_fossology_license_get_partition_failure(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition call with wrong limit input should fail"""
         storage, data = swh_indexer_storage_with_data
         indexer_configuration_id = 42
         with pytest.raises(
             IndexerStorageArgumentException, match="limit should not be None"
         ):
             storage.content_fossology_license_get_partition(
                 indexer_configuration_id, 0, 3, limit=None,  # type: ignore
             )
 
     def test_generate_content_fossology_license_get_partition_no_limit(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition should return results"""
         storage, data = swh_indexer_storage_with_data
         # craft some consistent mimetypes
         fossology_licenses = data.fossology_licenses
         mimetypes = prepare_mimetypes_from_licenses(fossology_licenses)
         indexer_configuration_id = fossology_licenses[0].indexer_configuration_id
 
         storage.content_mimetype_add(mimetypes, conflict_update=True)
         # add fossology_licenses to storage
         storage.content_fossology_license_add(fossology_licenses)
 
         # All ids from the db
         expected_ids = set([c.id for c in fossology_licenses])
 
         assert len(fossology_licenses) == 10
         assert len(mimetypes) == 10
         nb_partitions = 4
 
         actual_ids = []
         for partition_id in range(nb_partitions):
 
             actual_result = storage.content_fossology_license_get_partition(
                 indexer_configuration_id, partition_id, nb_partitions
             )
             assert actual_result.next_page_token is None
             actual_ids.extend(actual_result.results)
 
         assert len(set(actual_ids)) == len(expected_ids)
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_generate_content_fossology_license_get_partition_full(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition for a single partition should return available ids
 
         """
         storage, data = swh_indexer_storage_with_data
         # craft some consistent mimetypes
         fossology_licenses = data.fossology_licenses
         mimetypes = prepare_mimetypes_from_licenses(fossology_licenses)
         indexer_configuration_id = fossology_licenses[0].indexer_configuration_id
 
         storage.content_mimetype_add(mimetypes, conflict_update=True)
         # add fossology_licenses to storage
         storage.content_fossology_license_add(fossology_licenses)
 
         # All ids from the db
         expected_ids = set([c.id for c in fossology_licenses])
 
         actual_result = storage.content_fossology_license_get_partition(
             indexer_configuration_id, 0, 1
         )
         assert actual_result.next_page_token is None
         actual_ids = actual_result.results
         assert len(set(actual_ids)) == len(expected_ids)
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_generate_content_fossology_license_get_partition_empty(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition when at least one of the partitions is empty"""
         storage, data = swh_indexer_storage_with_data
         # craft some consistent mimetypes
         fossology_licenses = data.fossology_licenses
         mimetypes = prepare_mimetypes_from_licenses(fossology_licenses)
         indexer_configuration_id = fossology_licenses[0].indexer_configuration_id
 
         storage.content_mimetype_add(mimetypes, conflict_update=True)
         # add fossology_licenses to storage
         storage.content_fossology_license_add(fossology_licenses)
 
         # All ids from the db
         expected_ids = set([c.id for c in fossology_licenses])
 
         # nb_partitions = smallest power of 2 such that at least one of
         # the partitions is empty
         nb_licenses = len(fossology_licenses)
         nb_partitions = 1 << math.floor(math.log2(nb_licenses) + 1)
 
         seen_ids = []
 
         for partition_id in range(nb_partitions):
             actual_result = storage.content_fossology_license_get_partition(
                 indexer_configuration_id,
                 partition_id,
                 nb_partitions,
                 limit=nb_licenses + 1,
             )
 
             for actual_id in actual_result.results:
                 seen_ids.append(actual_id)
 
             # Limit is higher than the max number of results
             assert actual_result.next_page_token is None
 
         assert set(seen_ids) == expected_ids
 
     def test_generate_content_fossology_license_get_partition_with_pagination(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition should return ids provided with paginationv
 
         """
         storage, data = swh_indexer_storage_with_data
         # craft some consistent mimetypes
         fossology_licenses = data.fossology_licenses
         mimetypes = prepare_mimetypes_from_licenses(fossology_licenses)
         indexer_configuration_id = fossology_licenses[0].indexer_configuration_id
 
         storage.content_mimetype_add(mimetypes, conflict_update=True)
         # add fossology_licenses to storage
         storage.content_fossology_license_add(fossology_licenses)
 
         # All ids from the db
         expected_ids = [c.id for c in fossology_licenses]
 
         nb_partitions = 4
 
         actual_ids = []
         for partition_id in range(nb_partitions):
             next_page_token = None
             while True:
                 actual_result = storage.content_fossology_license_get_partition(
                     indexer_configuration_id,
                     partition_id,
                     nb_partitions,
                     limit=2,
                     page_token=next_page_token,
                 )
                 actual_ids.extend(actual_result.results)
                 next_page_token = actual_result.next_page_token
                 if next_page_token is None:
                     break
 
         assert len(set(actual_ids)) == len(set(expected_ids))
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_add_empty(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         (storage, data) = swh_indexer_storage_with_data
         etype = self.endpoint_type
 
         summary = endpoint(storage, etype, "add")([])
         assert summary == {"content_fossology_license:add": 0}
 
         actual_license = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         assert actual_license == []
 
     def test_get_unknown(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         (storage, data) = swh_indexer_storage_with_data
         etype = self.endpoint_type
 
         actual_license = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         assert actual_license == []
 
 
 class TestIndexerStorageOriginIntrinsicMetadata:
     def test_origin_intrinsic_metadata_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata = {
             "version": None,
             "name": None,
         }
         metadata_rev = {
             "id": data.revision_id_2,
             "metadata": metadata,
             "mappings": ["mapping1"],
             "indexer_configuration_id": tool_id,
         }
         metadata_origin = {
             "id": data.origin_url_1,
             "metadata": metadata,
             "indexer_configuration_id": tool_id,
             "mappings": ["mapping1"],
             "from_revision": data.revision_id_2,
         }
 
         # when
         storage.revision_intrinsic_metadata_add([metadata_rev])
         storage.origin_intrinsic_metadata_add([metadata_origin])
 
         # then
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1, "no://where"])
         )
 
         expected_metadata = [
             {
                 "id": data.origin_url_1,
                 "metadata": metadata,
                 "tool": data.tools["swh-metadata-detector"],
                 "from_revision": data.revision_id_2,
                 "mappings": ["mapping1"],
             }
         ]
 
         assert actual_metadata == expected_metadata
 
     def test_origin_intrinsic_metadata_delete(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata = {
             "version": None,
             "name": None,
         }
         metadata_rev = {
             "id": data.revision_id_2,
             "metadata": metadata,
             "mappings": ["mapping1"],
             "indexer_configuration_id": tool_id,
         }
         metadata_origin = {
             "id": data.origin_url_1,
             "metadata": metadata,
             "indexer_configuration_id": tool_id,
             "mappings": ["mapping1"],
             "from_revision": data.revision_id_2,
         }
         metadata_origin2 = metadata_origin.copy()
         metadata_origin2["id"] = data.origin_url_2
 
         # when
         storage.revision_intrinsic_metadata_add([metadata_rev])
         storage.origin_intrinsic_metadata_add([metadata_origin, metadata_origin2])
 
         storage.origin_intrinsic_metadata_delete(
             [{"id": data.origin_url_1, "indexer_configuration_id": tool_id}]
         )
 
         # then
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get(
                 [data.origin_url_1, data.origin_url_2, "no://where"]
             )
         )
         for item in actual_metadata:
             item["indexer_configuration_id"] = item.pop("tool")["id"]
         assert actual_metadata == [metadata_origin2]
 
     def test_origin_intrinsic_metadata_delete_nonexisting(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool_id = data.tools["swh-metadata-detector"]["id"]
         storage.origin_intrinsic_metadata_delete(
             [{"id": data.origin_url_1, "indexer_configuration_id": tool_id}]
         )
 
     def test_origin_intrinsic_metadata_add_drop_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata_v1: Dict[str, Any] = {
             "version": None,
             "name": None,
         }
         metadata_rev_v1 = {
             "id": data.revision_id_1,
             "metadata": metadata_v1.copy(),
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata_origin_v1 = {
             "id": data.origin_url_1,
             "metadata": metadata_v1.copy(),
             "indexer_configuration_id": tool_id,
             "mappings": [],
             "from_revision": data.revision_id_1,
         }
 
         # given
         storage.revision_intrinsic_metadata_add([metadata_rev_v1])
         storage.origin_intrinsic_metadata_add([metadata_origin_v1])
 
         # when
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1, "no://where"])
         )
 
         expected_metadata_v1 = [
             {
                 "id": data.origin_url_1,
                 "metadata": metadata_v1,
                 "tool": data.tools["swh-metadata-detector"],
                 "from_revision": data.revision_id_1,
                 "mappings": [],
             }
         ]
 
         assert actual_metadata == expected_metadata_v1
 
         # given
         metadata_v2 = metadata_v1.copy()
         metadata_v2.update(
             {"name": "test_metadata", "author": "MG",}
         )
         metadata_rev_v2 = metadata_rev_v1.copy()
         metadata_origin_v2 = metadata_origin_v1.copy()
         metadata_rev_v2["metadata"] = metadata_v2
         metadata_origin_v2["metadata"] = metadata_v2
 
         storage.revision_intrinsic_metadata_add([metadata_rev_v2])
         storage.origin_intrinsic_metadata_add([metadata_origin_v2])
 
         # then
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1])
         )
 
         # metadata did not change as the v2 was dropped.
         assert actual_metadata == expected_metadata_v1
 
     def test_origin_intrinsic_metadata_add_update_in_place_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata_v1: Dict[str, Any] = {
             "version": None,
             "name": None,
         }
         metadata_rev_v1 = {
             "id": data.revision_id_2,
             "metadata": metadata_v1,
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata_origin_v1 = {
             "id": data.origin_url_1,
             "metadata": metadata_v1.copy(),
             "indexer_configuration_id": tool_id,
             "mappings": [],
             "from_revision": data.revision_id_2,
         }
 
         # given
         storage.revision_intrinsic_metadata_add([metadata_rev_v1])
         storage.origin_intrinsic_metadata_add([metadata_origin_v1])
 
         # when
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1])
         )
 
         # then
         expected_metadata_v1 = [
             {
                 "id": data.origin_url_1,
                 "metadata": metadata_v1,
                 "tool": data.tools["swh-metadata-detector"],
                 "from_revision": data.revision_id_2,
                 "mappings": [],
             }
         ]
         assert actual_metadata == expected_metadata_v1
 
         # given
         metadata_v2 = metadata_v1.copy()
         metadata_v2.update(
             {"name": "test_update_duplicated_metadata", "author": "MG",}
         )
         metadata_rev_v2 = metadata_rev_v1.copy()
         metadata_origin_v2 = metadata_origin_v1.copy()
         metadata_rev_v2["metadata"] = metadata_v2
         metadata_origin_v2 = {
             "id": data.origin_url_1,
             "metadata": metadata_v2.copy(),
             "indexer_configuration_id": tool_id,
             "mappings": ["npm"],
             "from_revision": data.revision_id_1,
         }
 
         storage.revision_intrinsic_metadata_add([metadata_rev_v2], conflict_update=True)
         storage.origin_intrinsic_metadata_add(
             [metadata_origin_v2], conflict_update=True
         )
 
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1])
         )
 
         expected_metadata_v2 = [
             {
                 "id": data.origin_url_1,
                 "metadata": metadata_v2,
                 "tool": data.tools["swh-metadata-detector"],
                 "from_revision": data.revision_id_1,
                 "mappings": ["npm"],
             }
         ]
 
         # metadata did change as the v2 was used to overwrite v1
         assert actual_metadata == expected_metadata_v2
 
     def test_origin_intrinsic_metadata_add__update_in_place_deadlock(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         ids = list(range(10))
 
         example_data1 = {
             "metadata": {"version": None, "name": None,},
             "mappings": [],
         }
         example_data2 = {
             "metadata": {"version": "v1.1.1", "name": "foo",},
             "mappings": [],
         }
 
         metadata_rev_v1 = {
             "id": data.revision_id_2,
             "metadata": {"version": None, "name": None,},
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
 
         data_v1 = [
             {
                 "id": "file:///tmp/origin%d" % id_,
                 "from_revision": data.revision_id_2,
                 **example_data1,
                 "indexer_configuration_id": tool_id,
             }
             for id_ in ids
         ]
         data_v2 = [
             {
                 "id": "file:///tmp/origin%d" % id_,
                 "from_revision": data.revision_id_2,
                 **example_data2,
                 "indexer_configuration_id": tool_id,
             }
             for id_ in ids
         ]
 
         # Remove one item from each, so that both queries have to succeed for
         # all items to be in the DB.
         data_v2a = data_v2[1:]
         data_v2b = list(reversed(data_v2[0:-1]))
 
         # given
         storage.revision_intrinsic_metadata_add([metadata_rev_v1])
         storage.origin_intrinsic_metadata_add(data_v1)
 
         # when
         origins = ["file:///tmp/origin%d" % i for i in ids]
         actual_data = list(storage.origin_intrinsic_metadata_get(origins))
 
         expected_data_v1 = [
             {
                 "id": "file:///tmp/origin%d" % id_,
                 "from_revision": data.revision_id_2,
                 **example_data1,
                 "tool": data.tools["swh-metadata-detector"],
             }
             for id_ in ids
         ]
 
         # then
         assert actual_data == expected_data_v1
 
         # given
         def f1() -> None:
             storage.origin_intrinsic_metadata_add(data_v2a, conflict_update=True)
 
         def f2() -> None:
             storage.origin_intrinsic_metadata_add(data_v2b, conflict_update=True)
 
         t1 = threading.Thread(target=f1)
         t2 = threading.Thread(target=f2)
         t2.start()
         t1.start()
 
         t1.join()
         t2.join()
 
         actual_data = list(storage.origin_intrinsic_metadata_get(origins))
 
         expected_data_v2 = [
             {
                 "id": "file:///tmp/origin%d" % id_,
                 "from_revision": data.revision_id_2,
                 **example_data2,
                 "tool": data.tools["swh-metadata-detector"],
             }
             for id_ in ids
         ]
 
         assert len(actual_data) == len(expected_data_v2)
         assert sorted(actual_data, key=lambda x: x["id"]) == expected_data_v2
 
     def test_origin_intrinsic_metadata_add__duplicate_twice(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata = {
             "developmentStatus": None,
             "name": None,
         }
         metadata_rev = {
             "id": data.revision_id_2,
             "metadata": metadata,
             "mappings": ["mapping1"],
             "indexer_configuration_id": tool_id,
         }
         metadata_origin = {
             "id": data.origin_url_1,
             "metadata": metadata,
             "indexer_configuration_id": tool_id,
             "mappings": ["mapping1"],
             "from_revision": data.revision_id_2,
         }
 
         # when
         storage.revision_intrinsic_metadata_add([metadata_rev])
 
         with pytest.raises(DuplicateId):
             storage.origin_intrinsic_metadata_add([metadata_origin, metadata_origin])
 
     def test_origin_intrinsic_metadata_search_fulltext(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata1 = {
             "author": "John Doe",
         }
         metadata1_rev = {
             "id": data.revision_id_1,
             "metadata": metadata1,
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata1_origin = {
             "id": data.origin_url_1,
             "metadata": metadata1,
             "mappings": [],
             "indexer_configuration_id": tool_id,
             "from_revision": data.revision_id_1,
         }
         metadata2 = {
             "author": "Jane Doe",
         }
         metadata2_rev = {
             "id": data.revision_id_2,
             "metadata": metadata2,
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata2_origin = {
             "id": data.origin_url_2,
             "metadata": metadata2,
             "mappings": [],
             "indexer_configuration_id": tool_id,
             "from_revision": data.revision_id_2,
         }
 
         # when
         storage.revision_intrinsic_metadata_add([metadata1_rev])
         storage.origin_intrinsic_metadata_add([metadata1_origin])
         storage.revision_intrinsic_metadata_add([metadata2_rev])
         storage.origin_intrinsic_metadata_add([metadata2_origin])
 
         # then
         search = storage.origin_intrinsic_metadata_search_fulltext
         assert set([res["id"] for res in search(["Doe"])]) == set(
             [data.origin_url_1, data.origin_url_2]
         )
         assert [res["id"] for res in search(["John", "Doe"])] == [data.origin_url_1]
         assert [res["id"] for res in search(["John"])] == [data.origin_url_1]
         assert not list(search(["John", "Jane"]))
 
     def test_origin_intrinsic_metadata_search_fulltext_rank(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         # The following authors have "Random Person" to add some more content
         # to the JSON data, to work around normalization quirks when there
         # are few words (rank/(1+ln(nb_words)) is very sensitive to nb_words
         # for small values of nb_words).
         metadata1 = {"author": ["Random Person", "John Doe", "Jane Doe",]}
         metadata1_rev = {
             "id": data.revision_id_1,
             "metadata": metadata1,
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata1_origin = {
             "id": data.origin_url_1,
             "metadata": metadata1,
             "mappings": [],
             "indexer_configuration_id": tool_id,
             "from_revision": data.revision_id_1,
         }
         metadata2 = {"author": ["Random Person", "Jane Doe",]}
         metadata2_rev = {
             "id": data.revision_id_2,
             "metadata": metadata2,
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata2_origin = {
             "id": data.origin_url_2,
             "metadata": metadata2,
             "mappings": [],
             "indexer_configuration_id": tool_id,
             "from_revision": data.revision_id_2,
         }
 
         # when
         storage.revision_intrinsic_metadata_add([metadata1_rev])
         storage.origin_intrinsic_metadata_add([metadata1_origin])
         storage.revision_intrinsic_metadata_add([metadata2_rev])
         storage.origin_intrinsic_metadata_add([metadata2_origin])
 
         # then
         search = storage.origin_intrinsic_metadata_search_fulltext
         assert [res["id"] for res in search(["Doe"])] == [
             data.origin_url_1,
             data.origin_url_2,
         ]
         assert [res["id"] for res in search(["Doe"], limit=1)] == [data.origin_url_1]
         assert [res["id"] for res in search(["John"])] == [data.origin_url_1]
         assert [res["id"] for res in search(["Jane"])] == [
             data.origin_url_2,
             data.origin_url_1,
         ]
         assert [res["id"] for res in search(["John", "Jane"])] == [data.origin_url_1]
 
     def _fill_origin_intrinsic_metadata(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool1_id = data.tools["swh-metadata-detector"]["id"]
         tool2_id = data.tools["swh-metadata-detector2"]["id"]
 
         metadata1 = {
             "@context": "foo",
             "author": "John Doe",
         }
         metadata1_rev = {
             "id": data.revision_id_1,
             "metadata": metadata1,
             "mappings": ["npm"],
             "indexer_configuration_id": tool1_id,
         }
         metadata1_origin = {
             "id": data.origin_url_1,
             "metadata": metadata1,
             "mappings": ["npm"],
             "indexer_configuration_id": tool1_id,
             "from_revision": data.revision_id_1,
         }
         metadata2 = {
             "@context": "foo",
             "author": "Jane Doe",
         }
         metadata2_rev = {
             "id": data.revision_id_2,
             "metadata": metadata2,
             "mappings": ["npm", "gemspec"],
             "indexer_configuration_id": tool2_id,
         }
         metadata2_origin = {
             "id": data.origin_url_2,
             "metadata": metadata2,
             "mappings": ["npm", "gemspec"],
             "indexer_configuration_id": tool2_id,
             "from_revision": data.revision_id_2,
         }
         metadata3 = {
             "@context": "foo",
         }
         metadata3_rev = {
             "id": data.revision_id_3,
             "metadata": metadata3,
             "mappings": ["npm", "gemspec"],
             "indexer_configuration_id": tool2_id,
         }
         metadata3_origin = {
             "id": data.origin_url_3,
             "metadata": metadata3,
             "mappings": ["pkg-info"],
             "indexer_configuration_id": tool2_id,
             "from_revision": data.revision_id_3,
         }
 
         storage.revision_intrinsic_metadata_add([metadata1_rev])
         storage.origin_intrinsic_metadata_add([metadata1_origin])
         storage.revision_intrinsic_metadata_add([metadata2_rev])
         storage.origin_intrinsic_metadata_add([metadata2_origin])
         storage.revision_intrinsic_metadata_add([metadata3_rev])
         storage.origin_intrinsic_metadata_add([metadata3_origin])
 
     def test_origin_intrinsic_metadata_search_by_producer(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         self._fill_origin_intrinsic_metadata(swh_indexer_storage_with_data)
         tool1 = data.tools["swh-metadata-detector"]
         tool2 = data.tools["swh-metadata-detector2"]
         endpoint = storage.origin_intrinsic_metadata_search_by_producer
 
         # test pagination
         # no 'page_token' param, return all origins
         result = endpoint(ids_only=True)
         assert result["origins"] == [
             data.origin_url_1,
             data.origin_url_2,
             data.origin_url_3,
         ]
         assert "next_page_token" not in result
 
         # 'page_token' is < than origin_1, return everything
         result = endpoint(page_token=data.origin_url_1[:-1], ids_only=True)
         assert result["origins"] == [
             data.origin_url_1,
             data.origin_url_2,
             data.origin_url_3,
         ]
         assert "next_page_token" not in result
 
         # 'page_token' is origin_3, return nothing
         result = endpoint(page_token=data.origin_url_3, ids_only=True)
         assert not result["origins"]
         assert "next_page_token" not in result
 
         # test limit argument
         result = endpoint(page_token=data.origin_url_1[:-1], limit=2, ids_only=True)
         assert result["origins"] == [data.origin_url_1, data.origin_url_2]
         assert result["next_page_token"] == result["origins"][-1]
 
         result = endpoint(page_token=data.origin_url_1, limit=2, ids_only=True)
         assert result["origins"] == [data.origin_url_2, data.origin_url_3]
         assert "next_page_token" not in result
 
         result = endpoint(page_token=data.origin_url_2, limit=2, ids_only=True)
         assert result["origins"] == [data.origin_url_3]
         assert "next_page_token" not in result
 
         # test mappings filtering
         result = endpoint(mappings=["npm"], ids_only=True)
         assert result["origins"] == [data.origin_url_1, data.origin_url_2]
         assert "next_page_token" not in result
 
         result = endpoint(mappings=["npm", "gemspec"], ids_only=True)
         assert result["origins"] == [data.origin_url_1, data.origin_url_2]
         assert "next_page_token" not in result
 
         result = endpoint(mappings=["gemspec"], ids_only=True)
         assert result["origins"] == [data.origin_url_2]
         assert "next_page_token" not in result
 
         result = endpoint(mappings=["pkg-info"], ids_only=True)
         assert result["origins"] == [data.origin_url_3]
         assert "next_page_token" not in result
 
         result = endpoint(mappings=["foobar"], ids_only=True)
         assert not result["origins"]
         assert "next_page_token" not in result
 
         # test pagination + mappings
         result = endpoint(mappings=["npm"], limit=1, ids_only=True)
         assert result["origins"] == [data.origin_url_1]
         assert result["next_page_token"] == result["origins"][-1]
 
         # test tool filtering
         result = endpoint(tool_ids=[tool1["id"]], ids_only=True)
         assert result["origins"] == [data.origin_url_1]
         assert "next_page_token" not in result
 
         result = endpoint(tool_ids=[tool2["id"]], ids_only=True)
         assert sorted(result["origins"]) == [data.origin_url_2, data.origin_url_3]
         assert "next_page_token" not in result
 
         result = endpoint(tool_ids=[tool1["id"], tool2["id"]], ids_only=True)
         assert sorted(result["origins"]) == [
             data.origin_url_1,
             data.origin_url_2,
             data.origin_url_3,
         ]
         assert "next_page_token" not in result
 
         # test ids_only=False
         assert endpoint(mappings=["gemspec"])["origins"] == [
             {
                 "id": data.origin_url_2,
                 "metadata": {"@context": "foo", "author": "Jane Doe",},
                 "mappings": ["npm", "gemspec"],
                 "tool": tool2,
                 "from_revision": data.revision_id_2,
             }
         ]
 
     def test_origin_intrinsic_metadata_stats(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         self._fill_origin_intrinsic_metadata(swh_indexer_storage_with_data)
 
         result = storage.origin_intrinsic_metadata_stats()
         assert result == {
             "per_mapping": {
                 "gemspec": 1,
                 "npm": 2,
                 "pkg-info": 1,
                 "codemeta": 0,
                 "maven": 0,
             },
             "total": 3,
             "non_empty": 2,
         }
 
 
 class TestIndexerStorageIndexerCondifuration:
     def test_indexer_configuration_add(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "some-unknown-tool",
             "tool_version": "some-version",
             "tool_configuration": {"debian-package": "some-package"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
         assert actual_tool is None  # does not exist
 
         # add it
         actual_tools = list(storage.indexer_configuration_add([tool]))
 
         assert len(actual_tools) == 1
         actual_tool = actual_tools[0]
         assert actual_tool is not None  # now it exists
         new_id = actual_tool.pop("id")
         assert actual_tool == tool
 
         actual_tools2 = list(storage.indexer_configuration_add([tool]))
         actual_tool2 = actual_tools2[0]
         assert actual_tool2 is not None  # now it exists
         new_id2 = actual_tool2.pop("id")
 
         assert new_id == new_id2
         assert actual_tool == actual_tool2
 
     def test_indexer_configuration_add_multiple(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "some-unknown-tool",
             "tool_version": "some-version",
             "tool_configuration": {"debian-package": "some-package"},
         }
 
         actual_tools = list(storage.indexer_configuration_add([tool]))
         assert len(actual_tools) == 1
 
         new_tools = [
             tool,
             {
                 "tool_name": "yet-another-tool",
                 "tool_version": "version",
                 "tool_configuration": {},
             },
         ]
 
         actual_tools = list(storage.indexer_configuration_add(new_tools))
         assert len(actual_tools) == 2
 
         # order not guaranteed, so we iterate over results to check
         for tool in actual_tools:
             _id = tool.pop("id")
             assert _id is not None
             assert tool in new_tools
 
     def test_indexer_configuration_get_missing(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "unknown-tool",
             "tool_version": "3.1.0rc2-31-ga2cbb8c",
             "tool_configuration": {"command_line": "nomossa <filepath>"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
 
         assert actual_tool is None
 
     def test_indexer_configuration_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "nomos",
             "tool_version": "3.1.0rc2-31-ga2cbb8c",
             "tool_configuration": {"command_line": "nomossa <filepath>"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
         assert actual_tool
 
         expected_tool = tool.copy()
         del actual_tool["id"]
 
         assert expected_tool == actual_tool
 
     def test_indexer_configuration_metadata_get_missing_context(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "swh-metadata-translator",
             "tool_version": "0.0.1",
             "tool_configuration": {"context": "unknown-context"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
 
         assert actual_tool is None
 
     def test_indexer_configuration_metadata_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "swh-metadata-translator",
             "tool_version": "0.0.1",
             "tool_configuration": {"type": "local", "context": "NpmMapping"},
         }
 
         storage.indexer_configuration_add([tool])
         actual_tool = storage.indexer_configuration_get(tool)
         assert actual_tool
 
         expected_tool = tool.copy()
         expected_tool["id"] = actual_tool["id"]
 
         assert expected_tool == actual_tool
diff --git a/swh/indexer/tests/test_metadata.py b/swh/indexer/tests/test_metadata.py
index 8187606..e9abe9d 100644
--- a/swh/indexer/tests/test_metadata.py
+++ b/swh/indexer/tests/test_metadata.py
@@ -1,1202 +1,1205 @@
 # Copyright (C) 2017-2020  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
 
 import json
 import unittest
 
 from hypothesis import HealthCheck, given, settings, strategies
 
 from swh.indexer.codemeta import CODEMETA_TERMS
 from swh.indexer.metadata import ContentMetadataIndexer, RevisionMetadataIndexer
 from swh.indexer.metadata_detector import detect_metadata
 from swh.indexer.metadata_dictionary import MAPPINGS
 from swh.indexer.metadata_dictionary.maven import MavenMapping
 from swh.indexer.metadata_dictionary.npm import NpmMapping
 from swh.indexer.metadata_dictionary.ruby import GemspecMapping
+from swh.indexer.storage.model import ContentMetadataRow
 from swh.indexer.tests.utils import DIRECTORY2, REVISION
 from swh.model.hashutil import hash_to_bytes
 from swh.model.model import Directory, DirectoryEntry, Revision
 
 from .utils import (
     BASE_TEST_CONFIG,
     YARN_PARSER_METADATA,
     fill_obj_storage,
     fill_storage,
     json_document_strategy,
     xml_document_strategy,
 )
 
 TRANSLATOR_TOOL = {
     "name": "swh-metadata-translator",
     "version": "0.0.2",
     "configuration": {"type": "local", "context": "NpmMapping"},
 }
 
 
 class ContentMetadataTestIndexer(ContentMetadataIndexer):
     """Specific Metadata whose configuration is enough to satisfy the
        indexing tests.
     """
 
     def parse_config_file(self, *args, **kwargs):
         assert False, "should not be called; the rev indexer configures it."
 
 
 REVISION_METADATA_CONFIG = {
     **BASE_TEST_CONFIG,
     "tools": TRANSLATOR_TOOL,
 }
 
 
 class Metadata(unittest.TestCase):
     """
     Tests metadata_mock_tool tool for Metadata detection
     """
 
     def setUp(self):
         """
         shows the entire diff in the results
         """
         self.maxDiff = None
         self.npm_mapping = MAPPINGS["NpmMapping"]()
         self.codemeta_mapping = MAPPINGS["CodemetaMapping"]()
         self.maven_mapping = MAPPINGS["MavenMapping"]()
         self.pkginfo_mapping = MAPPINGS["PythonPkginfoMapping"]()
         self.gemspec_mapping = MAPPINGS["GemspecMapping"]()
 
     def test_compute_metadata_none(self):
         """
         testing content empty content is empty
         should return None
         """
         # given
         content = b""
 
         # None if no metadata was found or an error occurred
         declared_metadata = None
         # when
         result = self.npm_mapping.translate(content)
         # then
         self.assertEqual(declared_metadata, result)
 
     def test_compute_metadata_npm(self):
         """
         testing only computation of metadata with hard_mapping_npm
         """
         # given
         content = b"""
             {
                 "name": "test_metadata",
                 "version": "0.0.2",
                 "description": "Simple package.json test for indexer",
                   "repository": {
                     "type": "git",
                     "url": "https://github.com/moranegg/metadata_test"
                 },
                 "author": {
                     "email": "moranegg@example.com",
                     "name": "Morane G"
                 }
             }
         """
         declared_metadata = {
             "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
             "type": "SoftwareSourceCode",
             "name": "test_metadata",
             "version": "0.0.2",
             "description": "Simple package.json test for indexer",
             "codeRepository": "git+https://github.com/moranegg/metadata_test",
             "author": [
                 {"type": "Person", "name": "Morane G", "email": "moranegg@example.com",}
             ],
         }
 
         # when
         result = self.npm_mapping.translate(content)
         # then
         self.assertEqual(declared_metadata, result)
 
     def test_index_content_metadata_npm(self):
         """
         testing NPM with package.json
         - one sha1 uses a file that can't be translated to metadata and
           should return None in the translated metadata
         """
         # given
         sha1s = [
             hash_to_bytes("26a9f72a7c87cc9205725cfd879f514ff4f3d8d5"),
             hash_to_bytes("d4c647f0fc257591cc9ba1722484229780d1c607"),
             hash_to_bytes("02fb2c89e14f7fab46701478c83779c7beb7b069"),
         ]
         # this metadata indexer computes only metadata for package.json
         # in npm context with a hard mapping
         config = BASE_TEST_CONFIG.copy()
         config["tools"] = [TRANSLATOR_TOOL]
         metadata_indexer = ContentMetadataTestIndexer(config=config)
         fill_obj_storage(metadata_indexer.objstorage)
         fill_storage(metadata_indexer.storage)
 
         # when
         metadata_indexer.run(sha1s, policy_update="ignore-dups")
         results = list(metadata_indexer.idx_storage.content_metadata_get(sha1s))
 
         expected_results = [
-            {
-                "metadata": {
+            ContentMetadataRow(
+                id=hash_to_bytes("26a9f72a7c87cc9205725cfd879f514ff4f3d8d5"),
+                tool=TRANSLATOR_TOOL,
+                metadata={
                     "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                     "type": "SoftwareSourceCode",
                     "codeRepository": "git+https://github.com/moranegg/metadata_test",
                     "description": "Simple package.json test for indexer",
                     "name": "test_metadata",
                     "version": "0.0.1",
                 },
-                "id": hash_to_bytes("26a9f72a7c87cc9205725cfd879f514ff4f3d8d5"),
-            },
-            {
-                "metadata": {
+            ),
+            ContentMetadataRow(
+                id=hash_to_bytes("d4c647f0fc257591cc9ba1722484229780d1c607"),
+                tool=TRANSLATOR_TOOL,
+                metadata={
                     "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                     "type": "SoftwareSourceCode",
                     "issueTracker": "https://github.com/npm/npm/issues",
                     "author": [
                         {
                             "type": "Person",
                             "name": "Isaac Z. Schlueter",
                             "email": "i@izs.me",
                             "url": "http://blog.izs.me",
                         }
                     ],
                     "codeRepository": "git+https://github.com/npm/npm",
                     "description": "a package manager for JavaScript",
                     "license": "https://spdx.org/licenses/Artistic-2.0",
                     "version": "5.0.3",
                     "name": "npm",
                     "keywords": [
                         "install",
                         "modules",
                         "package manager",
                         "package.json",
                     ],
                     "url": "https://docs.npmjs.com/",
                 },
-                "id": hash_to_bytes("d4c647f0fc257591cc9ba1722484229780d1c607"),
-            },
+            ),
         ]
 
         for result in results:
-            del result["tool"]
+            del result.tool["id"]
 
         # The assertion below returns False sometimes because of nested lists
         self.assertEqual(expected_results, results)
 
     def test_npm_bugs_normalization(self):
         # valid dictionary
         package_json = b"""{
             "name": "foo",
             "bugs": {
                 "url": "https://github.com/owner/project/issues",
                 "email": "foo@example.com"
             }
         }"""
         result = self.npm_mapping.translate(package_json)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "name": "foo",
                 "issueTracker": "https://github.com/owner/project/issues",
                 "type": "SoftwareSourceCode",
             },
         )
 
         # "invalid" dictionary
         package_json = b"""{
             "name": "foo",
             "bugs": {
                 "email": "foo@example.com"
             }
         }"""
         result = self.npm_mapping.translate(package_json)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "name": "foo",
                 "type": "SoftwareSourceCode",
             },
         )
 
         # string
         package_json = b"""{
             "name": "foo",
             "bugs": "https://github.com/owner/project/issues"
         }"""
         result = self.npm_mapping.translate(package_json)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "name": "foo",
                 "issueTracker": "https://github.com/owner/project/issues",
                 "type": "SoftwareSourceCode",
             },
         )
 
     def test_npm_repository_normalization(self):
         # normal
         package_json = b"""{
             "name": "foo",
             "repository": {
                 "type" : "git",
                 "url" : "https://github.com/npm/cli.git"
             }
         }"""
         result = self.npm_mapping.translate(package_json)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "name": "foo",
                 "codeRepository": "git+https://github.com/npm/cli.git",
                 "type": "SoftwareSourceCode",
             },
         )
 
         # missing url
         package_json = b"""{
             "name": "foo",
             "repository": {
                 "type" : "git"
             }
         }"""
         result = self.npm_mapping.translate(package_json)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "name": "foo",
                 "type": "SoftwareSourceCode",
             },
         )
 
         # github shortcut
         package_json = b"""{
             "name": "foo",
             "repository": "github:npm/cli"
         }"""
         result = self.npm_mapping.translate(package_json)
         expected_result = {
             "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
             "name": "foo",
             "codeRepository": "git+https://github.com/npm/cli.git",
             "type": "SoftwareSourceCode",
         }
         self.assertEqual(result, expected_result)
 
         # github shortshortcut
         package_json = b"""{
             "name": "foo",
             "repository": "npm/cli"
         }"""
         result = self.npm_mapping.translate(package_json)
         self.assertEqual(result, expected_result)
 
         # gitlab shortcut
         package_json = b"""{
             "name": "foo",
             "repository": "gitlab:user/repo"
         }"""
         result = self.npm_mapping.translate(package_json)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "name": "foo",
                 "codeRepository": "git+https://gitlab.com/user/repo.git",
                 "type": "SoftwareSourceCode",
             },
         )
 
     def test_detect_metadata_package_json(self):
         # given
         df = [
             {
                 "sha1_git": b"abc",
                 "name": b"index.js",
                 "target": b"abc",
                 "length": 897,
                 "status": "visible",
                 "type": "file",
                 "perms": 33188,
                 "dir_id": b"dir_a",
                 "sha1": b"bcd",
             },
             {
                 "sha1_git": b"aab",
                 "name": b"package.json",
                 "target": b"aab",
                 "length": 712,
                 "status": "visible",
                 "type": "file",
                 "perms": 33188,
                 "dir_id": b"dir_a",
                 "sha1": b"cde",
             },
         ]
         # when
         results = detect_metadata(df)
 
         expected_results = {"NpmMapping": [b"cde"]}
         # then
         self.assertEqual(expected_results, results)
 
     def test_compute_metadata_valid_codemeta(self):
         raw_content = b"""{
             "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
             "@type": "SoftwareSourceCode",
             "identifier": "CodeMeta",
             "description": "CodeMeta is a concept vocabulary that can be used to standardize the exchange of software metadata across repositories and organizations.",
             "name": "CodeMeta: Minimal metadata schemas for science software and code, in JSON-LD",
             "codeRepository": "https://github.com/codemeta/codemeta",
             "issueTracker": "https://github.com/codemeta/codemeta/issues",
             "license": "https://spdx.org/licenses/Apache-2.0",
             "version": "2.0",
             "author": [
               {
                 "@type": "Person",
                 "givenName": "Carl",
                 "familyName": "Boettiger",
                 "email": "cboettig@gmail.com",
                 "@id": "http://orcid.org/0000-0002-1642-628X"
               },
               {
                 "@type": "Person",
                 "givenName": "Matthew B.",
                 "familyName": "Jones",
                 "email": "jones@nceas.ucsb.edu",
                 "@id": "http://orcid.org/0000-0003-0077-4738"
               }
             ],
             "maintainer": {
               "@type": "Person",
               "givenName": "Carl",
               "familyName": "Boettiger",
               "email": "cboettig@gmail.com",
               "@id": "http://orcid.org/0000-0002-1642-628X"
             },
             "contIntegration": "https://travis-ci.org/codemeta/codemeta",
             "developmentStatus": "active",
             "downloadUrl": "https://github.com/codemeta/codemeta/archive/2.0.zip",
             "funder": {
                 "@id": "https://doi.org/10.13039/100000001",
                 "@type": "Organization",
                 "name": "National Science Foundation"
             },
             "funding":"1549758; Codemeta: A Rosetta Stone for Metadata in Scientific Software",
             "keywords": [
               "metadata",
               "software"
             ],
             "version":"2.0",
             "dateCreated":"2017-06-05",
             "datePublished":"2017-06-05",
             "programmingLanguage": "JSON-LD"
           }"""  # noqa
         expected_result = {
             "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
             "type": "SoftwareSourceCode",
             "identifier": "CodeMeta",
             "description": "CodeMeta is a concept vocabulary that can "
             "be used to standardize the exchange of software metadata "
             "across repositories and organizations.",
             "name": "CodeMeta: Minimal metadata schemas for science "
             "software and code, in JSON-LD",
             "codeRepository": "https://github.com/codemeta/codemeta",
             "issueTracker": "https://github.com/codemeta/codemeta/issues",
             "license": "https://spdx.org/licenses/Apache-2.0",
             "version": "2.0",
             "author": [
                 {
                     "type": "Person",
                     "givenName": "Carl",
                     "familyName": "Boettiger",
                     "email": "cboettig@gmail.com",
                     "id": "http://orcid.org/0000-0002-1642-628X",
                 },
                 {
                     "type": "Person",
                     "givenName": "Matthew B.",
                     "familyName": "Jones",
                     "email": "jones@nceas.ucsb.edu",
                     "id": "http://orcid.org/0000-0003-0077-4738",
                 },
             ],
             "maintainer": {
                 "type": "Person",
                 "givenName": "Carl",
                 "familyName": "Boettiger",
                 "email": "cboettig@gmail.com",
                 "id": "http://orcid.org/0000-0002-1642-628X",
             },
             "contIntegration": "https://travis-ci.org/codemeta/codemeta",
             "developmentStatus": "active",
             "downloadUrl": "https://github.com/codemeta/codemeta/archive/2.0.zip",
             "funder": {
                 "id": "https://doi.org/10.13039/100000001",
                 "type": "Organization",
                 "name": "National Science Foundation",
             },
             "funding": "1549758; Codemeta: A Rosetta Stone for Metadata "
             "in Scientific Software",
             "keywords": ["metadata", "software"],
             "version": "2.0",
             "dateCreated": "2017-06-05",
             "datePublished": "2017-06-05",
             "programmingLanguage": "JSON-LD",
         }
         result = self.codemeta_mapping.translate(raw_content)
         self.assertEqual(result, expected_result)
 
     def test_compute_metadata_codemeta_alternate_context(self):
         raw_content = b"""{
             "@context": "https://raw.githubusercontent.com/codemeta/codemeta/master/codemeta.jsonld",
             "@type": "SoftwareSourceCode",
             "identifier": "CodeMeta"
         }"""  # noqa
         expected_result = {
             "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
             "type": "SoftwareSourceCode",
             "identifier": "CodeMeta",
         }
         result = self.codemeta_mapping.translate(raw_content)
         self.assertEqual(result, expected_result)
 
     def test_compute_metadata_maven(self):
         raw_content = b"""
         <project>
           <name>Maven Default Project</name>
           <modelVersion>4.0.0</modelVersion>
           <groupId>com.mycompany.app</groupId>
           <artifactId>my-app</artifactId>
           <version>1.2.3</version>
           <repositories>
             <repository>
               <id>central</id>
               <name>Maven Repository Switchboard</name>
               <layout>default</layout>
               <url>http://repo1.maven.org/maven2</url>
               <snapshots>
                 <enabled>false</enabled>
               </snapshots>
             </repository>
           </repositories>
           <licenses>
             <license>
               <name>Apache License, Version 2.0</name>
               <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
               <distribution>repo</distribution>
               <comments>A business-friendly OSS license</comments>
             </license>
           </licenses>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "Maven Default Project",
                 "identifier": "com.mycompany.app",
                 "version": "1.2.3",
                 "license": "https://www.apache.org/licenses/LICENSE-2.0.txt",
                 "codeRepository": (
                     "http://repo1.maven.org/maven2/com/mycompany/app/my-app"
                 ),
             },
         )
 
     def test_compute_metadata_maven_empty(self):
         raw_content = b"""
         <project>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
             },
         )
 
     def test_compute_metadata_maven_almost_empty(self):
         raw_content = b"""
         <project>
           <foo/>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
             },
         )
 
     def test_compute_metadata_maven_invalid_xml(self):
         expected_warning = (
             "WARNING:swh.indexer.metadata_dictionary.maven.MavenMapping:"
             "Error parsing XML from foo"
         )
 
         raw_content = b"""
         <project>"""
         with self.assertLogs("swh.indexer.metadata_dictionary", level="WARNING") as cm:
             result = MAPPINGS["MavenMapping"]("foo").translate(raw_content)
             self.assertEqual(cm.output, [expected_warning])
         self.assertEqual(result, None)
 
         raw_content = b"""
         """
         with self.assertLogs("swh.indexer.metadata_dictionary", level="WARNING") as cm:
             result = MAPPINGS["MavenMapping"]("foo").translate(raw_content)
             self.assertEqual(cm.output, [expected_warning])
         self.assertEqual(result, None)
 
     def test_compute_metadata_maven_unknown_encoding(self):
         expected_warning = (
             "WARNING:swh.indexer.metadata_dictionary.maven.MavenMapping:"
             "Error detecting XML encoding from foo"
         )
 
         raw_content = b"""<?xml version="1.0" encoding="foo"?>
         <project>
         </project>"""
         with self.assertLogs("swh.indexer.metadata_dictionary", level="WARNING") as cm:
             result = MAPPINGS["MavenMapping"]("foo").translate(raw_content)
             self.assertEqual(cm.output, [expected_warning])
         self.assertEqual(result, None)
 
         raw_content = b"""<?xml version="1.0" encoding="UTF-7"?>
         <project>
         </project>"""
         with self.assertLogs("swh.indexer.metadata_dictionary", level="WARNING") as cm:
             result = MAPPINGS["MavenMapping"]("foo").translate(raw_content)
             self.assertEqual(cm.output, [expected_warning])
         self.assertEqual(result, None)
 
     def test_compute_metadata_maven_invalid_encoding(self):
         expected_warning = (
             "WARNING:swh.indexer.metadata_dictionary.maven.MavenMapping:"
             "Error unidecoding XML from foo"
         )
 
         raw_content = b"""<?xml version="1.0" encoding="UTF-8"?>
         <foo\xe5ct>
         </foo>"""
         with self.assertLogs("swh.indexer.metadata_dictionary", level="WARNING") as cm:
             result = MAPPINGS["MavenMapping"]("foo").translate(raw_content)
             self.assertEqual(cm.output, [expected_warning])
         self.assertEqual(result, None)
 
     def test_compute_metadata_maven_minimal(self):
         raw_content = b"""
         <project>
           <name>Maven Default Project</name>
           <modelVersion>4.0.0</modelVersion>
           <groupId>com.mycompany.app</groupId>
           <artifactId>my-app</artifactId>
           <version>1.2.3</version>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "Maven Default Project",
                 "identifier": "com.mycompany.app",
                 "version": "1.2.3",
                 "codeRepository": (
                     "https://repo.maven.apache.org/maven2/com/mycompany/app/my-app"
                 ),
             },
         )
 
     def test_compute_metadata_maven_empty_nodes(self):
         raw_content = b"""
         <project>
           <name>Maven Default Project</name>
           <modelVersion>4.0.0</modelVersion>
           <groupId>com.mycompany.app</groupId>
           <artifactId>my-app</artifactId>
           <version>1.2.3</version>
           <repositories>
           </repositories>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "Maven Default Project",
                 "identifier": "com.mycompany.app",
                 "version": "1.2.3",
                 "codeRepository": (
                     "https://repo.maven.apache.org/maven2/com/mycompany/app/my-app"
                 ),
             },
         )
 
         raw_content = b"""
         <project>
           <name>Maven Default Project</name>
           <modelVersion>4.0.0</modelVersion>
           <groupId>com.mycompany.app</groupId>
           <artifactId>my-app</artifactId>
           <version></version>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "Maven Default Project",
                 "identifier": "com.mycompany.app",
                 "codeRepository": (
                     "https://repo.maven.apache.org/maven2/com/mycompany/app/my-app"
                 ),
             },
         )
 
         raw_content = b"""
         <project>
           <name></name>
           <modelVersion>4.0.0</modelVersion>
           <groupId>com.mycompany.app</groupId>
           <artifactId>my-app</artifactId>
           <version>1.2.3</version>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "identifier": "com.mycompany.app",
                 "version": "1.2.3",
                 "codeRepository": (
                     "https://repo.maven.apache.org/maven2/com/mycompany/app/my-app"
                 ),
             },
         )
 
         raw_content = b"""
         <project>
           <name>Maven Default Project</name>
           <modelVersion>4.0.0</modelVersion>
           <groupId>com.mycompany.app</groupId>
           <artifactId>my-app</artifactId>
           <version>1.2.3</version>
           <licenses>
           </licenses>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "Maven Default Project",
                 "identifier": "com.mycompany.app",
                 "version": "1.2.3",
                 "codeRepository": (
                     "https://repo.maven.apache.org/maven2/com/mycompany/app/my-app"
                 ),
             },
         )
 
         raw_content = b"""
         <project>
           <groupId></groupId>
           <version>1.2.3</version>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "version": "1.2.3",
             },
         )
 
     def test_compute_metadata_maven_invalid_licenses(self):
         raw_content = b"""
         <project>
           <name>Maven Default Project</name>
           <modelVersion>4.0.0</modelVersion>
           <groupId>com.mycompany.app</groupId>
           <artifactId>my-app</artifactId>
           <version>1.2.3</version>
           <licenses>
             foo
           </licenses>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "Maven Default Project",
                 "identifier": "com.mycompany.app",
                 "version": "1.2.3",
                 "codeRepository": (
                     "https://repo.maven.apache.org/maven2/com/mycompany/app/my-app"
                 ),
             },
         )
 
     def test_compute_metadata_maven_multiple(self):
         """Tests when there are multiple code repos and licenses."""
         raw_content = b"""
         <project>
           <name>Maven Default Project</name>
           <modelVersion>4.0.0</modelVersion>
           <groupId>com.mycompany.app</groupId>
           <artifactId>my-app</artifactId>
           <version>1.2.3</version>
           <repositories>
             <repository>
               <id>central</id>
               <name>Maven Repository Switchboard</name>
               <layout>default</layout>
               <url>http://repo1.maven.org/maven2</url>
               <snapshots>
                 <enabled>false</enabled>
               </snapshots>
             </repository>
             <repository>
               <id>example</id>
               <name>Example Maven Repo</name>
               <layout>default</layout>
               <url>http://example.org/maven2</url>
             </repository>
           </repositories>
           <licenses>
             <license>
               <name>Apache License, Version 2.0</name>
               <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
               <distribution>repo</distribution>
               <comments>A business-friendly OSS license</comments>
             </license>
             <license>
               <name>MIT license</name>
               <url>https://opensource.org/licenses/MIT</url>
             </license>
           </licenses>
         </project>"""
         result = self.maven_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "Maven Default Project",
                 "identifier": "com.mycompany.app",
                 "version": "1.2.3",
                 "license": [
                     "https://www.apache.org/licenses/LICENSE-2.0.txt",
                     "https://opensource.org/licenses/MIT",
                 ],
                 "codeRepository": [
                     "http://repo1.maven.org/maven2/com/mycompany/app/my-app",
                     "http://example.org/maven2/com/mycompany/app/my-app",
                 ],
             },
         )
 
     def test_compute_metadata_pkginfo(self):
         raw_content = b"""\
 Metadata-Version: 2.1
 Name: swh.core
 Version: 0.0.49
 Summary: Software Heritage core utilities
 Home-page: https://forge.softwareheritage.org/diffusion/DCORE/
 Author: Software Heritage developers
 Author-email: swh-devel@inria.fr
 License: UNKNOWN
 Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest
 Project-URL: Funding, https://www.softwareheritage.org/donate
 Project-URL: Source, https://forge.softwareheritage.org/source/swh-core
 Description: swh-core
         ========
        \x20
         core library for swh's modules:
         - config parser
         - hash computations
         - serialization
         - logging mechanism
        \x20
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable
 Description-Content-Type: text/markdown
 Provides-Extra: testing
 """  # noqa
         result = self.pkginfo_mapping.translate(raw_content)
         self.assertCountEqual(
             result["description"],
             [
                 "Software Heritage core utilities",  # note the comma here
                 "swh-core\n"
                 "========\n"
                 "\n"
                 "core library for swh's modules:\n"
                 "- config parser\n"
                 "- hash computations\n"
                 "- serialization\n"
                 "- logging mechanism\n"
                 "",
             ],
             result,
         )
         del result["description"]
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "url": "https://forge.softwareheritage.org/diffusion/DCORE/",
                 "name": "swh.core",
                 "author": [
                     {
                         "type": "Person",
                         "name": "Software Heritage developers",
                         "email": "swh-devel@inria.fr",
                     }
                 ],
                 "version": "0.0.49",
             },
         )
 
     def test_compute_metadata_pkginfo_utf8(self):
         raw_content = b"""\
 Metadata-Version: 1.1
 Name: snowpyt
 Description-Content-Type: UNKNOWN
 Description: foo
         Hydrology N\xc2\xb083
 """  # noqa
         result = self.pkginfo_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "snowpyt",
                 "description": "foo\nHydrology N°83",
             },
         )
 
     def test_compute_metadata_pkginfo_keywords(self):
         raw_content = b"""\
 Metadata-Version: 2.1
 Name: foo
 Keywords: foo bar baz
 """  # noqa
         result = self.pkginfo_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "foo",
                 "keywords": ["foo", "bar", "baz"],
             },
         )
 
     def test_compute_metadata_pkginfo_license(self):
         raw_content = b"""\
 Metadata-Version: 2.1
 Name: foo
 License: MIT
 """  # noqa
         result = self.pkginfo_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "foo",
                 "license": "MIT",
             },
         )
 
     def test_gemspec_base(self):
         raw_content = b"""
 Gem::Specification.new do |s|
   s.name        = 'example'
   s.version     = '0.1.0'
   s.licenses    = ['MIT']
   s.summary     = "This is an example!"
   s.description = "Much longer explanation of the example!"
   s.authors     = ["Ruby Coder"]
   s.email       = 'rubycoder@example.com'
   s.files       = ["lib/example.rb"]
   s.homepage    = 'https://rubygems.org/gems/example'
   s.metadata    = { "source_code_uri" => "https://github.com/example/example" }
 end"""
         result = self.gemspec_mapping.translate(raw_content)
         self.assertCountEqual(
             result.pop("description"),
             ["This is an example!", "Much longer explanation of the example!"],
         )
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "author": [{"type": "Person", "name": "Ruby Coder"}],
                 "name": "example",
                 "license": "https://spdx.org/licenses/MIT",
                 "codeRepository": "https://rubygems.org/gems/example",
                 "email": "rubycoder@example.com",
                 "version": "0.1.0",
             },
         )
 
     def test_gemspec_two_author_fields(self):
         raw_content = b"""
 Gem::Specification.new do |s|
   s.authors     = ["Ruby Coder1"]
   s.author      = "Ruby Coder2"
 end"""
         result = self.gemspec_mapping.translate(raw_content)
         self.assertCountEqual(
             result.pop("author"),
             [
                 {"type": "Person", "name": "Ruby Coder1"},
                 {"type": "Person", "name": "Ruby Coder2"},
             ],
         )
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
             },
         )
 
     def test_gemspec_invalid_author(self):
         raw_content = b"""
 Gem::Specification.new do |s|
   s.author      = ["Ruby Coder"]
 end"""
         result = self.gemspec_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
             },
         )
         raw_content = b"""
 Gem::Specification.new do |s|
   s.author      = "Ruby Coder1",
 end"""
         result = self.gemspec_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
             },
         )
         raw_content = b"""
 Gem::Specification.new do |s|
   s.authors     = ["Ruby Coder1", ["Ruby Coder2"]]
 end"""
         result = self.gemspec_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "author": [{"type": "Person", "name": "Ruby Coder1"}],
             },
         )
 
     def test_gemspec_alternative_header(self):
         raw_content = b"""
 require './lib/version'
 
 Gem::Specification.new { |s|
   s.name = 'rb-system-with-aliases'
   s.summary = 'execute system commands with aliases'
 }
 """
         result = self.gemspec_mapping.translate(raw_content)
         self.assertEqual(
             result,
             {
                 "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
                 "type": "SoftwareSourceCode",
                 "name": "rb-system-with-aliases",
                 "description": "execute system commands with aliases",
             },
         )
 
     @settings(suppress_health_check=[HealthCheck.too_slow])
     @given(json_document_strategy(keys=list(NpmMapping.mapping)))
     def test_npm_adversarial(self, doc):
         raw = json.dumps(doc).encode()
         self.npm_mapping.translate(raw)
 
     @settings(suppress_health_check=[HealthCheck.too_slow])
     @given(json_document_strategy(keys=CODEMETA_TERMS))
     def test_codemeta_adversarial(self, doc):
         raw = json.dumps(doc).encode()
         self.codemeta_mapping.translate(raw)
 
     @settings(suppress_health_check=[HealthCheck.too_slow])
     @given(
         xml_document_strategy(
             keys=list(MavenMapping.mapping),
             root="project",
             xmlns="http://maven.apache.org/POM/4.0.0",
         )
     )
     def test_maven_adversarial(self, doc):
         self.maven_mapping.translate(doc)
 
     @settings(suppress_health_check=[HealthCheck.too_slow])
     @given(
         strategies.dictionaries(
             # keys
             strategies.one_of(
                 strategies.text(), *map(strategies.just, GemspecMapping.mapping)
             ),
             # values
             strategies.recursive(
                 strategies.characters(),
                 lambda children: strategies.lists(children, min_size=1),
             ),
         )
     )
     def test_gemspec_adversarial(self, doc):
         parts = [b"Gem::Specification.new do |s|\n"]
         for (k, v) in doc.items():
             parts.append("  s.{} = {}\n".format(k, repr(v)).encode())
         parts.append(b"end\n")
         self.gemspec_mapping.translate(b"".join(parts))
 
     def test_revision_metadata_indexer(self):
         metadata_indexer = RevisionMetadataIndexer(config=REVISION_METADATA_CONFIG)
         fill_obj_storage(metadata_indexer.objstorage)
         fill_storage(metadata_indexer.storage)
 
         tool = metadata_indexer.idx_storage.indexer_configuration_get(
             {f"tool_{k}": v for (k, v) in TRANSLATOR_TOOL.items()}
         )
         assert tool is not None
         rev = REVISION
         assert rev.directory == DIRECTORY2.id
 
         metadata_indexer.idx_storage.content_metadata_add(
             [
-                {
-                    "indexer_configuration_id": tool["id"],
-                    "id": DIRECTORY2.entries[0].target,
-                    "metadata": YARN_PARSER_METADATA,
-                }
+                ContentMetadataRow(
+                    id=DIRECTORY2.entries[0].target,
+                    indexer_configuration_id=tool["id"],
+                    metadata=YARN_PARSER_METADATA,
+                )
             ]
         )
 
         metadata_indexer.run([rev.id], "update-dups")
 
         results = list(
             metadata_indexer.idx_storage.revision_intrinsic_metadata_get([REVISION.id])
         )
 
         expected_results = [
             {
                 "id": rev.id,
                 "tool": TRANSLATOR_TOOL,
                 "metadata": YARN_PARSER_METADATA,
                 "mappings": ["npm"],
             }
         ]
 
         for result in results:
             del result["tool"]["id"]
 
         # then
         self.assertEqual(results, expected_results)
 
     def test_revision_metadata_indexer_single_root_dir(self):
         metadata_indexer = RevisionMetadataIndexer(config=REVISION_METADATA_CONFIG)
         fill_obj_storage(metadata_indexer.objstorage)
         fill_storage(metadata_indexer.storage)
 
         # Add a parent directory, that is the only directory at the root
         # of the revision
         rev = REVISION
         assert rev.directory == DIRECTORY2.id
 
         directory = Directory(
             entries=(
                 DirectoryEntry(
                     name=b"foobar-1.0.0", type="dir", target=rev.directory, perms=16384,
                 ),
             ),
         )
         assert directory.id is not None
         metadata_indexer.storage.directory_add([directory])
 
         new_rev_dict = {**rev.to_dict(), "directory": directory.id}
         new_rev_dict.pop("id")
         new_rev = Revision.from_dict(new_rev_dict)
         metadata_indexer.storage.revision_add([new_rev])
 
         tool = metadata_indexer.idx_storage.indexer_configuration_get(
             {f"tool_{k}": v for (k, v) in TRANSLATOR_TOOL.items()}
         )
         assert tool is not None
 
         metadata_indexer.idx_storage.content_metadata_add(
             [
-                {
-                    "indexer_configuration_id": tool["id"],
-                    "id": DIRECTORY2.entries[0].target,
-                    "metadata": YARN_PARSER_METADATA,
-                }
+                ContentMetadataRow(
+                    id=DIRECTORY2.entries[0].target,
+                    indexer_configuration_id=tool["id"],
+                    metadata=YARN_PARSER_METADATA,
+                )
             ]
         )
 
         metadata_indexer.run([new_rev.id], "update-dups")
 
         results = list(
             metadata_indexer.idx_storage.revision_intrinsic_metadata_get([new_rev.id])
         )
 
         expected_results = [
             {
                 "id": new_rev.id,
                 "tool": TRANSLATOR_TOOL,
                 "metadata": YARN_PARSER_METADATA,
                 "mappings": ["npm"],
             }
         ]
 
         for result in results:
             del result["tool"]["id"]
 
         # then
         self.assertEqual(results, expected_results)