diff --git a/swh/indexer/fossology_license.py b/swh/indexer/fossology_license.py
index 38e69f1..2d7c978 100644
--- a/swh/indexer/fossology_license.py
+++ b/swh/indexer/fossology_license.py
@@ -1,184 +1,192 @@
 # 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 logging
 import subprocess
 from typing import Any, Dict, List, Optional, Union
 
 from swh.core.config import merge_configs
 from swh.indexer.storage.interface import IndexerStorageInterface, PagedResult, Sha1
+from swh.indexer.storage.model import ContentLicenseRow
 from swh.model import hashutil
 from swh.model.model import Revision
 
 from .indexer import ContentIndexer, ContentPartitionIndexer, write_to_temp
 
 logger = logging.getLogger(__name__)
 
 
-def compute_license(path):
+def compute_license(path) -> Dict:
     """Determine license from file at path.
 
     Args:
         path: filepath to determine the license
 
     Returns:
         dict: A dict with the following keys:
 
         - licenses ([str]): associated detected licenses to path
         - path (bytes): content filepath
 
     """
     try:
         properties = subprocess.check_output(["nomossa", path], universal_newlines=True)
         if properties:
             res = properties.rstrip().split(" contains license(s) ")
             licenses = res[1].split(",")
         else:
             licenses = []
 
         return {
             "licenses": licenses,
             "path": path,
         }
     except subprocess.CalledProcessError:
         from os import path as __path
 
         logger.exception(
             "Problem during license detection for sha1 %s" % __path.basename(path)
         )
         return {
             "licenses": [],
             "path": path,
         }
 
 
 DEFAULT_CONFIG: Dict[str, Any] = {
     "workdir": "/tmp/swh/indexer.fossology.license",
     "tools": {
         "name": "nomos",
         "version": "3.1.0rc2-31-ga2cbb8c",
         "configuration": {"command_line": "nomossa <filepath>",},
     },
     "write_batch_size": 1000,
 }
 
 
 class MixinFossologyLicenseIndexer:
     """Mixin fossology license indexer.
 
     See :class:`FossologyLicenseIndexer` and
     :class:`FossologyLicensePartitionIndexer`
 
     """
 
     tool: Any
     idx_storage: IndexerStorageInterface
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.config = merge_configs(DEFAULT_CONFIG, self.config)
         self.working_directory = self.config["workdir"]
 
     def index(
         self, id: Union[bytes, Dict, Revision], data: Optional[bytes] = None, **kwargs
-    ) -> Dict[str, Any]:
+    ) -> List[ContentLicenseRow]:
         """Index sha1s' content and store result.
 
         Args:
             id (bytes): content's identifier
             raw_content (bytes): associated raw content to content id
 
         Returns:
             dict: A dict, representing a content_license, with keys:
 
             - id (bytes): content's identifier (sha1)
             - license (bytes): license in bytes
             - path (bytes): path
             - indexer_configuration_id (int): tool used to compute the output
 
         """
         assert isinstance(id, bytes)
         assert data is not None
         with write_to_temp(
             filename=hashutil.hash_to_hex(id),  # use the id as pathname
             data=data,
             working_directory=self.working_directory,
         ) as content_path:
             properties = compute_license(path=content_path)
-        return [properties]
+        return [
+            ContentLicenseRow(
+                id=id, indexer_configuration_id=self.tool["id"], license=license,
+            )
+            for license in properties["licenses"]
+        ]
 
     def persist_index_computations(
-        self, results: List[Dict], policy_update: str
+        self, results: List[ContentLicenseRow], policy_update: str
     ) -> Dict[str, int]:
         """Persist the results in storage.
 
         Args:
             results: list of content_license dict with the
               following keys:
 
               - id (bytes): content's identifier (sha1)
               - license (bytes): license in bytes
               - path (bytes): path
 
             policy_update: either 'update-dups' or 'ignore-dups' to
               respectively update duplicates or ignore them
 
         """
         return self.idx_storage.content_fossology_license_add(
             results, conflict_update=(policy_update == "update-dups")
         )
 
 
-class FossologyLicenseIndexer(MixinFossologyLicenseIndexer, ContentIndexer[Dict]):
+class FossologyLicenseIndexer(
+    MixinFossologyLicenseIndexer, ContentIndexer[ContentLicenseRow]
+):
     """Indexer in charge of:
 
     - filtering out content already indexed
     - reading content from objstorage per the content's id (sha1)
     - computing {license, encoding} from that content
     - store result in storage
 
     """
 
     def filter(self, ids):
         """Filter out known sha1s and return only missing ones.
 
         """
         yield from self.idx_storage.content_fossology_license_missing(
             ({"id": sha1, "indexer_configuration_id": self.tool["id"],} for sha1 in ids)
         )
 
 
 class FossologyLicensePartitionIndexer(
-    MixinFossologyLicenseIndexer, ContentPartitionIndexer[Dict]
+    MixinFossologyLicenseIndexer, ContentPartitionIndexer[ContentLicenseRow]
 ):
     """FossologyLicense Range Indexer working on range/partition of content identifiers.
 
     - filters out the non textual content
     - (optionally) filters out content already indexed (cf
       :meth:`.indexed_contents_in_partition`)
     - reads content from objstorage per the content's id (sha1)
     - computes {mimetype, encoding} from that content
     - stores result in storage
 
     """
 
     def indexed_contents_in_partition(
         self, partition_id: int, nb_partitions: int, page_token: Optional[str] = None
     ) -> PagedResult[Sha1]:
         """Retrieve indexed content id within the partition id
 
         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
 
         """
         return self.idx_storage.content_fossology_license_get_partition(
             self.tool["id"], partition_id, nb_partitions, page_token=page_token
         )
diff --git a/swh/indexer/storage/__init__.py b/swh/indexer/storage/__init__.py
index 9be136c..9c9a21d 100644
--- a/swh/indexer/storage/__init__.py
+++ b/swh/indexer/storage/__init__.py
@@ -1,651 +1,649 @@
 # Copyright (C) 2015-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 
-from collections import Counter, defaultdict
+from collections import Counter
 import itertools
 import json
 from typing import Dict, Iterable, List, Optional, Tuple
 
 import psycopg2
 import psycopg2.pool
 
 from swh.core.db.common import db_transaction, db_transaction_generator
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.model import SHA1_SIZE
 from swh.storage.exc import StorageDBError
 from swh.storage.utils import get_partition_bounds_bytes
 
 from . import converters
 from .db import Db
 from .exc import DuplicateId, IndexerStorageArgumentException
 from .interface import PagedResult, Sha1
 from .metrics import process_metrics, send_metric, timed
 from .model import (
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
     ContentMetadataRow,
     ContentMimetypeRow,
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 
 INDEXER_CFG_KEY = "indexer_storage"
 
 
 MAPPING_NAMES = ["codemeta", "gemspec", "maven", "npm", "pkg-info"]
 
 
 def get_indexer_storage(cls, args):
     """Get an indexer storage object of class `storage_class` with
     arguments `storage_args`.
 
     Args:
         cls (str): storage's class, either 'local' or 'remote'
         args (dict): dictionary of arguments passed to the
             storage class constructor
 
     Returns:
         an instance of swh.indexer's storage (either local or remote)
 
     Raises:
         ValueError if passed an unknown storage class.
 
     """
     if cls == "remote":
         from .api.client import RemoteStorage as IndexerStorage
     elif cls == "local":
         from . import IndexerStorage
     elif cls == "memory":
         from .in_memory import IndexerStorage
     else:
         raise ValueError("Unknown indexer storage class `%s`" % cls)
 
     return IndexerStorage(**args)
 
 
 def check_id_duplicates(data):
     """
     If any two row models in `data` have the same unique key, raises
     a `ValueError`.
 
     Values associated to the key must be hashable.
 
     Args:
         data (List[dict]): List of dictionaries to be inserted
 
     >>> check_id_duplicates([
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=42, lang="python"),
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=32, lang="python"),
     ... ])
     >>> check_id_duplicates([
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=42, lang="python"),
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=42, lang="python"),
     ... ])
     Traceback (most recent call last):
       ...
     swh.indexer.storage.exc.DuplicateId: [{'id': b'foo', 'indexer_configuration_id': 42}]
     """  # noqa
     counter = Counter(tuple(sorted(item.unique_key().items())) for item in data)
     duplicates = [id_ for (id_, count) in counter.items() if count >= 2]
     if duplicates:
         raise DuplicateId(list(map(dict, duplicates)))
 
 
 class IndexerStorage:
     """SWH Indexer Storage
 
     """
 
     def __init__(self, db, min_pool_conns=1, max_pool_conns=10):
         """
         Args:
             db_conn: either a libpq connection string, or a psycopg2 connection
 
         """
         try:
             if isinstance(db, psycopg2.extensions.connection):
                 self._pool = None
                 self._db = Db(db)
             else:
                 self._pool = psycopg2.pool.ThreadedConnectionPool(
                     min_pool_conns, max_pool_conns, db
                 )
                 self._db = None
         except psycopg2.OperationalError as e:
             raise StorageDBError(e)
 
     def get_db(self):
         if self._db:
             return self._db
         return Db.from_pool(self._pool)
 
     def put_db(self, db):
         if db is not self._db:
             db.put_conn()
 
     @timed
     @db_transaction()
     def check_config(self, *, check_write, db=None, cur=None):
         # Check permissions on one of the tables
         if check_write:
             check = "INSERT"
         else:
             check = "SELECT"
 
         cur.execute(
             "select has_table_privilege(current_user, 'content_mimetype', %s)",  # noqa
             (check,),
         )
         return cur.fetchone()[0]
 
     @timed
     @db_transaction_generator()
     def content_mimetype_missing(
         self, mimetypes: Iterable[Dict], db=None, cur=None
     ) -> Iterable[Tuple[Sha1, int]]:
         for obj in db.content_mimetype_missing_from_list(mimetypes, cur):
             yield obj[0]
 
     @timed
     @db_transaction()
     def get_partition(
         self,
         indexer_type: str,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
         with_textual_data=False,
         db=None,
         cur=None,
     ) -> PagedResult[Sha1]:
         """Retrieve ids of content with `indexer_type` within within partition partition_id
         bound by limit.
 
         Args:
             **indexer_type**: Type of data content to index (mimetype, language, etc...)
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
             **with_textual_data** (bool): Deal with only textual content (True) or all
                 content (all contents by defaults, False)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns:
             PagedResult of Sha1. If next_page_token is None, there is no more data to
             fetch
 
         """
         if limit is None:
             raise IndexerStorageArgumentException("limit should not be None")
         if indexer_type not in db.content_indexer_names:
             err = f"Wrong type. Should be one of [{','.join(db.content_indexer_names)}]"
             raise IndexerStorageArgumentException(err)
 
         start, end = get_partition_bounds_bytes(partition_id, nb_partitions, SHA1_SIZE)
         if page_token is not None:
             start = hash_to_bytes(page_token)
         if end is None:
             end = b"\xff" * SHA1_SIZE
 
         next_page_token: Optional[str] = None
         ids = [
             row[0]
             for row in db.content_get_range(
                 indexer_type,
                 start,
                 end,
                 indexer_configuration_id,
                 limit=limit + 1,
                 with_textual_data=with_textual_data,
                 cur=cur,
             )
         ]
 
         if len(ids) >= limit:
             next_page_token = hash_to_hex(ids[-1])
             ids = ids[:limit]
 
         assert len(ids) <= limit
         return PagedResult(results=ids, next_page_token=next_page_token)
 
     @timed
     @db_transaction()
     def content_mimetype_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
         db=None,
         cur=None,
     ) -> PagedResult[Sha1]:
         return self.get_partition(
             "mimetype",
             indexer_configuration_id,
             partition_id,
             nb_partitions,
             page_token=page_token,
             limit=limit,
             db=db,
             cur=cur,
         )
 
     @timed
     @process_metrics
     @db_transaction()
     def content_mimetype_add(
         self,
         mimetypes: List[ContentMimetypeRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(mimetypes)
         mimetypes.sort(key=lambda m: m.id)
         db.mktemp_content_mimetype(cur)
         db.copy_to(
             [m.to_dict() for m in mimetypes],
             "tmp_content_mimetype",
             ["id", "mimetype", "encoding", "indexer_configuration_id"],
             cur,
         )
         count = db.content_mimetype_add_from_temp(conflict_update, cur)
         return {"content_mimetype:add": count}
 
     @timed
     @db_transaction_generator()
     def content_mimetype_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> Iterable[ContentMimetypeRow]:
         for c in db.content_mimetype_get_from_list(ids, cur):
             yield ContentMimetypeRow.from_dict(
                 converters.db_to_mimetype(dict(zip(db.content_mimetype_cols, c)))
             )
 
     @timed
     @db_transaction_generator()
     def content_language_missing(self, languages, db=None, cur=None):
         for obj in db.content_language_missing_from_list(languages, cur):
             yield obj[0]
 
     @timed
     @db_transaction_generator()
     def content_language_get(self, ids, db=None, cur=None):
         for c in db.content_language_get_from_list(ids, cur):
             yield converters.db_to_language(dict(zip(db.content_language_cols, c)))
 
     @timed
     @process_metrics
     @db_transaction()
     def content_language_add(
         self, languages: List[Dict], conflict_update: bool = False, db=None, cur=None
     ) -> Dict[str, int]:
         check_id_duplicates(map(ContentLanguageRow.from_dict, languages))
         languages.sort(key=lambda m: m["id"])
         db.mktemp_content_language(cur)
         # empty language is mapped to 'unknown'
         db.copy_to(
             (
                 {
                     "id": lang["id"],
                     "lang": "unknown" if not lang["lang"] else lang["lang"],
                     "indexer_configuration_id": lang["indexer_configuration_id"],
                 }
                 for lang in languages
             ),
             "tmp_content_language",
             ["id", "lang", "indexer_configuration_id"],
             cur,
         )
 
         count = db.content_language_add_from_temp(conflict_update, cur)
         return {"content_language:add": count}
 
     @timed
     @db_transaction_generator()
     def content_ctags_missing(self, ctags, db=None, cur=None):
         for obj in db.content_ctags_missing_from_list(ctags, cur):
             yield obj[0]
 
     @timed
     @db_transaction_generator()
     def content_ctags_get(self, ids, db=None, cur=None):
         for c in db.content_ctags_get_from_list(ids, cur):
             yield converters.db_to_ctags(dict(zip(db.content_ctags_cols, c)))
 
     @timed
     @process_metrics
     @db_transaction()
     def content_ctags_add(
         self, ctags: List[Dict], conflict_update: bool = False, db=None, cur=None
     ) -> Dict[str, int]:
         rows = list(itertools.chain.from_iterable(map(converters.ctags_to_db, ctags)))
         check_id_duplicates(map(ContentCtagsRow.from_dict, rows))
         ctags.sort(key=lambda m: m["id"])
 
         db.mktemp_content_ctags(cur)
         db.copy_to(
             rows,
             tblname="tmp_content_ctags",
             columns=["id", "name", "kind", "line", "lang", "indexer_configuration_id"],
             cur=cur,
         )
 
         count = db.content_ctags_add_from_temp(conflict_update, cur)
         return {"content_ctags:add": count}
 
     @timed
     @db_transaction_generator()
     def content_ctags_search(
         self, expression, limit=10, last_sha1=None, db=None, cur=None
     ):
         for obj in db.content_ctags_search(expression, last_sha1, limit, cur=cur):
             yield converters.db_to_ctags(dict(zip(db.content_ctags_cols, obj)))
 
     @timed
     @db_transaction_generator()
-    def content_fossology_license_get(self, ids, db=None, cur=None):
-        d = defaultdict(list)
+    def content_fossology_license_get(
+        self, ids: Iterable[Sha1], db=None, cur=None
+    ) -> Iterable[ContentLicenseRow]:
         for c in db.content_fossology_license_get_from_list(ids, cur):
-            license = dict(zip(db.content_fossology_license_cols, c))
-
-            id_ = license["id"]
-            d[id_].append(converters.db_to_fossology_license(license))
-
-        for id_, facts in d.items():
-            yield {id_: facts}
+            yield ContentLicenseRow.from_dict(
+                converters.db_to_fossology_license(
+                    dict(zip(db.content_fossology_license_cols, c))
+                )
+            )
 
     @timed
     @process_metrics
     @db_transaction()
     def content_fossology_license_add(
-        self, licenses: List[Dict], conflict_update: bool = False, db=None, cur=None
+        self,
+        licenses: List[ContentLicenseRow],
+        conflict_update: bool = False,
+        db=None,
+        cur=None,
     ) -> Dict[str, int]:
-        rows = list(
-            itertools.chain.from_iterable(
-                map(converters.fossology_license_to_db, licenses)
-            )
-        )
-        check_id_duplicates(map(ContentLicenseRow.from_dict, rows))
-        licenses.sort(key=lambda m: m["id"])
+        check_id_duplicates(licenses)
+        licenses.sort(key=lambda m: m.id)
         db.mktemp_content_fossology_license(cur)
         db.copy_to(
-            rows,
+            [license.to_dict() for license in licenses],
             tblname="tmp_content_fossology_license",
             columns=["id", "license", "indexer_configuration_id"],
             cur=cur,
         )
         count = db.content_fossology_license_add_from_temp(conflict_update, cur)
         return {"content_fossology_license:add": count}
 
     @timed
     @db_transaction()
     def content_fossology_license_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
         db=None,
         cur=None,
     ) -> PagedResult[Sha1]:
         return self.get_partition(
             "fossology_license",
             indexer_configuration_id,
             partition_id,
             nb_partitions,
             page_token=page_token,
             limit=limit,
             with_textual_data=True,
             db=db,
             cur=cur,
         )
 
     @timed
     @db_transaction_generator()
     def content_metadata_missing(self, metadata, db=None, cur=None):
         for obj in db.content_metadata_missing_from_list(metadata, cur):
             yield obj[0]
 
     @timed
     @db_transaction_generator()
     def content_metadata_get(self, ids, db=None, cur=None):
         for c in db.content_metadata_get_from_list(ids, cur):
             yield converters.db_to_metadata(dict(zip(db.content_metadata_cols, c)))
 
     @timed
     @process_metrics
     @db_transaction()
     def content_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False, db=None, cur=None
     ) -> Dict[str, int]:
         check_id_duplicates(map(ContentMetadataRow.from_dict, metadata))
         metadata.sort(key=lambda m: m["id"])
 
         db.mktemp_content_metadata(cur)
 
         db.copy_to(
             metadata,
             "tmp_content_metadata",
             ["id", "metadata", "indexer_configuration_id"],
             cur,
         )
         count = db.content_metadata_add_from_temp(conflict_update, cur)
         return {
             "content_metadata:add": count,
         }
 
     @timed
     @db_transaction_generator()
     def revision_intrinsic_metadata_missing(self, metadata, db=None, cur=None):
         for obj in db.revision_intrinsic_metadata_missing_from_list(metadata, cur):
             yield obj[0]
 
     @timed
     @db_transaction_generator()
     def revision_intrinsic_metadata_get(self, ids, db=None, cur=None):
         for c in db.revision_intrinsic_metadata_get_from_list(ids, cur):
             yield converters.db_to_metadata(
                 dict(zip(db.revision_intrinsic_metadata_cols, c))
             )
 
     @timed
     @process_metrics
     @db_transaction()
     def revision_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False, db=None, cur=None
     ) -> Dict[str, int]:
         check_id_duplicates(map(RevisionIntrinsicMetadataRow.from_dict, metadata))
         metadata.sort(key=lambda m: m["id"])
 
         db.mktemp_revision_intrinsic_metadata(cur)
 
         db.copy_to(
             metadata,
             "tmp_revision_intrinsic_metadata",
             ["id", "metadata", "mappings", "indexer_configuration_id"],
             cur,
         )
         count = db.revision_intrinsic_metadata_add_from_temp(conflict_update, cur)
         return {
             "revision_intrinsic_metadata:add": count,
         }
 
     @timed
     @process_metrics
     @db_transaction()
     def revision_intrinsic_metadata_delete(
         self, entries: List[Dict], db=None, cur=None
     ) -> Dict:
         count = db.revision_intrinsic_metadata_delete(entries, cur)
         return {"revision_intrinsic_metadata:del": count}
 
     @timed
     @db_transaction_generator()
     def origin_intrinsic_metadata_get(self, ids, db=None, cur=None):
         for c in db.origin_intrinsic_metadata_get_from_list(ids, cur):
             yield converters.db_to_metadata(
                 dict(zip(db.origin_intrinsic_metadata_cols, c))
             )
 
     @timed
     @process_metrics
     @db_transaction()
     def origin_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False, db=None, cur=None
     ) -> Dict[str, int]:
         check_id_duplicates(map(OriginIntrinsicMetadataRow.from_dict, metadata))
         metadata.sort(key=lambda m: m["id"])
 
         db.mktemp_origin_intrinsic_metadata(cur)
 
         db.copy_to(
             metadata,
             "tmp_origin_intrinsic_metadata",
             ["id", "metadata", "indexer_configuration_id", "from_revision", "mappings"],
             cur,
         )
         count = db.origin_intrinsic_metadata_add_from_temp(conflict_update, cur)
         return {
             "origin_intrinsic_metadata:add": count,
         }
 
     @timed
     @process_metrics
     @db_transaction()
     def origin_intrinsic_metadata_delete(
         self, entries: List[Dict], db=None, cur=None
     ) -> Dict:
         count = db.origin_intrinsic_metadata_delete(entries, cur)
         return {
             "origin_intrinsic_metadata:del": count,
         }
 
     @timed
     @db_transaction_generator()
     def origin_intrinsic_metadata_search_fulltext(
         self, conjunction, limit=100, db=None, cur=None
     ):
         for c in db.origin_intrinsic_metadata_search_fulltext(
             conjunction, limit=limit, cur=cur
         ):
             yield converters.db_to_metadata(
                 dict(zip(db.origin_intrinsic_metadata_cols, c))
             )
 
     @timed
     @db_transaction()
     def origin_intrinsic_metadata_search_by_producer(
         self,
         page_token="",
         limit=100,
         ids_only=False,
         mappings=None,
         tool_ids=None,
         db=None,
         cur=None,
     ):
         assert isinstance(page_token, str)
         # we go to limit+1 to check whether we should add next_page_token in
         # the response
         res = db.origin_intrinsic_metadata_search_by_producer(
             page_token, limit + 1, ids_only, mappings, tool_ids, cur
         )
         result = {}
         if ids_only:
             result["origins"] = [origin for (origin,) in res]
             if len(result["origins"]) > limit:
                 result["origins"][limit:] = []
                 result["next_page_token"] = result["origins"][-1]
         else:
             result["origins"] = [
                 converters.db_to_metadata(
                     dict(zip(db.origin_intrinsic_metadata_cols, c))
                 )
                 for c in res
             ]
             if len(result["origins"]) > limit:
                 result["origins"][limit:] = []
                 result["next_page_token"] = result["origins"][-1]["id"]
         return result
 
     @timed
     @db_transaction()
     def origin_intrinsic_metadata_stats(self, db=None, cur=None):
         mapping_names = [m for m in MAPPING_NAMES]
         select_parts = []
 
         # Count rows for each mapping
         for mapping_name in mapping_names:
             select_parts.append(
                 (
                     "sum(case when (mappings @> ARRAY['%s']) "
                     "         then 1 else 0 end)"
                 )
                 % mapping_name
             )
 
         # Total
         select_parts.append("sum(1)")
 
         # Rows whose metadata has at least one key that is not '@context'
         select_parts.append(
             "sum(case when ('{}'::jsonb @> (metadata - '@context')) "
             "         then 0 else 1 end)"
         )
         cur.execute(
             "select " + ", ".join(select_parts) + " from origin_intrinsic_metadata"
         )
         results = dict(zip(mapping_names + ["total", "non_empty"], cur.fetchone()))
         return {
             "total": results.pop("total"),
             "non_empty": results.pop("non_empty"),
             "per_mapping": results,
         }
 
     @timed
     @db_transaction_generator()
     def indexer_configuration_add(self, tools, db=None, cur=None):
         db.mktemp_indexer_configuration(cur)
         db.copy_to(
             tools,
             "tmp_indexer_configuration",
             ["tool_name", "tool_version", "tool_configuration"],
             cur,
         )
 
         tools = db.indexer_configuration_add_from_temp(cur)
         count = 0
         for line in tools:
             yield dict(zip(db.indexer_configuration_cols, line))
             count += 1
         send_metric(
             "indexer_configuration:add", count, method_name="indexer_configuration_add"
         )
 
     @timed
     @db_transaction()
     def indexer_configuration_get(self, tool, db=None, cur=None):
         tool_conf = tool["tool_configuration"]
         if isinstance(tool_conf, dict):
             tool_conf = json.dumps(tool_conf)
         idx = db.indexer_configuration_get(
             tool["tool_name"], tool["tool_version"], tool_conf
         )
         if not idx:
             return None
         return dict(zip(db.indexer_configuration_cols, idx))
