diff --git a/swh/indexer/indexer.py b/swh/indexer/indexer.py
index 3abb378..c31c728 100644
--- a/swh/indexer/indexer.py
+++ b/swh/indexer/indexer.py
@@ -1,614 +1,605 @@
 # Copyright (C) 2016-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 abc
 from contextlib import contextmanager
 import logging
 import os
 import shutil
 import tempfile
 from typing import Any, Dict, Generic, Iterator, List, Optional, Set, TypeVar, Union
 
 from swh.core import utils
 from swh.core.config import load_from_envvar, merge_configs
 from swh.indexer.storage import INDEXER_CFG_KEY, PagedResult, Sha1, get_indexer_storage
 from swh.indexer.storage.interface import IndexerStorageInterface
 from swh.model import hashutil
 from swh.objstorage.exc import ObjNotFoundError
 from swh.objstorage.factory import get_objstorage
 from swh.scheduler import CONFIG as SWH_CONFIG
 from swh.storage import get_storage
 from swh.storage.interface import StorageInterface
 
 
 @contextmanager
 def write_to_temp(filename: str, data: bytes, working_directory: str) -> Iterator[str]:
     """Write the sha1's content in a temporary file.
 
     Args:
         filename: one of sha1's many filenames
         data: the sha1's content to write in temporary
           file
         working_directory: the directory into which the
           file is written
 
     Returns:
         The path to the temporary file created. That file is
         filled in with the raw content's data.
 
     """
     os.makedirs(working_directory, exist_ok=True)
     temp_dir = tempfile.mkdtemp(dir=working_directory)
     content_path = os.path.join(temp_dir, filename)
 
     with open(content_path, "wb") as f:
         f.write(data)
 
     yield content_path
     shutil.rmtree(temp_dir)
 
 
 DEFAULT_CONFIG = {
     INDEXER_CFG_KEY: {"cls": "memory"},
     "storage": {"cls": "memory"},
     "objstorage": {"cls": "memory"},
 }
 
 
-# TODO: should be bound=Optional[BaseRow] when all endpoints move away from dicts
 TResult = TypeVar("TResult")
 
 
 class BaseIndexer(Generic[TResult], metaclass=abc.ABCMeta):
     """Base class for indexers to inherit from.
 
     The main entry point is the :func:`run` function which is in
     charge of triggering the computations on the batch dict/ids
     received.
 
     Indexers can:
 
     - filter out ids whose data has already been indexed.
     - retrieve ids data from storage or objstorage
     - index this data depending on the object and store the result in
       storage.
 
     To implement a new object type indexer, inherit from the
     BaseIndexer and implement indexing:
 
     :meth:`~BaseIndexer.run`:
       object_ids are different depending on object. For example: sha1 for
       content, sha1_git for revision, directory, release, and id for origin
 
     To implement a new concrete indexer, inherit from the object level
     classes: :class:`ContentIndexer`, :class:`RevisionIndexer`,
     :class:`OriginIndexer`.
 
     Then you need to implement the following functions:
 
     :meth:`~BaseIndexer.filter`:
       filter out data already indexed (in storage).
 
     :meth:`~BaseIndexer.index_object`:
       compute index on id with data (retrieved from the storage or the
       objstorage by the id key) and return the resulting index computation.
 
     :meth:`~BaseIndexer.persist_index_computations`:
       persist the results of multiple index computations in the storage.
 
     The new indexer implementation can also override the following functions:
 
     :meth:`~BaseIndexer.prepare`:
       Configuration preparation for the indexer.  When overriding, this must
       call the `super().prepare()` instruction.
 
     :meth:`~BaseIndexer.check`:
       Configuration check for the indexer.  When overriding, this must call the
       `super().check()` instruction.
 
     :meth:`~BaseIndexer.register_tools`:
       This should return a dict of the tool(s) to use when indexing or
       filtering.
 
     """
 
     results: List[TResult]
 
     USE_TOOLS = True
 
     catch_exceptions = True
     """Prevents exceptions in `index()` from raising too high. Set to False
     in tests to properly catch all exceptions."""
 
     scheduler: Any
     storage: StorageInterface
     objstorage: Any
     idx_storage: IndexerStorageInterface
 
     def __init__(self, config=None, **kw) -> None:
         """Prepare and check that the indexer is ready to run.
 
         """
         super().__init__()
         if config is not None:
             self.config = config
         elif SWH_CONFIG:
             self.config = SWH_CONFIG.copy()
         else:
             self.config = load_from_envvar()
         self.config = merge_configs(DEFAULT_CONFIG, self.config)
         self.prepare()
         self.check()
         self.log.debug("%s: config=%s", self, self.config)
 
     def prepare(self) -> None:
         """Prepare the indexer's needed runtime configuration.
            Without this step, the indexer cannot possibly run.
 
         """
         config_storage = self.config.get("storage")
         if config_storage:
             self.storage = get_storage(**config_storage)
 
         objstorage = self.config["objstorage"]
         self.objstorage = get_objstorage(objstorage["cls"], objstorage["args"])
 
         idx_storage = self.config[INDEXER_CFG_KEY]
         self.idx_storage = get_indexer_storage(**idx_storage)
 
         _log = logging.getLogger("requests.packages.urllib3.connectionpool")
         _log.setLevel(logging.WARN)
         self.log = logging.getLogger("swh.indexer")
 
         if self.USE_TOOLS:
             self.tools = list(self.register_tools(self.config.get("tools", [])))
         self.results = []
 
     @property
     def tool(self) -> Dict:
         return self.tools[0]
 
     def check(self) -> None:
         """Check the indexer's configuration is ok before proceeding.
            If ok, does nothing. If not raise error.
 
         """
         if self.USE_TOOLS and not self.tools:
             raise ValueError("Tools %s is unknown, cannot continue" % self.tools)
 
     def _prepare_tool(self, tool: Dict[str, Any]) -> Dict[str, Any]:
         """Prepare the tool dict to be compliant with the storage api.
 
         """
         return {"tool_%s" % key: value for key, value in tool.items()}
 
     def register_tools(
         self, tools: Union[Dict[str, Any], List[Dict[str, Any]]]
     ) -> List[Dict[str, Any]]:
         """Permit to register tools to the storage.
 
            Add a sensible default which can be overridden if not
            sufficient.  (For now, all indexers use only one tool)
 
            Expects the self.config['tools'] property to be set with
            one or more tools.
 
         Args:
             tools: Either a dict or a list of dict.
 
         Returns:
             list: List of dicts with additional id key.
 
         Raises:
             ValueError: if not a list nor a dict.
 
         """
         if isinstance(tools, list):
             tools = list(map(self._prepare_tool, tools))
         elif isinstance(tools, dict):
             tools = [self._prepare_tool(tools)]
         else:
             raise ValueError("Configuration tool(s) must be a dict or list!")
 
         if tools:
             return self.idx_storage.indexer_configuration_add(tools)
         else:
             return []
 
     def index(self, id, data: Optional[bytes] = None, **kwargs) -> List[TResult]:
         """Index computation for the id and associated raw data.
 
         Args:
             id: identifier or Dict object
             data: id's data from storage or objstorage depending on
               object type
 
         Returns:
             dict: a dict that makes sense for the
             :meth:`.persist_index_computations` method.
 
         """
         raise NotImplementedError()
 
     def filter(self, ids: List[bytes]) -> Iterator[bytes]:
         """Filter missing ids for that particular indexer.
 
         Args:
             ids: list of ids
 
         Yields:
             iterator of missing ids
 
         """
         yield from ids
 
     @abc.abstractmethod
     def persist_index_computations(
         self, results: List[TResult], policy_update: str
     ) -> Dict[str, int]:
         """Persist the computation resulting from the index.
 
         Args:
 
             results: List of results. One result is the
               result of the index function.
             policy_update: either 'update-dups' or 'ignore-dups' to
               respectively update duplicates or ignore them
 
         Returns:
             a summary dict of what has been inserted in the storage
 
         """
         return {}
 
 
 class ContentIndexer(BaseIndexer[TResult], Generic[TResult]):
     """A content indexer working on a list of ids directly.
 
     To work on indexer partition, use the :class:`ContentPartitionIndexer`
     instead.
 
     Note: :class:`ContentIndexer` is not an instantiable object. To
     use it, one should inherit from this class and override the
     methods mentioned in the :class:`BaseIndexer` class.
 
     """
 
     def run(
         self, ids: Union[List[bytes], bytes, str], policy_update: str, **kwargs
     ) -> Dict:
         """Given a list of ids:
 
         - retrieve the content from the storage
         - execute the indexing computations
         - store the results (according to policy_update)
 
         Args:
             ids (Iterable[Union[bytes, str]]): sha1's identifier list
             policy_update (str): either 'update-dups' or 'ignore-dups' to
                                  respectively update duplicates or ignore
                                  them
             **kwargs: passed to the `index` method
 
         Returns:
             A summary Dict of the task's status
 
         """
         sha1s = [
             hashutil.hash_to_bytes(id_) if isinstance(id_, str) else id_ for id_ in ids
         ]
         results = []
         summary: Dict = {"status": "uneventful"}
         try:
             for sha1 in sha1s:
                 try:
                     raw_content = self.objstorage.get(sha1)
                 except ObjNotFoundError:
                     self.log.warning(
                         "Content %s not found in objstorage"
                         % hashutil.hash_to_hex(sha1)
                     )
                     continue
                 res = self.index(sha1, raw_content, **kwargs)
                 if res:  # If no results, skip it
                     results.extend(res)
                     summary["status"] = "eventful"
             summary = self.persist_index_computations(results, policy_update)
             self.results = results
         except Exception:
             if not self.catch_exceptions:
                 raise
             self.log.exception("Problem when reading contents metadata.")
             summary["status"] = "failed"
         return summary
 
 
 class ContentPartitionIndexer(BaseIndexer[TResult], Generic[TResult]):
     """A content partition indexer.
 
     This expects as input a partition_id and a nb_partitions. This will then index the
     contents within that partition.
 
     To work on a list of ids, use the :class:`ContentIndexer` instead.
 
     Note: :class:`ContentPartitionIndexer` is not an instantiable
     object. To use it, one should inherit from this class and override
     the methods mentioned in the :class:`BaseIndexer` class.
 
     """
 
     @abc.abstractmethod
     def indexed_contents_in_partition(
         self, partition_id: int, nb_partitions: int, page_token: Optional[str] = None
     ) -> PagedResult[Sha1]:
         """Retrieve indexed contents within range [start, end].
 
         Args:
             partition_id: Index of the partition to fetch
             nb_partitions: Total number of partitions to split into
             page_token: opaque token used for pagination
 
         Returns:
             PagedResult of Sha1. If next_page_token is None, there is no more data
             to fetch
 
         """
         pass
 
     def _list_contents_to_index(
         self, partition_id: int, nb_partitions: int, indexed: Set[Sha1]
     ) -> Iterator[Sha1]:
         """Compute from storage the new contents to index in the partition_id . The already
            indexed contents are skipped.
 
         Args:
             partition_id: Index of the partition to fetch data from
             nb_partitions: Total number of partition
             indexed: Set of content already indexed.
 
         Yields:
             Sha1 id (bytes) of contents to index
 
         """
         if not isinstance(partition_id, int) or not isinstance(nb_partitions, int):
             raise TypeError(
                 f"identifiers must be int, not {partition_id!r} and {nb_partitions!r}."
             )
         next_page_token = None
         while True:
             result = self.storage.content_get_partition(
                 partition_id, nb_partitions, page_token=next_page_token
             )
             contents = result.results
             for c in contents:
                 _id = hashutil.hash_to_bytes(c.sha1)
                 if _id in indexed:
                     continue
                 yield _id
             next_page_token = result.next_page_token
             if next_page_token is None:
                 break
 
     def _index_contents(
         self, partition_id: int, nb_partitions: int, indexed: Set[Sha1], **kwargs: Any
     ) -> Iterator[TResult]:
         """Index the contents within the partition_id.
 
         Args:
             start: Starting bound from range identifier
             end: End range identifier
             indexed: Set of content already indexed.
 
         Yields:
             indexing result as dict to persist in the indexer backend
 
         """
         for sha1 in self._list_contents_to_index(partition_id, nb_partitions, indexed):
             try:
                 raw_content = self.objstorage.get(sha1)
             except ObjNotFoundError:
                 self.log.warning(f"Content {sha1.hex()} not found in objstorage")
                 continue
