diff --git a/swh/web/tests/api/views/test_content.py b/swh/web/tests/api/views/test_content.py
index fd330def..69f0e2d2 100644
--- a/swh/web/tests/api/views/test_content.py
+++ b/swh/web/tests/api/views/test_content.py
@@ -1,399 +1,399 @@
 # Copyright (C) 2015-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import pytest
 
 from hypothesis import given
 
 from swh.web.common.utils import reverse
 from swh.web.tests.data import random_content
 from swh.web.tests.strategies import content, contents_with_ctags
 from swh.web.tests.conftest import ctags_json_missing, fossology_missing
 
 
 @given(content())
 def test_api_content_filetype(api_client, indexer_data, content):
     indexer_data.content_add_mimetype(content["sha1"])
     url = reverse(
         "api-1-content-filetype", url_args={"q": "sha1_git:%s" % content["sha1_git"]}
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     content_url = reverse(
         "api-1-content",
         url_args={"q": "sha1:%s" % content["sha1"]},
         request=rv.wsgi_request,
     )
     expected_data = indexer_data.content_get_mimetype(content["sha1"])
     expected_data["content_url"] = content_url
     assert rv.data == expected_data
 
 
 def test_api_content_filetype_sha_not_found(api_client):
     unknown_content_ = random_content()
 
     url = reverse(
         "api-1-content-filetype", url_args={"q": "sha1:%s" % unknown_content_["sha1"]}
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 404, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "No filetype information found for content "
         "sha1:%s." % unknown_content_["sha1"],
     }
 
 
 @pytest.mark.skip  # Language indexer is disabled
 @given(content())
 def test_api_content_language(api_client, indexer_data, content):
     indexer_data.content_add_language(content["sha1"])
     url = reverse(
         "api-1-content-language", url_args={"q": "sha1_git:%s" % content["sha1_git"]}
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     content_url = reverse(
         "api-1-content",
         url_args={"q": "sha1:%s" % content["sha1"]},
         request=rv.wsgi_request,
     )
     expected_data = indexer_data.content_get_language(content["sha1"])
     expected_data["content_url"] = content_url
     assert rv.data == expected_data
 
 
 def test_api_content_language_sha_not_found(api_client):
     unknown_content_ = random_content()
 
     url = reverse(
         "api-1-content-language", url_args={"q": "sha1:%s" % unknown_content_["sha1"]}
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 404, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "No language information found for content "
         "sha1:%s." % unknown_content_["sha1"],
     }
 
 
 @pytest.mark.skip  # Language indexer is disabled
 @pytest.mark.skipif(
     ctags_json_missing, reason="requires ctags with json output support"
 )
 @given(contents_with_ctags())
 def test_api_content_symbol(api_client, indexer_data, contents_with_ctags):
     expected_data = {}
     for content_sha1 in contents_with_ctags["sha1s"]:
         indexer_data.content_add_ctags(content_sha1)
         for ctag in indexer_data.content_get_ctags(content_sha1):
             if ctag["name"] == contents_with_ctags["symbol_name"]:
                 expected_data[content_sha1] = ctag
                 break
     url = reverse(
         "api-1-content-symbol",
         url_args={"q": contents_with_ctags["symbol_name"]},
         query_params={"per_page": 100},
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     for entry in rv.data:
         content_sha1 = entry["sha1"]
         expected_entry = expected_data[content_sha1]
         for key, view_name in (
             ("content_url", "api-1-content"),
             ("data_url", "api-1-content-raw"),
             ("license_url", "api-1-content-license"),
             ("language_url", "api-1-content-language"),
             ("filetype_url", "api-1-content-filetype"),
         ):
             expected_entry[key] = reverse(
                 view_name,
                 url_args={"q": "sha1:%s" % content_sha1},
                 request=rv.wsgi_request,
             )
         expected_entry["sha1"] = content_sha1
         del expected_entry["id"]
         assert entry == expected_entry
     assert "Link" not in rv
 
     url = reverse(
         "api-1-content-symbol",
         url_args={"q": contents_with_ctags["symbol_name"]},
         query_params={"per_page": 2},
     )
     rv = api_client.get(url)
 
     next_url = (
         reverse(
             "api-1-content-symbol",
             url_args={"q": contents_with_ctags["symbol_name"]},
             query_params={"last_sha1": rv.data[1]["sha1"], "per_page": 2},
             request=rv.wsgi_request,
         ),
     )
     assert rv["Link"] == '<%s>; rel="next"' % next_url
 
 
 def test_api_content_symbol_not_found(api_client):
     url = reverse("api-1-content-symbol", url_args={"q": "bar"})
     rv = api_client.get(url)
 
     assert rv.status_code == 404, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "No indexed raw content match expression 'bar'.",
     }
     assert "Link" not in rv
 
 
 @pytest.mark.skipif(
     ctags_json_missing, reason="requires ctags with json output support"
 )
 @given(content())
 def test_api_content_ctags(api_client, indexer_data, content):
     indexer_data.content_add_ctags(content["sha1"])
     url = reverse(
         "api-1-content-ctags", url_args={"q": "sha1_git:%s" % content["sha1_git"]}
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     content_url = reverse(
         "api-1-content",
         url_args={"q": "sha1:%s" % content["sha1"]},
         request=rv.wsgi_request,
     )
     expected_data = list(indexer_data.content_get_ctags(content["sha1"]))
     for e in expected_data:
         e["content_url"] = content_url
     assert rv.data == expected_data
 
 
 @pytest.mark.skipif(fossology_missing, reason="requires fossology-nomossa installed")
 @given(content())
 def test_api_content_license(api_client, indexer_data, content):
     indexer_data.content_add_license(content["sha1"])
     url = reverse(
         "api-1-content-license", url_args={"q": "sha1_git:%s" % content["sha1_git"]}
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     content_url = reverse(
         "api-1-content",
         url_args={"q": "sha1:%s" % content["sha1"]},
         request=rv.wsgi_request,
     )
     expected_data = indexer_data.content_get_license(content["sha1"])
     expected_data["content_url"] = content_url
     assert rv.data == expected_data
 
 
 def test_api_content_license_sha_not_found(api_client):
     unknown_content_ = random_content()
 
     url = reverse(
         "api-1-content-license", url_args={"q": "sha1:%s" % unknown_content_["sha1"]}
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 404, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "No license information found for content "
         "sha1:%s." % unknown_content_["sha1"],
     }
 
 
 @given(content())
 def test_api_content_metadata(api_client, archive_data, content):
     url = reverse("api-1-content", {"q": "sha1:%s" % content["sha1"]})
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
-    expected_data = archive_data.content_get_metadata(content["sha1"])
+    expected_data = archive_data.content_get(content["sha1"])
     for key, view_name in (
         ("data_url", "api-1-content-raw"),
         ("license_url", "api-1-content-license"),
         ("language_url", "api-1-content-language"),
         ("filetype_url", "api-1-content-filetype"),
     ):
         expected_data[key] = reverse(
             view_name,
             url_args={"q": "sha1:%s" % content["sha1"]},
             request=rv.wsgi_request,
         )
     assert rv.data == expected_data
 
 
 def test_api_content_not_found_as_json(api_client):
     unknown_content_ = random_content()
 
     url = reverse("api-1-content", url_args={"q": "sha1:%s" % unknown_content_["sha1"]})
     rv = api_client.get(url)
     assert rv.status_code == 404, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "Content with sha1 checksum equals to %s not found!"
         % unknown_content_["sha1"],
     }
 
 
 def test_api_content_not_found_as_yaml(api_client):
     unknown_content_ = random_content()
 
     url = reverse(
         "api-1-content", url_args={"q": "sha256:%s" % unknown_content_["sha256"]}
     )
     rv = api_client.get(url, HTTP_ACCEPT="application/yaml")
 
     assert rv.status_code == 404, rv.data
     assert "application/yaml" in rv["Content-Type"]
 
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "Content with sha256 checksum equals to %s not found!"
         % unknown_content_["sha256"],
     }
 
 
 def test_api_content_raw_ko_not_found(api_client):
     unknown_content_ = random_content()
 
     url = reverse(
         "api-1-content-raw", url_args={"q": "sha1:%s" % unknown_content_["sha1"]}
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 404, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "Content with sha1 checksum equals to %s not found!"
         % unknown_content_["sha1"],
     }
 
 
 @given(content())
 def test_api_content_raw_text(api_client, archive_data, content):
     url = reverse("api-1-content-raw", url_args={"q": "sha1:%s" % content["sha1"]})
 
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/octet-stream"
     assert (
         rv["Content-disposition"]
         == "attachment; filename=content_sha1_%s_raw" % content["sha1"]
     )
     assert rv["Content-Type"] == "application/octet-stream"
     expected_data = archive_data.content_get_data(content["sha1"])
     assert rv.content == expected_data["data"]
 
 
 @given(content())
 def test_api_content_raw_text_with_filename(api_client, archive_data, content):
     url = reverse(
         "api-1-content-raw",
         url_args={"q": "sha1:%s" % content["sha1"]},
         query_params={"filename": "filename.txt"},
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/octet-stream"
     assert rv["Content-disposition"] == "attachment; filename=filename.txt"
     assert rv["Content-Type"] == "application/octet-stream"
     expected_data = archive_data.content_get_data(content["sha1"])
     assert rv.content == expected_data["data"]
 
 
 @given(content())
 def test_api_check_content_known(api_client, content):
     url = reverse("api-1-content-known", url_args={"q": content["sha1"]})
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
 
     assert rv.data == {
         "search_res": [{"found": True, "sha1": content["sha1"]}],
         "search_stats": {"nbfiles": 1, "pct": 100.0},
     }
 
 
 @given(content())
 def test_api_check_content_known_as_yaml(api_client, content):
     url = reverse("api-1-content-known", url_args={"q": content["sha1"]})
     rv = api_client.get(url, HTTP_ACCEPT="application/yaml")
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/yaml"
 
     assert rv.data == {
         "search_res": [{"found": True, "sha1": content["sha1"]}],
         "search_stats": {"nbfiles": 1, "pct": 100.0},
     }
 
 
 @given(content())
 def test_api_check_content_known_post_as_yaml(api_client, content):
     url = reverse("api-1-content-known")
     rv = api_client.post(
         url, data={"q": content["sha1"]}, HTTP_ACCEPT="application/yaml"
     )
 
     assert rv.status_code == 200, rv.data
     assert "application/yaml" in rv["Content-Type"]
     assert rv.data == {
         "search_res": [{"found": True, "sha1": content["sha1"]}],
         "search_stats": {"nbfiles": 1, "pct": 100.0},
     }
 
 
 def test_api_check_content_known_not_found(api_client):
     unknown_content_ = random_content()
 
     url = reverse("api-1-content-known", url_args={"q": unknown_content_["sha1"]})
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "search_res": [{"found": False, "sha1": unknown_content_["sha1"]}],
         "search_stats": {"nbfiles": 1, "pct": 0.0},
     }
 
 
 @given(content())
 def test_api_content_uppercase(api_client, content):
     url = reverse(
         "api-1-content-uppercase-checksum", url_args={"q": content["sha1"].upper()}
     )
 
     rv = api_client.get(url)
     assert rv.status_code == 302, rv.data
 
     redirect_url = reverse("api-1-content", url_args={"q": content["sha1"]})
 
     assert rv["location"] == redirect_url
diff --git a/swh/web/tests/browse/views/test_content.py b/swh/web/tests/browse/views/test_content.py
index 1f87eded..6bba3f81 100644
--- a/swh/web/tests/browse/views/test_content.py
+++ b/swh/web/tests/browse/views/test_content.py
@@ -1,592 +1,591 @@
 # Copyright (C) 2017-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import random
 
 from django.utils.html import escape
 
 from hypothesis import given
 
 from swh.model.identifiers import CONTENT, DIRECTORY, RELEASE, REVISION, SNAPSHOT
 from swh.web.browse.snapshot_context import process_snapshot_branches
 from swh.web.browse.utils import (
     get_mimetype_and_encoding_for_content,
     prepare_content_for_display,
     _re_encode_content,
 )
 from swh.web.common.exc import NotFoundExc
 from swh.web.common.identifiers import gen_swhid
 from swh.web.common.utils import gen_path_info, reverse
 from swh.web.tests.django_asserts import (
     assert_contains,
     assert_not_contains,
     assert_template_used,
 )
 from swh.web.tests.strategies import (
     content,
     content_text_non_utf8,
     content_text_no_highlight,
     content_image_type,
     content_unsupported_image_type_rendering,
     content_text,
     invalid_sha1,
     unknown_content,
     content_utf8_detected_as_binary,
     origin_with_multiple_visits,
 )
 
 
 @given(content_text())
 def test_content_view_text(client, archive_data, content):
     sha1_git = content["sha1_git"]
 
     url = reverse(
         "browse-content",
         url_args={"query_string": content["sha1"]},
         query_params={"path": content["path"]},
     )
 
     url_raw = reverse("browse-content-raw", url_args={"query_string": content["sha1"]})
 
     resp = client.get(url)
 
     content_display = _process_content_for_display(archive_data, content)
     mimetype = content_display["mimetype"]
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
 
     if mimetype.startswith("text/"):
         assert_contains(resp, '<code class="%s">' % content_display["language"])
         assert_contains(resp, escape(content_display["content_data"]))
     assert_contains(resp, url_raw)
 
     swh_cnt_id = gen_swhid(CONTENT, sha1_git)
     swh_cnt_id_url = reverse("browse-swhid", url_args={"swhid": swh_cnt_id})
     assert_contains(resp, swh_cnt_id)
     assert_contains(resp, swh_cnt_id_url)
 
 
 @given(content_text_no_highlight())
 def test_content_view_text_no_highlight(client, archive_data, content):
     sha1_git = content["sha1_git"]
 
     url = reverse("browse-content", url_args={"query_string": content["sha1"]})
 
     url_raw = reverse("browse-content-raw", url_args={"query_string": content["sha1"]})
 
     resp = client.get(url)
 
     content_display = _process_content_for_display(archive_data, content)
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
 
     assert_contains(resp, '<code class="nohighlight">')
     assert_contains(resp, escape(content_display["content_data"]))
     assert_contains(resp, url_raw)
 
     swh_cnt_id = gen_swhid(CONTENT, sha1_git)
     swh_cnt_id_url = reverse("browse-swhid", url_args={"swhid": swh_cnt_id})
 
     assert_contains(resp, swh_cnt_id)
     assert_contains(resp, swh_cnt_id_url)
 
 
 @given(content_text_non_utf8())
 def test_content_view_no_utf8_text(client, archive_data, content):
     sha1_git = content["sha1_git"]
 
     url = reverse("browse-content", url_args={"query_string": content["sha1"]})
 
     resp = client.get(url)
 
     content_display = _process_content_for_display(archive_data, content)
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
     swh_cnt_id = gen_swhid(CONTENT, sha1_git)
     swh_cnt_id_url = reverse("browse-swhid", url_args={"swhid": swh_cnt_id})
     assert_contains(resp, swh_cnt_id_url)
     assert_contains(resp, escape(content_display["content_data"]))
 
 
 @given(content_image_type())
 def test_content_view_image(client, archive_data, content):
     url = reverse("browse-content", url_args={"query_string": content["sha1"]})
 
     url_raw = reverse("browse-content-raw", url_args={"query_string": content["sha1"]})
 
     resp = client.get(url)
 
     content_display = _process_content_for_display(archive_data, content)
     mimetype = content_display["mimetype"]
     content_data = content_display["content_data"]
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
     assert_contains(resp, '<img src="data:%s;base64,%s"/>' % (mimetype, content_data))
     assert_contains(resp, url_raw)
 
 
 @given(content_unsupported_image_type_rendering())
 def test_content_view_image_no_rendering(client, archive_data, content):
     url = reverse("browse-content", url_args={"query_string": content["sha1"]})
 
     resp = client.get(url)
 
     mimetype = content["mimetype"]
     encoding = content["encoding"]
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
     assert_contains(
         resp,
         (
             f"Content with mime type {mimetype} and encoding {encoding} "
             "cannot be displayed."
         ),
     )
 
 
 @given(content_text())
 def test_content_view_text_with_path(client, archive_data, content):
     path = content["path"]
 
     url = reverse(
         "browse-content",
         url_args={"query_string": content["sha1"]},
         query_params={"path": path},
     )
 
     resp = client.get(url)
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
 
     assert_contains(resp, '<nav class="bread-crumbs')
 
     content_display = _process_content_for_display(archive_data, content)
     mimetype = content_display["mimetype"]
 
     if mimetype.startswith("text/"):
         hljs_language = content["hljs_language"]
         assert_contains(resp, '<code class="%s">' % hljs_language)
         assert_contains(resp, escape(content_display["content_data"]))
 
     split_path = path.split("/")
 
     root_dir_sha1 = split_path[0]
     filename = split_path[-1]
     path = path.replace(root_dir_sha1 + "/", "").replace(filename, "")
 
     swhid_context = {
         "anchor": gen_swhid(DIRECTORY, root_dir_sha1),
         "path": f"/{path}{filename}",
     }
 
     swh_cnt_id = gen_swhid(CONTENT, content["sha1_git"], metadata=swhid_context)
     swh_cnt_id_url = reverse("browse-swhid", url_args={"swhid": swh_cnt_id})
     assert_contains(resp, swh_cnt_id)
     assert_contains(resp, swh_cnt_id_url)
 
     path_info = gen_path_info(path)
 
     root_dir_url = reverse("browse-directory", url_args={"sha1_git": root_dir_sha1})
 
     assert_contains(resp, '<li class="swh-path">', count=len(path_info) + 1)
 
     assert_contains(
         resp, '<a href="' + root_dir_url + '">' + root_dir_sha1[:7] + "</a>"
     )
 
     for p in path_info:
         dir_url = reverse(
             "browse-directory",
             url_args={"sha1_git": root_dir_sha1},
             query_params={"path": p["path"]},
         )
         assert_contains(resp, '<a href="' + dir_url + '">' + p["name"] + "</a>")
 
     assert_contains(resp, "<li>" + filename + "</li>")
 
     url_raw = reverse(
         "browse-content-raw",
         url_args={"query_string": content["sha1"]},
         query_params={"filename": filename},
     )
     assert_contains(resp, url_raw)
 
     url = reverse(
         "browse-content",
         url_args={"query_string": content["sha1"]},
         query_params={"path": filename},
     )
 
     resp = client.get(url)
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
 
     assert_not_contains(resp, '<nav class="bread-crumbs')
 
     invalid_path = "%s/foo/bar/baz" % root_dir_sha1
     url = reverse(
         "browse-content",
         url_args={"query_string": content["sha1"]},
         query_params={"path": invalid_path},
     )
     resp = client.get(url)
     assert resp.status_code == 404
 
 
 @given(content_text())
 def test_content_raw_text(client, archive_data, content):
     url = reverse("browse-content-raw", url_args={"query_string": content["sha1"]})
 
     resp = client.get(url)
 
     content_data = archive_data.content_get_data(content["sha1"])["data"]
 
     assert resp.status_code == 200
     assert resp["Content-Type"] == "text/plain"
     assert resp["Content-disposition"] == ("filename=%s_%s" % ("sha1", content["sha1"]))
     assert resp.content == content_data
 
     filename = content["path"].split("/")[-1]
 
     url = reverse(
         "browse-content-raw",
         url_args={"query_string": content["sha1"]},
         query_params={"filename": filename},
     )
 
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert resp["Content-Type"] == "text/plain"
     assert resp["Content-disposition"] == "filename=%s" % filename
     assert resp.content == content_data
 
 
 @given(content_text_non_utf8())
 def test_content_raw_no_utf8_text(client, content):
     url = reverse("browse-content-raw", url_args={"query_string": content["sha1"]})
 
     resp = client.get(url)
     assert resp.status_code == 200
     _, encoding = get_mimetype_and_encoding_for_content(resp.content)
     assert encoding == content["encoding"]
 
 
 @given(content_image_type())
 def test_content_raw_bin(client, archive_data, content):
     url = reverse("browse-content-raw", url_args={"query_string": content["sha1"]})
 
     resp = client.get(url)
 
     filename = content["path"].split("/")[-1]
     content_data = archive_data.content_get_data(content["sha1"])["data"]
 
     assert resp.status_code == 200
     assert resp["Content-Type"] == "application/octet-stream"
     assert resp["Content-disposition"] == "attachment; filename=%s_%s" % (
         "sha1",
         content["sha1"],
     )
     assert resp.content == content_data
 
     url = reverse(
         "browse-content-raw",
         url_args={"query_string": content["sha1"]},
         query_params={"filename": filename},
     )
 
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert resp["Content-Type"] == "application/octet-stream"
     assert resp["Content-disposition"] == "attachment; filename=%s" % filename
     assert resp.content == content_data
 
 
 @given(invalid_sha1(), unknown_content())
 def test_content_request_errors(client, invalid_sha1, unknown_content):
     url = reverse("browse-content", url_args={"query_string": invalid_sha1})
     resp = client.get(url)
     assert resp.status_code == 400
     assert_template_used(resp, "error.html")
 
     url = reverse("browse-content", url_args={"query_string": unknown_content["sha1"]})
     resp = client.get(url)
     assert resp.status_code == 404
     assert_template_used(resp, "error.html")
 
 
 @given(content())
 def test_content_bytes_missing(client, archive_data, mocker, content):
     mock_service = mocker.patch("swh.web.browse.utils.service")
-    content_data = archive_data.content_get_metadata(content["sha1"])
-    content_data["data"] = None
+    content_data = archive_data.content_get(content["sha1"])
 
     mock_service.lookup_content.return_value = content_data
     mock_service.lookup_content_filetype.side_effect = Exception()
     mock_service.lookup_content_raw.side_effect = NotFoundExc(
         "Content bytes not available!"
     )
 
     url = reverse("browse-content", url_args={"query_string": content["sha1"]})
 
     resp = client.get(url)
 
     assert resp.status_code == 404
     assert_template_used(resp, "browse/content.html")
 
 
 def test_content_too_large(client, mocker):
     mock_request_content = mocker.patch("swh.web.browse.views.content.request_content")
     stub_content_too_large_data = {
         "checksums": {
             "sha1": "8624bcdae55baeef00cd11d5dfcfa60f68710a02",
             "sha1_git": "94a9ed024d3859793618152ea559a168bbcbb5e2",
             "sha256": (
                 "8ceb4b9ee5adedde47b31e975c1d90c73ad27b6b16" "5a1dcd80c7c545eb65b903"
             ),
             "blake2s256": (
                 "38702b7168c7785bfe748b51b45d9856070ba90" "f9dc6d90f2ea75d4356411ffe"
             ),
         },
         "length": 30000000,
         "raw_data": None,
         "mimetype": "text/plain",
         "encoding": "us-ascii",
         "language": "not detected",
         "licenses": "GPL",
         "error_code": 200,
         "error_message": "",
         "error_description": "",
     }
 
     content_sha1 = stub_content_too_large_data["checksums"]["sha1"]
 
     mock_request_content.return_value = stub_content_too_large_data
 
     url = reverse("browse-content", url_args={"query_string": content_sha1})
 
     url_raw = reverse("browse-content-raw", url_args={"query_string": content_sha1})
 
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
 
     assert_contains(resp, "Content is too large to be displayed")
     assert_contains(resp, url_raw)
 
 
 @given(content())
 def test_content_uppercase(client, content):
     url = reverse(
         "browse-content-uppercase-checksum",
         url_args={"query_string": content["sha1"].upper()},
     )
     resp = client.get(url)
     assert resp.status_code == 302
 
     redirect_url = reverse("browse-content", url_args={"query_string": content["sha1"]})
 
     assert resp["location"] == redirect_url
 
 
 @given(content_utf8_detected_as_binary())
 def test_content_utf8_detected_as_binary_display(client, archive_data, content):
     url = reverse("browse-content", url_args={"query_string": content["sha1"]})
     resp = client.get(url)
 
     content_display = _process_content_for_display(archive_data, content)
 
     assert_contains(resp, escape(content_display["content_data"]))
 
 
 @given(origin_with_multiple_visits())
 def test_content_origin_snapshot_branch_browse(client, archive_data, origin):
     visits = archive_data.origin_visit_get(origin["url"])
     visit = random.choice(visits)
     snapshot = archive_data.snapshot_get(visit["snapshot"])
     branches, releases = process_snapshot_branches(snapshot)
     branch_info = random.choice(branches)
 
     directory = archive_data.revision_get(branch_info["revision"])["directory"]
     directory_content = archive_data.directory_ls(directory)
     directory_file = random.choice(
         [e for e in directory_content if e["type"] == "file"]
     )
 
     url = reverse(
         "browse-content",
         url_args={"query_string": directory_file["checksums"]["sha1"]},
         query_params={
             "origin_url": origin["url"],
             "snapshot": snapshot["id"],
             "branch": branch_info["name"],
             "path": directory_file["name"],
         },
     )
 
     resp = client.get(url)
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
     _check_origin_snapshot_related_html(resp, origin, snapshot, branches, releases)
     assert_contains(resp, directory_file["name"])
     assert_contains(resp, f"Branch: <strong>{branch_info['name']}</strong>")
 
     cnt_swhid = gen_swhid(
         CONTENT,
         directory_file["checksums"]["sha1_git"],
         metadata={
             "origin": origin["url"],
             "visit": gen_swhid(SNAPSHOT, snapshot),
             "anchor": gen_swhid(REVISION, branch_info["revision"]),
             "path": f"/{directory_file['name']}",
         },
     )
     assert_contains(resp, cnt_swhid)
 
     dir_swhid = gen_swhid(
         DIRECTORY,
         directory,
         metadata={
             "origin": origin["url"],
             "visit": gen_swhid(SNAPSHOT, snapshot),
             "anchor": gen_swhid(REVISION, branch_info["revision"]),
             "path": "/",
         },
     )
     assert_contains(resp, dir_swhid)
 
     rev_swhid = gen_swhid(
         REVISION,
         branch_info["revision"],
         metadata={"origin": origin["url"], "visit": gen_swhid(SNAPSHOT, snapshot),},
     )
     assert_contains(resp, rev_swhid)
 
     snp_swhid = gen_swhid(SNAPSHOT, snapshot, metadata={"origin": origin["url"],},)
     assert_contains(resp, snp_swhid)
 
 
 @given(origin_with_multiple_visits())
 def test_content_origin_snapshot_release_browse(client, archive_data, origin):
     visits = archive_data.origin_visit_get(origin["url"])
     visit = random.choice(visits)
     snapshot = archive_data.snapshot_get(visit["snapshot"])
     branches, releases = process_snapshot_branches(snapshot)
     release_info = random.choice(releases)
 
     directory_content = archive_data.directory_ls(release_info["directory"])
     directory_file = random.choice(
         [e for e in directory_content if e["type"] == "file"]
     )
 
     url = reverse(
         "browse-content",
         url_args={"query_string": directory_file["checksums"]["sha1"]},
         query_params={
             "origin_url": origin["url"],
             "snapshot": snapshot["id"],
             "release": release_info["name"],
             "path": directory_file["name"],
         },
     )
 
     resp = client.get(url)
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
     _check_origin_snapshot_related_html(resp, origin, snapshot, branches, releases)
     assert_contains(resp, directory_file["name"])
     assert_contains(resp, f"Release: <strong>{release_info['name']}</strong>")
 
     cnt_swhid = gen_swhid(
         CONTENT,
         directory_file["checksums"]["sha1_git"],
         metadata={
             "origin": origin["url"],
             "visit": gen_swhid(SNAPSHOT, snapshot),
             "anchor": gen_swhid(RELEASE, release_info["id"]),
             "path": f"/{directory_file['name']}",
         },
     )
     assert_contains(resp, cnt_swhid)
 
     dir_swhid = gen_swhid(
         DIRECTORY,
         release_info["directory"],
         metadata={
             "origin": origin["url"],
             "visit": gen_swhid(SNAPSHOT, snapshot),
             "anchor": gen_swhid(RELEASE, release_info["id"]),
             "path": "/",
         },
     )
     assert_contains(resp, dir_swhid)
 
     rev_swhid = gen_swhid(
         REVISION,
         release_info["target"],
         metadata={"origin": origin["url"], "visit": gen_swhid(SNAPSHOT, snapshot),},
     )
     assert_contains(resp, rev_swhid)
 
     rel_swhid = gen_swhid(
         RELEASE,
         release_info["id"],
         metadata={"origin": origin["url"], "visit": gen_swhid(SNAPSHOT, snapshot),},
     )
     assert_contains(resp, rel_swhid)
 
     snp_swhid = gen_swhid(SNAPSHOT, snapshot, metadata={"origin": origin["url"],},)
     assert_contains(resp, snp_swhid)
 
 
 def _check_origin_snapshot_related_html(resp, origin, snapshot, branches, releases):
     browse_origin_url = reverse(
         "browse-origin", query_params={"origin_url": origin["url"]}
     )
     assert_contains(resp, f'href="{browse_origin_url}"')
 
     origin_branches_url = reverse(
         "browse-origin-branches",
         query_params={"origin_url": origin["url"], "snapshot": snapshot["id"]},
     )
 
     assert_contains(resp, f'href="{escape(origin_branches_url)}"')
     assert_contains(resp, f"Branches ({len(branches)})")
 
     origin_releases_url = reverse(
         "browse-origin-releases",
         query_params={"origin_url": origin["url"], "snapshot": snapshot["id"]},
     )
 
     assert_contains(resp, f'href="{escape(origin_releases_url)}"')
     assert_contains(resp, f"Releases ({len(releases)})")
 
     assert_contains(resp, '<li class="swh-branch">', count=len(branches))
     assert_contains(resp, '<li class="swh-release">', count=len(releases))
 
 
 def _process_content_for_display(archive_data, content):
     content_data = archive_data.content_get_data(content["sha1"])
 
     mime_type, encoding = get_mimetype_and_encoding_for_content(content_data["data"])
 
     mime_type, encoding, content_data = _re_encode_content(
         mime_type, encoding, content_data["data"]
     )
 
     content_display = prepare_content_for_display(
         content_data, mime_type, content["path"]
     )
 
     assert type(content_display["content_data"]) == str
 
     return content_display
diff --git a/swh/web/tests/common/test_service.py b/swh/web/tests/common/test_service.py
index d14240f3..63205ffd 100644
--- a/swh/web/tests/common/test_service.py
+++ b/swh/web/tests/common/test_service.py
@@ -1,975 +1,975 @@
 # Copyright (C) 2015-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import itertools
 import pytest
 import random
 
 from collections import defaultdict
 from hypothesis import given
 
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.from_disk import DentryPerms
 from swh.model.identifiers import CONTENT, DIRECTORY, RELEASE, REVISION, SNAPSHOT
 from swh.model.model import Directory, DirectoryEntry, Origin, OriginVisit, Revision
 
 from swh.web.common import service
 from swh.web.common.exc import BadInputExc, NotFoundExc
 from swh.web.tests.data import random_sha1, random_content
 from swh.web.tests.strategies import (
     content,
     unknown_content,
     contents,
     unknown_contents,
     contents_with_ctags,
     origin,
     new_origin,
     visit_dates,
     directory,
     unknown_directory,
     release,
     unknown_release,
     revision,
     unknown_revision,
     revisions,
     ancestor_revisions,
     non_ancestor_revisions,
     invalid_sha1,
     sha256,
     revision_with_submodules,
     empty_directory,
     new_revision,
     snapshot,
     unknown_snapshot,
 )
 from swh.web.tests.conftest import ctags_json_missing, fossology_missing
 
 
 @given(contents())
 def test_lookup_multiple_hashes_all_present(contents):
     input_data = []
     expected_output = []
     for cnt in contents:
         input_data.append({"sha1": cnt["sha1"]})
         expected_output.append({"sha1": cnt["sha1"], "found": True})
 
     assert service.lookup_multiple_hashes(input_data) == expected_output
 
 
 @given(contents(), unknown_contents())
 def test_lookup_multiple_hashes_some_missing(contents, unknown_contents):
     input_contents = list(itertools.chain(contents, unknown_contents))
     random.shuffle(input_contents)
 
     input_data = []
     expected_output = []
     for cnt in input_contents:
         input_data.append({"sha1": cnt["sha1"]})
         expected_output.append({"sha1": cnt["sha1"], "found": cnt in contents})
 
     assert service.lookup_multiple_hashes(input_data) == expected_output
 
 
 def test_lookup_hash_does_not_exist():
     unknown_content_ = random_content()
 
     actual_lookup = service.lookup_hash("sha1_git:%s" % unknown_content_["sha1_git"])
 
     assert actual_lookup == {"found": None, "algo": "sha1_git"}
 
 
 @given(content())
 def test_lookup_hash_exist(archive_data, content):
     actual_lookup = service.lookup_hash("sha1:%s" % content["sha1"])
 
-    content_metadata = archive_data.content_get_metadata(content["sha1"])
+    content_metadata = archive_data.content_get(content["sha1"])
 
     assert {"found": content_metadata, "algo": "sha1"} == actual_lookup
 
 
 def test_search_hash_does_not_exist():
     unknown_content_ = random_content()
 
     actual_lookup = service.search_hash("sha1_git:%s" % unknown_content_["sha1_git"])
 
     assert {"found": False} == actual_lookup
 
 
 @given(content())
 def test_search_hash_exist(content):
     actual_lookup = service.search_hash("sha1:%s" % content["sha1"])
 
     assert {"found": True} == actual_lookup
 
 
 @pytest.mark.skipif(
     ctags_json_missing, reason="requires ctags with json output support"
 )
 @given(contents_with_ctags())
 def test_lookup_content_ctags(indexer_data, contents_with_ctags):
     content_sha1 = random.choice(contents_with_ctags["sha1s"])
     indexer_data.content_add_ctags(content_sha1)
     actual_ctags = list(service.lookup_content_ctags("sha1:%s" % content_sha1))
 
     expected_data = list(indexer_data.content_get_ctags(content_sha1))
     for ctag in expected_data:
         ctag["id"] = content_sha1
 
     assert actual_ctags == expected_data
 
 
 def test_lookup_content_ctags_no_hash():
     unknown_content_ = random_content()
 
     actual_ctags = list(
         service.lookup_content_ctags("sha1:%s" % unknown_content_["sha1"])
     )
 
     assert actual_ctags == []
 
 
 @given(content())
 def test_lookup_content_filetype(indexer_data, content):
     indexer_data.content_add_mimetype(content["sha1"])
     actual_filetype = service.lookup_content_filetype(content["sha1"])
 
     expected_filetype = indexer_data.content_get_mimetype(content["sha1"])
     assert actual_filetype == expected_filetype
 
 
 @pytest.mark.skip  # Language indexer is disabled.
 @given(content())
 def test_lookup_content_language(indexer_data, content):
     indexer_data.content_add_language(content["sha1"])
     actual_language = service.lookup_content_language(content["sha1"])
 
     expected_language = indexer_data.content_get_language(content["sha1"])
     assert actual_language == expected_language
 
 
 @given(contents_with_ctags())
 def test_lookup_expression(indexer_data, contents_with_ctags):
     per_page = 10
     expected_ctags = []
 
     for content_sha1 in contents_with_ctags["sha1s"]:
         if len(expected_ctags) == per_page:
             break
         indexer_data.content_add_ctags(content_sha1)
         for ctag in indexer_data.content_get_ctags(content_sha1):
             if len(expected_ctags) == per_page:
                 break
             if ctag["name"] == contents_with_ctags["symbol_name"]:
                 del ctag["id"]
                 ctag["sha1"] = content_sha1
                 expected_ctags.append(ctag)
 
     actual_ctags = list(
         service.lookup_expression(
             contents_with_ctags["symbol_name"], last_sha1=None, per_page=10
         )
     )
 
     assert actual_ctags == expected_ctags
 
 
 def test_lookup_expression_no_result():
     expected_ctags = []
 
     actual_ctags = list(
         service.lookup_expression("barfoo", last_sha1=None, per_page=10)
     )
     assert actual_ctags == expected_ctags
 
 
 @pytest.mark.skipif(fossology_missing, reason="requires fossology-nomossa installed")
 @given(content())
 def test_lookup_content_license(indexer_data, content):
     indexer_data.content_add_license(content["sha1"])
     actual_license = service.lookup_content_license(content["sha1"])
 
     expected_license = indexer_data.content_get_license(content["sha1"])
     assert actual_license == expected_license
 
 
 def test_stat_counters(archive_data):
     actual_stats = service.stat_counters()
     assert actual_stats == archive_data.stat_counters()
 
 
 @given(new_origin(), visit_dates())
 def test_lookup_origin_visits(archive_data, new_origin, visit_dates):
     archive_data.origin_add([new_origin])
 
     archive_data.origin_visit_add(
         [OriginVisit(origin=new_origin.url, date=ts, type="git",) for ts in visit_dates]
     )
 
     actual_origin_visits = list(
         service.lookup_origin_visits(new_origin.url, per_page=100)
     )
 
     expected_visits = archive_data.origin_visit_get(new_origin.url)
     for expected_visit in expected_visits:
         expected_visit["origin"] = new_origin.url
 
     assert actual_origin_visits == expected_visits
 
 
 @given(new_origin(), visit_dates())
 def test_lookup_origin_visit(archive_data, new_origin, visit_dates):
     archive_data.origin_add([new_origin])
     visits = archive_data.origin_visit_add(
         [OriginVisit(origin=new_origin.url, date=ts, type="git",) for ts in visit_dates]
     )
 
     visit = random.choice(visits).visit
     actual_origin_visit = service.lookup_origin_visit(new_origin.url, visit)
 
     expected_visit = dict(archive_data.origin_visit_get_by(new_origin.url, visit))
 
     assert actual_origin_visit == expected_visit
 
 
 @given(new_origin())
 def test_lookup_origin(archive_data, new_origin):
     archive_data.origin_add([new_origin])
 
     actual_origin = service.lookup_origin({"url": new_origin.url})
     expected_origin = archive_data.origin_get([new_origin.url])[0]
     assert actual_origin == expected_origin
 
 
 @given(invalid_sha1())
 def test_lookup_release_ko_id_checksum_not_a_sha1(invalid_sha1):
     with pytest.raises(BadInputExc) as e:
         service.lookup_release(invalid_sha1)
     assert e.match("Invalid checksum")
 
 
 @given(sha256())
 def test_lookup_release_ko_id_checksum_too_long(sha256):
     with pytest.raises(BadInputExc) as e:
         service.lookup_release(sha256)
     assert e.match("Only sha1_git is supported.")
 
 
 @given(directory())
 def test_lookup_directory_with_path_not_found(directory):
     path = "some/invalid/path/here"
     with pytest.raises(NotFoundExc) as e:
         service.lookup_directory_with_path(directory, path)
     assert e.match("Directory entry with path %s from %s not found" % (path, directory))
 
 
 @given(directory())
 def test_lookup_directory_with_path_found(archive_data, directory):
     directory_content = archive_data.directory_ls(directory)
     directory_entry = random.choice(directory_content)
     path = directory_entry["name"]
     actual_result = service.lookup_directory_with_path(directory, path)
     assert actual_result == directory_entry
 
 
 @given(release())
 def test_lookup_release(archive_data, release):
     actual_release = service.lookup_release(release)
 
     assert actual_release == archive_data.release_get(release)
 
 
 @given(revision(), invalid_sha1(), sha256())
 def test_lookup_revision_with_context_ko_not_a_sha1(revision, invalid_sha1, sha256):
     sha1_git_root = revision
     sha1_git = invalid_sha1
 
     with pytest.raises(BadInputExc) as e:
         service.lookup_revision_with_context(sha1_git_root, sha1_git)
     assert e.match("Invalid checksum query string")
 
     sha1_git = sha256
 
     with pytest.raises(BadInputExc) as e:
         service.lookup_revision_with_context(sha1_git_root, sha1_git)
     assert e.match("Only sha1_git is supported")
 
 
 @given(revision(), unknown_revision())
 def test_lookup_revision_with_context_ko_sha1_git_does_not_exist(
     revision, unknown_revision
 ):
     sha1_git_root = revision
     sha1_git = unknown_revision
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_revision_with_context(sha1_git_root, sha1_git)
     assert e.match("Revision %s not found" % sha1_git)
 
 
 @given(revision(), unknown_revision())
 def test_lookup_revision_with_context_ko_root_sha1_git_does_not_exist(
     revision, unknown_revision
 ):
     sha1_git_root = unknown_revision
     sha1_git = revision
     with pytest.raises(NotFoundExc) as e:
         service.lookup_revision_with_context(sha1_git_root, sha1_git)
     assert e.match("Revision root %s not found" % sha1_git_root)
 
 
 @given(ancestor_revisions())
 def test_lookup_revision_with_context(archive_data, ancestor_revisions):
     sha1_git = ancestor_revisions["sha1_git"]
     root_sha1_git = ancestor_revisions["sha1_git_root"]
     for sha1_git_root in (root_sha1_git, {"id": hash_to_bytes(root_sha1_git)}):
         actual_revision = service.lookup_revision_with_context(sha1_git_root, sha1_git)
 
         children = []
         for rev in archive_data.revision_log(root_sha1_git):
             for p_rev in rev["parents"]:
                 p_rev_hex = hash_to_hex(p_rev)
                 if p_rev_hex == sha1_git:
                     children.append(rev["id"])
 
         expected_revision = archive_data.revision_get(sha1_git)
         expected_revision["children"] = children
         assert actual_revision == expected_revision
 
 
 @given(non_ancestor_revisions())
 def test_lookup_revision_with_context_ko(non_ancestor_revisions):
     sha1_git = non_ancestor_revisions["sha1_git"]
     root_sha1_git = non_ancestor_revisions["sha1_git_root"]
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_revision_with_context(root_sha1_git, sha1_git)
     assert e.match("Revision %s is not an ancestor of %s" % (sha1_git, root_sha1_git))
 
 
 def test_lookup_directory_with_revision_not_found():
     unknown_revision_ = random_sha1()
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_directory_with_revision(unknown_revision_)
     assert e.match("Revision %s not found" % unknown_revision_)
 
 
 @given(new_revision())
 def test_lookup_directory_with_revision_unknown_content(archive_data, new_revision):
     unknown_content_ = random_content()
 
     dir_path = "README.md"
 
     # A directory that points to unknown content
     dir = Directory(
         entries=(
             DirectoryEntry(
                 name=bytes(dir_path.encode("utf-8")),
                 type="file",
                 target=hash_to_bytes(unknown_content_["sha1_git"]),
                 perms=DentryPerms.content,
             ),
         )
     )
 
     # Create a revision that points to a directory
     # Which points to unknown content
     new_revision = new_revision.to_dict()
     new_revision["directory"] = dir.id
     del new_revision["id"]
     new_revision = Revision.from_dict(new_revision)
 
     # Add the directory and revision in mem
     archive_data.directory_add([dir])
     archive_data.revision_add([new_revision])
     new_revision_id = hash_to_hex(new_revision.id)
     with pytest.raises(NotFoundExc) as e:
         service.lookup_directory_with_revision(new_revision_id, dir_path)
     assert e.match("Content not found for revision %s" % new_revision_id)
 
 
 @given(revision())
 def test_lookup_directory_with_revision_ko_path_to_nowhere(revision):
     invalid_path = "path/to/something/unknown"
     with pytest.raises(NotFoundExc) as e:
         service.lookup_directory_with_revision(revision, invalid_path)
     assert e.match("Directory or File")
     assert e.match(invalid_path)
     assert e.match("revision %s" % revision)
     assert e.match("not found")
 
 
 @given(revision_with_submodules())
 def test_lookup_directory_with_revision_submodules(
     archive_data, revision_with_submodules
 ):
     rev_sha1_git = revision_with_submodules["rev_sha1_git"]
     rev_dir_path = revision_with_submodules["rev_dir_rev_path"]
 
     actual_data = service.lookup_directory_with_revision(rev_sha1_git, rev_dir_path)
 
     revision = archive_data.revision_get(revision_with_submodules["rev_sha1_git"])
     directory = archive_data.directory_ls(revision["directory"])
     rev_entry = next(e for e in directory if e["name"] == rev_dir_path)
 
     expected_data = {
         "content": archive_data.revision_get(rev_entry["target"]),
         "path": rev_dir_path,
         "revision": rev_sha1_git,
         "type": "rev",
     }
 
     assert actual_data == expected_data
 
 
 @given(revision())
 def test_lookup_directory_with_revision_without_path(archive_data, revision):
     actual_directory_entries = service.lookup_directory_with_revision(revision)
 
     revision_data = archive_data.revision_get(revision)
     expected_directory_entries = archive_data.directory_ls(revision_data["directory"])
 
     assert actual_directory_entries["type"] == "dir"
     assert actual_directory_entries["content"] == expected_directory_entries
 
 
 @given(revision())
 def test_lookup_directory_with_revision_with_path(archive_data, revision):
     rev_data = archive_data.revision_get(revision)
     dir_entries = [
         e
         for e in archive_data.directory_ls(rev_data["directory"])
         if e["type"] in ("file", "dir")
     ]
     expected_dir_entry = random.choice(dir_entries)
 
     actual_dir_entry = service.lookup_directory_with_revision(
         revision, expected_dir_entry["name"]
     )
 
     assert actual_dir_entry["type"] == expected_dir_entry["type"]
     assert actual_dir_entry["revision"] == revision
     assert actual_dir_entry["path"] == expected_dir_entry["name"]
     if actual_dir_entry["type"] == "file":
         del actual_dir_entry["content"]["checksums"]["blake2s256"]
         for key in ("checksums", "status", "length"):
             assert actual_dir_entry["content"][key] == expected_dir_entry[key]
     else:
         sub_dir_entries = archive_data.directory_ls(expected_dir_entry["target"])
         assert actual_dir_entry["content"] == sub_dir_entries
 
 
 @given(revision())
 def test_lookup_directory_with_revision_with_path_to_file_and_data(
     archive_data, revision
 ):
     rev_data = archive_data.revision_get(revision)
     dir_entries = [
         e
         for e in archive_data.directory_ls(rev_data["directory"])
         if e["type"] == "file"
     ]
     expected_dir_entry = random.choice(dir_entries)
     expected_data = archive_data.content_get_data(
         expected_dir_entry["checksums"]["sha1"]
     )
 
     actual_dir_entry = service.lookup_directory_with_revision(
         revision, expected_dir_entry["name"], with_data=True
     )
 
     assert actual_dir_entry["type"] == expected_dir_entry["type"]
     assert actual_dir_entry["revision"] == revision
     assert actual_dir_entry["path"] == expected_dir_entry["name"]
     del actual_dir_entry["content"]["checksums"]["blake2s256"]
     for key in ("checksums", "status", "length"):
         assert actual_dir_entry["content"][key] == expected_dir_entry[key]
     assert actual_dir_entry["content"]["data"] == expected_data["data"]
 
 
 @given(revision())
 def test_lookup_revision(archive_data, revision):
     actual_revision = service.lookup_revision(revision)
     assert actual_revision == archive_data.revision_get(revision)
 
 
 @given(new_revision())
 def test_lookup_revision_invalid_msg(archive_data, new_revision):
     new_revision = new_revision.to_dict()
     new_revision["message"] = b"elegant fix for bug \xff"
     archive_data.revision_add([Revision.from_dict(new_revision)])
 
     revision = service.lookup_revision(hash_to_hex(new_revision["id"]))
     assert revision["message"] is None
     assert revision["message_decoding_failed"] is True
 
 
 @given(new_revision())
 def test_lookup_revision_msg_ok(archive_data, new_revision):
     archive_data.revision_add([new_revision])
 
     revision_message = service.lookup_revision_message(hash_to_hex(new_revision.id))
 
     assert revision_message == {"message": new_revision.message}
 
 
 def test_lookup_revision_msg_no_rev():
     unknown_revision_ = random_sha1()
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_revision_message(unknown_revision_)
 
     assert e.match("Revision with sha1_git %s not found." % unknown_revision_)
 
 
 @given(revisions())
 def test_lookup_revision_multiple(archive_data, revisions):
     actual_revisions = list(service.lookup_revision_multiple(revisions))
 
     expected_revisions = []
     for rev in revisions:
         expected_revisions.append(archive_data.revision_get(rev))
 
     assert actual_revisions == expected_revisions
 
 
 def test_lookup_revision_multiple_none_found():
     unknown_revisions_ = [random_sha1(), random_sha1(), random_sha1()]
 
     actual_revisions = list(service.lookup_revision_multiple(unknown_revisions_))
 
     assert actual_revisions == [None] * len(unknown_revisions_)
 
 
 @given(revision())
 def test_lookup_revision_log(archive_data, revision):
     actual_revision_log = list(service.lookup_revision_log(revision, limit=25))
     expected_revision_log = archive_data.revision_log(revision, limit=25)
 
     assert actual_revision_log == expected_revision_log
 
 
 def _get_origin_branches(archive_data, origin):
     origin_visit = archive_data.origin_visit_get(origin["url"])[-1]
     snapshot = archive_data.snapshot_get(origin_visit["snapshot"])
     branches = {
         k: v
         for (k, v) in snapshot["branches"].items()
         if v["target_type"] == "revision"
     }
     return branches
 
 
 @given(origin())
 def test_lookup_revision_log_by(archive_data, origin):
     branches = _get_origin_branches(archive_data, origin)
     branch_name = random.choice(list(branches.keys()))
 
     actual_log = list(
         service.lookup_revision_log_by(origin["url"], branch_name, None, limit=25)
     )
 
     expected_log = archive_data.revision_log(branches[branch_name]["target"], limit=25)
 
     assert actual_log == expected_log
 
 
 @given(origin())
 def test_lookup_revision_log_by_notfound(origin):
     with pytest.raises(NotFoundExc):
         service.lookup_revision_log_by(
             origin["url"], "unknown_branch_name", None, limit=100
         )
 
 
 def test_lookup_content_raw_not_found():
     unknown_content_ = random_content()
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_content_raw("sha1:" + unknown_content_["sha1"])
 
     assert e.match(
         "Content with %s checksum equals to %s not found!"
         % ("sha1", unknown_content_["sha1"])
     )
 
 
 @given(content())
 def test_lookup_content_raw(archive_data, content):
     actual_content = service.lookup_content_raw("sha256:%s" % content["sha256"])
 
     expected_content = archive_data.content_get_data(content["sha1"])
 
     assert actual_content == expected_content
 
 
 def test_lookup_content_not_found():
     unknown_content_ = random_content()
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_content("sha1:%s" % unknown_content_["sha1"])
 
     assert e.match(
         "Content with %s checksum equals to %s not found!"
         % ("sha1", unknown_content_["sha1"])
     )
 
 
 @given(content())
 def test_lookup_content_with_sha1(archive_data, content):
-    actual_content = service.lookup_content("sha1:%s" % content["sha1"])
+    actual_content = service.lookup_content(f"sha1:{content['sha1']}")
 
-    expected_content = archive_data.content_get_metadata(content["sha1"])
+    expected_content = archive_data.content_get(content["sha1"])
 
     assert actual_content == expected_content
 
 
 @given(content())
 def test_lookup_content_with_sha256(archive_data, content):
-    actual_content = service.lookup_content("sha256:%s" % content["sha256"])
+    actual_content = service.lookup_content(f"sha256:{content['sha256']}")
 
-    expected_content = archive_data.content_get_metadata(content["sha1"])
+    expected_content = archive_data.content_get(content["sha1"])
 
     assert actual_content == expected_content
 
 
 def test_lookup_directory_bad_checksum():
     with pytest.raises(BadInputExc):
         service.lookup_directory("directory_id")
 
 
 def test_lookup_directory_not_found():
     unknown_directory_ = random_sha1()
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_directory(unknown_directory_)
 
     assert e.match("Directory with sha1_git %s not found" % unknown_directory_)
 
 
 @given(directory())
 def test_lookup_directory(archive_data, directory):
     actual_directory_ls = list(service.lookup_directory(directory))
 
     expected_directory_ls = archive_data.directory_ls(directory)
 
     assert actual_directory_ls == expected_directory_ls
 
 
 @given(empty_directory())
 def test_lookup_directory_empty(empty_directory):
     actual_directory_ls = list(service.lookup_directory(empty_directory))
 
     assert actual_directory_ls == []
 
 
 @given(origin())
 def test_lookup_revision_by_nothing_found(origin):
     with pytest.raises(NotFoundExc):
         service.lookup_revision_by(origin["url"], "invalid-branch-name")
 
 
 @given(origin())
 def test_lookup_revision_by(archive_data, origin):
     branches = _get_origin_branches(archive_data, origin)
     branch_name = random.choice(list(branches.keys()))
 
     actual_revision = service.lookup_revision_by(origin["url"], branch_name)
 
     expected_revision = archive_data.revision_get(branches[branch_name]["target"])
 
     assert actual_revision == expected_revision
 
 
 @given(origin(), revision())
 def test_lookup_revision_with_context_by_ko(origin, revision):
     with pytest.raises(NotFoundExc):
         service.lookup_revision_with_context_by(
             origin["url"], "invalid-branch-name", None, revision
         )
 
 
 @given(origin())
 def test_lookup_revision_with_context_by(archive_data, origin):
     branches = _get_origin_branches(archive_data, origin)
     branch_name = random.choice(list(branches.keys()))
 
     root_rev = branches[branch_name]["target"]
     root_rev_log = archive_data.revision_log(root_rev)
 
     children = defaultdict(list)
 
     for rev in root_rev_log:
         for rev_p in rev["parents"]:
             children[rev_p].append(rev["id"])
 
     rev = root_rev_log[-1]["id"]
 
     actual_root_rev, actual_rev = service.lookup_revision_with_context_by(
         origin["url"], branch_name, None, rev
     )
 
     expected_root_rev = archive_data.revision_get(root_rev)
     expected_rev = archive_data.revision_get(rev)
     expected_rev["children"] = children[rev]
 
     assert actual_root_rev == expected_root_rev
     assert actual_rev == expected_rev
 
 
 def test_lookup_revision_through_ko_not_implemented():
     with pytest.raises(NotImplementedError):
         service.lookup_revision_through({"something-unknown": 10})
 
 
 @given(origin())
 def test_lookup_revision_through_with_context_by(archive_data, origin):
     branches = _get_origin_branches(archive_data, origin)
     branch_name = random.choice(list(branches.keys()))
 
     root_rev = branches[branch_name]["target"]
     root_rev_log = archive_data.revision_log(root_rev)
     rev = root_rev_log[-1]["id"]
 
     assert service.lookup_revision_through(
         {
             "origin_url": origin["url"],
             "branch_name": branch_name,
             "ts": None,
             "sha1_git": rev,
         }
     ) == service.lookup_revision_with_context_by(origin["url"], branch_name, None, rev)
 
 
 @given(origin())
 def test_lookup_revision_through_with_revision_by(archive_data, origin):
     branches = _get_origin_branches(archive_data, origin)
     branch_name = random.choice(list(branches.keys()))
 
     assert service.lookup_revision_through(
         {"origin_url": origin["url"], "branch_name": branch_name, "ts": None,}
     ) == service.lookup_revision_by(origin["url"], branch_name, None)
 
 
 @given(ancestor_revisions())
 def test_lookup_revision_through_with_context(ancestor_revisions):
     sha1_git = ancestor_revisions["sha1_git"]
     sha1_git_root = ancestor_revisions["sha1_git_root"]
 
     assert service.lookup_revision_through(
         {"sha1_git_root": sha1_git_root, "sha1_git": sha1_git,}
     ) == service.lookup_revision_with_context(sha1_git_root, sha1_git)
 
 
 @given(revision())
 def test_lookup_revision_through_with_revision(revision):
     assert service.lookup_revision_through(
         {"sha1_git": revision}
     ) == service.lookup_revision(revision)
 
 
 @given(revision())
 def test_lookup_directory_through_revision_ko_not_found(revision):
     with pytest.raises(NotFoundExc):
         service.lookup_directory_through_revision(
             {"sha1_git": revision}, "some/invalid/path"
         )
 
 
 @given(revision())
 def test_lookup_directory_through_revision_ok(archive_data, revision):
     rev_data = archive_data.revision_get(revision)
     dir_entries = [
         e
         for e in archive_data.directory_ls(rev_data["directory"])
         if e["type"] == "file"
     ]
     dir_entry = random.choice(dir_entries)
 
     assert service.lookup_directory_through_revision(
         {"sha1_git": revision}, dir_entry["name"]
     ) == (revision, service.lookup_directory_with_revision(revision, dir_entry["name"]))
 
 
 @given(revision())
 def test_lookup_directory_through_revision_ok_with_data(archive_data, revision):
     rev_data = archive_data.revision_get(revision)
     dir_entries = [
         e
         for e in archive_data.directory_ls(rev_data["directory"])
         if e["type"] == "file"
     ]
     dir_entry = random.choice(dir_entries)
 
     assert service.lookup_directory_through_revision(
         {"sha1_git": revision}, dir_entry["name"], with_data=True
     ) == (
         revision,
         service.lookup_directory_with_revision(
             revision, dir_entry["name"], with_data=True
         ),
     )
 
 
 @given(content(), directory(), release(), revision(), snapshot())
 def test_lookup_known_objects(
     archive_data, content, directory, release, revision, snapshot
 ):
     expected = archive_data.content_find(content)
     assert service.lookup_object(CONTENT, content["sha1_git"]) == expected
 
     expected = archive_data.directory_get(directory)
     assert service.lookup_object(DIRECTORY, directory) == expected
 
     expected = archive_data.release_get(release)
     assert service.lookup_object(RELEASE, release) == expected
 
     expected = archive_data.revision_get(revision)
     assert service.lookup_object(REVISION, revision) == expected
 
     expected = archive_data.snapshot_get(snapshot)
     assert service.lookup_object(SNAPSHOT, snapshot) == expected
 
 
 @given(
     unknown_content(),
     unknown_directory(),
     unknown_release(),
     unknown_revision(),
     unknown_snapshot(),
 )
 def test_lookup_unknown_objects(
     unknown_content,
     unknown_directory,
     unknown_release,
     unknown_revision,
     unknown_snapshot,
 ):
     with pytest.raises(NotFoundExc) as e:
         service.lookup_object(CONTENT, unknown_content["sha1_git"])
     assert e.match(r"Content.*not found")
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_object(DIRECTORY, unknown_directory)
     assert e.match(r"Directory.*not found")
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_object(RELEASE, unknown_release)
     assert e.match(r"Release.*not found")
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_object(REVISION, unknown_revision)
     assert e.match(r"Revision.*not found")
 
     with pytest.raises(NotFoundExc) as e:
         service.lookup_object(SNAPSHOT, unknown_snapshot)
     assert e.match(r"Snapshot.*not found")
 
 
 @given(invalid_sha1())
 def test_lookup_invalid_objects(invalid_sha1):
 
     with pytest.raises(BadInputExc) as e:
         service.lookup_object("foo", invalid_sha1)
     assert e.match("Invalid swh object type")
 
     with pytest.raises(BadInputExc) as e:
         service.lookup_object(CONTENT, invalid_sha1)
     assert e.match("Invalid hash")
 
     with pytest.raises(BadInputExc) as e:
         service.lookup_object(DIRECTORY, invalid_sha1)
     assert e.match("Invalid checksum")
 
     with pytest.raises(BadInputExc) as e:
         service.lookup_object(RELEASE, invalid_sha1)
     assert e.match("Invalid checksum")
 
     with pytest.raises(BadInputExc) as e:
         service.lookup_object(REVISION, invalid_sha1)
     assert e.match("Invalid checksum")
 
     with pytest.raises(BadInputExc) as e:
         service.lookup_object(SNAPSHOT, invalid_sha1)
     assert e.match("Invalid checksum")
 
 
 def test_lookup_missing_hashes_non_present():
     missing_cnt = random_sha1()
     missing_dir = random_sha1()
     missing_rev = random_sha1()
     missing_rel = random_sha1()
     missing_snp = random_sha1()
 
     grouped_swhids = {
         CONTENT: [hash_to_bytes(missing_cnt)],
         DIRECTORY: [hash_to_bytes(missing_dir)],
         REVISION: [hash_to_bytes(missing_rev)],
         RELEASE: [hash_to_bytes(missing_rel)],
         SNAPSHOT: [hash_to_bytes(missing_snp)],
     }
 
     actual_result = service.lookup_missing_hashes(grouped_swhids)
 
     assert actual_result == {
         missing_cnt,
         missing_dir,
         missing_rev,
         missing_rel,
         missing_snp,
     }
 
 
 @given(content(), directory())
 def test_lookup_missing_hashes_some_present(archive_data, content, directory):
     missing_rev = random_sha1()
     missing_rel = random_sha1()
     missing_snp = random_sha1()
 
     grouped_swhids = {
         CONTENT: [hash_to_bytes(content["sha1_git"])],
         DIRECTORY: [hash_to_bytes(directory)],
         REVISION: [hash_to_bytes(missing_rev)],
         RELEASE: [hash_to_bytes(missing_rel)],
         SNAPSHOT: [hash_to_bytes(missing_snp)],
     }
 
     actual_result = service.lookup_missing_hashes(grouped_swhids)
 
     assert actual_result == {missing_rev, missing_rel, missing_snp}
 
 
 @given(origin())
 def test_lookup_origin_extra_trailing_slash(origin):
     origin_info = service.lookup_origin({"url": f"{origin['url']}/"})
     assert origin_info["url"] == origin["url"]
 
 
 def test_lookup_origin_missing_trailing_slash(archive_data):
     deb_origin = Origin(url="http://snapshot.debian.org/package/r-base/")
     archive_data.origin_add([deb_origin])
     origin_info = service.lookup_origin({"url": deb_origin.url[:-1]})
     assert origin_info["url"] == deb_origin.url
 
 
 @given(snapshot())
 def test_lookup_snapshot_branch_name_from_tip_revision(archive_data, snapshot_id):
     snapshot = archive_data.snapshot_get(snapshot_id)
     branches = [
         {"name": k, "revision": v["target"]}
         for k, v in snapshot["branches"].items()
         if v["target_type"] == "revision"
     ]
     branch_info = random.choice(branches)
     possible_results = [
         b["name"] for b in branches if b["revision"] == branch_info["revision"]
     ]
 
     assert (
         service.lookup_snapshot_branch_name_from_tip_revision(
             snapshot_id, branch_info["revision"]
         )
         in possible_results
     )
diff --git a/swh/web/tests/conftest.py b/swh/web/tests/conftest.py
index 974e22c6..8cf10ecb 100644
--- a/swh/web/tests/conftest.py
+++ b/swh/web/tests/conftest.py
@@ -1,359 +1,362 @@
 # Copyright (C) 2018-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import json
 import os
 import shutil
 import sys
 
 from subprocess import run, PIPE
 from typing import Any, Dict, List, Optional
 
 import pytest
 
 from django.core.cache import cache
 from hypothesis import settings, HealthCheck
 from rest_framework.test import APIClient, APIRequestFactory
 
 from swh.model.hashutil import ALGORITHMS, hash_to_bytes
 from swh.web.common import converters
 from swh.web.common.typing import OriginVisitInfo
 from swh.web.tests.data import get_tests_data, override_storages
 from swh.storage.algos.origin import origin_get_latest_visit_status
 from swh.storage.algos.snapshot import snapshot_get_latest
 
 # Used to skip some tests
 ctags_json_missing = (
     shutil.which("ctags") is None
     or b"+json" not in run(["ctags", "--version"], stdout=PIPE).stdout
 )
 
 fossology_missing = shutil.which("nomossa") is None
 
 # Register some hypothesis profiles
 settings.register_profile("default", settings())
 
 settings.register_profile(
     "swh-web",
     settings(
         deadline=None,
         suppress_health_check=[HealthCheck.too_slow, HealthCheck.filter_too_much],
     ),
 )
 
 settings.register_profile(
     "swh-web-fast",
     settings(
         deadline=None,
         max_examples=1,
         suppress_health_check=[HealthCheck.too_slow, HealthCheck.filter_too_much],
     ),
 )
 
 
 def pytest_configure(config):
     # Use fast hypothesis profile by default if none has been
     # explicitly specified in pytest option
     if config.getoption("--hypothesis-profile") is None:
         settings.load_profile("swh-web-fast")
     # Small hack in order to be able to run the unit tests
     # without static assets generated by webpack.
     # Those assets are not really needed for the Python tests
     # but the django templates will fail to load due to missing
     # generated file webpack-stats.json describing the js and css
     # files to include.
     # So generate a dummy webpack-stats.json file to overcome
     # that issue.
     test_dir = os.path.dirname(__file__)
     # location of the static folder when running tests through tox
     static_dir = os.path.join(sys.prefix, "share/swh/web/static")
 
     if not os.path.exists(static_dir):
         # location of the static folder when running tests locally with pytest
         static_dir = os.path.join(test_dir, "../../../static")
     webpack_stats = os.path.join(static_dir, "webpack-stats.json")
     if os.path.exists(webpack_stats):
         return
     bundles_dir = os.path.join(test_dir, "../assets/src/bundles")
     _, dirs, _ = next(os.walk(bundles_dir))
     mock_webpack_stats = {"status": "done", "publicPath": "/static", "chunks": {}}
     for bundle in dirs:
         asset = "js/%s.js" % bundle
         mock_webpack_stats["chunks"][bundle] = [
             {
                 "name": asset,
                 "publicPath": "/static/%s" % asset,
                 "path": os.path.join(static_dir, asset),
             }
         ]
 
     with open(webpack_stats, "w") as outfile:
         json.dump(mock_webpack_stats, outfile)
 
 
 # Clear Django cache before each test
 @pytest.fixture(autouse=True)
 def django_cache_cleared():
     cache.clear()
 
 
 # Alias rf fixture from pytest-django
 @pytest.fixture
 def request_factory(rf):
     return rf
 
 
 # Fixture to get test client from Django REST Framework
 @pytest.fixture(scope="module")
 def api_client():
     return APIClient()
 
 
 # Fixture to get API request factory from Django REST Framework
 @pytest.fixture(scope="module")
 def api_request_factory():
     return APIRequestFactory()
 
 
 # Initialize tests data
 @pytest.fixture(scope="session", autouse=True)
 def tests_data():
     data = get_tests_data(reset=True)
     # Update swh-web configuration to use the in-memory storages
     # instantiated in the tests.data module
     override_storages(data["storage"], data["idx_storage"], data["search"])
     return data
 
 
 # Fixture to manipulate data from a sample archive used in the tests
 @pytest.fixture(scope="session")
 def archive_data(tests_data):
     return _ArchiveData(tests_data)
 
 
 # Fixture to manipulate indexer data from a sample archive used in the tests
 @pytest.fixture(scope="session")
 def indexer_data(tests_data):
     return _IndexerData(tests_data)
 
 
 # Custom data directory for requests_mock
 @pytest.fixture
 def datadir():
     return os.path.join(os.path.abspath(os.path.dirname(__file__)), "resources")
 
 
 class _ArchiveData:
     """
     Helper class to manage data from a sample test archive.
 
     It is initialized with a reference to an in-memory storage
     containing raw tests data.
 
     It is basically a proxy to Storage interface but it overrides some methods
     to retrieve those tests data in a json serializable format in order to ease
     tests implementation.
     """
 
     def __init__(self, tests_data):
         self.storage = tests_data["storage"]
 
     def __getattr__(self, key):
         if key == "storage":
             raise AttributeError(key)
         # Forward calls to non overridden Storage methods to wrapped
         # storage instance
         return getattr(self.storage, key)
 
     def content_find(self, content: Dict[str, Any]) -> Dict[str, Any]:
         cnt_ids_bytes = {
             algo_hash: hash_to_bytes(content[algo_hash])
             for algo_hash in ALGORITHMS
             if content.get(algo_hash)
         }
         cnt = self.storage.content_find(cnt_ids_bytes)
         return converters.from_content(cnt[0].to_dict()) if cnt else cnt
 
-    def content_get_metadata(self, cnt_id):
+    def content_get(self, cnt_id: str) -> Dict[str, Any]:
         cnt_id_bytes = hash_to_bytes(cnt_id)
-        metadata = self.storage.content_get_metadata([cnt_id_bytes])
-        contents = metadata[cnt_id_bytes]
-        content = None if not contents else contents[0]
+        content = self.storage.content_get([cnt_id_bytes])[0]
+        if content:
+            content_d = content.to_dict()
+            content_d.pop("ctime", None)
+        else:
+            content_d = None
         return converters.from_swh(
-            content, hashess={"sha1", "sha1_git", "sha256", "blake2s256"}
+            content_d, hashess={"sha1", "sha1_git", "sha256", "blake2s256"}
         )
 
     def content_get_data(self, cnt_id: str) -> Optional[Dict[str, Any]]:
         cnt_id_bytes = hash_to_bytes(cnt_id)
         cnt_data = self.storage.content_get_data(cnt_id_bytes)
         if cnt_data is None:
             return None
         return converters.from_content({"data": cnt_data, "sha1": cnt_id_bytes})
 
     def directory_get(self, dir_id):
         return {"id": dir_id, "content": self.directory_ls(dir_id)}
 
     def directory_ls(self, dir_id):
         cnt_id_bytes = hash_to_bytes(dir_id)
         dir_content = map(
             converters.from_directory_entry, self.storage.directory_ls(cnt_id_bytes)
         )
         return list(dir_content)
 
     def release_get(self, rel_id):
         rel_id_bytes = hash_to_bytes(rel_id)
         rel_data = next(self.storage.release_get([rel_id_bytes]))
         return converters.from_release(rel_data)
 
     def revision_get(self, rev_id):
         rev_id_bytes = hash_to_bytes(rev_id)
         rev_data = next(self.storage.revision_get([rev_id_bytes]))
         return converters.from_revision(rev_data)
 
     def revision_log(self, rev_id, limit=None):
         rev_id_bytes = hash_to_bytes(rev_id)
         return list(
             map(
                 converters.from_revision,
                 self.storage.revision_log([rev_id_bytes], limit=limit),
             )
         )
 
     def snapshot_get_latest(self, origin_url):
         snp = snapshot_get_latest(self.storage, origin_url)
         return converters.from_snapshot(snp.to_dict())
 
     def origin_get(self, origin_urls):
         origins = self.storage.origin_get(origin_urls)
         return [converters.from_origin(o.to_dict()) for o in origins]
 
     def origin_visit_get(self, origin_url):
         next_page_token = None
         visits = []
         while True:
             visit_page = self.storage.origin_visit_get(
                 origin_url, page_token=next_page_token
             )
             next_page_token = visit_page.next_page_token
 
             for visit in visit_page.results:
                 visit_status = self.storage.origin_visit_status_get_latest(
                     origin_url, visit.visit
                 )
                 visits.append(
                     converters.from_origin_visit(
                         {**visit_status.to_dict(), "type": visit.type}
                     )
                 )
             if not next_page_token:
                 break
         return visits
 
     def origin_visit_get_by(self, origin_url: str, visit_id: int) -> OriginVisitInfo:
         visit = self.storage.origin_visit_get_by(origin_url, visit_id)
         assert visit is not None
         visit_status = self.storage.origin_visit_status_get_latest(origin_url, visit_id)
         assert visit_status is not None
         return converters.from_origin_visit(
             {**visit_status.to_dict(), "type": visit.type}
         )
 
     def origin_visit_status_get_latest(
         self,
         origin_url,
         type: Optional[str] = None,
         allowed_statuses: Optional[List[str]] = None,
         require_snapshot: bool = False,
     ):
         visit_and_status = origin_get_latest_visit_status(
             self.storage,
             origin_url,
             type=type,
             allowed_statuses=allowed_statuses,
             require_snapshot=require_snapshot,
         )
         return (
             converters.from_origin_visit(
                 {**visit_and_status[0].to_dict(), **visit_and_status[1].to_dict()}
             )
             if visit_and_status
             else None
         )
 
     def snapshot_get(self, snapshot_id):
         snp = self.storage.snapshot_get(hash_to_bytes(snapshot_id))
         return converters.from_snapshot(snp)
 
     def snapshot_get_branches(
         self, snapshot_id, branches_from="", branches_count=1000, target_types=None
     ):
         snp = self.storage.snapshot_get_branches(
             hash_to_bytes(snapshot_id),
             branches_from.encode(),
             branches_count,
             target_types,
         )
         return converters.from_snapshot(snp)
 
     def snapshot_get_head(self, snapshot):
         if snapshot["branches"]["HEAD"]["target_type"] == "alias":
             target = snapshot["branches"]["HEAD"]["target"]
             head = snapshot["branches"][target]["target"]
         else:
             head = snapshot["branches"]["HEAD"]["target"]
         return head
 
 
 class _IndexerData:
     """
     Helper class to manage indexer tests data
 
     It is initialized with a reference to an in-memory indexer storage
     containing raw tests data.
 
     It also defines class methods to retrieve those tests data in
     a json serializable format in order to ease tests implementation.
 
     """
 
     def __init__(self, tests_data):
         self.idx_storage = tests_data["idx_storage"]
         self.mimetype_indexer = tests_data["mimetype_indexer"]
         self.license_indexer = tests_data["license_indexer"]
         self.ctags_indexer = tests_data["ctags_indexer"]
 
     def content_add_mimetype(self, cnt_id):
         self.mimetype_indexer.run([hash_to_bytes(cnt_id)], "update-dups")
 
     def content_get_mimetype(self, cnt_id):
         mimetype = next(self.idx_storage.content_mimetype_get([hash_to_bytes(cnt_id)]))
         return converters.from_filetype(mimetype)
 
     def content_add_language(self, cnt_id):
         raise NotImplementedError("Language indexer is disabled.")
         self.language_indexer.run([hash_to_bytes(cnt_id)], "update-dups")
 
     def content_get_language(self, cnt_id):
         lang = next(self.idx_storage.content_language_get([hash_to_bytes(cnt_id)]))
         return converters.from_swh(lang, hashess={"id"})
 
     def content_add_license(self, cnt_id):
         self.license_indexer.run([hash_to_bytes(cnt_id)], "update-dups")
 
     def content_get_license(self, cnt_id):
         cnt_id_bytes = hash_to_bytes(cnt_id)
         lic = next(self.idx_storage.content_fossology_license_get([cnt_id_bytes]))
         return converters.from_swh(
             {"id": cnt_id_bytes, "facts": lic[cnt_id_bytes]}, hashess={"id"}
         )
 
     def content_add_ctags(self, cnt_id):
         self.ctags_indexer.run([hash_to_bytes(cnt_id)], "update-dups")
 
     def content_get_ctags(self, cnt_id):
         cnt_id_bytes = hash_to_bytes(cnt_id)
         ctags = self.idx_storage.content_ctags_get([cnt_id_bytes])
         for ctag in ctags:
             yield converters.from_swh(ctag, hashess={"id"})
diff --git a/swh/web/tests/data.py b/swh/web/tests/data.py
index f090a726..1d59d3e3 100644
--- a/swh/web/tests/data.py
+++ b/swh/web/tests/data.py
@@ -1,364 +1,368 @@
 # Copyright (C) 2018-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
-from datetime import timedelta
 import os
 import random
 import time
 
 from copy import deepcopy
+from datetime import timedelta
+from typing import Dict, List, Optional, Set
 
 from swh.indexer.fossology_license import FossologyLicenseIndexer
 from swh.indexer.mimetype import MimetypeIndexer
 from swh.indexer.ctags import CtagsIndexer
 from swh.indexer.storage import get_indexer_storage
-from swh.model.model import Content, OriginVisitStatus
 from swh.model.hashutil import hash_to_hex, hash_to_bytes, DEFAULT_ALGORITHMS
-from swh.model.model import Directory, Origin, OriginVisit
+from swh.model.model import Content, Directory, Origin, OriginVisit, OriginVisitStatus
 from swh.loader.git.from_disk import GitLoaderFromArchive
 from swh.search import get_search
 from swh.storage.algos.dir_iterators import dir_iterator
 from swh.storage.algos.snapshot import snapshot_get_latest
+from swh.storage.interface import Sha1
 from swh.storage.utils import now
 from swh.web import config
 from swh.web.browse.utils import (
     get_mimetype_and_encoding_for_content,
     prepare_content_for_display,
     _re_encode_content,
 )
 from swh.web.common import service
 
 # Module used to initialize data that will be provided as tests input
 
 # Configuration for git loader
 _TEST_LOADER_CONFIG = {
     "storage": {"cls": "memory",},
     "save_data": False,
     "max_content_size": 100 * 1024 * 1024,
 }
 
 # Base content indexer configuration
 _TEST_INDEXER_BASE_CONFIG = {
     "storage": {"cls": "memory"},
     "objstorage": {"cls": "memory", "args": {},},
     "indexer_storage": {"cls": "memory", "args": {},},
 }
 
 
 def random_sha1():
     return hash_to_hex(bytes(random.randint(0, 255) for _ in range(20)))
 
 
 def random_sha256():
     return hash_to_hex(bytes(random.randint(0, 255) for _ in range(32)))
 
 
 def random_blake2s256():
     return hash_to_hex(bytes(random.randint(0, 255) for _ in range(32)))
 
 
 def random_content():
     return {
         "sha1": random_sha1(),
         "sha1_git": random_sha1(),
         "sha256": random_sha256(),
         "blake2s256": random_blake2s256(),
     }
 
 
 # MimetypeIndexer with custom configuration for tests
 class _MimetypeIndexer(MimetypeIndexer):
     def parse_config_file(self, *args, **kwargs):
         return {
             **_TEST_INDEXER_BASE_CONFIG,
             "tools": {
                 "name": "file",
                 "version": "1:5.30-1+deb9u1",
                 "configuration": {"type": "library", "debian-package": "python3-magic"},
             },
         }
 
 
 # FossologyLicenseIndexer with custom configuration for tests
 class _FossologyLicenseIndexer(FossologyLicenseIndexer):
     def parse_config_file(self, *args, **kwargs):
         return {
             **_TEST_INDEXER_BASE_CONFIG,
             "workdir": "/tmp/swh/indexer.fossology.license",
             "tools": {
                 "name": "nomos",
                 "version": "3.1.0rc2-31-ga2cbb8c",
                 "configuration": {"command_line": "nomossa <filepath>",},
             },
         }
 
 
 # CtagsIndexer with custom configuration for tests
 class _CtagsIndexer(CtagsIndexer):
     def parse_config_file(self, *args, **kwargs):
         return {
             **_TEST_INDEXER_BASE_CONFIG,
             "workdir": "/tmp/swh/indexer.ctags",
             "languages": {"c": "c"},
             "tools": {
                 "name": "universal-ctags",
                 "version": "~git7859817b",
                 "configuration": {
                     "command_line": """ctags --fields=+lnz --sort=no --links=no """
                     """--output-format=json <filepath>"""
                 },
             },
         }
 
 
 # Lightweight git repositories that will be loaded to generate
 # input data for tests
 _TEST_ORIGINS = [
     {
         "type": "git",
         "url": "https://github.com/wcoder/highlightjs-line-numbers.js",
         "archives": [
             "highlightjs-line-numbers.js.zip",
             "highlightjs-line-numbers.js_visit2.zip",
         ],
     },
     {
         "type": "git",
         "url": "https://github.com/memononen/libtess2",
         "archives": ["libtess2.zip"],
     },
     {
         "type": "git",
         "url": "repo_with_submodules",
         "archives": ["repo_with_submodules.tgz"],
     },
 ]
 
 _contents = {}
 
 
 def _add_extra_contents(storage, contents):
     pbm_image_data = b"""P1
 # PBM example
 24 7
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 1 1 0
 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0
 0 1 1 1 0 0 0 1 1 1 0 0 0 1 1 1 0 0 0 1 1 1 1 0
 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
 0 1 0 0 0 0 0 1 1 1 1 0 0 1 1 1 1 0 0 1 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"""
 
     # add file with mimetype image/x-portable-bitmap in the archive content
     pbm_content = Content.from_data(pbm_image_data)
     storage.content_add([pbm_content])
     contents.add(pbm_content.sha1)
 
 
 # Tests data initialization
 def _init_tests_data():
     # To hold reference to the memory storage
     storage = None
 
     # Create search instance
     search = get_search("memory")
     search.initialize()
     search.origin_update({"url": origin["url"]} for origin in _TEST_ORIGINS)
 
     # Load git repositories from archives
     for origin in _TEST_ORIGINS:
         for i, archive in enumerate(origin["archives"]):
             if i > 0:
                 # ensure visit dates will be different when simulating
                 # multiple visits of an origin
                 time.sleep(1)
             origin_repo_archive = os.path.join(
                 os.path.dirname(__file__), "resources/repos/%s" % archive
             )
             loader = GitLoaderFromArchive(
                 origin["url"],
                 archive_path=origin_repo_archive,
                 config=_TEST_LOADER_CONFIG,
             )
             if storage is None:
                 storage = loader.storage
             else:
                 loader.storage = storage
             loader.load()
 
         ori = storage.origin_get([origin["url"]])[0]
         origin.update(ori.to_dict())  # add an 'id' key if enabled
         search.origin_update([{"url": origin["url"], "has_visits": True}])
 
     for i in range(250):
         url = "https://many.origins/%d" % (i + 1)
         # storage.origin_add([{'url': url}])
         storage.origin_add([Origin(url=url)])
         search.origin_update([{"url": url, "has_visits": True}])
         date = now()
         visit = OriginVisit(origin=url, date=date, type="tar")
         visit = storage.origin_visit_add([visit])[0]
         visit_status = OriginVisitStatus(
             origin=url,
             visit=visit.visit,
             date=date + timedelta(minutes=1),
             status="full",
             snapshot=hash_to_bytes("1a8893e6a86f444e8be8e7bda6cb34fb1735a00e"),
         )
         storage.origin_visit_status_add([visit_status])
 
-    contents = set()
+    sha1s: Set[Sha1] = set()
     directories = set()
     revisions = set()
     releases = set()
     snapshots = set()
 
     content_path = {}
 
     # Get all objects loaded into the test archive
     for origin in _TEST_ORIGINS:
         snp = snapshot_get_latest(storage, origin["url"])
         snapshots.add(hash_to_hex(snp.id))
         for branch_name, branch_data in snp.branches.items():
             target_type = branch_data.target_type.value
             if target_type == "revision":
                 revisions.add(branch_data.target)
             elif target_type == "release":
                 release = next(storage.release_get([branch_data.target]))
                 revisions.add(release["target"])
                 releases.add(hash_to_hex(branch_data.target))
 
         for rev_log in storage.revision_shortlog(set(revisions)):
             rev_id = rev_log[0]
             revisions.add(rev_id)
 
         for rev in storage.revision_get(revisions):
             dir_id = rev["directory"]
             directories.add(hash_to_hex(dir_id))
             for entry in dir_iterator(storage, dir_id):
                 if entry["type"] == "file":
-                    contents.add(entry["sha1"])
+                    sha1s.add(entry["sha1"])
                     content_path[entry["sha1"]] = "/".join(
                         [hash_to_hex(dir_id), entry["path"].decode("utf-8")]
                     )
                 elif entry["type"] == "dir":
                     directories.add(hash_to_hex(entry["target"]))
 
-    _add_extra_contents(storage, contents)
+    _add_extra_contents(storage, sha1s)
 
     # Get all checksums for each content
-    result = storage.content_get_metadata(contents)
-    contents = []
-    for sha1, contents_metadata in result.items():
-        sha1 = contents_metadata[0]["sha1"]
+    result: List[Optional[Content]] = storage.content_get(list(sha1s))
+
+    contents: List[Dict] = []
+    for content in result:
+        assert content is not None
+        sha1 = hash_to_hex(content.sha1)
         content_metadata = {
-            algo: hash_to_hex(contents_metadata[0][algo]) for algo in DEFAULT_ALGORITHMS
+            algo: hash_to_hex(getattr(content, algo)) for algo in DEFAULT_ALGORITHMS
         }
 
         path = ""
-        if sha1 in content_path:
-            path = content_path[sha1]
-        cnt_data = storage.content_get_data(sha1)
+        if content.sha1 in content_path:
+            path = content_path[content.sha1]
+
+        cnt_data = storage.content_get_data(content.sha1)
         assert cnt_data is not None
         mimetype, encoding = get_mimetype_and_encoding_for_content(cnt_data)
         _, _, cnt_data = _re_encode_content(mimetype, encoding, cnt_data)
         content_display_data = prepare_content_for_display(cnt_data, mimetype, path)
 
         content_metadata.update(
             {
                 "path": path,
                 "mimetype": mimetype,
                 "encoding": encoding,
                 "hljs_language": content_display_data["language"],
                 "data": content_display_data["content_data"],
             }
         )
-        _contents[hash_to_hex(sha1)] = content_metadata
+        _contents[sha1] = content_metadata
         contents.append(content_metadata)
 
     # Create indexer storage instance that will be shared by indexers
     idx_storage = get_indexer_storage("memory", {})
 
     # Add the empty directory to the test archive
     storage.directory_add([Directory(entries=())])
 
     # Return tests data
     return {
         "search": search,
         "storage": storage,
         "idx_storage": idx_storage,
         "origins": _TEST_ORIGINS,
         "contents": contents,
         "directories": list(directories),
         "releases": list(releases),
         "revisions": list(map(hash_to_hex, revisions)),
         "snapshots": list(snapshots),
         "generated_checksums": set(),
     }
 
 
 def _init_indexers(tests_data):
     # Instantiate content indexers that will be used in tests
     # and force them to use the memory storages
     indexers = {}
     for idx_name, idx_class in (
         ("mimetype_indexer", _MimetypeIndexer),
         ("license_indexer", _FossologyLicenseIndexer),
         ("ctags_indexer", _CtagsIndexer),
     ):
         idx = idx_class()
         idx.storage = tests_data["storage"]
         idx.objstorage = tests_data["storage"].objstorage
         idx.idx_storage = tests_data["idx_storage"]
         idx.register_tools(idx.config["tools"])
         indexers[idx_name] = idx
 
     return indexers
 
 
 def get_content(content_sha1):
     return _contents.get(content_sha1)
 
 
 _tests_data = None
 _current_tests_data = None
 _indexer_loggers = {}
 
 
 def get_tests_data(reset=False):
     """
     Initialize tests data and return them in a dict.
     """
     global _tests_data, _current_tests_data
     if _tests_data is None:
         _tests_data = _init_tests_data()
         indexers = _init_indexers(_tests_data)
         for (name, idx) in indexers.items():
             # pytest makes the loggers use a temporary file; and deepcopy
             # requires serializability. So we remove them, and add them
             # back after the copy.
             _indexer_loggers[name] = idx.log
             del idx.log
         _tests_data.update(indexers)
     if reset or _current_tests_data is None:
         _current_tests_data = deepcopy(_tests_data)
         for (name, logger) in _indexer_loggers.items():
             _current_tests_data[name].log = logger
     return _current_tests_data
 
 
 def override_storages(storage, idx_storage, search):
     """
     Helper function to replace the storages from which archive data
     are fetched.
     """
     swh_config = config.get_config()
     swh_config.update(
         {"storage": storage, "indexer_storage": idx_storage, "search": search,}
     )
 
     service.storage = storage
     service.idx_storage = idx_storage
     service.search = search