diff --git a/swh/indexer/storage/converters.py b/swh/indexer/storage/converters.py
index 354db52..7141664 100644
--- a/swh/indexer/storage/converters.py
+++ b/swh/indexer/storage/converters.py
@@ -1,152 +1,141 @@
 # Copyright (C) 2015-2017  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
 
 
 def ctags_to_db(ctags):
     """Convert a ctags entry into a ready ctags entry.
 
     Args:
         ctags (dict): ctags entry with the following keys:
 
             - id (bytes): content's identifier
             - tool_id (int): tool id used to compute ctags
             - ctags ([dict]): List of dictionary with the following keys:
 
               - name (str): symbol's name
               - kind (str): symbol's kind
               - line (int): symbol's line in the content
               - language (str): language
 
     Returns:
         list: list of ctags entries as dicts with the following keys:
 
         - id (bytes): content's identifier
         - name (str): symbol's name
         - kind (str): symbol's kind
         - language (str): language for that content
         - tool_id (int): tool id used to compute ctags
 
     """
     id = ctags["id"]
     tool_id = ctags["indexer_configuration_id"]
     for ctag in ctags["ctags"]:
         yield {
             "id": id,
             "name": ctag["name"],
             "kind": ctag["kind"],
             "line": ctag["line"],
             "lang": ctag["lang"],
             "indexer_configuration_id": tool_id,
         }
 
 
-def fossology_license_to_db(licenses):
-    """Similar to ctags_to_db, but for licenses."""
-    id = licenses["id"]
-    tool_id = licenses["indexer_configuration_id"]
-    for license in licenses["licenses"]:
-        yield {
-            "id": id,
-            "indexer_configuration_id": tool_id,
-            "license": license,
-        }
-
-
 def db_to_ctags(ctag):
     """Convert a ctags entry into a ready ctags entry.
 
     Args:
         ctags (dict): ctags entry with the following keys:
 
           - id (bytes): content's identifier
           - ctags ([dict]): List of dictionary with the following keys:
             - name (str): symbol's name
             - kind (str): symbol's kind
             - line (int): symbol's line in the content
             - language (str): language
 
     Returns:
         list: list of ctags ready entry (dict with the following keys):
 
         - id (bytes): content's identifier
         - name (str): symbol's name
         - kind (str): symbol's kind
         - language (str): language for that content
         - tool (dict): tool used to compute the ctags
 
     """
     return {
         "id": ctag["id"],
         "name": ctag["name"],
         "kind": ctag["kind"],
         "line": ctag["line"],
         "lang": ctag["lang"],
         "tool": {
             "id": ctag["tool_id"],
             "name": ctag["tool_name"],
             "version": ctag["tool_version"],
             "configuration": ctag["tool_configuration"],
         },
     }
 
 
 def db_to_mimetype(mimetype):
     """Convert a ctags entry into a ready ctags output.
 
     """
     return {
         "id": mimetype["id"],
         "encoding": mimetype["encoding"],
         "mimetype": mimetype["mimetype"],
         "tool": {
             "id": mimetype["tool_id"],
             "name": mimetype["tool_name"],
             "version": mimetype["tool_version"],
             "configuration": mimetype["tool_configuration"],
         },
     }
 
 
 def db_to_language(language):
     """Convert a language entry into a ready language output.
 
     """
     return {
         "id": language["id"],
         "lang": language["lang"],
         "tool": {
             "id": language["tool_id"],
             "name": language["tool_name"],
             "version": language["tool_version"],
             "configuration": language["tool_configuration"],
         },
     }
 
 
 def db_to_metadata(metadata):
     """Convert a metadata entry into a ready metadata output.
 
     """
     metadata["tool"] = {
         "id": metadata["tool_id"],
         "name": metadata["tool_name"],
         "version": metadata["tool_version"],
         "configuration": metadata["tool_configuration"],
     }
     del metadata["tool_id"], metadata["tool_configuration"]
     del metadata["tool_version"], metadata["tool_name"]
     return metadata
 
 
 def db_to_fossology_license(license):
     return {
-        "licenses": license["licenses"],
+        "id": license["id"],
+        "license": license["license"],
         "tool": {
             "id": license["tool_id"],
             "name": license["tool_name"],
             "version": license["tool_version"],
             "configuration": license["tool_configuration"],
         },
     }