-            results = self.index(sha1, raw_content, **kwargs)
-            for res in results:
-                # TODO: remove this check when all endpoints moved away from dicts.
-                if isinstance(res, dict) and not isinstance(res["id"], bytes):
-                    raise TypeError(
-                        "%r.index should return ids as bytes, not %r"
-                        % (self.__class__.__name__, res["id"])
-                    )
-                yield res
+            yield from self.index(sha1, raw_content, **kwargs)
 
     def _index_with_skipping_already_done(
         self, partition_id: int, nb_partitions: int
     ) -> Iterator[TResult]:
         """Index not already indexed contents within the partition partition_id
 
         Args:
             partition_id: Index of the partition to fetch
             nb_partitions: Total number of partitions to split into
 
         Yields:
            indexing result as dict to persist in the indexer backend
 
         """
         next_page_token = None
         contents = set()
         while True:
             indexed_page = self.indexed_contents_in_partition(
                 partition_id, nb_partitions, page_token=next_page_token
             )
             for sha1 in indexed_page.results:
                 contents.add(sha1)
             yield from self._index_contents(partition_id, nb_partitions, contents)
             next_page_token = indexed_page.next_page_token
             if next_page_token is None:
                 break
 
     def run(
         self,
         partition_id: int,
         nb_partitions: int,
         skip_existing: bool = True,
         **kwargs,
     ) -> Dict:
         """Given a partition of content ids, index the contents within.
 
            Either the indexer is incremental (filter out existing computed data) or it
            computes everything from scratch.
 
         Args:
             partition_id: Index of the partition to fetch
             nb_partitions: Total number of partitions to split into
             skip_existing: Skip existing indexed data
                 (default) or not
             **kwargs: passed to the `index` method
 
         Returns:
             dict with the indexing task status
 
         """
         summary: Dict[str, Any] = {"status": "uneventful"}
         count = 0
         try:
             if skip_existing:
                 gen = self._index_with_skipping_already_done(
                     partition_id, nb_partitions
                 )
             else:
                 gen = self._index_contents(partition_id, nb_partitions, indexed=set([]))
 
             count_object_added_key: Optional[str] = None
 
             for contents in utils.grouper(gen, n=self.config["write_batch_size"]):
                 res = self.persist_index_computations(
                     list(contents), policy_update="update-dups"
                 )
                 if not count_object_added_key:
                     count_object_added_key = list(res.keys())[0]
                 count += res[count_object_added_key]
                 if count > 0:
                     summary["status"] = "eventful"
         except Exception:
             if not self.catch_exceptions:
                 raise
             self.log.exception("Problem when computing metadata.")
             summary["status"] = "failed"
 
         if count > 0 and count_object_added_key:
             summary[count_object_added_key] = count
         return summary
 
 
 class OriginIndexer(BaseIndexer[TResult], Generic[TResult]):
     """An object type indexer, inherits from the :class:`BaseIndexer` and
     implements Origin indexing using the run method
 
     Note: the :class:`OriginIndexer` is not an instantiable object.
     To use it in another context one should inherit from this class
     and override the methods mentioned in the :class:`BaseIndexer`
     class.
 
     """
 
     def run(
         self, origin_urls: List[str], policy_update: str = "update-dups", **kwargs
     ) -> Dict:
         """Given a list of origin urls:
 
         - retrieve origins from storage
         - execute the indexing computations
         - store the results (according to policy_update)
 
         Args:
             origin_urls: list of origin urls.
             policy_update: either 'update-dups' or 'ignore-dups' to
               respectively update duplicates (default) or ignore them
             **kwargs: passed to the `index` method
 
         """
         summary: Dict[str, Any] = {"status": "uneventful"}
         try:
             results = self.index_list(origin_urls, **kwargs)
         except Exception:
             if not self.catch_exceptions:
                 raise
             summary["status"] = "failed"
             return summary
 
         summary_persist = self.persist_index_computations(results, policy_update)
         self.results = results
         if summary_persist:
             for value in summary_persist.values():
                 if value > 0:
                     summary["status"] = "eventful"
             summary.update(summary_persist)
         return summary
 
     def index_list(self, origin_urls: List[str], **kwargs) -> List[TResult]:
         results = []
         for origin_url in origin_urls:
             try:
                 results.extend(self.index(origin_url, **kwargs))
             except Exception:
                 self.log.exception("Problem when processing origin %s", origin_url)
                 raise
         return results
 
 
 class RevisionIndexer(BaseIndexer[TResult], Generic[TResult]):
     """An object type indexer, inherits from the :class:`BaseIndexer` and
     implements Revision indexing using the run method
 
     Note: the :class:`RevisionIndexer` is not an instantiable object.
     To use it in another context one should inherit from this class
     and override the methods mentioned in the :class:`BaseIndexer`
     class.
 
     """
 
     def run(self, ids: Union[str, bytes], policy_update: str) -> Dict:
         """Given a list of sha1_gits:
 
         - retrieve revisions from storage
         - execute the indexing computations
         - store the results (according to policy_update)
 
         Args:
             ids: sha1_git's identifier list
             policy_update: either 'update-dups' or 'ignore-dups' to
               respectively update duplicates or ignore them
 
         """
         summary: Dict[str, Any] = {"status": "uneventful"}
         results = []
 
         revision_ids = [
             hashutil.hash_to_bytes(id_) if isinstance(id_, str) else id_ for id_ in ids
         ]
         for rev in self.storage.revision_get(revision_ids):
             if not rev:
                 self.log.warning(
                     "Revisions %s not found in storage"
                     % list(map(hashutil.hash_to_hex, ids))
                 )
                 continue
             try:
                 results.extend(self.index(rev))
             except Exception:
                 if not self.catch_exceptions:
                     raise
                 self.log.exception("Problem when processing revision")
                 summary["status"] = "failed"
                 return summary
 
         summary_persist = self.persist_index_computations(results, policy_update)
         if summary_persist:
             for value in summary_persist.values():
                 if value > 0:
                     summary["status"] = "eventful"
             summary.update(summary_persist)
         self.results = results
         return summary