diff --git a/swh/indexer/storage/db.py b/swh/indexer/storage/db.py
index e6c3f13..c5ea770 100644
--- a/swh/indexer/storage/db.py
+++ b/swh/indexer/storage/db.py
@@ -1,566 +1,566 @@
 # Copyright (C) 2015-2018  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from typing import Dict, Iterable, Iterator, List
 
 from swh.core.db import BaseDb
 from swh.core.db.db_utils import execute_values_generator, stored_procedure
 from swh.model import hashutil
 
 from .interface import Sha1
 
 
 class Db(BaseDb):
     """Proxy to the SWH Indexer DB, with wrappers around stored procedures
 
     """
 
     content_mimetype_hash_keys = ["id", "indexer_configuration_id"]
 
     def _missing_from_list(
         self, table: str, data: Iterable[Dict], hash_keys: List[str], cur=None
     ):
         """Read from table the data with hash_keys that are missing.
 
         Args:
             table: Table name (e.g content_mimetype, content_language,
               etc...)
             data: Dict of data to read from
             hash_keys: List of keys to read in the data dict.
 
         Yields:
             The data which is missing from the db.
 
         """
         cur = self._cursor(cur)
         keys = ", ".join(hash_keys)
         equality = " AND ".join(("t.%s = c.%s" % (key, key)) for key in hash_keys)
         yield from execute_values_generator(
             cur,
             """
             select %s from (values %%s) as t(%s)
             where not exists (
                 select 1 from %s c
                 where %s
             )
             """
             % (keys, keys, table, equality),
             (tuple(m[k] for k in hash_keys) for m in data),
         )
 
     def content_mimetype_missing_from_list(
         self, mimetypes: Iterable[Dict], cur=None
     ) -> Iterator[Sha1]:
         """List missing mimetypes.
 
         """
         yield from self._missing_from_list(
             "content_mimetype", mimetypes, self.content_mimetype_hash_keys, cur=cur
         )
 
     content_mimetype_cols = [
         "id",
         "mimetype",
         "encoding",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_content_mimetype")
     def mktemp_content_mimetype(self, cur=None):
         pass
 
     def content_mimetype_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute("select * from swh_content_mimetype_add(%s)", (conflict_update,))
         return cur.fetchone()[0]
 
     def _convert_key(self, key, main_table="c"):
         """Convert keys according to specific use in the module.
 
         Args:
             key (str): Key expression to change according to the alias
               used in the query
             main_table (str): Alias to use for the main table. Default
               to c for content_{something}.
 
         Expected:
             Tables content_{something} being aliased as 'c' (something
             in {language, mimetype, ...}), table indexer_configuration
             being aliased as 'i'.
 
         """
         if key == "id":
             return "%s.id" % main_table
         elif key == "tool_id":
             return "i.id as tool_id"
-        elif key == "licenses":
+        elif key == "license":
             return (
                 """
-                array(select name
-                      from fossology_license
-                      where id = ANY(
-                         array_agg(%s.license_id))) as licenses"""
+                (
+                    select name
+                    from fossology_license
+                    where id = %s.license_id
+                )
+                as licenses"""
                 % main_table
             )
         return key
 
     def _get_from_list(self, table, ids, cols, cur=None, id_col="id"):
         """Fetches entries from the `table` such that their `id` field
         (or whatever is given to `id_col`) is in `ids`.
         Returns the columns `cols`.
         The `cur` parameter is used to connect to the database.
         """
         cur = self._cursor(cur)
         keys = map(self._convert_key, cols)
         query = """
             select {keys}
             from (values %s) as t(id)
             inner join {table} c
                 on c.{id_col}=t.id
             inner join indexer_configuration i
                 on c.indexer_configuration_id=i.id;
             """.format(
             keys=", ".join(keys), id_col=id_col, table=table
         )
         yield from execute_values_generator(cur, query, ((_id,) for _id in ids))
 
     content_indexer_names = {
         "mimetype": "content_mimetype",
         "fossology_license": "content_fossology_license",
     }
 
     def content_get_range(
         self,
         content_type,
         start,
         end,
         indexer_configuration_id,
         limit=1000,
         with_textual_data=False,
         cur=None,
     ):
         """Retrieve contents with content_type, within range [start, end]
            bound by limit and associated to the given indexer
            configuration id.
 
            When asking to work on textual content, that filters on the
            mimetype table with any mimetype that is not binary.
 
         """
         cur = self._cursor(cur)
         table = self.content_indexer_names[content_type]
         if with_textual_data:
             extra = """inner join content_mimetype cm
                          on (t.id=cm.id and cm.mimetype like 'text/%%' and
                              %(start)s <= cm.id and cm.id <= %(end)s)
                     """
         else:
             extra = ""
         query = f"""select t.id
                     from {table} t
                     {extra}
                     where t.indexer_configuration_id=%(tool_id)s
                           and %(start)s <= t.id and t.id <= %(end)s
                     order by t.indexer_configuration_id, t.id
                     limit %(limit)s"""
         cur.execute(
             query,
             {
                 "start": start,
                 "end": end,
                 "tool_id": indexer_configuration_id,
                 "limit": limit,
             },
         )
         yield from cur
 
     def content_mimetype_get_from_list(self, ids, cur=None):
         yield from self._get_from_list(
             "content_mimetype", ids, self.content_mimetype_cols, cur=cur
         )
 
     content_language_hash_keys = ["id", "indexer_configuration_id"]
 
     def content_language_missing_from_list(self, languages, cur=None):
         """List missing languages.
 
         """
         yield from self._missing_from_list(
             "content_language", languages, self.content_language_hash_keys, cur=cur
         )
 
     content_language_cols = [
         "id",
         "lang",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_content_language")
     def mktemp_content_language(self, cur=None):
         pass
 
     def content_language_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute("select * from swh_content_language_add(%s)", (conflict_update,))
         return cur.fetchone()[0]
 
     def content_language_get_from_list(self, ids, cur=None):
         yield from self._get_from_list(
             "content_language", ids, self.content_language_cols, cur=cur
         )
 
     content_ctags_hash_keys = ["id", "indexer_configuration_id"]
 
     def content_ctags_missing_from_list(self, ctags, cur=None):
         """List missing ctags.
 
         """
         yield from self._missing_from_list(
             "content_ctags", ctags, self.content_ctags_hash_keys, cur=cur
         )
 
     content_ctags_cols = [
         "id",
         "name",
         "kind",
         "line",
         "lang",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_content_ctags")
     def mktemp_content_ctags(self, cur=None):
         pass
 
     def content_ctags_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute("select * from swh_content_ctags_add(%s)", (conflict_update,))
         return cur.fetchone()[0]
 
     def content_ctags_get_from_list(self, ids, cur=None):
         cur = self._cursor(cur)
         keys = map(self._convert_key, self.content_ctags_cols)
         yield from execute_values_generator(
             cur,
             """
             select %s
             from (values %%s) as t(id)
             inner join content_ctags c
                 on c.id=t.id
             inner join indexer_configuration i
                 on c.indexer_configuration_id=i.id
             order by line
             """
             % ", ".join(keys),
             ((_id,) for _id in ids),
         )
 
     def content_ctags_search(self, expression, last_sha1, limit, cur=None):
         cur = self._cursor(cur)
         if not last_sha1:
             query = """SELECT %s
                        FROM swh_content_ctags_search(%%s, %%s)""" % (
                 ",".join(self.content_ctags_cols)
             )
             cur.execute(query, (expression, limit))
         else:
             if last_sha1 and isinstance(last_sha1, bytes):
                 last_sha1 = "\\x%s" % hashutil.hash_to_hex(last_sha1)
             elif last_sha1:
                 last_sha1 = "\\x%s" % last_sha1
 
             query = """SELECT %s
                        FROM swh_content_ctags_search(%%s, %%s, %%s)""" % (
                 ",".join(self.content_ctags_cols)
             )
             cur.execute(query, (expression, limit, last_sha1))
 
         yield from cur
 
     content_fossology_license_cols = [
         "id",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
-        "licenses",
+        "license",
     ]
 
     @stored_procedure("swh_mktemp_content_fossology_license")
     def mktemp_content_fossology_license(self, cur=None):
         pass
 
     def content_fossology_license_add_from_temp(self, conflict_update, cur=None):
         """Add new licenses per content.
 
         """
         cur = self._cursor(cur)
         cur.execute(
             "select * from swh_content_fossology_license_add(%s)", (conflict_update,)
         )
         return cur.fetchone()[0]
 
     def content_fossology_license_get_from_list(self, ids, cur=None):
         """Retrieve licenses per id.
 
         """
         cur = self._cursor(cur)
         keys = map(self._convert_key, self.content_fossology_license_cols)
         yield from execute_values_generator(
             cur,
             """
             select %s
             from (values %%s) as t(id)
             inner join content_fossology_license c on t.id=c.id
             inner join indexer_configuration i
                 on i.id=c.indexer_configuration_id
-            group by c.id, i.id, i.tool_name, i.tool_version,
-                     i.tool_configuration;
             """
             % ", ".join(keys),
             ((_id,) for _id in ids),
         )
 
     content_metadata_hash_keys = ["id", "indexer_configuration_id"]
 
     def content_metadata_missing_from_list(self, metadata, cur=None):
         """List missing metadata.
 
         """
         yield from self._missing_from_list(
             "content_metadata", metadata, self.content_metadata_hash_keys, cur=cur
         )
 
     content_metadata_cols = [
         "id",
         "metadata",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_content_metadata")
     def mktemp_content_metadata(self, cur=None):
         pass
 
     def content_metadata_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute("select * from swh_content_metadata_add(%s)", (conflict_update,))
         return cur.fetchone()[0]
 
     def content_metadata_get_from_list(self, ids, cur=None):
         yield from self._get_from_list(
             "content_metadata", ids, self.content_metadata_cols, cur=cur
         )
 
     revision_intrinsic_metadata_hash_keys = ["id", "indexer_configuration_id"]
 
     def revision_intrinsic_metadata_missing_from_list(self, metadata, cur=None):
         """List missing metadata.
 
         """
         yield from self._missing_from_list(
             "revision_intrinsic_metadata",
             metadata,
             self.revision_intrinsic_metadata_hash_keys,
             cur=cur,
         )
 
     revision_intrinsic_metadata_cols = [
         "id",
         "metadata",
         "mappings",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_revision_intrinsic_metadata")
     def mktemp_revision_intrinsic_metadata(self, cur=None):
         pass
 
     def revision_intrinsic_metadata_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute(
             "select * from swh_revision_intrinsic_metadata_add(%s)", (conflict_update,)
         )
         return cur.fetchone()[0]
 
     def revision_intrinsic_metadata_delete(self, entries, cur=None):
         cur = self._cursor(cur)
         cur.execute(
             "DELETE from revision_intrinsic_metadata "
             "WHERE (id, indexer_configuration_id) IN "
             "   (VALUES %s) "
             "RETURNING id" % (", ".join("%s" for _ in entries)),
             tuple((e["id"], e["indexer_configuration_id"]) for e in entries),
         )
         return len(cur.fetchall())
 
     def revision_intrinsic_metadata_get_from_list(self, ids, cur=None):
         yield from self._get_from_list(
             "revision_intrinsic_metadata",
             ids,
             self.revision_intrinsic_metadata_cols,
             cur=cur,
         )
 
     origin_intrinsic_metadata_cols = [
         "id",
         "metadata",
         "from_revision",
         "mappings",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     origin_intrinsic_metadata_regconfig = "pg_catalog.simple"
     """The dictionary used to normalize 'metadata' and queries.
     'pg_catalog.simple' provides no stopword, so it should be suitable
     for proper names and non-English content.
     When updating this value, make sure to add a new index on
     origin_intrinsic_metadata.metadata."""
 
     @stored_procedure("swh_mktemp_origin_intrinsic_metadata")
     def mktemp_origin_intrinsic_metadata(self, cur=None):
         pass
 
     def origin_intrinsic_metadata_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute(
             "select * from swh_origin_intrinsic_metadata_add(%s)", (conflict_update,)
         )
         return cur.fetchone()[0]
 
     def origin_intrinsic_metadata_delete(self, entries, cur=None):
         cur = self._cursor(cur)
         cur.execute(
             "DELETE from origin_intrinsic_metadata "
             "WHERE (id, indexer_configuration_id) IN"
             "   (VALUES %s) "
             "RETURNING id" % (", ".join("%s" for _ in entries)),
             tuple((e["id"], e["indexer_configuration_id"]) for e in entries),
         )
         return len(cur.fetchall())
 
     def origin_intrinsic_metadata_get_from_list(self, ids, cur=None):
         yield from self._get_from_list(
             "origin_intrinsic_metadata",
             ids,
             self.origin_intrinsic_metadata_cols,
             cur=cur,
             id_col="id",
         )
 
     def origin_intrinsic_metadata_search_fulltext(self, terms, *, limit, cur):
         regconfig = self.origin_intrinsic_metadata_regconfig
         tsquery_template = " && ".join(
             "plainto_tsquery('%s', %%s)" % regconfig for _ in terms
         )
         tsquery_args = [(term,) for term in terms]
         keys = (
             self._convert_key(col, "oim") for col in self.origin_intrinsic_metadata_cols
         )
 
         query = (
             "SELECT {keys} FROM origin_intrinsic_metadata AS oim "
             "INNER JOIN indexer_configuration AS i "
             "ON oim.indexer_configuration_id=i.id "
             "JOIN LATERAL (SELECT {tsquery_template}) AS s(tsq) ON true "
             "WHERE oim.metadata_tsvector @@ tsq "
             "ORDER BY ts_rank(oim.metadata_tsvector, tsq, 1) DESC "
             "LIMIT %s;"
         ).format(keys=", ".join(keys), tsquery_template=tsquery_template)
         cur.execute(query, tsquery_args + [limit])
         yield from cur
 
     def origin_intrinsic_metadata_search_by_producer(
         self, last, limit, ids_only, mappings, tool_ids, cur
     ):
         if ids_only:
             keys = "oim.id"
         else:
             keys = ", ".join(
                 (
                     self._convert_key(col, "oim")
                     for col in self.origin_intrinsic_metadata_cols
                 )
             )
         query_parts = [
             "SELECT %s" % keys,
             "FROM origin_intrinsic_metadata AS oim",
             "INNER JOIN indexer_configuration AS i",
             "ON oim.indexer_configuration_id=i.id",
         ]
         args = []
 
         where = []
         if last:
             where.append("oim.id > %s")
             args.append(last)
         if mappings is not None:
             where.append("oim.mappings && %s")
             args.append(mappings)
         if tool_ids is not None:
             where.append("oim.indexer_configuration_id = ANY(%s)")
             args.append(tool_ids)
         if where:
             query_parts.append("WHERE")
             query_parts.append(" AND ".join(where))
 
         if limit:
             query_parts.append("LIMIT %s")
             args.append(limit)
 
         cur.execute(" ".join(query_parts), args)
         yield from cur
 
     indexer_configuration_cols = [
         "id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_indexer_configuration")
     def mktemp_indexer_configuration(self, cur=None):
         pass
 
     def indexer_configuration_add_from_temp(self, cur=None):
         cur = self._cursor(cur)
         cur.execute(
             "SELECT %s from swh_indexer_configuration_add()"
             % (",".join(self.indexer_configuration_cols),)
         )
         yield from cur
 
     def indexer_configuration_get(
         self, tool_name, tool_version, tool_configuration, cur=None
     ):
         cur = self._cursor(cur)
         cur.execute(
             """select %s
                        from indexer_configuration
                        where tool_name=%%s and
                              tool_version=%%s and
                              tool_configuration=%%s"""
             % (",".join(self.indexer_configuration_cols)),
             (tool_name, tool_version, tool_configuration),
         )
 
         return cur.fetchone()
diff --git a/swh/indexer/storage/in_memory.py b/swh/indexer/storage/in_memory.py
index 29dbdf9..6b81038 100644
--- a/swh/indexer/storage/in_memory.py
+++ b/swh/indexer/storage/in_memory.py
@@ -1,539 +1,518 @@
 # Copyright (C) 2018-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from collections import Counter, defaultdict
 import itertools
 import json
 import math
 import operator
 import re
 from typing import (
     Any,
     Dict,
     Generic,
     Iterable,
     Iterator,
     List,
     Optional,
     Set,
     Tuple,
     Type,
     TypeVar,
 )
 
 from swh.core.collections import SortedList
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.model import SHA1_SIZE, Sha1Git
 from swh.storage.utils import get_partition_bounds_bytes
 
 from . import MAPPING_NAMES, check_id_duplicates, converters
 from .exc import IndexerStorageArgumentException
 from .interface import PagedResult, Sha1
 from .model import (
     BaseRow,
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
     ContentMetadataRow,
     ContentMimetypeRow,
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 
 SHA1_DIGEST_SIZE = 160
 
 
 def _transform_tool(tool):
     return {
         "id": tool["id"],
         "name": tool["tool_name"],
         "version": tool["tool_version"],
         "configuration": tool["tool_configuration"],
     }
 
 
 def check_id_types(data: List[Dict[str, Any]]):
     """Checks all elements of the list have an 'id' whose type is 'bytes'."""
     if not all(isinstance(item.get("id"), bytes) for item in data):
         raise IndexerStorageArgumentException("identifiers must be bytes.")
 
 
 def _key_from_dict(d):
     return tuple(sorted(d.items()))
 
 
 ToolId = int
 TValue = TypeVar("TValue", bound=BaseRow)
 
 
 class SubStorage(Generic[TValue]):
     """Implements common missing/get/add logic for each indexer type."""
 
     _data: Dict[Sha1, Dict[Tuple, Dict[str, Any]]]
     _tools_per_id: Dict[Sha1, Set[ToolId]]
 
     def __init__(self, row_class: Type[TValue], tools):
         self.row_class = row_class
         self._tools = tools
         self._sorted_ids = SortedList[bytes, Sha1]()
         self._data = defaultdict(dict)
         self._tools_per_id = defaultdict(set)
 
     def _key_from_dict(self, d) -> Tuple:
         """Like the global _key_from_dict, but filters out dict keys that don't
         belong in the unique key."""
         return _key_from_dict({k: d[k] for k in self.row_class.UNIQUE_KEY_FIELDS})
 
     def missing(self, keys: Iterable[Dict]) -> Iterator[Sha1]:
         """List data missing from storage.
 
         Args:
             data (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Yields:
             missing sha1s
 
         """
         for key in keys:
             tool_id = key["indexer_configuration_id"]
             id_ = key["id"]
             if tool_id not in self._tools_per_id.get(id_, set()):
                 yield id_
 
     def get(self, ids: Iterable[Sha1]) -> Iterator[TValue]:
         """Retrieve data per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Yields:
             dict: dictionaries with the following keys:
 
               - **id** (bytes)
               - **tool** (dict): tool used to compute metadata
               - arbitrary data (as provided to `add`)
 
         """
         for id_ in ids:
             for entry in self._data[id_].values():
                 entry = entry.copy()
                 tool_id = entry.pop("indexer_configuration_id")
                 yield self.row_class(
                     id=id_, tool=_transform_tool(self._tools[tool_id]), **entry,
                 )
 
     def get_all(self) -> Iterator[TValue]:
         yield from self.get(self._sorted_ids)
 
     def get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         """Retrieve ids of content with `indexer_type` within partition partition_id
         bound by limit.
 
         Args:
             **indexer_type**: Type of data content to index (mimetype, language, etc...)
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
             **with_textual_data** (bool): Deal with only textual content (True) or all
                 content (all contents by defaults, False)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns:
             PagedResult of Sha1. If next_page_token is None, there is no more data to
             fetch
 
         """
         if limit is None:
             raise IndexerStorageArgumentException("limit should not be None")
         (start, end) = get_partition_bounds_bytes(
             partition_id, nb_partitions, SHA1_SIZE
         )
 
         if page_token:
             start = hash_to_bytes(page_token)
         if end is None:
             end = b"\xff" * SHA1_SIZE
 
         next_page_token: Optional[str] = None
         ids: List[Sha1] = []
         sha1s = (sha1 for sha1 in self._sorted_ids.iter_from(start))
         for counter, sha1 in enumerate(sha1s):
             if sha1 > end:
                 break
             if counter >= limit:
                 next_page_token = hash_to_hex(sha1)
                 break
             ids.append(sha1)
 
         assert len(ids) <= limit
         return PagedResult(results=ids, next_page_token=next_page_token)
 
     def add(self, data: Iterable[TValue], conflict_update: bool) -> int:
         """Add data not present in storage.
 
         Args:
             data (iterable): dictionaries with keys:
 
               - **id**: sha1
               - **indexer_configuration_id**: tool used to compute the
                 results
               - arbitrary data
 
             conflict_update (bool): Flag to determine if we want to overwrite
               (true) or skip duplicates (false)
 
         """
         data = list(data)
         check_id_duplicates(data)
         count = 0
         for obj in data:
             item = obj.to_dict()
             id_ = item.pop("id")
             tool_id = item["indexer_configuration_id"]
             key = _key_from_dict(obj.unique_key())
             if not conflict_update and key in self._data[id_]:
                 # Duplicate, should not be updated
                 continue
             self._data[id_][key] = item
             self._tools_per_id[id_].add(tool_id)
             count += 1
             if id_ not in self._sorted_ids:
                 self._sorted_ids.add(id_)
         return count
 
     def delete(self, entries: List[Dict]) -> int:
         """Delete entries and return the number of entries deleted.
 
         """
         deleted = 0
         for entry in entries:
             (id_, tool_id) = (entry["id"], entry["indexer_configuration_id"])
             if tool_id in self._tools_per_id[id_]:
                 self._tools_per_id[id_].remove(tool_id)
             if id_ in self._data:
                 key = self._key_from_dict(entry)
                 if key in self._data[id_]:
                     deleted += 1
                     del self._data[id_][key]
         return deleted
 
 
 class IndexerStorage:
     """In-memory SWH indexer storage."""
 
     def __init__(self):
         self._tools = {}
         self._mimetypes = SubStorage(ContentMimetypeRow, self._tools)
         self._languages = SubStorage(ContentLanguageRow, self._tools)
         self._content_ctags = SubStorage(ContentCtagsRow, self._tools)
         self._licenses = SubStorage(ContentLicenseRow, self._tools)
         self._content_metadata = SubStorage(ContentMetadataRow, self._tools)
         self._revision_intrinsic_metadata = SubStorage(
             RevisionIntrinsicMetadataRow, self._tools
         )
         self._origin_intrinsic_metadata = SubStorage(
             OriginIntrinsicMetadataRow, self._tools
         )
 
     def check_config(self, *, check_write):
         return True
 
     def content_mimetype_missing(
         self, mimetypes: Iterable[Dict]
     ) -> Iterable[Tuple[Sha1, int]]:
         yield from self._mimetypes.missing(mimetypes)
 
     def content_mimetype_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         return self._mimetypes.get_partition(
             indexer_configuration_id, partition_id, nb_partitions, page_token, limit
         )
 
     def content_mimetype_add(
         self, mimetypes: List[ContentMimetypeRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._mimetypes.add(mimetypes, conflict_update)
         return {"content_mimetype:add": added}
 
     def content_mimetype_get(self, ids: Iterable[Sha1]) -> Iterable[ContentMimetypeRow]:
         yield from self._mimetypes.get(ids)
 
     def content_language_missing(self, languages):
         yield from self._languages.missing(languages)
 
     def content_language_get(self, ids):
         yield from (obj.to_dict() for obj in self._languages.get(ids))
 
     def content_language_add(
         self, languages: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         check_id_types(languages)
         added = self._languages.add(
             map(ContentLanguageRow.from_dict, languages), conflict_update
         )
         return {"content_language:add": added}
 
     def content_ctags_missing(self, ctags):
         yield from self._content_ctags.missing(ctags)
 
     def content_ctags_get(self, ids):
         for item in self._content_ctags.get(ids):
             yield {"id": item.id, "tool": item.tool, **item.to_dict()}
 
     def content_ctags_add(
         self, ctags: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         check_id_types(ctags)
         added = self._content_ctags.add(
             map(
                 ContentCtagsRow.from_dict,
                 itertools.chain.from_iterable(map(converters.ctags_to_db, ctags)),
             ),
             conflict_update,
         )
         return {"content_ctags:add": added}
 
     def content_ctags_search(self, expression, limit=10, last_sha1=None):
         nb_matches = 0
         items_per_id: Dict[Tuple[Sha1Git, ToolId], List[ContentCtagsRow]] = {}
         for item in sorted(self._content_ctags.get_all()):
             if item.id <= (last_sha1 or bytes(0 for _ in range(SHA1_DIGEST_SIZE))):
                 continue
             items_per_id.setdefault(
                 (item.id, item.indexer_configuration_id), []
             ).append(item)
 
         for items in items_per_id.values():
             ctags = []
             for item in items:
                 if item.name != expression:
                     continue
                 nb_matches += 1
                 if nb_matches > limit:
                     break
                 item_dict = item.to_dict()
                 id_ = item_dict.pop("id")
                 tool = item_dict.pop("tool")
                 ctags.append(item_dict)
 
             if ctags:
                 for ctag in ctags:
                     yield {"id": id_, "tool": tool, **ctag}
 
-    def content_fossology_license_get(self, ids):
-        # Rewrites the output of SubStorage.get from the old format to
-        # the new one. SubStorage.get should be updated once all other
-        # *_get methods use the new format.
-        # See: https://forge.softwareheritage.org/T1433
-        for id_ in ids:
-            items = {}
-            for obj in self._licenses.get([id_]):
-                items.setdefault(obj.tool["id"], (obj.tool, []))[1].append(obj.license)
-            if items:
-                yield {
-                    id_: [
-                        {"tool": tool, "licenses": licenses}
-                        for (tool, licenses) in items.values()
-                    ]
-                }
+    def content_fossology_license_get(
+        self, ids: Iterable[Sha1]
+    ) -> Iterable[ContentLicenseRow]:
+        return self._licenses.get(ids)
 
     def content_fossology_license_add(
-        self, licenses: List[Dict], conflict_update: bool = False
+        self, licenses: List[ContentLicenseRow], conflict_update: bool = False
     ) -> Dict[str, int]:
-        check_id_types(licenses)
-        added = self._licenses.add(
-            map(
-                ContentLicenseRow.from_dict,
-                itertools.chain.from_iterable(
-                    map(converters.fossology_license_to_db, licenses)
-                ),
-            ),
-            conflict_update,
-        )
+        added = self._licenses.add(licenses, conflict_update)
         return {"content_fossology_license:add": added}
 
     def content_fossology_license_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         return self._licenses.get_partition(
             indexer_configuration_id, partition_id, nb_partitions, page_token, limit
         )
 
     def content_metadata_missing(self, metadata):
         yield from self._content_metadata.missing(metadata)
 
     def content_metadata_get(self, ids):
         yield from (obj.to_dict() for obj in self._content_metadata.get(ids))
 
     def content_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         check_id_types(metadata)
         added = self._content_metadata.add(
             map(ContentMetadataRow.from_dict, metadata), conflict_update
         )
         return {"content_metadata:add": added}
 
     def revision_intrinsic_metadata_missing(self, metadata):
         yield from self._revision_intrinsic_metadata.missing(metadata)
 
     def revision_intrinsic_metadata_get(self, ids):
         yield from (obj.to_dict() for obj in self._revision_intrinsic_metadata.get(ids))
 
     def revision_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         check_id_types(metadata)
         added = self._revision_intrinsic_metadata.add(
             map(RevisionIntrinsicMetadataRow.from_dict, metadata), conflict_update
         )
         return {"revision_intrinsic_metadata:add": added}
 
     def revision_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
         deleted = self._revision_intrinsic_metadata.delete(entries)
         return {"revision_intrinsic_metadata:del": deleted}
 
     def origin_intrinsic_metadata_get(self, ids):
         yield from (obj.to_dict() for obj in self._origin_intrinsic_metadata.get(ids))
 
     def origin_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._origin_intrinsic_metadata.add(
             map(OriginIntrinsicMetadataRow.from_dict, metadata), conflict_update
         )
         return {"origin_intrinsic_metadata:add": added}
 
     def origin_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
         deleted = self._origin_intrinsic_metadata.delete(entries)
         return {"origin_intrinsic_metadata:del": deleted}
 
     def origin_intrinsic_metadata_search_fulltext(self, conjunction, limit=100):
         # A very crude fulltext search implementation, but that's enough
         # to work on English metadata
         tokens_re = re.compile("[a-zA-Z0-9]+")
         search_tokens = list(itertools.chain(*map(tokens_re.findall, conjunction)))
 
         def rank(data):
             # Tokenize the metadata
             text = json.dumps(data.metadata)
             text_tokens = tokens_re.findall(text)
             text_token_occurences = Counter(text_tokens)
 
             # Count the number of occurrences of search tokens in the text
             score = 0
             for search_token in search_tokens:
                 if text_token_occurences[search_token] == 0:
                     # Search token is not in the text.
                     return 0
                 score += text_token_occurences[search_token]
 
             # Normalize according to the text's length
             return score / math.log(len(text_tokens))
 
         results = [
             (rank(data), data) for data in self._origin_intrinsic_metadata.get_all()
         ]
         results = [(rank_, data) for (rank_, data) in results if rank_ > 0]
         results.sort(
             key=operator.itemgetter(0), reverse=True  # Don't try to order 'data'
         )
         for (rank_, result) in results[:limit]:
             yield result.to_dict()
 
     def origin_intrinsic_metadata_search_by_producer(
         self, page_token="", limit=100, ids_only=False, mappings=None, tool_ids=None
     ):
         assert isinstance(page_token, str)
         nb_results = 0
         if mappings is not None:
             mappings = frozenset(mappings)
         if tool_ids is not None:
             tool_ids = frozenset(tool_ids)
         origins = []
 
         # we go to limit+1 to check whether we should add next_page_token in
         # the response
         for entry in self._origin_intrinsic_metadata.get_all():
             if entry.id <= page_token:
                 continue
             if nb_results >= (limit + 1):
                 break
             if mappings is not None and mappings.isdisjoint(entry.mappings):
                 continue
             if tool_ids is not None and entry.tool["id"] not in tool_ids:
                 continue
             origins.append(entry.to_dict())
             nb_results += 1
 
         result = {}
         if len(origins) > limit:
             origins = origins[:limit]
             result["next_page_token"] = origins[-1]["id"]
         if ids_only:
             origins = [origin["id"] for origin in origins]
         result["origins"] = origins
         return result
 
     def origin_intrinsic_metadata_stats(self):
         mapping_count = {m: 0 for m in MAPPING_NAMES}
         total = non_empty = 0
         for data in self._origin_intrinsic_metadata.get_all():
             total += 1
             if set(data.metadata) - {"@context"}:
                 non_empty += 1
             for mapping in data.mappings:
                 mapping_count[mapping] += 1
         return {"per_mapping": mapping_count, "total": total, "non_empty": non_empty}
 
     def indexer_configuration_add(self, tools):
         inserted = []
         for tool in tools:
             tool = tool.copy()
             id_ = self._tool_key(tool)
             tool["id"] = id_
             self._tools[id_] = tool
             inserted.append(tool)
         return inserted
 
     def indexer_configuration_get(self, tool):
         return self._tools.get(self._tool_key(tool))
 
     def _tool_key(self, tool):
         return hash(
             (
                 tool["tool_name"],
                 tool["tool_version"],
                 json.dumps(tool["tool_configuration"], sort_keys=True),
             )
         )
diff --git a/swh/indexer/storage/interface.py b/swh/indexer/storage/interface.py
index 3470dee..4c592d6 100644
--- a/swh/indexer/storage/interface.py
+++ b/swh/indexer/storage/interface.py
@@ -1,609 +1,605 @@
 # Copyright (C) 2015-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from typing import Dict, Iterable, List, Optional, Tuple, TypeVar
 
 from swh.core.api import remote_api_endpoint
 from swh.core.api.classes import PagedResult as CorePagedResult
-from swh.indexer.storage.model import ContentMimetypeRow
+from swh.indexer.storage.model import ContentLicenseRow, ContentMimetypeRow
 
 TResult = TypeVar("TResult")
 PagedResult = CorePagedResult[TResult, str]
 
 
 Sha1 = bytes
 
 
 class IndexerStorageInterface:
     @remote_api_endpoint("check_config")
     def check_config(self, *, check_write):
         """Check that the storage is configured and ready to go."""
         ...
 
     @remote_api_endpoint("content_mimetype/missing")
     def content_mimetype_missing(
         self, mimetypes: Iterable[Dict]
     ) -> Iterable[Tuple[Sha1, int]]:
         """Generate mimetypes missing from storage.
 
         Args:
             mimetypes (iterable): iterable of dict with keys:
 
               - **id** (bytes): sha1 identifier
               - **indexer_configuration_id** (int): tool used to compute the
                 results
 
         Yields:
             tuple (id, indexer_configuration_id): missing id
 
         """
         ...
 
     @remote_api_endpoint("content_mimetype/range")
     def content_mimetype_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         """Retrieve mimetypes within partition partition_id bound by limit.
 
         Args:
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns:
             PagedResult of Sha1. If next_page_token is None, there is no more data
             to fetch
 
         """
         ...
 
     @remote_api_endpoint("content_mimetype/add")
     def content_mimetype_add(
         self, mimetypes: List[ContentMimetypeRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add mimetypes not present in storage.
 
         Args:
             mimetypes: mimetype rows to be added, with their `tool` attribute set to
-            not None.
+            None.
             conflict_update: Flag to determine if we want to
             overwrite (``True``) or skip duplicates (``False``, the
             default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content_mimetype")
     def content_mimetype_get(self, ids: Iterable[Sha1]) -> Iterable[ContentMimetypeRow]:
         """Retrieve full content mimetype per ids.
 
         Args:
             ids: sha1 identifiers
 
         Yields:
             mimetype row objects
 
         """
         ...
 
     @remote_api_endpoint("content_language/missing")
     def content_language_missing(self, languages):
         """List languages missing from storage.
 
         Args:
             languages (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Yields:
             an iterable of missing id for the tuple (id,
             indexer_configuration_id)
 
         """
         ...
 
     @remote_api_endpoint("content_language")
     def content_language_get(self, ids):
         """Retrieve full content language per ids.
 
         Args:
             ids (iterable): sha1 identifier
 
         Yields:
             languages (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **lang** (bytes): raw content's language
                 - **tool** (dict): Tool used to compute the language
 
         """
         ...
 
     @remote_api_endpoint("content_language/add")
     def content_language_add(
         self, languages: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add languages not present in storage.
 
         Args:
             languages (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1
                 - **lang** (bytes): language detected
 
             conflict_update (bool): Flag to determine if we want to
                 overwrite (true) or skip duplicates (false, the
                 default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content/ctags/missing")
     def content_ctags_missing(self, ctags):
         """List ctags missing from storage.
 
         Args:
             ctags (iterable): dicts with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Yields:
             an iterable of missing id for the tuple (id,
             indexer_configuration_id)
 
         """
         ...
 
     @remote_api_endpoint("content/ctags")
     def content_ctags_get(self, ids):
         """Retrieve ctags per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Yields:
             Dictionaries with keys:
 
                 - **id** (bytes): content's identifier
                 - **name** (str): symbol's name
                 - **kind** (str): symbol's kind
                 - **lang** (str): language for that content
                 - **tool** (dict): tool used to compute the ctags' info
 
 
         """
         ...
 
     @remote_api_endpoint("content/ctags/add")
     def content_ctags_add(
         self, ctags: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add ctags not present in storage
 
         Args:
             ctags (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1
                 - **ctags** ([list): List of dictionary with keys: name, kind,
                   line, lang
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content/ctags/search")
     def content_ctags_search(self, expression, limit=10, last_sha1=None):
         """Search through content's raw ctags symbols.
 
         Args:
             expression (str): Expression to search for
             limit (int): Number of rows to return (default to 10).
             last_sha1 (str): Offset from which retrieving data (default to '').
 
         Yields:
             rows of ctags including id, name, lang, kind, line, etc...
 
         """
         ...
 
     @remote_api_endpoint("content/fossology_license")
-    def content_fossology_license_get(self, ids):
+    def content_fossology_license_get(
+        self, ids: Iterable[Sha1]
+    ) -> Iterable[ContentLicenseRow]:
         """Retrieve licenses per id.
 
         Args:
-            ids (iterable): sha1 checksums
+            ids: sha1 identifiers
 
         Yields:
-            dict: ``{id: facts}`` where ``facts`` is a dict with the
-            following keys:
-
-                - **licenses** ([str]): associated licenses for that content
-                - **tool** (dict): Tool used to compute the license
+            license rows; possibly more than one per (sha1, tool_id) if there
+            are multiple licenses.
 
         """
         ...
 
     @remote_api_endpoint("content/fossology_license/add")
     def content_fossology_license_add(
-        self, licenses: List[Dict], conflict_update: bool = False
+        self, licenses: List[ContentLicenseRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add licenses not present in storage.
 
         Args:
-            licenses (iterable): dictionaries with keys:
-
-                - **id**: sha1
-                - **licenses** ([bytes]): List of licenses associated to sha1
-                - **tool** (str): nomossa
+            license: license rows to be added, with their `tool` attribute set to
+            None.
 
             conflict_update: Flag to determine if we want to overwrite (true)
                 or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content/fossology_license/range")
     def content_fossology_license_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         """Retrieve licenses within the partition partition_id bound by limit.
 
         Args:
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns: PagedResult of Sha1. If next_page_token is None, there is no more data
             to fetch
 
         """
         ...
 
     @remote_api_endpoint("content_metadata/missing")
     def content_metadata_missing(self, metadata):
         """List metadata missing from storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Yields:
             missing sha1s
 
         """
         ...
 
     @remote_api_endpoint("content_metadata")
     def content_metadata_get(self, ids):
         """Retrieve metadata per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Yields:
             dictionaries with the following keys:
 
                 id (bytes)
                 metadata (str): associated metadata
                 tool (dict): tool used to compute metadata
 
         """
         ...
 
     @remote_api_endpoint("content_metadata/add")
     def content_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add metadata not present in storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                 - **id**: sha1
                 - **metadata**: arbitrary dict
 
             conflict_update: Flag to determine if we want to overwrite (true)
                 or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata/missing")
     def revision_intrinsic_metadata_missing(self, metadata):
         """List metadata missing from storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                - **id** (bytes): sha1_git revision identifier
                - **indexer_configuration_id** (int): tool used to compute
                  the results
 
         Yields:
             missing ids
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata")
     def revision_intrinsic_metadata_get(self, ids):
         """Retrieve revision metadata per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Yields:
             : dictionaries with the following keys:
 
                 - **id** (bytes)
                 - **metadata** (str): associated metadata
                 - **tool** (dict): tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata/add")
     def revision_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add metadata not present in storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                 - **id**: sha1_git of revision
                 - **metadata**: arbitrary dict
                 - **indexer_configuration_id**: tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
             conflict_update: Flag to determine if we want to overwrite (true)
               or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata/delete")
     def revision_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
         """Remove revision metadata from the storage.
 
         Args:
             entries (dict): dictionaries with the following keys:
 
                 - **id** (bytes): revision identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   metadata
 
         Returns:
             Summary of number of rows deleted
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata")
     def origin_intrinsic_metadata_get(self, ids):
         """Retrieve origin metadata per id.
 
         Args:
             ids (iterable): origin identifiers
 
         Yields:
             list: dictionaries with the following keys:
 
                 - **id** (str): origin url
                 - **from_revision** (bytes): which revision this metadata
                   was extracted from
                 - **metadata** (str): associated metadata
                 - **tool** (dict): tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/add")
     def origin_intrinsic_metadata_add(
         self, metadata: List[Dict], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add origin metadata not present in storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                 - **id**: origin urls
                 - **from_revision**: sha1 id of the revision used to generate
                   these metadata.
                 - **metadata**: arbitrary dict
                 - **indexer_configuration_id**: tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
             conflict_update: Flag to determine if we want to overwrite (true)
               or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/delete")
     def origin_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
         """Remove origin metadata from the storage.
 
         Args:
             entries (dict): dictionaries with the following keys:
 
                 - **id** (str): origin urls
                 - **indexer_configuration_id** (int): tool used to compute
                   metadata
 
         Returns:
             Summary of number of rows deleted
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/search/fulltext")
     def origin_intrinsic_metadata_search_fulltext(self, conjunction, limit=100):
         """Returns the list of origins whose metadata contain all the terms.
 
         Args:
             conjunction (List[str]): List of terms to be searched for.
             limit (int): The maximum number of results to return
 
         Yields:
             list: dictionaries with the following keys:
 
                 - **id** (str): origin urls
                 - **from_revision**: sha1 id of the revision used to generate
                   these metadata.
                 - **metadata** (str): associated metadata
                 - **tool** (dict): tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/search/by_producer")
     def origin_intrinsic_metadata_search_by_producer(
         self, page_token="", limit=100, ids_only=False, mappings=None, tool_ids=None
     ):
         """Returns the list of origins whose metadata contain all the terms.
 
         Args:
             page_token (str): Opaque token used for pagination.
             limit (int): The maximum number of results to return
             ids_only (bool): Determines whether only origin urls are
                 returned or the content as well
             mappings (List[str]): Returns origins whose intrinsic metadata
                 were generated using at least one of these mappings.
 
         Returns:
             dict: dict with the following keys:
               - **next_page_token** (str, optional): opaque token to be used as
                 `page_token` for retrieving the next page. If absent, there is
                 no more pages to gather.
               - **origins** (list): list of origin url (str) if `ids_only=True`
                 else dictionaries with the following keys:
 
                 - **id** (str): origin urls
                 - **from_revision**: sha1 id of the revision used to generate
                   these metadata.
                 - **metadata** (str): associated metadata
                 - **tool** (dict): tool used to compute metadata
                 - **mappings** (List[str]): list of mappings used to translate
                   these metadata
 
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/stats")
     def origin_intrinsic_metadata_stats(self):
         """Returns counts of indexed metadata per origins, broken down
         into metadata types.
 
         Returns:
             dict: dictionary with keys:
 
                 - total (int): total number of origins that were indexed
                   (possibly yielding an empty metadata dictionary)
                 - non_empty (int): total number of origins that we extracted
                   a non-empty metadata dictionary from
                 - per_mapping (dict): a dictionary with mapping names as
                   keys and number of origins whose indexing used this
                   mapping. Note that indexing a given origin may use
                   0, 1, or many mappings.
         """
         ...
 
     @remote_api_endpoint("indexer_configuration/add")
     def indexer_configuration_add(self, tools):
         """Add new tools to the storage.
 
         Args:
             tools ([dict]): List of dictionary representing tool to
                 insert in the db. Dictionary with the following keys:
 
                 - **tool_name** (str): tool's name
                 - **tool_version** (str): tool's version
                 - **tool_configuration** (dict): tool's configuration
                   (free form dict)
 
         Returns:
             List of dict inserted in the db (holding the id key as
             well).  The order of the list is not guaranteed to match
             the order of the initial list.
 
         """
         ...
 
     @remote_api_endpoint("indexer_configuration/data")
     def indexer_configuration_get(self, tool):
         """Retrieve tool information.
 
         Args:
             tool (dict): Dictionary representing a tool with the
                 following keys:
 
                 - **tool_name** (str): tool's name
                 - **tool_version** (str): tool's version
                 - **tool_configuration** (dict): tool's configuration
                   (free form dict)
 
         Returns:
             The same dictionary with an `id` key, None otherwise.
 
         """
         ...
diff --git a/swh/indexer/tests/storage/conftest.py b/swh/indexer/tests/storage/conftest.py
index 6bcc638..7c0c53c 100644
--- a/swh/indexer/tests/storage/conftest.py
+++ b/swh/indexer/tests/storage/conftest.py
@@ -1,75 +1,80 @@
 # Copyright (C) 2015-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from os.path import join
 
 import pytest
 
 from swh.indexer.storage import get_indexer_storage
-from swh.indexer.storage.model import ContentMimetypeRow
+from swh.indexer.storage.model import ContentLicenseRow, ContentMimetypeRow
 from swh.model.hashutil import hash_to_bytes
 from swh.storage.pytest_plugin import postgresql_fact
 
 from . import SQL_DIR
 from .generate_data_test import FOSSOLOGY_LICENSES, MIMETYPE_OBJECTS, TOOLS
 
 DUMP_FILES = join(SQL_DIR, "*.sql")
 
 
 class DataObj(dict):
     def __getattr__(self, key):
         return self.__getitem__(key)
 
     def __setattr__(self, key, value):
         return self.__setitem__(key, value)
 
 
 @pytest.fixture
 def swh_indexer_storage_with_data(swh_indexer_storage):
     data = DataObj()
     tools = {
         tool["tool_name"]: {
             "id": tool["id"],
             "name": tool["tool_name"],
             "version": tool["tool_version"],
             "configuration": tool["tool_configuration"],
         }
         for tool in swh_indexer_storage.indexer_configuration_add(TOOLS)
     }
     data.tools = tools
     data.sha1_1 = hash_to_bytes("34973274ccef6ab4dfaaf86599792fa9c3fe4689")
     data.sha1_2 = hash_to_bytes("61c2b3a30496d329e21af70dd2d7e097046d07b7")
     data.revision_id_1 = hash_to_bytes("7026b7c1a2af56521e951c01ed20f255fa054238")
     data.revision_id_2 = hash_to_bytes("7026b7c1a2af56521e9587659012345678904321")
     data.revision_id_3 = hash_to_bytes("7026b7c1a2af56521e9587659012345678904320")
     data.origin_url_1 = "file:///dev/0/zero"  # 44434341
     data.origin_url_2 = "file:///dev/1/one"  # 44434342
     data.origin_url_3 = "file:///dev/2/two"  # 54974445
     data.mimetypes = [
         ContentMimetypeRow(indexer_configuration_id=tools["file"]["id"], **mimetype_obj)
         for mimetype_obj in MIMETYPE_OBJECTS
     ]
     swh_indexer_storage.content_mimetype_add(data.mimetypes)
     data.fossology_licenses = [
-        {**fossology_obj, "indexer_configuration_id": tools["nomos"]["id"]}
+        ContentLicenseRow(
+            id=fossology_obj["id"],
+            indexer_configuration_id=tools["nomos"]["id"],
+            license=license,
+        )
         for fossology_obj in FOSSOLOGY_LICENSES
+        for license in fossology_obj["licenses"]
     ]
     swh_indexer_storage._test_data = data
 
     return (swh_indexer_storage, data)
 
 
 swh_indexer_storage_postgresql = postgresql_fact(
     "postgresql_proc", dump_files=DUMP_FILES
 )
 
 
 @pytest.fixture
 def swh_indexer_storage(swh_indexer_storage_postgresql):
     storage_config = {
         "cls": "local",
         "args": {"db": swh_indexer_storage_postgresql.dsn,},
     }
     return get_indexer_storage(**storage_config)
diff --git a/swh/indexer/tests/storage/test_converters.py b/swh/indexer/tests/storage/test_converters.py
index 7cf56df..4f605c1 100644
--- a/swh/indexer/tests/storage/test_converters.py
+++ b/swh/indexer/tests/storage/test_converters.py
@@ -1,175 +1,176 @@
 # Copyright (C) 2015-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from swh.indexer.storage import converters
 
 
 def test_ctags_to_db() -> None:
     input_ctag = {
         "id": b"some-id",
         "indexer_configuration_id": 100,
         "ctags": [
             {"name": "some-name", "kind": "some-kind", "line": 10, "lang": "Yaml",},
             {"name": "main", "kind": "function", "line": 12, "lang": "Yaml",},
         ],
     }
 
     expected_ctags = [
         {
             "id": b"some-id",
             "name": "some-name",
             "kind": "some-kind",
             "line": 10,
             "lang": "Yaml",
             "indexer_configuration_id": 100,
         },
         {
             "id": b"some-id",
             "name": "main",
             "kind": "function",
             "line": 12,
             "lang": "Yaml",
             "indexer_configuration_id": 100,
         },
     ]
 
     # when
     actual_ctags = list(converters.ctags_to_db(input_ctag))
 
     # then
     assert actual_ctags == expected_ctags
 
 
 def test_db_to_ctags() -> None:
     input_ctags = {
         "id": b"some-id",
         "name": "some-name",
         "kind": "some-kind",
         "line": 10,
         "lang": "Yaml",
         "tool_id": 200,
         "tool_name": "some-toolname",
         "tool_version": "some-toolversion",
         "tool_configuration": {},
     }
     expected_ctags = {
         "id": b"some-id",
         "name": "some-name",
         "kind": "some-kind",
         "line": 10,
         "lang": "Yaml",
         "tool": {
             "id": 200,
             "name": "some-toolname",
             "version": "some-toolversion",
             "configuration": {},
         },
     }
 
     # when
     actual_ctags = converters.db_to_ctags(input_ctags)
 
     # then
     assert actual_ctags == expected_ctags
 
 
 def test_db_to_mimetype() -> None:
     input_mimetype = {
         "id": b"some-id",
         "tool_id": 10,
         "tool_name": "some-toolname",
         "tool_version": "some-toolversion",
         "tool_configuration": {},
         "encoding": b"ascii",
         "mimetype": b"text/plain",
     }
 
     expected_mimetype = {
         "id": b"some-id",
         "encoding": b"ascii",
         "mimetype": b"text/plain",
         "tool": {
             "id": 10,
             "name": "some-toolname",
             "version": "some-toolversion",
             "configuration": {},
         },
     }
 
     actual_mimetype = converters.db_to_mimetype(input_mimetype)
 
     assert actual_mimetype == expected_mimetype
 
 
 def test_db_to_language() -> None:
     input_language = {
         "id": b"some-id",
         "tool_id": 20,
         "tool_name": "some-toolname",
         "tool_version": "some-toolversion",
         "tool_configuration": {},
         "lang": b"css",
     }
 
     expected_language = {
         "id": b"some-id",
         "lang": b"css",
         "tool": {
             "id": 20,
             "name": "some-toolname",
             "version": "some-toolversion",
             "configuration": {},
         },
     }
 
     actual_language = converters.db_to_language(input_language)
 
     assert actual_language == expected_language
 
 
 def test_db_to_fossology_license() -> None:
     input_license = {
         "id": b"some-id",
         "tool_id": 20,
         "tool_name": "nomossa",
         "tool_version": "5.22",
         "tool_configuration": {},
-        "licenses": ["GPL2.0"],
+        "license": "GPL2.0",
     }
 
     expected_license = {
-        "licenses": ["GPL2.0"],
+        "id": b"some-id",
+        "license": "GPL2.0",
         "tool": {"id": 20, "name": "nomossa", "version": "5.22", "configuration": {},},
     }
 
     actual_license = converters.db_to_fossology_license(input_license)
 
     assert actual_license == expected_license
 
 
 def test_db_to_metadata() -> None:
     input_metadata = {
         "id": b"some-id",
         "tool_id": 20,
         "tool_name": "some-toolname",
         "tool_version": "some-toolversion",
         "tool_configuration": {},
         "metadata": b"metadata",
     }
 
     expected_metadata = {
         "id": b"some-id",
         "metadata": b"metadata",
         "tool": {
             "id": 20,
             "name": "some-toolname",
             "version": "some-toolversion",
             "configuration": {},
         },
     }
 
     actual_metadata = converters.db_to_metadata(input_metadata)
 
     assert actual_metadata == expected_metadata
diff --git a/swh/indexer/tests/storage/test_storage.py b/swh/indexer/tests/storage/test_storage.py
index 070f391..5500ac1 100644
--- a/swh/indexer/tests/storage/test_storage.py
+++ b/swh/indexer/tests/storage/test_storage.py
@@ -1,2047 +1,2042 @@
 # Copyright (C) 2015-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import inspect
 import math
 import threading
 from typing import Any, Dict, List, Tuple, Union
 
 import pytest
 
 from swh.indexer.storage.exc import DuplicateId, IndexerStorageArgumentException
 from swh.indexer.storage.interface import IndexerStorageInterface
-from swh.indexer.storage.model import BaseRow, ContentMimetypeRow
+from swh.indexer.storage.model import BaseRow, ContentLicenseRow, ContentMimetypeRow
 from swh.model.hashutil import hash_to_bytes
 
 
-def prepare_mimetypes_from(fossology_licenses: List[Dict]) -> List[ContentMimetypeRow]:
+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"],
+                id=c.id,
                 mimetype="text/plain",  # for filtering on textual data to work
                 encoding="utf-8",
-                indexer_configuration_id=c["indexer_configuration_id"],
+                indexer_configuration_id=c.indexer_configuration_id,
             )
         )
     return mimetypes
 
 
 def endpoint_name(etype: str, ename: str) -> str:
     """Compute the storage's endpoint's name
 
     >>> endpoint_name('content_mimetype', 'add')
     'content_mimetype_add'
     >>> endpoint_name('content_fosso_license', 'delete')
     'content_fosso_license_delete'
 
     """
     return f"{etype}_{ename}"
 
 
 def endpoint(storage, etype: str, ename: str):
     return getattr(storage, endpoint_name(etype, ename))
 
 
 def expected_summary(count: int, etype: str, ename: str = "add") -> Dict[str, int]:
     """Compute the expected summary
 
     The key is determine according to etype and ename
 
         >>> expected_summary(10, 'content_mimetype', 'add')
         {'content_mimetype:add': 10}
         >>> expected_summary(9, 'origin_intrinsic_metadata', 'delete')
         {'origin_intrinsic_metadata:del': 9}
 
     """
     pattern = ename[0:3]
     key = endpoint_name(etype, ename).replace(f"_{ename}", f":{pattern}")
     return {key: count}
 
 
 def test_check_config(swh_indexer_storage) -> None:
     assert swh_indexer_storage.check_config(check_write=True)
     assert swh_indexer_storage.check_config(check_write=False)
 
 
 def test_types(swh_indexer_storage) -> None:
     """Checks all methods of StorageInterface are implemented by this
     backend, and that they have the same signature."""
     # Create an instance of the protocol (which cannot be instantiated
     # directly, so this creates a subclass, then instantiates it)
     interface = type("_", (IndexerStorageInterface,), {})()
 
     assert "content_mimetype_add" in dir(interface)
 
     missing_methods = []
 
     for meth_name in dir(interface):
         if meth_name.startswith("_"):
             continue
         interface_meth = getattr(interface, meth_name)
         try:
             concrete_meth = getattr(swh_indexer_storage, meth_name)
         except AttributeError:
             missing_methods.append(meth_name)
             continue
 
         expected_signature = inspect.signature(interface_meth)
         actual_signature = inspect.signature(concrete_meth)
 
         assert expected_signature == actual_signature, meth_name
 
     assert missing_methods == []
 
 
 class StorageETypeTester:
     """Base class for testing a series of common behaviour between a bunch of
     endpoint types supported by an IndexerStorage.
 
     This is supposed to be inherited with the following class attributes:
     - endpoint_type
     - tool_name
     - example_data
 
     See below for example usage.
     """
 
     endpoint_type: str
     tool_name: str
     example_data: List[Dict]
 
     # For old endpoints (which use dicts), this is just the identity function.
     # For new endpoints, it returns a BaseRow instance.
     @staticmethod
     def row_from_dict(d: Dict) -> Union[Dict, BaseRow]:
         return d
 
     # Inverse function of row_from_dict
     # TODO: remove this once all endpoints are migrated to rows
     @staticmethod
     def dict_from_row(r: Union[Dict, BaseRow]) -> Dict:
         assert isinstance(r, Dict)
         return r
 
     def test_missing(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool_id = data.tools[self.tool_name]["id"]
 
         # given 2 (hopefully) unknown objects
         query = [
             {"id": data.sha1_1, "indexer_configuration_id": tool_id,},
             {"id": data.sha1_2, "indexer_configuration_id": tool_id,},
         ]
 
         # we expect these are both returned by the xxx_missing endpoint
         actual_missing = endpoint(storage, etype, "missing")(query)
         assert list(actual_missing) == [
             data.sha1_1,
             data.sha1_2,
         ]
 
         # now, when we add one of them
         summary = endpoint(storage, etype, "add")(
             [
                 self.row_from_dict(
                     {
                         "id": data.sha1_2,
                         **self.example_data[0],
                         "indexer_configuration_id": tool_id,
                     }
                 )
             ]
         )
 
         assert summary == expected_summary(1, etype)
 
         # we expect only the other one returned
         actual_missing = endpoint(storage, etype, "missing")(query)
         assert list(actual_missing) == [data.sha1_1]
 
     def test_add__drop_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool_id = data.tools[self.tool_name]["id"]
 
         # add the first object
         data_v1 = {
             "id": data.sha1_2,
             **self.example_data[0],
             "indexer_configuration_id": tool_id,
         }
         summary = endpoint(storage, etype, "add")([self.row_from_dict(data_v1)])
         assert summary == expected_summary(1, etype)
 
         # should be able to retrieve it
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
         expected_data_v1 = [
             self.row_from_dict(
                 {
                     "id": data.sha1_2,
                     **self.example_data[0],
                     "tool": data.tools[self.tool_name],
                 }
             )
         ]
         assert actual_data == expected_data_v1
 
         # now if we add a modified version of the same object (same id)
         data_v2 = data_v1.copy()
         data_v2.update(self.example_data[1])
         summary2 = endpoint(storage, etype, "add")([self.row_from_dict(data_v2)])
         assert summary2 == expected_summary(0, etype)  # not added
 
         # we expect to retrieve the original data, not the modified one
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
         assert actual_data == expected_data_v1
 
     def test_add__update_in_place_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         data_v1 = {
             "id": data.sha1_2,
             **self.example_data[0],
             "indexer_configuration_id": tool["id"],
         }
 
         # given
         summary = endpoint(storage, etype, "add")([self.row_from_dict(data_v1)])
         assert summary == expected_summary(1, etype)  # not added
 
         # when
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         expected_data_v1 = [
             self.row_from_dict(
                 {"id": data.sha1_2, **self.example_data[0], "tool": tool}
             )
         ]
 
         # then
         assert actual_data == expected_data_v1
 
         # given
         data_v2 = data_v1.copy()
         data_v2.update(self.example_data[1])
 
         endpoint(storage, etype, "add")(
             [self.row_from_dict(data_v2)], conflict_update=True
         )
         assert summary == expected_summary(1, etype)  # modified so counted
 
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         expected_data_v2 = [
             self.row_from_dict(
                 {"id": data.sha1_2, **self.example_data[1], "tool": tool,}
             )
         ]
 
         # data did change as the v2 was used to overwrite v1
         assert actual_data == expected_data_v2
 
     def test_add__update_in_place_deadlock(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         hashes = [
             hash_to_bytes("34973274ccef6ab4dfaaf86599792fa9c3fe4{:03d}".format(i))
             for i in range(1000)
         ]
 
         data_v1 = [
             self.row_from_dict(
                 {
                     "id": hash_,
                     **self.example_data[0],
                     "indexer_configuration_id": tool["id"],
                 }
             )
             for hash_ in hashes
         ]
         data_v2 = [
             self.row_from_dict(
                 {
                     "id": hash_,
                     **self.example_data[1],
                     "indexer_configuration_id": tool["id"],
                 }
             )
             for hash_ in hashes
         ]
 
         # Remove one item from each, so that both queries have to succeed for
         # all items to be in the DB.
         data_v2a = data_v2[1:]
         data_v2b = list(reversed(data_v2[0:-1]))
 
         # given
         endpoint(storage, etype, "add")(data_v1)
 
         # when
         actual_data = list(endpoint(storage, etype, "get")(hashes))
 
         expected_data_v1 = [
             self.row_from_dict({"id": hash_, **self.example_data[0], "tool": tool})
             for hash_ in hashes
         ]
 
         # then
         assert actual_data == expected_data_v1
 
         # given
         def f1() -> None:
             endpoint(storage, etype, "add")(data_v2a, conflict_update=True)
 
         def f2() -> None:
             endpoint(storage, etype, "add")(data_v2b, conflict_update=True)
 
         t1 = threading.Thread(target=f1)
         t2 = threading.Thread(target=f2)
         t2.start()
         t1.start()
 
         t1.join()
         t2.join()
 
         actual_data = sorted(
             map(self.dict_from_row, endpoint(storage, etype, "get")(hashes)),
             key=lambda x: x["id"],
         )
 
         expected_data_v2 = [
             {"id": hash_, **self.example_data[1], "tool": tool} for hash_ in hashes
         ]
 
         assert actual_data == expected_data_v2
 
     def test_add__duplicate_twice(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         data_rev1 = self.row_from_dict(
             {
                 "id": data.revision_id_2,
                 **self.example_data[0],
                 "indexer_configuration_id": tool["id"],
             }
         )
 
         data_rev2 = self.row_from_dict(
             {
                 "id": data.revision_id_2,
                 **self.example_data[1],
                 "indexer_configuration_id": tool["id"],
             }
         )
 
         # when
         summary = endpoint(storage, etype, "add")([data_rev1])
         assert summary == expected_summary(1, etype)
 
         with pytest.raises(DuplicateId):
             endpoint(storage, etype, "add")(
                 [data_rev2, data_rev2], conflict_update=True
             )
 
         # then
         actual_data = list(
             endpoint(storage, etype, "get")([data.revision_id_2, data.revision_id_1])
         )
 
         expected_data = [
             self.row_from_dict(
                 {"id": data.revision_id_2, **self.example_data[0], "tool": tool}
             )
         ]
         assert actual_data == expected_data
 
     def test_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         query = [data.sha1_2, data.sha1_1]
         data1 = self.row_from_dict(
             {
                 "id": data.sha1_2,
                 **self.example_data[0],
                 "indexer_configuration_id": tool["id"],
             }
         )
 
         # when
         summary = endpoint(storage, etype, "add")([data1])
         assert summary == expected_summary(1, etype)
 
         # then
         actual_data = list(endpoint(storage, etype, "get")(query))
 
         # then
         expected_data = [
             self.row_from_dict(
                 {"id": data.sha1_2, **self.example_data[0], "tool": tool}
             )
         ]
 
         assert actual_data == expected_data
 
 
 class TestIndexerStorageContentMimetypes(StorageETypeTester):
     """Test Indexer Storage content_mimetype related methods
     """
 
     endpoint_type = "content_mimetype"
     tool_name = "file"
     example_data = [
         {"mimetype": "text/plain", "encoding": "utf-8",},
         {"mimetype": "text/html", "encoding": "us-ascii",},
     ]
     row_from_dict = ContentMimetypeRow.from_dict
     dict_from_row = staticmethod(lambda x: x.to_dict())  # type: ignore
 
     def test_generate_content_mimetype_get_partition_failure(
         self, swh_indexer_storage: IndexerStorageInterface
     ) -> None:
         """get_partition call with wrong limit input should fail"""
         storage = swh_indexer_storage
         indexer_configuration_id = 42
         with pytest.raises(
             IndexerStorageArgumentException, match="limit should not be None"
         ):
             storage.content_mimetype_get_partition(
                 indexer_configuration_id, 0, 3, limit=None  # type: ignore
             )
 
     def test_generate_content_mimetype_get_partition_no_limit(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition should return result"""
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
 
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         assert len(mimetypes) == 16
         nb_partitions = 16
 
         actual_ids = []
         for partition_id in range(nb_partitions):
             actual_result = storage.content_mimetype_get_partition(
                 indexer_configuration_id, partition_id, nb_partitions
             )
             assert actual_result.next_page_token is None
             actual_ids.extend(actual_result.results)
 
         assert len(actual_ids) == len(expected_ids)
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_generate_content_mimetype_get_partition_full(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition for a single partition should return available ids
 
         """
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         actual_result = storage.content_mimetype_get_partition(
             indexer_configuration_id, 0, 1
         )
         assert actual_result.next_page_token is None
         actual_ids = actual_result.results
         assert len(actual_ids) == len(expected_ids)
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_generate_content_mimetype_get_partition_empty(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition when at least one of the partitions is empty"""
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         # nb_partitions = smallest power of 2 such that at least one of
         # the partitions is empty
         nb_mimetypes = len(mimetypes)
         nb_partitions = 1 << math.floor(math.log2(nb_mimetypes) + 1)
 
         seen_ids = []
 
         for partition_id in range(nb_partitions):
             actual_result = storage.content_mimetype_get_partition(
                 indexer_configuration_id,
                 partition_id,
                 nb_partitions,
                 limit=nb_mimetypes + 1,
             )
 
             for actual_id in actual_result.results:
                 seen_ids.append(actual_id)
 
             # Limit is higher than the max number of results
             assert actual_result.next_page_token is None
 
         assert set(seen_ids) == expected_ids
 
     def test_generate_content_mimetype_get_partition_with_pagination(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition should return ids provided with pagination
 
         """
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         nb_partitions = 4
 
         actual_ids = []
         for partition_id in range(nb_partitions):
             next_page_token = None
             while True:
                 actual_result = storage.content_mimetype_get_partition(
                     indexer_configuration_id,
                     partition_id,
                     nb_partitions,
                     limit=2,
                     page_token=next_page_token,
                 )
                 actual_ids.extend(actual_result.results)
                 next_page_token = actual_result.next_page_token
                 if next_page_token is None:
                     break
 
         assert len(set(actual_ids)) == len(set(expected_ids))
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
 
 class TestIndexerStorageContentLanguage(StorageETypeTester):
     """Test Indexer Storage content_language related methods
     """
 
     endpoint_type = "content_language"
     tool_name = "pygments"
     example_data = [
         {"lang": "haskell",},
         {"lang": "common-lisp",},
     ]
 
 
 class TestIndexerStorageContentCTags(StorageETypeTester):
     """Test Indexer Storage content_ctags related methods
     """
 
     endpoint_type = "content_ctags"
     tool_name = "universal-ctags"
     example_data = [
         {
             "ctags": [
                 {"name": "done", "kind": "variable", "line": 119, "lang": "OCaml",}
             ]
         },
         {
             "ctags": [
                 {"name": "done", "kind": "variable", "line": 100, "lang": "Python",},
                 {"name": "main", "kind": "function", "line": 119, "lang": "Python",},
             ]
         },
     ]
 
     # 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"]
 
         ctag1 = {
             "id": data.sha1_1,
             "indexer_configuration_id": tool_id,
             "ctags": [
                 {"name": "hello", "kind": "function", "line": 133, "lang": "Python",},
                 {"name": "counter", "kind": "variable", "line": 119, "lang": "Python",},
                 {"name": "hello", "kind": "variable", "line": 210, "lang": "Python",},
             ],
         }
 
         ctag2 = {
             "id": data.sha1_2,
             "indexer_configuration_id": tool_id,
             "ctags": [
                 {"name": "hello", "kind": "variable", "line": 100, "lang": "C",},
                 {"name": "result", "kind": "variable", "line": 120, "lang": "C",},
             ],
         }
 
         storage.content_ctags_add([ctag1, ctag2])
 
         # 1. when
         actual_ctags = list(storage.content_ctags_search("hello", limit=1))
 
         # 1. then
         assert actual_ctags == [
             {
                 "id": ctag1["id"],
                 "tool": tool,
                 "name": "hello",
                 "kind": "function",
                 "line": 133,
                 "lang": "Python",
             }
         ]
 
         # 2. when
         actual_ctags = list(
             storage.content_ctags_search("hello", limit=1, last_sha1=ctag1["id"])
         )
 
         # 2. then
         assert actual_ctags == [
             {
                 "id": ctag2["id"],
                 "tool": tool,
                 "name": "hello",
                 "kind": "variable",
                 "line": 100,
                 "lang": "C",
             }
         ]
 
         # 3. when
         actual_ctags = list(storage.content_ctags_search("hello"))
 
         # 3. then
         assert actual_ctags == [
             {
                 "id": ctag1["id"],
                 "tool": tool,
                 "name": "hello",
                 "kind": "function",
                 "line": 133,
                 "lang": "Python",
             },
             {
                 "id": ctag1["id"],
                 "tool": tool,
                 "name": "hello",
                 "kind": "variable",
                 "line": 210,
                 "lang": "Python",
             },
             {
                 "id": ctag2["id"],
                 "tool": tool,
                 "name": "hello",
                 "kind": "variable",
                 "line": 100,
                 "lang": "C",
             },
         ]
 
         # 4. when
         actual_ctags = list(storage.content_ctags_search("counter"))
 
         # then
         assert actual_ctags == [
             {
                 "id": ctag1["id"],
                 "tool": tool,
                 "name": "counter",
                 "kind": "variable",
                 "line": 119,
                 "lang": "Python",
             }
         ]
 
         # 5. when
         actual_ctags = list(storage.content_ctags_search("result", limit=1))
 
         # then
         assert actual_ctags == [
             {
                 "id": ctag2["id"],
                 "tool": tool,
                 "name": "result",
                 "kind": "variable",
                 "line": 120,
                 "lang": "C",
             }
         ]
 
     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"]
 
         ctag_v1 = {
             "id": data.sha1_2,
             "indexer_configuration_id": tool_id,
             "ctags": [
                 {"name": "done", "kind": "variable", "line": 100, "lang": "Scheme",}
             ],
         }
 
         # given
         storage.content_ctags_add([ctag_v1])
         storage.content_ctags_add([ctag_v1])  # conflict does nothing
 
         # when
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         # then
         expected_ctags = [
             {
                 "id": data.sha1_2,
                 "name": "done",
                 "kind": "variable",
                 "line": 100,
                 "lang": "Scheme",
                 "tool": tool,
             }
         ]
 
         assert actual_ctags == expected_ctags
 
         # given
         ctag_v2 = ctag_v1.copy()
         ctag_v2.update(
             {
                 "ctags": [
                     {"name": "defn", "kind": "function", "line": 120, "lang": "Scheme",}
                 ]
             }
         )
 
         storage.content_ctags_add([ctag_v2])
 
         expected_ctags = [
             {
                 "id": data.sha1_2,
                 "name": "done",
                 "kind": "variable",
                 "line": 100,
                 "lang": "Scheme",
                 "tool": tool,
             },
             {
                 "id": data.sha1_2,
                 "name": "defn",
                 "kind": "function",
                 "line": 120,
                 "lang": "Scheme",
                 "tool": tool,
             },
         ]
 
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         assert actual_ctags == expected_ctags
 
     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"]
 
         ctag_v1 = {
             "id": data.sha1_2,
             "indexer_configuration_id": tool_id,
             "ctags": [
                 {"name": "done", "kind": "variable", "line": 100, "lang": "Scheme",}
             ],
         }
 
         # given
         storage.content_ctags_add([ctag_v1])
 
         # when
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         # then
         expected_ctags = [
             {
                 "id": data.sha1_2,
                 "name": "done",
                 "kind": "variable",
                 "line": 100,
                 "lang": "Scheme",
                 "tool": tool,
             }
         ]
         assert actual_ctags == expected_ctags
 
         # given
         ctag_v2 = ctag_v1.copy()
         ctag_v2.update(
             {
                 "ctags": [
                     {
                         "name": "done",
                         "kind": "variable",
                         "line": 100,
                         "lang": "Scheme",
                     },
                     {
                         "name": "defn",
                         "kind": "function",
                         "line": 120,
                         "lang": "Scheme",
                     },
                 ]
             }
         )
 
         storage.content_ctags_add([ctag_v2], conflict_update=True)
 
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         # ctag did change as the v2 was used to overwrite v1
         expected_ctags = [
             {
                 "id": data.sha1_2,
                 "name": "done",
                 "kind": "variable",
                 "line": 100,
                 "lang": "Scheme",
                 "tool": tool,
             },
             {
                 "id": data.sha1_2,
                 "name": "defn",
                 "kind": "function",
                 "line": 120,
                 "lang": "Scheme",
                 "tool": tool,
             },
         ]
         assert actual_ctags == expected_ctags
 
     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
         tool = data.tools[self.tool_name]
 
         summary = endpoint(storage, etype, "add")(
             [{"id": data.sha1_2, "indexer_configuration_id": tool["id"], "ctags": [],}]
         )
         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"},},
     ]
 
 
 class TestIndexerStorageRevisionIntrinsicMetadata(StorageETypeTester):
     """Test Indexer Storage revision_intrinsic_metadata related methods
     """
 
     tool_name = "swh-metadata-detector"
     endpoint_type = "revision_intrinsic_metadata"
     example_data = [
         {
             "metadata": {
                 "other": {},
                 "codeRepository": {
                     "type": "git",
                     "url": "https://github.com/moranegg/metadata_test",
                 },
                 "description": "Simple package.json test for indexer",
                 "name": "test_metadata",
                 "version": "0.0.1",
             },
             "mappings": ["mapping1"],
         },
         {
             "metadata": {"other": {}, "name": "test_metadata", "version": "0.0.1"},
             "mappings": ["mapping2"],
         },
     ]
 
     def test_revision_intrinsic_metadata_delete(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         query = [data.sha1_2, data.sha1_1]
         data1 = {
             "id": data.sha1_2,
             **self.example_data[0],
             "indexer_configuration_id": tool["id"],
         }
 
         # when
         summary = endpoint(storage, etype, "add")([data1])
         assert summary == expected_summary(1, etype)
 
         summary2 = endpoint(storage, etype, "delete")(
             [{"id": data.sha1_2, "indexer_configuration_id": tool["id"],}]
         )
         assert summary2 == expected_summary(1, etype, "del")
 
         # then
         actual_data = list(endpoint(storage, etype, "get")(query))
 
         # then
         assert not actual_data
 
     def test_revision_intrinsic_metadata_delete_nonexisting(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
         endpoint(storage, etype, "delete")(
             [{"id": data.sha1_2, "indexer_configuration_id": tool["id"],}]
         )
 
 
 class TestIndexerStorageContentFossologyLicense:
     endpoint_type = "content_fossology_license"
     tool_name = "nomos"
 
+    row_from_dict = ContentLicenseRow.from_dict
+    dict_from_row = staticmethod(lambda x: x.to_dict())
+
     def test_content_fossology_license_add__new_license_added(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool = data.tools["nomos"]
         tool_id = tool["id"]
 
-        license_v1 = {
-            "id": data.sha1_1,
-            "licenses": ["Apache-2.0"],
-            "indexer_configuration_id": tool_id,
-        }
+        license1 = ContentLicenseRow(
+            id=data.sha1_1, license="Apache-2.0", indexer_configuration_id=tool_id,
+        )
 
         # given
-        storage.content_fossology_license_add([license_v1])
+        storage.content_fossology_license_add([license1])
         # conflict does nothing
-        storage.content_fossology_license_add([license_v1])
+        storage.content_fossology_license_add([license1])
 
         # when
         actual_licenses = list(storage.content_fossology_license_get([data.sha1_1]))
 
         # then
-        expected_license = {data.sha1_1: [{"licenses": ["Apache-2.0"], "tool": tool,}]}
-        assert actual_licenses == [expected_license]
+        expected_licenses = [
+            ContentLicenseRow(id=data.sha1_1, license="Apache-2.0", tool=tool,)
+        ]
+        assert actual_licenses == expected_licenses
 
         # given
-        license_v2 = license_v1.copy()
-        license_v2.update(
-            {"licenses": ["BSD-2-Clause"],}
+        license2 = ContentLicenseRow(
+            id=data.sha1_1, license="BSD-2-Clause", indexer_configuration_id=tool_id,
         )
 
-        storage.content_fossology_license_add([license_v2])
+        storage.content_fossology_license_add([license2])
 
         actual_licenses = list(storage.content_fossology_license_get([data.sha1_1]))
 
-        expected_license = {
-            data.sha1_1: [{"licenses": ["Apache-2.0", "BSD-2-Clause"], "tool": tool}]
-        }
+        expected_licenses.append(
+            ContentLicenseRow(id=data.sha1_1, license="BSD-2-Clause", tool=tool,)
+        )
 
-        # license did not change as the v2 was dropped.
-        assert actual_licenses == [expected_license]
+        # 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(fossology_licenses)
-        indexer_configuration_id = fossology_licenses[0]["indexer_configuration_id"]
+        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])
+        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(fossology_licenses)
-        indexer_configuration_id = fossology_licenses[0]["indexer_configuration_id"]
+        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])
+        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(fossology_licenses)
-        indexer_configuration_id = fossology_licenses[0]["indexer_configuration_id"]
+        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])
+        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(fossology_licenses)
-        indexer_configuration_id = fossology_licenses[0]["indexer_configuration_id"]
+        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]
+        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
-        tool = data.tools[self.tool_name]
 
-        summary = endpoint(storage, etype, "add")(
-            [
-                {
-                    "id": data.sha1_2,
-                    "indexer_configuration_id": tool["id"],
-                    "licenses": [],
-                }
-            ]
-        )
+        summary = endpoint(storage, etype, "add")([])
         assert summary == {"content_fossology_license:add": 0}
 
         actual_license = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         assert actual_license == []
 
     def test_get_unknown(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         (storage, data) = swh_indexer_storage_with_data
         etype = self.endpoint_type
 
         actual_license = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         assert actual_license == []
 
 
 class TestIndexerStorageOriginIntrinsicMetadata:
     def test_origin_intrinsic_metadata_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata = {
             "version": None,
             "name": None,
         }
         metadata_rev = {
             "id": data.revision_id_2,
             "metadata": metadata,
             "mappings": ["mapping1"],
             "indexer_configuration_id": tool_id,
         }
         metadata_origin = {
             "id": data.origin_url_1,
             "metadata": metadata,
             "indexer_configuration_id": tool_id,
             "mappings": ["mapping1"],
             "from_revision": data.revision_id_2,
         }
 
         # when
         storage.revision_intrinsic_metadata_add([metadata_rev])
         storage.origin_intrinsic_metadata_add([metadata_origin])
 
         # then
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1, "no://where"])
         )
 
         expected_metadata = [
             {
                 "id": data.origin_url_1,
                 "metadata": metadata,
                 "tool": data.tools["swh-metadata-detector"],
                 "from_revision": data.revision_id_2,
                 "mappings": ["mapping1"],
             }
         ]
 
         assert actual_metadata == expected_metadata
 
     def test_origin_intrinsic_metadata_delete(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata = {
             "version": None,
             "name": None,
         }
         metadata_rev = {
             "id": data.revision_id_2,
             "metadata": metadata,
             "mappings": ["mapping1"],
             "indexer_configuration_id": tool_id,
         }
         metadata_origin = {
             "id": data.origin_url_1,
             "metadata": metadata,
             "indexer_configuration_id": tool_id,
             "mappings": ["mapping1"],
             "from_revision": data.revision_id_2,
         }
         metadata_origin2 = metadata_origin.copy()
         metadata_origin2["id"] = data.origin_url_2
 
         # when
         storage.revision_intrinsic_metadata_add([metadata_rev])
         storage.origin_intrinsic_metadata_add([metadata_origin, metadata_origin2])
 
         storage.origin_intrinsic_metadata_delete(
             [{"id": data.origin_url_1, "indexer_configuration_id": tool_id}]
         )
 
         # then
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get(
                 [data.origin_url_1, data.origin_url_2, "no://where"]
             )
         )
         for item in actual_metadata:
             item["indexer_configuration_id"] = item.pop("tool")["id"]
         assert actual_metadata == [metadata_origin2]
 
     def test_origin_intrinsic_metadata_delete_nonexisting(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool_id = data.tools["swh-metadata-detector"]["id"]
         storage.origin_intrinsic_metadata_delete(
             [{"id": data.origin_url_1, "indexer_configuration_id": tool_id}]
         )
 
     def test_origin_intrinsic_metadata_add_drop_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata_v1: Dict[str, Any] = {
             "version": None,
             "name": None,
         }
         metadata_rev_v1 = {
             "id": data.revision_id_1,
             "metadata": metadata_v1.copy(),
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata_origin_v1 = {
             "id": data.origin_url_1,
             "metadata": metadata_v1.copy(),
             "indexer_configuration_id": tool_id,
             "mappings": [],
             "from_revision": data.revision_id_1,
         }
 
         # given
         storage.revision_intrinsic_metadata_add([metadata_rev_v1])
         storage.origin_intrinsic_metadata_add([metadata_origin_v1])
 
         # when
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1, "no://where"])
         )
 
         expected_metadata_v1 = [
             {
                 "id": data.origin_url_1,
                 "metadata": metadata_v1,
                 "tool": data.tools["swh-metadata-detector"],
                 "from_revision": data.revision_id_1,
                 "mappings": [],
             }
         ]
 
         assert actual_metadata == expected_metadata_v1
 
         # given
         metadata_v2 = metadata_v1.copy()
         metadata_v2.update(
             {"name": "test_metadata", "author": "MG",}
         )
         metadata_rev_v2 = metadata_rev_v1.copy()
         metadata_origin_v2 = metadata_origin_v1.copy()
         metadata_rev_v2["metadata"] = metadata_v2
         metadata_origin_v2["metadata"] = metadata_v2
 
         storage.revision_intrinsic_metadata_add([metadata_rev_v2])
         storage.origin_intrinsic_metadata_add([metadata_origin_v2])
 
         # then
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1])
         )
 
         # metadata did not change as the v2 was dropped.
         assert actual_metadata == expected_metadata_v1
 
     def test_origin_intrinsic_metadata_add_update_in_place_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata_v1: Dict[str, Any] = {
             "version": None,
             "name": None,
         }
         metadata_rev_v1 = {
             "id": data.revision_id_2,
             "metadata": metadata_v1,
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata_origin_v1 = {
             "id": data.origin_url_1,
             "metadata": metadata_v1.copy(),
             "indexer_configuration_id": tool_id,
             "mappings": [],
             "from_revision": data.revision_id_2,
         }
 
         # given
         storage.revision_intrinsic_metadata_add([metadata_rev_v1])
         storage.origin_intrinsic_metadata_add([metadata_origin_v1])
 
         # when
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1])
         )
 
         # then
         expected_metadata_v1 = [
             {
                 "id": data.origin_url_1,
                 "metadata": metadata_v1,
                 "tool": data.tools["swh-metadata-detector"],
                 "from_revision": data.revision_id_2,
                 "mappings": [],
             }
         ]
         assert actual_metadata == expected_metadata_v1
 
         # given
         metadata_v2 = metadata_v1.copy()
         metadata_v2.update(
             {"name": "test_update_duplicated_metadata", "author": "MG",}
         )
         metadata_rev_v2 = metadata_rev_v1.copy()
         metadata_origin_v2 = metadata_origin_v1.copy()
         metadata_rev_v2["metadata"] = metadata_v2
         metadata_origin_v2 = {
             "id": data.origin_url_1,
             "metadata": metadata_v2.copy(),
             "indexer_configuration_id": tool_id,
             "mappings": ["npm"],
             "from_revision": data.revision_id_1,
         }
 
         storage.revision_intrinsic_metadata_add([metadata_rev_v2], conflict_update=True)
         storage.origin_intrinsic_metadata_add(
             [metadata_origin_v2], conflict_update=True
         )
 
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1])
         )
 
         expected_metadata_v2 = [
             {
                 "id": data.origin_url_1,
                 "metadata": metadata_v2,
                 "tool": data.tools["swh-metadata-detector"],
                 "from_revision": data.revision_id_1,
                 "mappings": ["npm"],
             }
         ]
 
         # metadata did change as the v2 was used to overwrite v1
         assert actual_metadata == expected_metadata_v2
 
     def test_origin_intrinsic_metadata_add__update_in_place_deadlock(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         ids = list(range(10))
 
         example_data1 = {
             "metadata": {"version": None, "name": None,},
             "mappings": [],
         }
         example_data2 = {
             "metadata": {"version": "v1.1.1", "name": "foo",},
             "mappings": [],
         }
 
         metadata_rev_v1 = {
             "id": data.revision_id_2,
             "metadata": {"version": None, "name": None,},
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
 
         data_v1 = [
             {
                 "id": "file:///tmp/origin%d" % id_,
                 "from_revision": data.revision_id_2,
                 **example_data1,
                 "indexer_configuration_id": tool_id,
             }
             for id_ in ids
         ]
         data_v2 = [
             {
                 "id": "file:///tmp/origin%d" % id_,
                 "from_revision": data.revision_id_2,
                 **example_data2,
                 "indexer_configuration_id": tool_id,
             }
             for id_ in ids
         ]
 
         # Remove one item from each, so that both queries have to succeed for
         # all items to be in the DB.
         data_v2a = data_v2[1:]
         data_v2b = list(reversed(data_v2[0:-1]))
 
         # given
         storage.revision_intrinsic_metadata_add([metadata_rev_v1])
         storage.origin_intrinsic_metadata_add(data_v1)
 
         # when
         origins = ["file:///tmp/origin%d" % i for i in ids]
         actual_data = list(storage.origin_intrinsic_metadata_get(origins))
 
         expected_data_v1 = [
             {
                 "id": "file:///tmp/origin%d" % id_,
                 "from_revision": data.revision_id_2,
                 **example_data1,
                 "tool": data.tools["swh-metadata-detector"],
             }
             for id_ in ids
         ]
 
         # then
         assert actual_data == expected_data_v1
 
         # given
         def f1() -> None:
             storage.origin_intrinsic_metadata_add(data_v2a, conflict_update=True)
 
         def f2() -> None:
             storage.origin_intrinsic_metadata_add(data_v2b, conflict_update=True)
 
         t1 = threading.Thread(target=f1)
         t2 = threading.Thread(target=f2)
         t2.start()
         t1.start()
 
         t1.join()
         t2.join()
 
         actual_data = list(storage.origin_intrinsic_metadata_get(origins))
 
         expected_data_v2 = [
             {
                 "id": "file:///tmp/origin%d" % id_,
                 "from_revision": data.revision_id_2,
                 **example_data2,
                 "tool": data.tools["swh-metadata-detector"],
             }
             for id_ in ids
         ]
 
         assert len(actual_data) == len(expected_data_v2)
         assert sorted(actual_data, key=lambda x: x["id"]) == expected_data_v2
 
     def test_origin_intrinsic_metadata_add__duplicate_twice(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata = {
             "developmentStatus": None,
             "name": None,
         }
         metadata_rev = {
             "id": data.revision_id_2,
             "metadata": metadata,
             "mappings": ["mapping1"],
             "indexer_configuration_id": tool_id,
         }
         metadata_origin = {
             "id": data.origin_url_1,
             "metadata": metadata,
             "indexer_configuration_id": tool_id,
             "mappings": ["mapping1"],
             "from_revision": data.revision_id_2,
         }
 
         # when
         storage.revision_intrinsic_metadata_add([metadata_rev])
 
         with pytest.raises(DuplicateId):
             storage.origin_intrinsic_metadata_add([metadata_origin, metadata_origin])
 
     def test_origin_intrinsic_metadata_search_fulltext(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata1 = {
             "author": "John Doe",
         }
         metadata1_rev = {
             "id": data.revision_id_1,
             "metadata": metadata1,
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata1_origin = {
             "id": data.origin_url_1,
             "metadata": metadata1,
             "mappings": [],
             "indexer_configuration_id": tool_id,
             "from_revision": data.revision_id_1,
         }
         metadata2 = {
             "author": "Jane Doe",
         }
         metadata2_rev = {
             "id": data.revision_id_2,
             "metadata": metadata2,
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata2_origin = {
             "id": data.origin_url_2,
             "metadata": metadata2,
             "mappings": [],
             "indexer_configuration_id": tool_id,
             "from_revision": data.revision_id_2,
         }
 
         # when
         storage.revision_intrinsic_metadata_add([metadata1_rev])
         storage.origin_intrinsic_metadata_add([metadata1_origin])
         storage.revision_intrinsic_metadata_add([metadata2_rev])
         storage.origin_intrinsic_metadata_add([metadata2_origin])
 
         # then
         search = storage.origin_intrinsic_metadata_search_fulltext
         assert set([res["id"] for res in search(["Doe"])]) == set(
             [data.origin_url_1, data.origin_url_2]
         )
         assert [res["id"] for res in search(["John", "Doe"])] == [data.origin_url_1]
         assert [res["id"] for res in search(["John"])] == [data.origin_url_1]
         assert not list(search(["John", "Jane"]))
 
     def test_origin_intrinsic_metadata_search_fulltext_rank(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         # The following authors have "Random Person" to add some more content
         # to the JSON data, to work around normalization quirks when there
         # are few words (rank/(1+ln(nb_words)) is very sensitive to nb_words
         # for small values of nb_words).
         metadata1 = {"author": ["Random Person", "John Doe", "Jane Doe",]}
         metadata1_rev = {
             "id": data.revision_id_1,
             "metadata": metadata1,
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata1_origin = {
             "id": data.origin_url_1,
             "metadata": metadata1,
             "mappings": [],
             "indexer_configuration_id": tool_id,
             "from_revision": data.revision_id_1,
         }
         metadata2 = {"author": ["Random Person", "Jane Doe",]}
         metadata2_rev = {
             "id": data.revision_id_2,
             "metadata": metadata2,
             "mappings": [],
             "indexer_configuration_id": tool_id,
         }
         metadata2_origin = {
             "id": data.origin_url_2,
             "metadata": metadata2,
             "mappings": [],
             "indexer_configuration_id": tool_id,
             "from_revision": data.revision_id_2,
         }
 
         # when
         storage.revision_intrinsic_metadata_add([metadata1_rev])
         storage.origin_intrinsic_metadata_add([metadata1_origin])
         storage.revision_intrinsic_metadata_add([metadata2_rev])
         storage.origin_intrinsic_metadata_add([metadata2_origin])
 
         # then
         search = storage.origin_intrinsic_metadata_search_fulltext
         assert [res["id"] for res in search(["Doe"])] == [
             data.origin_url_1,
             data.origin_url_2,
         ]
         assert [res["id"] for res in search(["Doe"], limit=1)] == [data.origin_url_1]
         assert [res["id"] for res in search(["John"])] == [data.origin_url_1]
         assert [res["id"] for res in search(["Jane"])] == [
             data.origin_url_2,
             data.origin_url_1,
         ]
         assert [res["id"] for res in search(["John", "Jane"])] == [data.origin_url_1]
 
     def _fill_origin_intrinsic_metadata(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool1_id = data.tools["swh-metadata-detector"]["id"]
         tool2_id = data.tools["swh-metadata-detector2"]["id"]
 
         metadata1 = {
             "@context": "foo",
             "author": "John Doe",
         }
         metadata1_rev = {
             "id": data.revision_id_1,
             "metadata": metadata1,
             "mappings": ["npm"],
             "indexer_configuration_id": tool1_id,
         }
         metadata1_origin = {
             "id": data.origin_url_1,
             "metadata": metadata1,
             "mappings": ["npm"],
             "indexer_configuration_id": tool1_id,
             "from_revision": data.revision_id_1,
         }
         metadata2 = {
             "@context": "foo",
             "author": "Jane Doe",
         }
         metadata2_rev = {
             "id": data.revision_id_2,
             "metadata": metadata2,
             "mappings": ["npm", "gemspec"],
             "indexer_configuration_id": tool2_id,
         }
         metadata2_origin = {
             "id": data.origin_url_2,
             "metadata": metadata2,
             "mappings": ["npm", "gemspec"],
             "indexer_configuration_id": tool2_id,
             "from_revision": data.revision_id_2,
         }
         metadata3 = {
             "@context": "foo",
         }
         metadata3_rev = {
             "id": data.revision_id_3,
             "metadata": metadata3,
             "mappings": ["npm", "gemspec"],
             "indexer_configuration_id": tool2_id,
         }
         metadata3_origin = {
             "id": data.origin_url_3,
             "metadata": metadata3,
             "mappings": ["pkg-info"],
             "indexer_configuration_id": tool2_id,
             "from_revision": data.revision_id_3,
         }
 
         storage.revision_intrinsic_metadata_add([metadata1_rev])
         storage.origin_intrinsic_metadata_add([metadata1_origin])
         storage.revision_intrinsic_metadata_add([metadata2_rev])
         storage.origin_intrinsic_metadata_add([metadata2_origin])
         storage.revision_intrinsic_metadata_add([metadata3_rev])
         storage.origin_intrinsic_metadata_add([metadata3_origin])
 
     def test_origin_intrinsic_metadata_search_by_producer(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         self._fill_origin_intrinsic_metadata(swh_indexer_storage_with_data)
         tool1 = data.tools["swh-metadata-detector"]
         tool2 = data.tools["swh-metadata-detector2"]
         endpoint = storage.origin_intrinsic_metadata_search_by_producer
 
         # test pagination
         # no 'page_token' param, return all origins
         result = endpoint(ids_only=True)
         assert result["origins"] == [
             data.origin_url_1,
             data.origin_url_2,
             data.origin_url_3,
         ]
         assert "next_page_token" not in result
 
         # 'page_token' is < than origin_1, return everything
         result = endpoint(page_token=data.origin_url_1[:-1], ids_only=True)
         assert result["origins"] == [
             data.origin_url_1,
             data.origin_url_2,
             data.origin_url_3,
         ]
         assert "next_page_token" not in result
 
         # 'page_token' is origin_3, return nothing
         result = endpoint(page_token=data.origin_url_3, ids_only=True)
         assert not result["origins"]
         assert "next_page_token" not in result
 
         # test limit argument
         result = endpoint(page_token=data.origin_url_1[:-1], limit=2, ids_only=True)
         assert result["origins"] == [data.origin_url_1, data.origin_url_2]
         assert result["next_page_token"] == result["origins"][-1]
 
         result = endpoint(page_token=data.origin_url_1, limit=2, ids_only=True)
         assert result["origins"] == [data.origin_url_2, data.origin_url_3]
         assert "next_page_token" not in result
 
         result = endpoint(page_token=data.origin_url_2, limit=2, ids_only=True)
         assert result["origins"] == [data.origin_url_3]
         assert "next_page_token" not in result
 
         # test mappings filtering
         result = endpoint(mappings=["npm"], ids_only=True)
         assert result["origins"] == [data.origin_url_1, data.origin_url_2]
         assert "next_page_token" not in result
 
         result = endpoint(mappings=["npm", "gemspec"], ids_only=True)
         assert result["origins"] == [data.origin_url_1, data.origin_url_2]
         assert "next_page_token" not in result
 
         result = endpoint(mappings=["gemspec"], ids_only=True)
         assert result["origins"] == [data.origin_url_2]
         assert "next_page_token" not in result
 
         result = endpoint(mappings=["pkg-info"], ids_only=True)
         assert result["origins"] == [data.origin_url_3]
         assert "next_page_token" not in result
 
         result = endpoint(mappings=["foobar"], ids_only=True)
         assert not result["origins"]
         assert "next_page_token" not in result
 
         # test pagination + mappings
         result = endpoint(mappings=["npm"], limit=1, ids_only=True)
         assert result["origins"] == [data.origin_url_1]
         assert result["next_page_token"] == result["origins"][-1]
 
         # test tool filtering
         result = endpoint(tool_ids=[tool1["id"]], ids_only=True)
         assert result["origins"] == [data.origin_url_1]
         assert "next_page_token" not in result
 
         result = endpoint(tool_ids=[tool2["id"]], ids_only=True)
         assert sorted(result["origins"]) == [data.origin_url_2, data.origin_url_3]
         assert "next_page_token" not in result
 
         result = endpoint(tool_ids=[tool1["id"], tool2["id"]], ids_only=True)
         assert sorted(result["origins"]) == [
             data.origin_url_1,
             data.origin_url_2,
             data.origin_url_3,
         ]
         assert "next_page_token" not in result
 
         # test ids_only=False
         assert endpoint(mappings=["gemspec"])["origins"] == [
             {
                 "id": data.origin_url_2,
                 "metadata": {"@context": "foo", "author": "Jane Doe",},
                 "mappings": ["npm", "gemspec"],
                 "tool": tool2,
                 "from_revision": data.revision_id_2,
             }
         ]
 
     def test_origin_intrinsic_metadata_stats(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         self._fill_origin_intrinsic_metadata(swh_indexer_storage_with_data)
 
         result = storage.origin_intrinsic_metadata_stats()
         assert result == {
             "per_mapping": {
                 "gemspec": 1,
                 "npm": 2,
                 "pkg-info": 1,
                 "codemeta": 0,
                 "maven": 0,
             },
             "total": 3,
             "non_empty": 2,
         }
 
 
 class TestIndexerStorageIndexerCondifuration:
     def test_indexer_configuration_add(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "some-unknown-tool",
             "tool_version": "some-version",
             "tool_configuration": {"debian-package": "some-package"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
         assert actual_tool is None  # does not exist
 
         # add it
         actual_tools = list(storage.indexer_configuration_add([tool]))
 
         assert len(actual_tools) == 1
         actual_tool = actual_tools[0]
         assert actual_tool is not None  # now it exists
         new_id = actual_tool.pop("id")
         assert actual_tool == tool
 
         actual_tools2 = list(storage.indexer_configuration_add([tool]))
         actual_tool2 = actual_tools2[0]
         assert actual_tool2 is not None  # now it exists
         new_id2 = actual_tool2.pop("id")
 
         assert new_id == new_id2
         assert actual_tool == actual_tool2
 
     def test_indexer_configuration_add_multiple(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "some-unknown-tool",
             "tool_version": "some-version",
             "tool_configuration": {"debian-package": "some-package"},
         }
 
         actual_tools = list(storage.indexer_configuration_add([tool]))
         assert len(actual_tools) == 1
 
         new_tools = [
             tool,
             {
                 "tool_name": "yet-another-tool",
                 "tool_version": "version",
                 "tool_configuration": {},
             },
         ]
 
         actual_tools = list(storage.indexer_configuration_add(new_tools))
         assert len(actual_tools) == 2
 
         # order not guaranteed, so we iterate over results to check
         for tool in actual_tools:
             _id = tool.pop("id")
             assert _id is not None
             assert tool in new_tools
 
     def test_indexer_configuration_get_missing(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "unknown-tool",
             "tool_version": "3.1.0rc2-31-ga2cbb8c",
             "tool_configuration": {"command_line": "nomossa <filepath>"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
 
         assert actual_tool is None
 
     def test_indexer_configuration_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "nomos",
             "tool_version": "3.1.0rc2-31-ga2cbb8c",
             "tool_configuration": {"command_line": "nomossa <filepath>"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
         assert actual_tool
 
         expected_tool = tool.copy()
         del actual_tool["id"]
 
         assert expected_tool == actual_tool
 
     def test_indexer_configuration_metadata_get_missing_context(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "swh-metadata-translator",
             "tool_version": "0.0.1",
             "tool_configuration": {"context": "unknown-context"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
 
         assert actual_tool is None
 
     def test_indexer_configuration_metadata_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "swh-metadata-translator",
             "tool_version": "0.0.1",
             "tool_configuration": {"type": "local", "context": "NpmMapping"},
         }
 
         storage.indexer_configuration_add([tool])
         actual_tool = storage.indexer_configuration_get(tool)
         assert actual_tool
 
         expected_tool = tool.copy()
         expected_tool["id"] = actual_tool["id"]
 
         assert expected_tool == actual_tool
diff --git a/swh/indexer/tests/test_ctags.py b/swh/indexer/tests/test_ctags.py
index 7baa2f3..4bb2139 100644
--- a/swh/indexer/tests/test_ctags.py
+++ b/swh/indexer/tests/test_ctags.py
@@ -1,153 +1,164 @@
 # Copyright (C) 2017-2018  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import json
 import unittest
 from unittest.mock import patch
 
 import pytest
 
 import swh.indexer.ctags
 from swh.indexer.ctags import CtagsIndexer, run_ctags
 from swh.indexer.tests.utils import (
     BASE_TEST_CONFIG,
     OBJ_STORAGE_DATA,
     SHA1_TO_CTAGS,
     CommonContentIndexerTest,
     fill_obj_storage,
     fill_storage,
     filter_dict,
 )
+from swh.model.hashutil import hash_to_bytes
 
 
 class BasicTest(unittest.TestCase):
     @patch("swh.indexer.ctags.subprocess")
     def test_run_ctags(self, mock_subprocess):
         """Computing licenses from a raw content should return results
 
         """
         output0 = """
 {"name":"defun","kind":"function","line":1,"language":"scheme"}
 {"name":"name","kind":"symbol","line":5,"language":"else"}"""
         output1 = """
 {"name":"let","kind":"var","line":10,"language":"something"}"""
 
         expected_result0 = [
             {"name": "defun", "kind": "function", "line": 1, "lang": "scheme"},
             {"name": "name", "kind": "symbol", "line": 5, "lang": "else"},
         ]
 
         expected_result1 = [
             {"name": "let", "kind": "var", "line": 10, "lang": "something"}
         ]
         for path, lang, intermediary_result, expected_result in [
             (b"some/path", "lisp", output0, expected_result0),
             (b"some/path/2", "markdown", output1, expected_result1),
         ]:
             mock_subprocess.check_output.return_value = intermediary_result
             actual_result = list(run_ctags(path, lang=lang))
             self.assertEqual(actual_result, expected_result)
 
 
 class InjectCtagsIndexer:
     """Override ctags computations.
 
     """
 
     def compute_ctags(self, path, lang):
         """Inject fake ctags given path (sha1 identifier).
 
         """
         return {"lang": lang, **SHA1_TO_CTAGS.get(path)}
 
 
 CONFIG = {
     **BASE_TEST_CONFIG,
     "tools": {
         "name": "universal-ctags",
         "version": "~git7859817b",
         "configuration": {
             "command_line": """ctags --fields=+lnz --sort=no """
             """ --links=no <filepath>""",
             "max_content_size": 1000,
         },
     },
     "languages": {"python": "python", "haskell": "haskell", "bar": "bar",},
     "workdir": "/tmp",
 }
 
 
 class TestCtagsIndexer(CommonContentIndexerTest, unittest.TestCase):
     """Ctags indexer test scenarios:
 
     - Known sha1s in the input list have their data indexed
     - Unknown sha1 in the input list are not indexed
 
     """
 
-    legacy_get_format = True
-
     def get_indexer_results(self, ids):
         yield from self.idx_storage.content_ctags_get(ids)
 
     def setUp(self):
         super().setUp()
         self.indexer = CtagsIndexer(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)
 
         # Prepare test input
         self.id0 = "01c9379dfc33803963d07c1ccc748d3fe4c96bb5"
         self.id1 = "d4c647f0fc257591cc9ba1722484229780d1c607"
         self.id2 = "688a5ef812c53907562fe379d4b3851e69c7cb15"
 
         tool = {k.replace("tool_", ""): v for (k, v) in self.indexer.tool.items()}
 
-        self.expected_results = {
-            self.id0: {"id": self.id0, "tool": tool, **SHA1_TO_CTAGS[self.id0][0],},
-            self.id1: {"id": self.id1, "tool": tool, **SHA1_TO_CTAGS[self.id1][0],},
-            self.id2: {"id": self.id2, "tool": tool, **SHA1_TO_CTAGS[self.id2][0],},
-        }
+        self.expected_results = [
+            {
+                "id": hash_to_bytes(self.id0),
+                "tool": tool,
+                **SHA1_TO_CTAGS[self.id0][0],
+            },
+            {
+                "id": hash_to_bytes(self.id1),
+                "tool": tool,
+                **SHA1_TO_CTAGS[self.id1][0],
+            },
+            {
+                "id": hash_to_bytes(self.id2),
+                "tool": tool,
+                **SHA1_TO_CTAGS[self.id2][0],
+            },
+        ]
 
         self._set_mocks()
 
     def _set_mocks(self):
         def find_ctags_for_content(raw_content):
             for (sha1, ctags) in SHA1_TO_CTAGS.items():
                 if OBJ_STORAGE_DATA[sha1] == raw_content:
                     return ctags
             else:
                 raise ValueError(
                     ("%r not found in objstorage, can't mock its ctags.") % raw_content
                 )
 
         def fake_language(raw_content, *args, **kwargs):
             ctags = find_ctags_for_content(raw_content)
             return {"lang": ctags[0]["lang"]}
 
         self._real_compute_language = swh.indexer.ctags.compute_language
         swh.indexer.ctags.compute_language = fake_language
 
         def fake_check_output(cmd, *args, **kwargs):
             id_ = cmd[-1].split("/")[-1]
             return "\n".join(
                 json.dumps({"language": ctag["lang"], **ctag})
                 for ctag in SHA1_TO_CTAGS[id_]
             )
 
         self._real_check_output = swh.indexer.ctags.subprocess.check_output
         swh.indexer.ctags.subprocess.check_output = fake_check_output
 
     def tearDown(self):
         swh.indexer.ctags.compute_language = self._real_compute_language
         swh.indexer.ctags.subprocess.check_output = self._real_check_output
         super().tearDown()
 
 
 def test_ctags_w_no_tool():
     with pytest.raises(ValueError):
         CtagsIndexer(config=filter_dict(CONFIG, "tools"))
diff --git a/swh/indexer/tests/test_fossology_license.py b/swh/indexer/tests/test_fossology_license.py
index 8a6246a..7a087f7 100644
--- a/swh/indexer/tests/test_fossology_license.py
+++ b/swh/indexer/tests/test_fossology_license.py
@@ -1,163 +1,159 @@
 # Copyright (C) 2017-2018  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
 from unittest.mock import patch
 
 import pytest
 
 from swh.indexer import fossology_license
 from swh.indexer.fossology_license import (
     FossologyLicenseIndexer,
     FossologyLicensePartitionIndexer,
     compute_license,
 )
 from swh.indexer.storage.model import ContentLicenseRow
 from swh.indexer.tests.utils import (
     BASE_TEST_CONFIG,
     SHA1_TO_LICENSES,
     CommonContentIndexerPartitionTest,
     CommonContentIndexerTest,
     fill_obj_storage,
     fill_storage,
     filter_dict,
 )
+from swh.model.hashutil import hash_to_bytes
 
 
 class BasicTest(unittest.TestCase):
     @patch("swh.indexer.fossology_license.subprocess")
     def test_compute_license(self, mock_subprocess):
         """Computing licenses from a raw content should return results
 
         """
         for path, intermediary_result, output in [
             (b"some/path", None, []),
             (b"some/path/2", [], []),
             (b"other/path", " contains license(s) GPL,AGPL", ["GPL", "AGPL"]),
         ]:
             mock_subprocess.check_output.return_value = intermediary_result
 
             actual_result = compute_license(path)
 
             self.assertEqual(actual_result, {"licenses": output, "path": path,})
 
 
 def mock_compute_license(path):
     """path is the content identifier
 
     """
     if isinstance(id, bytes):
         path = path.decode("utf-8")
     # path is something like /tmp/tmpXXX/<sha1> so we keep only the sha1 part
     path = path.split("/")[-1]
     return {"licenses": SHA1_TO_LICENSES.get(path, [])}
 
 
 CONFIG = {
     **BASE_TEST_CONFIG,
     "workdir": "/tmp",
     "tools": {
         "name": "nomos",
         "version": "3.1.0rc2-31-ga2cbb8c",
         "configuration": {"command_line": "nomossa <filepath>",},
     },
 }  # type: Dict[str, Any]
 
 RANGE_CONFIG = dict(list(CONFIG.items()) + [("write_batch_size", 100)])
 
 
 class TestFossologyLicenseIndexer(CommonContentIndexerTest, unittest.TestCase):
     """Language 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_fossology_license_get(ids)
 
     def setUp(self):
         super().setUp()
         # replace actual license computation with a mock
         self.orig_compute_license = fossology_license.compute_license
         fossology_license.compute_license = mock_compute_license
 
         self.indexer = FossologyLicenseIndexer(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"  # empty content
 
         tool = {k.replace("tool_", ""): v for (k, v) in self.indexer.tool.items()}
         # then
-        self.expected_results = {
-            self.id0: {"tool": tool, "licenses": SHA1_TO_LICENSES[self.id0],},
-            self.id1: {"tool": tool, "licenses": SHA1_TO_LICENSES[self.id1],},
-            self.id2: None,
-        }
+        self.expected_results = [
+            *[
+                ContentLicenseRow(
+                    id=hash_to_bytes(self.id0), tool=tool, license=license
+                )
+                for license in SHA1_TO_LICENSES[self.id0]
+            ],
+            *[
+                ContentLicenseRow(
+                    id=hash_to_bytes(self.id1), tool=tool, license=license
+                )
+                for license in SHA1_TO_LICENSES[self.id1]
+            ],
+            *[],  # self.id2
+        ]
 
     def tearDown(self):
         super().tearDown()
         fossology_license.compute_license = self.orig_compute_license
 
 
 class TestFossologyLicensePartitionIndexer(
     CommonContentIndexerPartitionTest, unittest.TestCase
 ):
     """Range Fossology License 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
 
     """
 
     def setUp(self):
         super().setUp()
 
         # replace actual license computation with a mock
         self.orig_compute_license = fossology_license.compute_license
         fossology_license.compute_license = mock_compute_license
 
         self.indexer = FossologyLicensePartitionIndexer(config=RANGE_CONFIG)
         self.indexer.catch_exceptions = False
         fill_storage(self.indexer.storage)
         fill_obj_storage(self.indexer.objstorage)
 
     def tearDown(self):
         super().tearDown()
         fossology_license.compute_license = self.orig_compute_license
 
-    def assert_results_ok(self, partition_id, nb_partitions, actual_results):
-        # TODO: remove this method when fossology_license endpoints moved away
-        # from dicts.
-        actual_result_rows = []
-        for res in actual_results:
-            for license in res["licenses"]:
-                actual_result_rows.append(
-                    ContentLicenseRow(
-                        id=res["id"],
-                        indexer_configuration_id=res["indexer_configuration_id"],
-                        license=license,
-                    )
-                )
-        super().assert_results_ok(partition_id, nb_partitions, actual_result_rows)
-
 
 def test_fossology_w_no_tool():
     with pytest.raises(ValueError):
         FossologyLicenseIndexer(config=filter_dict(CONFIG, "tools"))
 
 
 def test_fossology_range_w_no_tool():
     with pytest.raises(ValueError):
         FossologyLicensePartitionIndexer(config=filter_dict(RANGE_CONFIG, "tools"))
diff --git a/swh/indexer/tests/test_mimetype.py b/swh/indexer/tests/test_mimetype.py
index 75b1f04..34744bd 100644
--- a/swh/indexer/tests/test_mimetype.py
+++ b/swh/indexer/tests/test_mimetype.py
@@ -1,127 +1,127 @@
 # 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
 
     """
 
-    legacy_get_format = True
-
     def get_indexer_results(self, ids):
-        yield from (x.to_dict() for x in self.idx_storage.content_mimetype_get(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 = {
-            self.id0: {
-                "id": self.id0,
-                "tool": tool,
-                "mimetype": "text/plain",
-                "encoding": "us-ascii",
-            },
-            self.id1: {
-                "id": self.id1,
-                "tool": tool,
-                "mimetype": "text/plain",
-                "encoding": "us-ascii",
-            },
-            self.id2: {
-                "id": self.id2,
-                "tool": tool,
-                "mimetype": "application/x-empty",
-                "encoding": "binary",
-            },
-        }
+        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 df3d53d..f97f502 100644
--- a/swh/indexer/tests/utils.py
+++ b/swh/indexer/tests/utils.py
@@ -1,768 +1,726 @@
 # 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
 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):
-    legacy_get_format = False
-    """True if and only if the tested indexer uses the legacy format.
-    see: https://forge.softwareheritage.org/T1433
-
-    """
-
     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_legacy_results_ok(self, sha1s, expected_results=None):
-        # XXX old format, remove this when all endpoints are
-        #     updated to the new one
-        #     see: https://forge.softwareheritage.org/T1433
-        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(
-            len(expected_results),
-            len(actual_results),
-            (expected_results, actual_results),
-        )
-        for indexed_data in actual_results:
-            _id = indexed_data["id"]
-            expected_data = expected_results[hashutil.hash_to_hex(_id)].copy()
-            expected_data["id"] = _id
-            self.assertEqual(indexed_data, expected_data)
-
     def assert_results_ok(self, sha1s, expected_results=None):
-        if self.legacy_get_format:
-            self.assert_legacy_results_ok(sha1s, expected_results)
-            return
-
         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(
-            sum(res is not None for res in expected_results.values()),
-            sum(sum(map(len, res.values())) for res in actual_results),
-            (expected_results, actual_results),
-        )
-        for indexed_data in actual_results:
-            (_id, indexed_data) = list(indexed_data.items())[0]
-            if expected_results.get(hashutil.hash_to_hex(_id)) is None:
-                self.assertEqual(indexed_data, [])
-            else:
-                expected_data = expected_results[hashutil.hash_to_hex(_id)].copy()
-                expected_data = [expected_data]
-                self.assertEqual(indexed_data, expected_data)
+        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
-        expected_results = {
-            k: v for k, v in self.expected_results.items() if k in sha1s
-        }
+        # 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
+        ]
 
         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}
 
         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"}