diff --git a/swh/indexer/tests/storage/test_storage.py b/swh/indexer/tests/storage/test_storage.py
index 38d3ff4..e464682 100644
--- a/swh/indexer/tests/storage/test_storage.py
+++ b/swh/indexer/tests/storage/test_storage.py
@@ -1,1937 +1,1921 @@
 # 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, cast
+from typing import Any, Dict, List, Tuple, Type, cast
 
 import attr
 import pytest
 
 from swh.indexer.storage.exc import DuplicateId, IndexerStorageArgumentException
 from swh.indexer.storage.interface import IndexerStorageInterface, PagedResult
 from swh.indexer.storage.model import (
     BaseRow,
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
     ContentMetadataRow,
     ContentMimetypeRow,
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 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
+    row_class: Type[BaseRow]
 
     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(
+                self.row_class.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)])
+        summary = endpoint(storage, etype, "add")([self.row_class.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(
+            self.row_class.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)])
+        summary2 = endpoint(storage, etype, "add")([self.row_class.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)])
+        summary = endpoint(storage, etype, "add")([self.row_class.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(
+            self.row_class.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
+            [self.row_class.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(
+            self.row_class.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(
+            self.row_class.from_dict(
                 {
                     "id": hash_,
                     **self.example_data[0],
                     "indexer_configuration_id": tool["id"],
                 }
             )
             for hash_ in hashes
         ]
         data_v2 = [
-            self.row_from_dict(
+            self.row_class.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})
+            self.row_class.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)),
+            (row.to_dict() for row in 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(
+        data_rev1 = self.row_class.from_dict(
             {
                 "id": data.revision_id_2,
                 **self.example_data[0],
                 "indexer_configuration_id": tool["id"],
             }
         )
 
-        data_rev2 = self.row_from_dict(
+        data_rev2 = self.row_class.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(
+            self.row_class.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(
+        data1 = self.row_class.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(
+            self.row_class.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
+    row_class = ContentMimetypeRow
 
     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
+    row_class = ContentLanguageRow
 
 
 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
+    row_class = ContentCtagsRow
 
     # 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
+    row_class = ContentMetadataRow
 
 
 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"],
         },
     ]
-    row_from_dict = RevisionIntrinsicMetadataRow.from_dict
-    dict_from_row = staticmethod(lambda x: x.to_dict())  # type: ignore
+    row_class = RevisionIntrinsicMetadataRow
 
     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 = RevisionIntrinsicMetadataRow(
             id=data.sha1_2,
             indexer_configuration_id=tool["id"],
             **self.example_data[0],  # type: ignore
         )
 
         # 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())
+    row_class = ContentLicenseRow
 
     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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata,
             mappings=["mapping1"],
             indexer_configuration_id=tool_id,
         )
         metadata_origin = OriginIntrinsicMetadataRow(
             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 = [
             OriginIntrinsicMetadataRow(
                 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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             indexer_configuration_id=tool_id,
             metadata=metadata,
             mappings=["mapping1"],
         )
         metadata_origin = OriginIntrinsicMetadataRow(
             id=data.origin_url_1,
             metadata=metadata,
             indexer_configuration_id=tool_id,
             mappings=["mapping1"],
             from_revision=data.revision_id_2,
         )
         metadata_origin2 = attr.evolve(metadata_origin, 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"]
             )
         )
         assert [
             attr.evolve(m, indexer_configuration_id=cast(Dict, m.tool)["id"], tool=None)
             for m in 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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_1,
             metadata=metadata_v1.copy(),
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata_origin_v1 = OriginIntrinsicMetadataRow(
             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 = [
             OriginIntrinsicMetadataRow(
                 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 = attr.evolve(metadata_rev_v1, metadata=metadata_v2)
         metadata_origin_v2 = attr.evolve(metadata_origin_v1, 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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata_v1,
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata_origin_v1 = OriginIntrinsicMetadataRow(
             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 = [
             OriginIntrinsicMetadataRow(
                 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 = attr.evolve(metadata_rev_v1, metadata=metadata_v2)
         metadata_origin_v2 = OriginIntrinsicMetadataRow(
             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 = [
             OriginIntrinsicMetadataRow(
                 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: Dict[str, Any] = {
             "metadata": {"version": None, "name": None,},
             "mappings": [],
         }
         example_data2: Dict[str, Any] = {
             "metadata": {"version": "v1.1.1", "name": "foo",},
             "mappings": [],
         }
 
         metadata_rev_v1 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata={"version": None, "name": None,},
             mappings=[],
             indexer_configuration_id=tool_id,
         )
 
         data_v1 = [
             OriginIntrinsicMetadataRow(
                 id="file:///tmp/origin%d" % id_,
                 from_revision=data.revision_id_2,
                 indexer_configuration_id=tool_id,
                 **example_data1,
             )
             for id_ in ids
         ]
         data_v2 = [
             OriginIntrinsicMetadataRow(
                 id="file:///tmp/origin%d" % id_,
                 from_revision=data.revision_id_2,
                 indexer_configuration_id=tool_id,
                 **example_data2,
             )
             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 = [
             OriginIntrinsicMetadataRow(
                 id="file:///tmp/origin%d" % id_,
                 from_revision=data.revision_id_2,
                 tool=data.tools["swh-metadata-detector"],
                 **example_data1,
             )
             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 = [
             OriginIntrinsicMetadataRow(
                 id="file:///tmp/origin%d" % id_,
                 from_revision=data.revision_id_2,
                 tool=data.tools["swh-metadata-detector"],
                 **example_data2,
             )
             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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata,
             mappings=["mapping1"],
             indexer_configuration_id=tool_id,
         )
         metadata_origin = OriginIntrinsicMetadataRow(
             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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_1,
             metadata=metadata1,
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata1_origin = OriginIntrinsicMetadataRow(
             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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata2,
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata2_origin = OriginIntrinsicMetadataRow(
             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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_1,
             metadata=metadata1,
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata1_origin = OriginIntrinsicMetadataRow(
             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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata2,
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata2_origin = OriginIntrinsicMetadataRow(
             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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_1,
             metadata=metadata1,
             mappings=["npm"],
             indexer_configuration_id=tool1_id,
         )
         metadata1_origin = OriginIntrinsicMetadataRow(
             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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata2,
             mappings=["npm", "gemspec"],
             indexer_configuration_id=tool2_id,
         )
         metadata2_origin = OriginIntrinsicMetadataRow(
             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 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_3,
             metadata=metadata3,
             mappings=["npm", "gemspec"],
             indexer_configuration_id=tool2_id,
         )
         metadata3_origin = OriginIntrinsicMetadataRow(
             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 == PagedResult(
             results=[data.origin_url_1, data.origin_url_2, data.origin_url_3,],
             next_page_token=None,
         )
 
         # 'page_token' is < than origin_1, return everything
         result = endpoint(page_token=data.origin_url_1[:-1], ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1, data.origin_url_2, data.origin_url_3,],
             next_page_token=None,
         )
 
         # 'page_token' is origin_3, return nothing
         result = endpoint(page_token=data.origin_url_3, ids_only=True)
         assert result == PagedResult(results=[], next_page_token=None)
 
         # test limit argument
         result = endpoint(page_token=data.origin_url_1[:-1], limit=2, ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1, data.origin_url_2],
             next_page_token=data.origin_url_2,
         )
 
         result = endpoint(page_token=data.origin_url_1, limit=2, ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_2, data.origin_url_3], next_page_token=None,
         )
 
         result = endpoint(page_token=data.origin_url_2, limit=2, ids_only=True)
         assert result == PagedResult(results=[data.origin_url_3], next_page_token=None,)
 
         # test mappings filtering
         result = endpoint(mappings=["npm"], ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1, data.origin_url_2], next_page_token=None,
         )
 
         result = endpoint(mappings=["npm", "gemspec"], ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1, data.origin_url_2], next_page_token=None,
         )
 
         result = endpoint(mappings=["gemspec"], ids_only=True)
         assert result == PagedResult(results=[data.origin_url_2], next_page_token=None,)
 
         result = endpoint(mappings=["pkg-info"], ids_only=True)
         assert result == PagedResult(results=[data.origin_url_3], next_page_token=None,)
 
         result = endpoint(mappings=["foobar"], ids_only=True)
         assert result == PagedResult(results=[], next_page_token=None,)
 
         # test pagination + mappings
         result = endpoint(mappings=["npm"], limit=1, ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1], next_page_token=data.origin_url_1,
         )
 
         # test tool filtering
         result = endpoint(tool_ids=[tool1["id"]], ids_only=True)
         assert result == PagedResult(results=[data.origin_url_1], next_page_token=None,)
 
         result = endpoint(tool_ids=[tool2["id"]], ids_only=True)
         assert sorted(result.results) == [data.origin_url_2, data.origin_url_3]
         assert result.next_page_token is None
 
         result = endpoint(tool_ids=[tool1["id"], tool2["id"]], ids_only=True)
         assert sorted(result.results) == [
             data.origin_url_1,
             data.origin_url_2,
             data.origin_url_3,
         ]
         assert result.next_page_token is None
 
         # test ids_only=False
         assert endpoint(mappings=["gemspec"]) == PagedResult(
             results=[
                 OriginIntrinsicMetadataRow(
                     id=data.origin_url_2,
                     metadata={"@context": "foo", "author": "Jane Doe",},
                     mappings=["npm", "gemspec"],
                     tool=tool2,
                     from_revision=data.revision_id_2,
                 )
             ],
             next_page_token=None,
         )
 
     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 TestIndexerStorageIndexerConfiguration:
     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_mimetype.py b/swh/indexer/tests/test_mimetype.py
index 34744bd..d3aef57 100644
--- a/swh/indexer/tests/test_mimetype.py
+++ b/swh/indexer/tests/test_mimetype.py
@@ -1,127 +1,125 @@
 # 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 typing import Any, Dict
 import unittest
 
 import pytest
 
 from swh.indexer.mimetype import (
     MimetypeIndexer,
     MimetypePartitionIndexer,
     compute_mimetype_encoding,
 )
 from swh.indexer.storage.model import ContentMimetypeRow
 from swh.indexer.tests.utils import (
     BASE_TEST_CONFIG,
     CommonContentIndexerPartitionTest,
     CommonContentIndexerTest,
     fill_obj_storage,
     fill_storage,
     filter_dict,
 )
 from swh.model.hashutil import hash_to_bytes
 
 
 def test_compute_mimetype_encoding():
     """Compute mimetype encoding should return results"""
     for _input, _mimetype, _encoding in [
         ("du français".encode(), "text/plain", "utf-8"),
         (b"def __init__(self):", "text/x-python", "us-ascii"),
         (b"\xff\xfe\x00\x00\x00\x00\xff\xfe\xff\xff", "application/octet-stream", ""),
     ]:
         actual_result = compute_mimetype_encoding(_input)
         assert actual_result == {"mimetype": _mimetype, "encoding": _encoding}
 
 
 CONFIG = {
     **BASE_TEST_CONFIG,
     "tools": {
         "name": "file",
         "version": "1:5.30-1+deb9u1",
         "configuration": {"type": "library", "debian-package": "python3-magic"},
     },
 }  # type: Dict[str, Any]
 
 
 class TestMimetypeIndexer(CommonContentIndexerTest, unittest.TestCase):
     """Mimetype indexer test scenarios:
 
     - Known sha1s in the input list have their data indexed
     - Unknown sha1 in the input list are not indexed
 
     """
 
     def get_indexer_results(self, ids):
         yield from self.idx_storage.content_mimetype_get(ids)
 
     def setUp(self):
         self.indexer = MimetypeIndexer(config=CONFIG)
         self.indexer.catch_exceptions = False
         self.idx_storage = self.indexer.idx_storage
         fill_storage(self.indexer.storage)
         fill_obj_storage(self.indexer.objstorage)
 
         self.id0 = "01c9379dfc33803963d07c1ccc748d3fe4c96bb5"
         self.id1 = "688a5ef812c53907562fe379d4b3851e69c7cb15"
         self.id2 = "da39a3ee5e6b4b0d3255bfef95601890afd80709"
 
         tool = {k.replace("tool_", ""): v for (k, v) in self.indexer.tool.items()}
 
         self.expected_results = [
             ContentMimetypeRow(
                 id=hash_to_bytes(self.id0),
                 tool=tool,
                 mimetype="text/plain",
                 encoding="us-ascii",
             ),
             ContentMimetypeRow(
                 id=hash_to_bytes(self.id1),
                 tool=tool,
                 mimetype="text/plain",
                 encoding="us-ascii",
             ),
             ContentMimetypeRow(
                 id=hash_to_bytes(self.id2),
                 tool=tool,
                 mimetype="application/x-empty",
                 encoding="binary",
             ),
         ]
 
 
 RANGE_CONFIG = dict(list(CONFIG.items()) + [("write_batch_size", 100)])
 
 
 class TestMimetypePartitionIndexer(
     CommonContentIndexerPartitionTest, unittest.TestCase
 ):
     """Range Mimetype Indexer tests.
 
     - new data within range are indexed
     - no data outside a range are indexed
     - with filtering existing indexed data prior to compute new index
     - without filtering existing indexed data prior to compute new index
 
     """
 
-    row_from_dict = staticmethod(lambda x: x)  # type: ignore
-
     def setUp(self):
         super().setUp()
         self.indexer = MimetypePartitionIndexer(config=RANGE_CONFIG)
         self.indexer.catch_exceptions = False
         fill_storage(self.indexer.storage)
         fill_obj_storage(self.indexer.objstorage)
 
 
 def test_mimetype_w_no_tool():
     with pytest.raises(ValueError):
         MimetypeIndexer(config=filter_dict(CONFIG, "tools"))
 
 
 def test_mimetype_range_w_no_tool():
     with pytest.raises(ValueError):
         MimetypePartitionIndexer(config=filter_dict(CONFIG, "tools"))
diff --git a/swh/indexer/tests/utils.py b/swh/indexer/tests/utils.py
index f97f502..c8e1f0c 100644
--- a/swh/indexer/tests/utils.py
+++ b/swh/indexer/tests/utils.py
@@ -1,726 +1,720 @@
 # 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 abc
 import functools
-from typing import Any, Callable, Dict, Union
+from typing import Any, Dict
 import unittest
 
 from hypothesis import strategies
 
 from swh.core.api.classes import stream_results
 from swh.indexer.storage import INDEXER_CFG_KEY
-from swh.indexer.storage.model import BaseRow
 from swh.model import hashutil
 from swh.model.hashutil import hash_to_bytes
 from swh.model.model import (
     Content,
     Directory,
     DirectoryEntry,
     Origin,
     OriginVisit,
     OriginVisitStatus,
     Person,
     Revision,
     RevisionType,
     Snapshot,
     SnapshotBranch,
     TargetType,
     Timestamp,
     TimestampWithTimezone,
 )
 from swh.storage.utils import now
 
 BASE_TEST_CONFIG: Dict[str, Dict[str, Any]] = {
     "storage": {"cls": "memory"},
     "objstorage": {"cls": "memory", "args": {},},
     INDEXER_CFG_KEY: {"cls": "memory", "args": {},},
 }
 
 
 ORIGINS = [
     Origin(url="https://github.com/SoftwareHeritage/swh-storage"),
     Origin(url="rsync://ftp.gnu.org/gnu/3dldf"),
     Origin(url="https://forge.softwareheritage.org/source/jesuisgpl/"),
     Origin(url="https://pypi.org/project/limnoria/"),
     Origin(url="http://0-512-md.googlecode.com/svn/"),
     Origin(url="https://github.com/librariesio/yarn-parser"),
     Origin(url="https://github.com/librariesio/yarn-parser.git"),
 ]
 
 
 ORIGIN_VISITS = [
     {"type": "git", "origin": ORIGINS[0].url},
     {"type": "ftp", "origin": ORIGINS[1].url},
     {"type": "deposit", "origin": ORIGINS[2].url},
     {"type": "pypi", "origin": ORIGINS[3].url},
     {"type": "svn", "origin": ORIGINS[4].url},
     {"type": "git", "origin": ORIGINS[5].url},
     {"type": "git", "origin": ORIGINS[6].url},
 ]
 
 
 DIRECTORY = Directory(
     id=hash_to_bytes("34f335a750111ca0a8b64d8034faec9eedc396be"),
     entries=(
         DirectoryEntry(
             name=b"index.js",
             type="file",
             target=hash_to_bytes("01c9379dfc33803963d07c1ccc748d3fe4c96bb5"),
             perms=0o100644,
         ),
         DirectoryEntry(
             name=b"package.json",
             type="file",
             target=hash_to_bytes("26a9f72a7c87cc9205725cfd879f514ff4f3d8d5"),
             perms=0o100644,
         ),
         DirectoryEntry(
             name=b".github",
             type="dir",
             target=Directory(entries=()).id,
             perms=0o040000,
         ),
     ),
 )
 
 DIRECTORY2 = Directory(
     id=b"\xf8zz\xa1\x12`<1$\xfav\xf9\x01\xfd5\x85F`\xf2\xb6",
     entries=(
         DirectoryEntry(
             name=b"package.json",
             type="file",
             target=hash_to_bytes("f5305243b3ce7ef8dc864ebc73794da304025beb"),
             perms=0o100644,
         ),
     ),
 )
 
 REVISION = Revision(
     id=hash_to_bytes("c6201cb1b9b9df9a7542f9665c3b5dfab85e9775"),
     message=b"Improve search functionality",
     author=Person(
         name=b"Andrew Nesbitt",
         fullname=b"Andrew Nesbitt <andrewnez@gmail.com>",
         email=b"andrewnez@gmail.com",
     ),
     committer=Person(
         name=b"Andrew Nesbitt",
         fullname=b"Andrew Nesbitt <andrewnez@gmail.com>",
         email=b"andrewnez@gmail.com",
     ),
     committer_date=TimestampWithTimezone(
         timestamp=Timestamp(seconds=1380883849, microseconds=0,),
         offset=120,
         negative_utc=False,
     ),
     type=RevisionType.GIT,
     synthetic=False,
     date=TimestampWithTimezone(
         timestamp=Timestamp(seconds=1487596456, microseconds=0,),
         offset=0,
         negative_utc=False,
     ),
     directory=DIRECTORY2.id,
     parents=(),
 )
 
 REVISIONS = [REVISION]
 
 SNAPSHOTS = [
     Snapshot(
         id=hash_to_bytes("a50fde72265343b7d28cecf6db20d98a81d21965"),
         branches={
             b"refs/heads/add-revision-origin-cache": SnapshotBranch(
                 target=b'L[\xce\x1c\x88\x8eF\t\xf1"\x19\x1e\xfb\xc0s\xe7/\xe9l\x1e',
                 target_type=TargetType.REVISION,
             ),
             b"refs/head/master": SnapshotBranch(
                 target=b"8K\x12\x00d\x03\xcc\xe4]bS\xe3\x8f{\xd7}\xac\xefrm",
                 target_type=TargetType.REVISION,
             ),
             b"HEAD": SnapshotBranch(
                 target=b"refs/head/master", target_type=TargetType.ALIAS
             ),
             b"refs/tags/v0.0.103": SnapshotBranch(
                 target=b'\xb6"Im{\xfdLb\xb0\x94N\xea\x96m\x13x\x88+\x0f\xdd',
                 target_type=TargetType.RELEASE,
             ),
         },
     ),
     Snapshot(
         id=hash_to_bytes("2c67f69a416bca4e1f3fcd848c588fab88ad0642"),
         branches={
             b"3DLDF-1.1.4.tar.gz": SnapshotBranch(
                 target=b'dJ\xfb\x1c\x91\xf4\x82B%]6\xa2\x90|\xd3\xfc"G\x99\x11',
                 target_type=TargetType.REVISION,
             ),
             b"3DLDF-2.0.2.tar.gz": SnapshotBranch(
                 target=b"\xb6\x0e\xe7\x9e9\xac\xaa\x19\x9e=\xd1\xc5\x00\\\xc6\xfc\xe0\xa6\xb4V",  # noqa
                 target_type=TargetType.REVISION,
             ),
             b"3DLDF-2.0.3-examples.tar.gz": SnapshotBranch(
                 target=b"!H\x19\xc0\xee\x82-\x12F1\xbd\x97\xfe\xadZ\x80\x80\xc1\x83\xff",  # noqa
                 target_type=TargetType.REVISION,
             ),
             b"3DLDF-2.0.3.tar.gz": SnapshotBranch(
                 target=b"\x8e\xa9\x8e/\xea}\x9feF\xf4\x9f\xfd\xee\xcc\x1a\xb4`\x8c\x8by",  # noqa
                 target_type=TargetType.REVISION,
             ),
             b"3DLDF-2.0.tar.gz": SnapshotBranch(
                 target=b"F6*\xff(?\x19a\xef\xb6\xc2\x1fv$S\xe3G\xd3\xd1m",
                 target_type=TargetType.REVISION,
             ),
         },
     ),
     Snapshot(
         id=hash_to_bytes("68c0d26104d47e278dd6be07ed61fafb561d0d20"),
         branches={
             b"master": SnapshotBranch(
                 target=b"\xe7n\xa4\x9c\x9f\xfb\xb7\xf76\x11\x08{\xa6\xe9\x99\xb1\x9e]q\xeb",  # noqa
                 target_type=TargetType.REVISION,
             )
         },
     ),
     Snapshot(
         id=hash_to_bytes("f255245269e15fc99d284affd79f766668de0b67"),
         branches={
             b"HEAD": SnapshotBranch(
                 target=b"releases/2018.09.09", target_type=TargetType.ALIAS
             ),
             b"releases/2018.09.01": SnapshotBranch(
                 target=b"<\xee1(\xe8\x8d_\xc1\xc9\xa6rT\xf1\x1d\xbb\xdfF\xfdw\xcf",
                 target_type=TargetType.REVISION,
             ),
             b"releases/2018.09.09": SnapshotBranch(
                 target=b"\x83\xb9\xb6\xc7\x05\xb1%\xd0\xfem\xd8kA\x10\x9d\xc5\xfa2\xf8t",  # noqa
                 target_type=TargetType.REVISION,
             ),
         },
     ),
     Snapshot(
         id=hash_to_bytes("a1a28c0ab387a8f9e0618cb705eab81fc448f473"),
         branches={
             b"master": SnapshotBranch(
                 target=b"\xe4?r\xe1,\x88\xab\xec\xe7\x9a\x87\xb8\xc9\xad#.\x1bw=\x18",
                 target_type=TargetType.REVISION,
             )
         },
     ),
     Snapshot(
         id=hash_to_bytes("bb4fd3a836930ce629d912864319637040ff3040"),
         branches={
             b"HEAD": SnapshotBranch(
                 target=REVISION.id, target_type=TargetType.REVISION,
             )
         },
     ),
     Snapshot(
         id=hash_to_bytes("bb4fd3a836930ce629d912864319637040ff3040"),
         branches={
             b"HEAD": SnapshotBranch(
                 target=REVISION.id, target_type=TargetType.REVISION,
             )
         },
     ),
 ]
 
 
 SHA1_TO_LICENSES = {
     "01c9379dfc33803963d07c1ccc748d3fe4c96bb5": ["GPL"],
     "02fb2c89e14f7fab46701478c83779c7beb7b069": ["Apache2.0"],
     "103bc087db1d26afc3a0283f38663d081e9b01e6": ["MIT"],
     "688a5ef812c53907562fe379d4b3851e69c7cb15": ["AGPL"],
     "da39a3ee5e6b4b0d3255bfef95601890afd80709": [],
 }
 
 
 SHA1_TO_CTAGS = {
     "01c9379dfc33803963d07c1ccc748d3fe4c96bb5": [
         {"name": "foo", "kind": "str", "line": 10, "lang": "bar",}
     ],
     "d4c647f0fc257591cc9ba1722484229780d1c607": [
         {"name": "let", "kind": "int", "line": 100, "lang": "haskell",}
     ],
     "688a5ef812c53907562fe379d4b3851e69c7cb15": [
         {"name": "symbol", "kind": "float", "line": 99, "lang": "python",}
     ],
 }
 
 
 OBJ_STORAGE_DATA = {
     "01c9379dfc33803963d07c1ccc748d3fe4c96bb5": b"this is some text",
     "688a5ef812c53907562fe379d4b3851e69c7cb15": b"another text",
     "8986af901dd2043044ce8f0d8fc039153641cf17": b"yet another text",
     "02fb2c89e14f7fab46701478c83779c7beb7b069": b"""
     import unittest
     import logging
     from swh.indexer.mimetype import MimetypeIndexer
     from swh.indexer.tests.test_utils import MockObjStorage
 
     class MockStorage():
         def content_mimetype_add(self, mimetypes):
             self.state = mimetypes
             self.conflict_update = conflict_update
 
         def indexer_configuration_add(self, tools):
             return [{
                 'id': 10,
             }]
     """,
     "103bc087db1d26afc3a0283f38663d081e9b01e6": b"""
         #ifndef __AVL__
         #define __AVL__
 
         typedef struct _avl_tree avl_tree;
 
         typedef struct _data_t {
           int content;
         } data_t;
     """,
     "93666f74f1cf635c8c8ac118879da6ec5623c410": b"""
     (should 'pygments (recognize 'lisp 'easily))
 
     """,
     "26a9f72a7c87cc9205725cfd879f514ff4f3d8d5": b"""
     {
         "name": "test_metadata",
         "version": "0.0.1",
         "description": "Simple package.json test for indexer",
         "repository": {
           "type": "git",
           "url": "https://github.com/moranegg/metadata_test"
       }
     }
     """,
     "d4c647f0fc257591cc9ba1722484229780d1c607": b"""
     {
       "version": "5.0.3",
       "name": "npm",
       "description": "a package manager for JavaScript",
       "keywords": [
         "install",
         "modules",
         "package manager",
         "package.json"
       ],
       "preferGlobal": true,
       "config": {
         "publishtest": false
       },
       "homepage": "https://docs.npmjs.com/",
       "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
       "repository": {
         "type": "git",
         "url": "https://github.com/npm/npm"
       },
       "bugs": {
         "url": "https://github.com/npm/npm/issues"
       },
       "dependencies": {
         "JSONStream": "~1.3.1",
         "abbrev": "~1.1.0",
         "ansi-regex": "~2.1.1",
         "ansicolors": "~0.3.2",
         "ansistyles": "~0.1.3"
       },
       "devDependencies": {
         "tacks": "~1.2.6",
         "tap": "~10.3.2"
       },
       "license": "Artistic-2.0"
     }
 
     """,
     "a7ab314d8a11d2c93e3dcf528ca294e7b431c449": b"""
     """,
     "da39a3ee5e6b4b0d3255bfef95601890afd80709": b"",
     # was 626364 / b'bcd'
     "e3e40fee6ff8a52f06c3b428bfe7c0ed2ef56e92": b"unimportant content for bcd",
     # was 636465 / b'cde' now yarn-parser package.json
     "f5305243b3ce7ef8dc864ebc73794da304025beb": b"""
     {
       "name": "yarn-parser",
       "version": "1.0.0",
       "description": "Tiny web service for parsing yarn.lock files",
       "main": "index.js",
       "scripts": {
         "start": "node index.js",
         "test": "mocha"
       },
       "engines": {
         "node": "9.8.0"
       },
       "repository": {
         "type": "git",
         "url": "git+https://github.com/librariesio/yarn-parser.git"
       },
       "keywords": [
         "yarn",
         "parse",
         "lock",
         "dependencies"
       ],
       "author": "Andrew Nesbitt",
       "license": "AGPL-3.0",
       "bugs": {
         "url": "https://github.com/librariesio/yarn-parser/issues"
       },
       "homepage": "https://github.com/librariesio/yarn-parser#readme",
       "dependencies": {
         "@yarnpkg/lockfile": "^1.0.0",
         "body-parser": "^1.15.2",
         "express": "^4.14.0"
       },
       "devDependencies": {
         "chai": "^4.1.2",
         "mocha": "^5.2.0",
         "request": "^2.87.0",
         "test": "^0.6.0"
       }
     }
 
 """,
 }
 
 
 YARN_PARSER_METADATA = {
     "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
     "url": "https://github.com/librariesio/yarn-parser#readme",
     "codeRepository": "git+git+https://github.com/librariesio/yarn-parser.git",
     "author": [{"type": "Person", "name": "Andrew Nesbitt"}],
     "license": "https://spdx.org/licenses/AGPL-3.0",
     "version": "1.0.0",
     "description": "Tiny web service for parsing yarn.lock files",
     "issueTracker": "https://github.com/librariesio/yarn-parser/issues",
     "name": "yarn-parser",
     "keywords": ["yarn", "parse", "lock", "dependencies"],
     "type": "SoftwareSourceCode",
 }
 
 
 json_dict_keys = strategies.one_of(
     strategies.characters(),
     strategies.just("type"),
     strategies.just("url"),
     strategies.just("name"),
     strategies.just("email"),
     strategies.just("@id"),
     strategies.just("@context"),
     strategies.just("repository"),
     strategies.just("license"),
     strategies.just("repositories"),
     strategies.just("licenses"),
 )
 """Hypothesis strategy that generates strings, with an emphasis on those
 that are often used as dictionary keys in metadata files."""
 
 
 generic_json_document = strategies.recursive(
     strategies.none()
     | strategies.booleans()
     | strategies.floats()
     | strategies.characters(),
     lambda children: (
         strategies.lists(children, min_size=1)
         | strategies.dictionaries(json_dict_keys, children, min_size=1)
     ),
 )
 """Hypothesis strategy that generates possible values for values of JSON
 metadata files."""
 
 
 def json_document_strategy(keys=None):
     """Generates an hypothesis strategy that generates metadata files
     for a JSON-based format that uses the given keys."""
     if keys is None:
         keys = strategies.characters()
     else:
         keys = strategies.one_of(map(strategies.just, keys))
 
     return strategies.dictionaries(keys, generic_json_document, min_size=1)
 
 
 def _tree_to_xml(root, xmlns, data):
     def encode(s):
         "Skips unpaired surrogates generated by json_document_strategy"
         return s.encode("utf8", "replace")
 
     def to_xml(data, indent=b" "):
         if data is None:
             return b""
         elif isinstance(data, (bool, str, int, float)):
             return indent + encode(str(data))
         elif isinstance(data, list):
             return b"\n".join(to_xml(v, indent=indent) for v in data)
         elif isinstance(data, dict):
             lines = []
             for (key, value) in data.items():
                 lines.append(indent + encode("<{}>".format(key)))
                 lines.append(to_xml(value, indent=indent + b" "))
                 lines.append(indent + encode("</{}>".format(key)))
             return b"\n".join(lines)
         else:
             raise TypeError(data)
 
     return b"\n".join(
         [
             '<{} xmlns="{}">'.format(root, xmlns).encode(),
             to_xml(data),
             "</{}>".format(root).encode(),
         ]
     )
 
 
 class TreeToXmlTest(unittest.TestCase):
     def test_leaves(self):
         self.assertEqual(
             _tree_to_xml("root", "http://example.com", None),
             b'<root xmlns="http://example.com">\n\n</root>',
         )
         self.assertEqual(
             _tree_to_xml("root", "http://example.com", True),
             b'<root xmlns="http://example.com">\n True\n</root>',
         )
         self.assertEqual(
             _tree_to_xml("root", "http://example.com", "abc"),
             b'<root xmlns="http://example.com">\n abc\n</root>',
         )
         self.assertEqual(
             _tree_to_xml("root", "http://example.com", 42),
             b'<root xmlns="http://example.com">\n 42\n</root>',
         )
         self.assertEqual(
             _tree_to_xml("root", "http://example.com", 3.14),
             b'<root xmlns="http://example.com">\n 3.14\n</root>',
         )
 
     def test_dict(self):
         self.assertIn(
             _tree_to_xml("root", "http://example.com", {"foo": "bar", "baz": "qux"}),
             [
                 b'<root xmlns="http://example.com">\n'
                 b" <foo>\n  bar\n </foo>\n"
                 b" <baz>\n  qux\n </baz>\n"
                 b"</root>",
                 b'<root xmlns="http://example.com">\n'
                 b" <baz>\n  qux\n </baz>\n"
                 b" <foo>\n  bar\n </foo>\n"
                 b"</root>",
             ],
         )
 
     def test_list(self):
         self.assertEqual(
             _tree_to_xml(
                 "root", "http://example.com", [{"foo": "bar"}, {"foo": "baz"},]
             ),
             b'<root xmlns="http://example.com">\n'
             b" <foo>\n  bar\n </foo>\n"
             b" <foo>\n  baz\n </foo>\n"
             b"</root>",
         )
 
 
 def xml_document_strategy(keys, root, xmlns):
     """Generates an hypothesis strategy that generates metadata files
     for an XML format that uses the given keys."""
 
     return strategies.builds(
         functools.partial(_tree_to_xml, root, xmlns), json_document_strategy(keys)
     )
 
 
 def filter_dict(d, keys):
     "return a copy of the dict with keys deleted"
     if not isinstance(keys, (list, tuple)):
         keys = (keys,)
     return dict((k, v) for (k, v) in d.items() if k not in keys)
 
 
 def fill_obj_storage(obj_storage):
     """Add some content in an object storage."""
     for (obj_id, content) in OBJ_STORAGE_DATA.items():
         obj_storage.add(content, obj_id=hash_to_bytes(obj_id))
 
 
 def fill_storage(storage):
     storage.origin_add(ORIGINS)
     storage.directory_add([DIRECTORY, DIRECTORY2])
     storage.revision_add(REVISIONS)
     storage.snapshot_add(SNAPSHOTS)
 
     for visit, snapshot in zip(ORIGIN_VISITS, SNAPSHOTS):
         assert snapshot.id is not None
 
         visit = storage.origin_visit_add(
             [OriginVisit(origin=visit["origin"], date=now(), type=visit["type"])]
         )[0]
         visit_status = OriginVisitStatus(
             origin=visit.origin,
             visit=visit.visit,
             date=now(),
             status="full",
             snapshot=snapshot.id,
         )
         storage.origin_visit_status_add([visit_status])
 
     contents = []
     for (obj_id, content) in OBJ_STORAGE_DATA.items():
         content_hashes = hashutil.MultiHash.from_data(content).digest()
         contents.append(
             Content(
                 data=content,
                 length=len(content),
                 status="visible",
                 sha1=hash_to_bytes(obj_id),
                 sha1_git=hash_to_bytes(obj_id),
                 sha256=content_hashes["sha256"],
                 blake2s256=content_hashes["blake2s256"],
             )
         )
     storage.content_add(contents)
 
 
 class CommonContentIndexerTest(metaclass=abc.ABCMeta):
     def get_indexer_results(self, ids):
         """Override this for indexers that don't have a mock storage."""
         return self.indexer.idx_storage.state
 
     def assert_results_ok(self, sha1s, expected_results=None):
         sha1s = [
             sha1 if isinstance(sha1, bytes) else hash_to_bytes(sha1) for sha1 in sha1s
         ]
         actual_results = list(self.get_indexer_results(sha1s))
 
         if expected_results is None:
             expected_results = self.expected_results
 
         self.assertEqual(expected_results, actual_results)
 
     def test_index(self):
         """Known sha1 have their data indexed
 
         """
         sha1s = [self.id0, self.id1, self.id2]
 
         # when
         self.indexer.run(sha1s, policy_update="update-dups")
 
         self.assert_results_ok(sha1s)
 
         # 2nd pass
         self.indexer.run(sha1s, policy_update="ignore-dups")
 
         self.assert_results_ok(sha1s)
 
     def test_index_one_unknown_sha1(self):
         """Unknown sha1 are not indexed"""
         sha1s = [
             self.id1,
             "799a5ef812c53907562fe379d4b3851e69c7cb15",  # unknown
             "800a5ef812c53907562fe379d4b3851e69c7cb15",
         ]  # unknown
 
         # when
         self.indexer.run(sha1s, policy_update="update-dups")
 
         # then
-        # TODO: unconditionally use res.id when all endpoints moved away from dicts
         expected_results = [
             res
             for res in self.expected_results
-            if hashutil.hash_to_hex(getattr(res, "id", None) or res["id"]) in sha1s
+            if hashutil.hash_to_hex(res.id) in sha1s
         ]
 
         self.assert_results_ok(sha1s, expected_results)
 
 
 class CommonContentIndexerPartitionTest:
     """Allows to factorize tests on range indexer.
 
     """
 
-    # TODO: remove this when all endpoints moved away from dicts
-    row_from_dict: Callable[[Union[Dict, BaseRow]], BaseRow]
-
     def setUp(self):
         self.contents = sorted(OBJ_STORAGE_DATA)
 
     def assert_results_ok(self, partition_id, nb_partitions, actual_results):
         expected_ids = [
             c.sha1
             for c in stream_results(
                 self.indexer.storage.content_get_partition,
                 partition_id=partition_id,
                 nb_partitions=nb_partitions,
             )
         ]
 
         actual_results = list(actual_results)
         for indexed_data in actual_results:
             _id = indexed_data.id
             assert _id in expected_ids
 
             _tool_id = indexed_data.indexer_configuration_id
             assert _tool_id == self.indexer.tool["id"]
 
     def test__index_contents(self):
         """Indexing contents without existing data results in indexed data
 
         """
         partition_id = 0
         nb_partitions = 4
 
         actual_results = list(
             self.indexer._index_contents(partition_id, nb_partitions, indexed={})
         )
 
         self.assert_results_ok(partition_id, nb_partitions, actual_results)
 
     def test__index_contents_with_indexed_data(self):
         """Indexing contents with existing data results in less indexed data
 
         """
         partition_id = 3
         nb_partitions = 4
 
         # first pass
         actual_results = list(
             self.indexer._index_contents(partition_id, nb_partitions, indexed={}),
         )
 
         self.assert_results_ok(partition_id, nb_partitions, actual_results)
 
-        # TODO: unconditionally use res.id when all endpoints moved away from dicts
-        indexed_ids = {getattr(res, "id", None) or res["id"] for res in actual_results}
+        indexed_ids = {res.id for res in actual_results}
 
         actual_results = list(
             self.indexer._index_contents(
                 partition_id, nb_partitions, indexed=indexed_ids
             )
         )
 
         # already indexed, so nothing new
         assert actual_results == []
 
     def test_generate_content_get(self):
         """Optimal indexing should result in indexed data
 
         """
         partition_id = 0
         nb_partitions = 1
 
         actual_results = self.indexer.run(
             partition_id, nb_partitions, skip_existing=False
         )
 
         assert actual_results["status"] == "eventful", actual_results
 
     def test_generate_content_get_no_result(self):
         """No result indexed returns False"""
         actual_results = self.indexer.run(1, 2 ** 512, incremental=False)
 
         assert actual_results == {"status": "uneventful"}