diff --git a/swh/web/common/identifiers.py b/swh/web/common/identifiers.py
index c1cd9079..c7f3781f 100644
--- a/swh/web/common/identifiers.py
+++ b/swh/web/common/identifiers.py
@@ -1,393 +1,398 @@
 # Copyright (C) 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 typing import Any, Dict, Iterable, List, Optional, cast
+from typing import Any, Dict, Iterable, List, Optional
 from urllib.parse import quote, unquote
 
 from typing_extensions import TypedDict
 
 from django.http import QueryDict
 
 from swh.model.exceptions import ValidationError
 from swh.model.hashutil import hash_to_bytes
 from swh.model.identifiers import (
     CONTENT,
     DIRECTORY,
     ORIGIN,
     RELEASE,
     REVISION,
     SNAPSHOT,
     SWHID,
+    ObjectType,
+    QualifiedSWHID,
     parse_swhid,
-    swhid,
 )
 from swh.web.common import archive
 from swh.web.common.exc import BadInputExc
 from swh.web.common.typing import (
     QueryParameters,
     SnapshotContext,
     SWHIDContext,
     SWHIDInfo,
     SWHObjectInfo,
 )
 from swh.web.common.utils import reverse
 
 
 def gen_swhid(
     object_type: str,
     object_id: str,
     scheme_version: int = 1,
     metadata: SWHIDContext = {},
 ) -> str:
     """
     Returns the SoftWare Heritage persistent IDentifier for a swh object based on:
 
         * the object type
         * the object id
         * the SWHID scheme version
 
     Args:
         object_type: the swh object type
             (content/directory/release/revision/snapshot)
         object_id: the swh object id (hexadecimal representation
             of its hash value)
         scheme_version: the scheme version of the SWHIDs
 
     Returns:
         the SWHID of the object
 
     Raises:
         BadInputExc: if the provided parameters do not enable to
             generate a valid identifier
     """
     try:
-        obj_swhid = swhid(
-            object_type,
-            object_id,
-            scheme_version,
-            cast(Dict[str, Any], {k: v for k, v in metadata.items() if v is not None}),
+        decoded_object_type = ObjectType[object_type.upper()]
+        decoded_object_id = hash_to_bytes(object_id)
+        obj_swhid = str(
+            QualifiedSWHID(
+                object_type=decoded_object_type,
+                object_id=decoded_object_id,
+                scheme_version=scheme_version,
+                **metadata,
+            )
         )
-    except ValidationError as e:
+    except (ValidationError, KeyError, ValueError) as e:
         raise BadInputExc("Invalid object (%s) for SWHID. %s" % (object_id, e))
     else:
         return obj_swhid
 
 
 class ResolvedSWHID(TypedDict):
     """parsed SWHID with context"""
 
     swhid_parsed: SWHID
     """URL to browse object according to SWHID context"""
     browse_url: Optional[str]
 
 
 def resolve_swhid(
     swhid: str, query_params: Optional[QueryParameters] = None
 ) -> ResolvedSWHID:
     """
     Try to resolve a SoftWare Heritage persistent IDentifier into an url for
     browsing the targeted object.
 
     Args:
         swhid: a SoftWare Heritage persistent IDentifier
         query_params: optional dict filled with
             query parameters to append to the browse url
 
     Returns:
         a dict with the following keys:
 
             * **swhid_parsed**: the parsed identifier
             * **browse_url**: the url for browsing the targeted object
     """
     swhid_parsed = get_swhid(swhid)
     object_type = swhid_parsed.object_type
     object_id = swhid_parsed.object_id
     browse_url = None
     url_args = {}
     query_dict = QueryDict("", mutable=True)
     fragment = ""
     anchor_swhid_parsed = None
     process_lines = object_type is CONTENT
 
     if query_params and len(query_params) > 0:
         for k in sorted(query_params.keys()):
             query_dict[k] = query_params[k]
 
     if "origin" in swhid_parsed.metadata:
         origin_url = unquote(swhid_parsed.metadata["origin"])
         origin_url = archive.lookup_origin({"url": origin_url})["url"]
         query_dict["origin_url"] = origin_url
 
     if "anchor" in swhid_parsed.metadata:
         anchor_swhid_parsed = get_swhid(swhid_parsed.metadata["anchor"])
 
     if "path" in swhid_parsed.metadata and swhid_parsed.metadata["path"] != "/":
         query_dict["path"] = unquote(swhid_parsed.metadata["path"])
         if anchor_swhid_parsed:
             directory = ""
             if anchor_swhid_parsed.object_type == DIRECTORY:
                 directory = anchor_swhid_parsed.object_id
             elif anchor_swhid_parsed.object_type == REVISION:
                 revision = archive.lookup_revision(anchor_swhid_parsed.object_id)
                 directory = revision["directory"]
             elif anchor_swhid_parsed.object_type == RELEASE:
                 release = archive.lookup_release(anchor_swhid_parsed.object_id)
                 if release["target_type"] == REVISION:
                     revision = archive.lookup_revision(release["target"])
                     directory = revision["directory"]
             if object_type == CONTENT:
                 if "origin" not in swhid_parsed.metadata:
                     # when no origin context, content objects need to have their
                     # path prefixed by root directory id for proper breadcrumbs display
                     query_dict["path"] = directory + query_dict["path"]
                 else:
                     # remove leading slash from SWHID content path
                     query_dict["path"] = query_dict["path"][1:]
             elif object_type == DIRECTORY:
                 object_id = directory
                 # remove leading and trailing slashes from SWHID directory path
                 if query_dict["path"].endswith("/"):
                     query_dict["path"] = query_dict["path"][1:-1]
                 else:
                     query_dict["path"] = query_dict["path"][1:]
 
     # snapshot context
     if "visit" in swhid_parsed.metadata:
 
         snp_swhid_parsed = get_swhid(swhid_parsed.metadata["visit"])
         if snp_swhid_parsed.object_type != SNAPSHOT:
             raise BadInputExc("Visit must be a snapshot SWHID.")
         query_dict["snapshot"] = snp_swhid_parsed.object_id
 
         if anchor_swhid_parsed:
             if anchor_swhid_parsed.object_type == REVISION:
                 # check if the anchor revision is the tip of a branch
                 branch_name = archive.lookup_snapshot_branch_name_from_tip_revision(
                     snp_swhid_parsed.object_id, anchor_swhid_parsed.object_id
                 )
                 if branch_name:
                     query_dict["branch"] = branch_name
                 elif object_type != REVISION:
                     query_dict["revision"] = anchor_swhid_parsed.object_id
 
             elif anchor_swhid_parsed.object_type == RELEASE:
                 release = archive.lookup_release(anchor_swhid_parsed.object_id)
                 if release:
                     query_dict["release"] = release["name"]
 
         if object_type == REVISION and "release" not in query_dict:
             branch_name = archive.lookup_snapshot_branch_name_from_tip_revision(
                 snp_swhid_parsed.object_id, object_id
             )
             if branch_name:
                 query_dict["branch"] = branch_name
 
     # browsing content or directory without snapshot context
     elif object_type in (CONTENT, DIRECTORY) and anchor_swhid_parsed:
         if anchor_swhid_parsed.object_type == REVISION:
             # anchor revision, objects are browsed from its view
             object_type = REVISION
             object_id = anchor_swhid_parsed.object_id
         elif object_type == DIRECTORY and anchor_swhid_parsed.object_type == DIRECTORY:
             # a directory is browsed from its root
             object_id = anchor_swhid_parsed.object_id
 
     if object_type == CONTENT:
         url_args["query_string"] = f"sha1_git:{object_id}"
     elif object_type == DIRECTORY:
         url_args["sha1_git"] = object_id
     elif object_type == RELEASE:
         url_args["sha1_git"] = object_id
     elif object_type == REVISION:
         url_args["sha1_git"] = object_id
     elif object_type == SNAPSHOT:
         url_args["snapshot_id"] = object_id
     elif object_type == ORIGIN:
         raise BadInputExc(
             (
                 "Origin SWHIDs are not publicly resolvable because they are for "
                 "internal usage only"
             )
         )
 
     if "lines" in swhid_parsed.metadata and process_lines:
         lines = swhid_parsed.metadata["lines"].split("-")
         fragment += "#L" + lines[0]
         if len(lines) > 1:
             fragment += "-L" + lines[1]
 
     if url_args:
         browse_url = (
             reverse(
                 f"browse-{object_type}", url_args=url_args, query_params=query_dict,
             )
             + fragment
         )
 
     return ResolvedSWHID(swhid_parsed=swhid_parsed, browse_url=browse_url)
 
 
 def get_swhid(swhid: str) -> SWHID:
     """Check if a SWHID is valid and return it parsed.
 
         Args:
             swhid: a SoftWare Heritage persistent IDentifier.
 
         Raises:
             BadInputExc: if the provided SWHID can not be parsed.
 
         Return:
             A parsed SWHID.
     """
     try:
         swhid_parsed = parse_swhid(swhid)
     except ValidationError as ve:
         raise BadInputExc("Error when parsing identifier: %s" % " ".join(ve.messages))
     else:
         return swhid_parsed
 
 
 def group_swhids(swhids: Iterable[SWHID],) -> Dict[str, List[bytes]]:
     """
     Groups many SoftWare Heritage persistent IDentifiers into a
     dictionary depending on their type.
 
     Args:
         swhids: an iterable of SoftWare Heritage persistent
             IDentifier objects
 
     Returns:
         A dictionary with:
             keys: object types
             values: object hashes
     """
     swhids_by_type: Dict[str, List[bytes]] = {
         CONTENT: [],
         DIRECTORY: [],
         REVISION: [],
         RELEASE: [],
         SNAPSHOT: [],
     }
 
     for obj_swhid in swhids:
         obj_id = obj_swhid.object_id
         obj_type = obj_swhid.object_type
         swhids_by_type[obj_type].append(hash_to_bytes(obj_id))
 
     return swhids_by_type
 
 
 def get_swhids_info(
     swh_objects: Iterable[SWHObjectInfo],
     snapshot_context: Optional[SnapshotContext] = None,
     extra_context: Optional[Dict[str, Any]] = None,
 ) -> List[SWHIDInfo]:
     """
     Returns a list of dict containing info related to SWHIDs of objects.
 
     Args:
         swh_objects: an iterable of dict describing archived objects
         snapshot_context: optional dict parameter describing the snapshot in
             which the objects have been found
         extra_context: optional dict filled with extra contextual info about
             the objects
 
     Returns:
         a list of dict containing SWHIDs info
 
     """
     swhids_info = []
     for swh_object in swh_objects:
         if not swh_object["object_id"]:
             swhids_info.append(
                 SWHIDInfo(
                     object_type=swh_object["object_type"],
                     object_id="",
                     swhid="",
                     swhid_url="",
                     context={},
                     swhid_with_context=None,
                     swhid_with_context_url=None,
                 )
             )
             continue
         object_type = swh_object["object_type"]
         object_id = swh_object["object_id"]
         swhid_context: SWHIDContext = {}
         if snapshot_context:
             if snapshot_context["origin_info"] is not None:
                 swhid_context["origin"] = quote(
                     snapshot_context["origin_info"]["url"], safe="/?:@&"
                 )
             if object_type != SNAPSHOT:
                 swhid_context["visit"] = gen_swhid(
                     SNAPSHOT, snapshot_context["snapshot_id"]
                 )
             if object_type in (CONTENT, DIRECTORY):
                 if snapshot_context["release_id"] is not None:
                     swhid_context["anchor"] = gen_swhid(
                         RELEASE, snapshot_context["release_id"]
                     )
                 elif snapshot_context["revision_id"] is not None:
                     swhid_context["anchor"] = gen_swhid(
                         REVISION, snapshot_context["revision_id"]
                     )
 
         if object_type in (CONTENT, DIRECTORY):
             if (
                 extra_context
                 and "revision" in extra_context
                 and extra_context["revision"]
                 and "anchor" not in swhid_context
             ):
                 swhid_context["anchor"] = gen_swhid(REVISION, extra_context["revision"])
             elif (
                 extra_context
                 and "root_directory" in extra_context
                 and extra_context["root_directory"]
                 and "anchor" not in swhid_context
                 and (
                     object_type != DIRECTORY
                     or extra_context["root_directory"] != object_id
                 )
             ):
                 swhid_context["anchor"] = gen_swhid(
                     DIRECTORY, extra_context["root_directory"]
                 )
             path = None
             if extra_context and "path" in extra_context:
                 path = extra_context["path"] or "/"
                 if "filename" in extra_context and object_type == CONTENT:
                     path += extra_context["filename"]
                 if object_type == DIRECTORY and path == "/":
                     path = None
             if path:
                 swhid_context["path"] = quote(path, safe="/?:@&")
 
         swhid = gen_swhid(object_type, object_id)
         swhid_url = reverse("browse-swhid", url_args={"swhid": swhid})
 
         swhid_with_context = None
         swhid_with_context_url = None
         if swhid_context:
             swhid_with_context = gen_swhid(
                 object_type, object_id, metadata=swhid_context
             )
             swhid_with_context_url = reverse(
                 "browse-swhid", url_args={"swhid": swhid_with_context}
             )
 
         swhids_info.append(
             SWHIDInfo(
                 object_type=object_type,
                 object_id=object_id,
                 swhid=swhid,
                 swhid_url=swhid_url,
                 context=swhid_context,
                 swhid_with_context=swhid_with_context,
                 swhid_with_context_url=swhid_with_context_url,
             )
         )
     return swhids_info
diff --git a/swh/web/tests/browse/views/test_content.py b/swh/web/tests/browse/views/test_content.py
index eb5475d7..231a15f5 100644
--- a/swh/web/tests/browse/views/test_content.py
+++ b/swh/web/tests/browse/views/test_content.py
@@ -1,599 +1,612 @@
 # 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 hypothesis import given
 
 from django.utils.html import escape
 
 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 (
     _re_encode_content,
     get_mimetype_and_encoding_for_content,
     prepare_content_for_display,
 )
 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
 from swh.web.tests.strategies import (
     content,
     content_image_type,
     content_text,
     content_text_no_highlight,
     content_text_non_utf8,
     content_unsupported_image_type_rendering,
     content_utf8_detected_as_binary,
     invalid_sha1,
     origin_with_multiple_visits,
     unknown_content,
 )
 from swh.web.tests.utils import check_html_get_response, check_http_get_response
 
 
 @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 = check_html_get_response(
         client, url, status_code=200, template_used="browse/content.html"
     )
 
     content_display = _process_content_for_display(archive_data, content)
     mimetype = content_display["mimetype"]
 
     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)
     assert_not_contains(resp, "swh-metadata-popover")
 
 
 @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 = check_html_get_response(
         client, url, status_code=200, template_used="browse/content.html"
     )
 
     content_display = _process_content_for_display(archive_data, content)
 
     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 = check_html_get_response(
         client, url, status_code=200, template_used="browse/content.html"
     )
 
     content_display = _process_content_for_display(archive_data, content)
 
     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 = check_html_get_response(
         client, url, status_code=200, template_used="browse/content.html"
     )
 
     content_display = _process_content_for_display(archive_data, content)
     mimetype = content_display["mimetype"]
     content_data = content_display["content_data"]
     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 = check_html_get_response(
         client, url, status_code=200, template_used="browse/content.html"
     )
 
     mimetype = content["mimetype"]
     encoding = content["encoding"]
     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 = check_html_get_response(
         client, url, status_code=200, template_used="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 = check_html_get_response(
         client, url, status_code=200, template_used="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 = check_html_get_response(
         client, url, status_code=404, template_used="error.html"
     )
 
 
 @given(content_text())
 def test_content_raw_text(client, archive_data, content):
     url = reverse("browse-content-raw", url_args={"query_string": content["sha1"]})
 
     resp = check_http_get_response(
         client, url, status_code=200, content_type="text/plain"
     )
 
     content_data = archive_data.content_get_data(content["sha1"])["data"]
 
     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 = check_http_get_response(
         client, url, status_code=200, content_type="text/plain"
     )
 
     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 = check_http_get_response(
         client, url, status_code=200, content_type="text/plain"
     )
     _, 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 = check_http_get_response(
         client, url, status_code=200, content_type="application/octet-stream"
     )
 
     filename = content["path"].split("/")[-1]
     content_data = archive_data.content_get_data(content["sha1"])["data"]
 
     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 = check_http_get_response(
         client, url, status_code=200, content_type="application/octet-stream"
     )
 
     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})
     check_html_get_response(client, url, status_code=400, template_used="error.html")
 
     url = reverse("browse-content", url_args={"query_string": unknown_content["sha1"]})
     check_html_get_response(
         client, url, status_code=404, template_used="browse/content.html"
     )
 
 
 @given(content())
 def test_content_bytes_missing(client, archive_data, mocker, content):
     mock_archive = mocker.patch("swh.web.browse.utils.archive")
     content_data = archive_data.content_get(content["sha1"])
 
     mock_archive.lookup_content.return_value = content_data
     mock_archive.lookup_content_filetype.side_effect = Exception()
     mock_archive.lookup_content_raw.side_effect = NotFoundExc(
         "Content bytes not available!"
     )
 
     url = reverse("browse-content", url_args={"query_string": content["sha1"]})
 
     check_html_get_response(
         client, url, status_code=404, template_used="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 = check_html_get_response(
         client, url, status_code=200, template_used="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 = check_html_get_response(client, url, 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 = check_html_get_response(
         client, url, status_code=200, template_used="browse/content.html"
     )
 
     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"])
     snapshot_sizes = archive_data.snapshot_count_branches(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 = check_html_get_response(
         client, url, status_code=200, template_used="browse/content.html"
     )
 
     _check_origin_snapshot_related_html(
         resp, origin, snapshot, snapshot_sizes, 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),
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
             "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),
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
             "anchor": gen_swhid(REVISION, branch_info["revision"]),
         },
     )
     assert_contains(resp, dir_swhid)
 
     rev_swhid = gen_swhid(
         REVISION,
         branch_info["revision"],
-        metadata={"origin": origin["url"], "visit": gen_swhid(SNAPSHOT, snapshot),},
+        metadata={
+            "origin": origin["url"],
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
+        },
     )
     assert_contains(resp, rev_swhid)
 
-    snp_swhid = gen_swhid(SNAPSHOT, snapshot, metadata={"origin": origin["url"],},)
+    snp_swhid = gen_swhid(
+        SNAPSHOT, snapshot["id"], 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"])
     snapshot_sizes = archive_data.snapshot_count_branches(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 = check_html_get_response(
         client, url, status_code=200, template_used="browse/content.html"
     )
 
     _check_origin_snapshot_related_html(
         resp, origin, snapshot, snapshot_sizes, 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),
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
             "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),
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
             "anchor": gen_swhid(RELEASE, release_info["id"]),
         },
     )
     assert_contains(resp, dir_swhid)
 
     rev_swhid = gen_swhid(
         REVISION,
         release_info["target"],
-        metadata={"origin": origin["url"], "visit": gen_swhid(SNAPSHOT, snapshot),},
+        metadata={
+            "origin": origin["url"],
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
+        },
     )
     assert_contains(resp, rev_swhid)
 
     rel_swhid = gen_swhid(
         RELEASE,
         release_info["id"],
-        metadata={"origin": origin["url"], "visit": gen_swhid(SNAPSHOT, snapshot),},
+        metadata={
+            "origin": origin["url"],
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
+        },
     )
     assert_contains(resp, rel_swhid)
 
-    snp_swhid = gen_swhid(SNAPSHOT, snapshot, metadata={"origin": origin["url"],},)
+    snp_swhid = gen_swhid(
+        SNAPSHOT, snapshot["id"], metadata={"origin": origin["url"],},
+    )
     assert_contains(resp, snp_swhid)
 
 
 def _check_origin_snapshot_related_html(
     resp, origin, snapshot, snapshot_sizes, 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 ({snapshot_sizes['revision']})")
 
     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 ({snapshot_sizes['release']})")
 
     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/browse/views/test_directory.py b/swh/web/tests/browse/views/test_directory.py
index 4067bb4e..7f40fe1a 100644
--- a/swh/web/tests/browse/views/test_directory.py
+++ b/swh/web/tests/browse/views/test_directory.py
@@ -1,457 +1,470 @@
 # 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 hypothesis import given
 
 from django.utils.html import escape
 
 from swh.model.from_disk import DentryPerms
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.identifiers import DIRECTORY, RELEASE, REVISION, SNAPSHOT
 from swh.model.model import (
     Directory,
     DirectoryEntry,
     Origin,
     OriginVisit,
     OriginVisitStatus,
     Revision,
     RevisionType,
     Snapshot,
     SnapshotBranch,
     TargetType,
     TimestampWithTimezone,
 )
 from swh.storage.utils import now
 from swh.web.browse.snapshot_context import process_snapshot_branches
 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
 from swh.web.tests.strategies import (
     directory,
     directory_with_subdirs,
     empty_directory,
     invalid_sha1,
     new_person,
     new_swh_date,
     origin_with_multiple_visits,
     unknown_directory,
 )
 from swh.web.tests.utils import check_html_get_response
 
 
 @given(directory())
 def test_root_directory_view(client, archive_data, directory):
     _directory_view_checks(client, directory, archive_data.directory_ls(directory))
 
 
 @given(directory_with_subdirs())
 def test_sub_directory_view(client, archive_data, directory):
     dir_content = archive_data.directory_ls(directory)
     subdir = random.choice([e for e in dir_content if e["type"] == "dir"])
     subdir_content = archive_data.directory_ls(subdir["target"])
     _directory_view_checks(client, directory, subdir_content, subdir["name"])
 
 
 @given(empty_directory(), new_person(), new_swh_date())
 def test_sub_directory_view_origin_context(
     client, archive_data, empty_directory, person, date
 ):
     origin_url = "test_sub_directory_view_origin_context"
     subdir = Directory(
         entries=(
             DirectoryEntry(
                 name=b"foo",
                 type="dir",
                 target=hash_to_bytes(empty_directory),
                 perms=DentryPerms.directory,
             ),
             DirectoryEntry(
                 name=b"bar",
                 type="dir",
                 target=hash_to_bytes(empty_directory),
                 perms=DentryPerms.directory,
             ),
         )
     )
 
     parentdir = Directory(
         entries=(
             DirectoryEntry(
                 name=b"baz", type="dir", target=subdir.id, perms=DentryPerms.directory,
             ),
         )
     )
     archive_data.directory_add([subdir, parentdir])
 
     revision = Revision(
         directory=parentdir.id,
         author=person,
         committer=person,
         message=b"commit message",
         date=TimestampWithTimezone.from_datetime(date),
         committer_date=TimestampWithTimezone.from_datetime(date),
         synthetic=False,
         type=RevisionType.GIT,
     )
     archive_data.revision_add([revision])
 
     snapshot = Snapshot(
         branches={
             b"HEAD": SnapshotBranch(
                 target="refs/head/master".encode(), target_type=TargetType.ALIAS,
             ),
             b"refs/head/master": SnapshotBranch(
                 target=revision.id, target_type=TargetType.REVISION,
             ),
         }
     )
     archive_data.snapshot_add([snapshot])
 
     archive_data.origin_add([Origin(url=origin_url)])
     date = now()
     visit = OriginVisit(origin=origin_url, date=date, type="git")
     visit = archive_data.origin_visit_add([visit])[0]
     visit_status = OriginVisitStatus(
         origin=origin_url,
         visit=visit.visit,
         date=date,
         status="full",
         snapshot=snapshot.id,
     )
     archive_data.origin_visit_status_add([visit_status])
 
     dir_content = archive_data.directory_ls(hash_to_hex(parentdir.id))
     subdir = dir_content[0]
     subdir_content = archive_data.directory_ls(subdir["target"])
     _directory_view_checks(
         client,
         hash_to_hex(parentdir.id),
         subdir_content,
         subdir["name"],
         origin_url,
         hash_to_hex(snapshot.id),
         hash_to_hex(revision.id),
     )
 
 
 @given(invalid_sha1(), unknown_directory())
 def test_directory_request_errors(client, invalid_sha1, unknown_directory):
     dir_url = reverse("browse-directory", url_args={"sha1_git": invalid_sha1})
 
     check_html_get_response(
         client, dir_url, status_code=400, template_used="error.html"
     )
 
     dir_url = reverse("browse-directory", url_args={"sha1_git": unknown_directory})
 
     check_html_get_response(
         client, dir_url, status_code=404, template_used="error.html"
     )
 
 
 @given(directory())
 def test_directory_with_invalid_path(client, directory):
     path = "foo/bar"
     dir_url = reverse(
         "browse-directory",
         url_args={"sha1_git": directory},
         query_params={"path": path},
     )
 
     resp = check_html_get_response(
         client, dir_url, status_code=404, template_used="browse/directory.html"
     )
     error_message = (
         f"Directory entry with path {path} from root directory {directory} not found"
     )
     assert_contains(resp, error_message, status_code=404)
 
 
 @given(directory())
 def test_directory_uppercase(client, directory):
     url = reverse(
         "browse-directory-uppercase-checksum", url_args={"sha1_git": directory.upper()}
     )
 
     resp = check_html_get_response(client, url, status_code=302)
 
     redirect_url = reverse("browse-directory", url_args={"sha1_git": directory})
 
     assert resp["location"] == redirect_url
 
 
 @given(directory())
 def test_permalink_box_context(client, tests_data, directory):
     origin_url = random.choice(tests_data["origins"])["url"]
     url = reverse(
         "browse-directory",
         url_args={"sha1_git": directory},
         query_params={"origin_url": origin_url},
     )
 
     resp = check_html_get_response(
         client, url, status_code=200, template_used="browse/directory.html"
     )
     assert_contains(resp, 'id="swhid-context-option-directory"')
 
 
 @given(origin_with_multiple_visits())
 def test_directory_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"])
     snapshot_sizes = archive_data.snapshot_count_branches(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_subdir = random.choice(
         [e for e in directory_content if e["type"] == "dir"]
     )
 
     url = reverse(
         "browse-directory",
         url_args={"sha1_git": directory},
         query_params={
             "origin_url": origin["url"],
             "snapshot": snapshot["id"],
             "branch": branch_info["name"],
             "path": directory_subdir["name"],
         },
     )
 
     resp = check_html_get_response(
         client, url, status_code=200, template_used="browse/directory.html"
     )
 
     _check_origin_snapshot_related_html(
         resp, origin, snapshot, snapshot_sizes, branches, releases
     )
     assert_contains(resp, directory_subdir["name"])
     assert_contains(resp, f"Branch: <strong>{branch_info['name']}</strong>")
 
     dir_swhid = gen_swhid(
         DIRECTORY,
         directory_subdir["target"],
         metadata={
             "origin": origin["url"],
-            "visit": gen_swhid(SNAPSHOT, snapshot),
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
             "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),},
+        metadata={
+            "origin": origin["url"],
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
+        },
     )
     assert_contains(resp, rev_swhid)
 
-    snp_swhid = gen_swhid(SNAPSHOT, snapshot, metadata={"origin": origin["url"],},)
+    snp_swhid = gen_swhid(
+        SNAPSHOT, snapshot["id"], 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"])
     snapshot_sizes = archive_data.snapshot_count_branches(visit["snapshot"])
     branches, releases, _ = process_snapshot_branches(snapshot)
     release_info = random.choice(releases)
 
     directory = release_info["directory"]
     directory_content = archive_data.directory_ls(directory)
     directory_subdir = random.choice(
         [e for e in directory_content if e["type"] == "dir"]
     )
 
     url = reverse(
         "browse-directory",
         url_args={"sha1_git": directory},
         query_params={
             "origin_url": origin["url"],
             "snapshot": snapshot["id"],
             "release": release_info["name"],
             "path": directory_subdir["name"],
         },
     )
 
     resp = check_html_get_response(
         client, url, status_code=200, template_used="browse/directory.html"
     )
 
     _check_origin_snapshot_related_html(
         resp, origin, snapshot, snapshot_sizes, branches, releases
     )
     assert_contains(resp, directory_subdir["name"])
     assert_contains(resp, f"Release: <strong>{release_info['name']}</strong>")
 
     dir_swhid = gen_swhid(
         DIRECTORY,
         directory_subdir["target"],
         metadata={
             "origin": origin["url"],
-            "visit": gen_swhid(SNAPSHOT, snapshot),
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
             "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),},
+        metadata={
+            "origin": origin["url"],
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
+        },
     )
     assert_contains(resp, rev_swhid)
 
     rel_swhid = gen_swhid(
         RELEASE,
         release_info["id"],
-        metadata={"origin": origin["url"], "visit": gen_swhid(SNAPSHOT, snapshot),},
+        metadata={
+            "origin": origin["url"],
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
+        },
     )
     assert_contains(resp, rel_swhid)
 
-    snp_swhid = gen_swhid(SNAPSHOT, snapshot, metadata={"origin": origin["url"],},)
+    snp_swhid = gen_swhid(
+        SNAPSHOT, snapshot["id"], metadata={"origin": origin["url"],},
+    )
     assert_contains(resp, snp_swhid)
 
 
 def _check_origin_snapshot_related_html(
     resp, origin, snapshot, snapshot_sizes, 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 ({snapshot_sizes['revision']})")
 
     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 ({snapshot_sizes['release']})")
 
     assert_contains(resp, '<li class="swh-branch">', count=len(branches))
     assert_contains(resp, '<li class="swh-release">', count=len(releases))
 
 
 def _directory_view_checks(
     client,
     root_directory_sha1,
     directory_entries,
     path=None,
     origin_url=None,
     snapshot_id=None,
     revision_id=None,
 ):
     dirs = [e for e in directory_entries if e["type"] in ("dir", "rev")]
     files = [e for e in directory_entries if e["type"] == "file"]
 
     url_args = {"sha1_git": root_directory_sha1}
     query_params = {"origin_url": origin_url, "snapshot": snapshot_id}
 
     url = reverse(
         "browse-directory",
         url_args=url_args,
         query_params={**query_params, "path": path},
     )
 
     root_dir_url = reverse(
         "browse-directory", url_args=url_args, query_params=query_params,
     )
 
     resp = check_html_get_response(
         client, url, status_code=200, template_used="browse/directory.html"
     )
 
     assert_contains(
         resp, '<a href="' + root_dir_url + '">' + root_directory_sha1[:7] + "</a>",
     )
     assert_contains(resp, '<td class="swh-directory">', count=len(dirs))
     assert_contains(resp, '<td class="swh-content">', count=len(files))
 
     for d in dirs:
         if d["type"] == "rev":
             dir_url = reverse("browse-revision", url_args={"sha1_git": d["target"]})
         else:
             dir_path = d["name"]
             if path:
                 dir_path = "%s/%s" % (path, d["name"])
             dir_url = reverse(
                 "browse-directory",
                 url_args={"sha1_git": root_directory_sha1},
                 query_params={**query_params, "path": dir_path},
             )
         assert_contains(resp, dir_url)
 
     for f in files:
         file_path = "%s/%s" % (root_directory_sha1, f["name"])
         if path:
             file_path = "%s/%s/%s" % (root_directory_sha1, path, f["name"])
         query_string = "sha1_git:" + f["target"]
         file_url = reverse(
             "browse-content",
             url_args={"query_string": query_string},
             query_params={**query_params, "path": file_path},
         )
         assert_contains(resp, file_url)
 
     path_info = gen_path_info(path)
 
     assert_contains(resp, '<li class="swh-path">', count=len(path_info) + 1)
     assert_contains(
         resp, '<a href="%s">%s</a>' % (root_dir_url, root_directory_sha1[:7])
     )
 
     for p in path_info:
         dir_url = reverse(
             "browse-directory",
             url_args={"sha1_git": root_directory_sha1},
             query_params={**query_params, "path": p["path"]},
         )
         assert_contains(resp, '<a href="%s">%s</a>' % (dir_url, p["name"]))
 
     assert_contains(resp, "vault-cook-directory")
 
     swh_dir_id = gen_swhid(DIRECTORY, directory_entries[0]["dir_id"])
     swh_dir_id_url = reverse("browse-swhid", url_args={"swhid": swh_dir_id})
 
     swhid_context = {}
     if origin_url:
         swhid_context["origin"] = origin_url
     if snapshot_id:
         swhid_context["visit"] = gen_swhid(SNAPSHOT, snapshot_id)
     if root_directory_sha1 != directory_entries[0]["dir_id"]:
         swhid_context["anchor"] = gen_swhid(DIRECTORY, root_directory_sha1)
     if root_directory_sha1 != directory_entries[0]["dir_id"]:
         swhid_context["anchor"] = gen_swhid(DIRECTORY, root_directory_sha1)
     if revision_id:
         swhid_context["anchor"] = gen_swhid(REVISION, revision_id)
     swhid_context["path"] = f"/{path}/" if path else None
 
     swh_dir_id = gen_swhid(
         DIRECTORY, directory_entries[0]["dir_id"], metadata=swhid_context
     )
     swh_dir_id_url = reverse("browse-swhid", url_args={"swhid": swh_dir_id})
     assert_contains(resp, swh_dir_id)
     assert_contains(resp, swh_dir_id_url)
 
     assert_not_contains(resp, "swh-metadata-popover")
diff --git a/swh/web/tests/browse/views/test_identifiers.py b/swh/web/tests/browse/views/test_identifiers.py
index e49a5069..ade9c564 100644
--- a/swh/web/tests/browse/views/test_identifiers.py
+++ b/swh/web/tests/browse/views/test_identifiers.py
@@ -1,203 +1,203 @@
 # 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 random
 from urllib.parse import quote
 
 from hypothesis import given
 
 from swh.model.identifiers import CONTENT, DIRECTORY, RELEASE, REVISION, SNAPSHOT
 from swh.model.model import Origin
 from swh.web.common.identifiers import gen_swhid
 from swh.web.common.utils import reverse
 from swh.web.tests.django_asserts import assert_contains
 from swh.web.tests.strategies import (
     content,
     directory,
     origin,
     release,
     revision,
     snapshot,
 )
 from swh.web.tests.utils import check_html_get_response
 
 
 @given(content())
 def test_content_id_browse(client, content):
     cnt_sha1_git = content["sha1_git"]
     swhid = gen_swhid(CONTENT, cnt_sha1_git)
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     query_string = "sha1_git:" + cnt_sha1_git
     content_browse_url = reverse(
         "browse-content", url_args={"query_string": query_string}
     )
 
     resp = check_html_get_response(client, url, status_code=302)
     assert resp["location"] == content_browse_url
 
 
 @given(directory())
 def test_directory_id_browse(client, directory):
     swhid = gen_swhid(DIRECTORY, directory)
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     directory_browse_url = reverse("browse-directory", url_args={"sha1_git": directory})
 
     resp = check_html_get_response(client, url, status_code=302)
     assert resp["location"] == directory_browse_url
 
 
 @given(revision())
 def test_revision_id_browse(client, revision):
     swhid = gen_swhid(REVISION, revision)
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     revision_browse_url = reverse("browse-revision", url_args={"sha1_git": revision})
 
     resp = check_html_get_response(client, url, status_code=302)
     assert resp["location"] == revision_browse_url
 
     query_params = {"origin_url": "https://github.com/user/repo"}
     url = reverse("browse-swhid", url_args={"swhid": swhid}, query_params=query_params)
 
     revision_browse_url = reverse(
         "browse-revision", url_args={"sha1_git": revision}, query_params=query_params
     )
 
     resp = check_html_get_response(client, url, status_code=302)
     assert resp["location"] == revision_browse_url
 
 
 @given(release())
 def test_release_id_browse(client, release):
     swhid = gen_swhid(RELEASE, release)
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     release_browse_url = reverse("browse-release", url_args={"sha1_git": release})
 
     resp = check_html_get_response(client, url, status_code=302)
     assert resp["location"] == release_browse_url
 
     query_params = {"origin_url": "https://github.com/user/repo"}
 
     url = reverse("browse-swhid", url_args={"swhid": swhid}, query_params=query_params)
 
     release_browse_url = reverse(
         "browse-release", url_args={"sha1_git": release}, query_params=query_params
     )
 
     resp = check_html_get_response(client, url, status_code=302)
     assert resp["location"] == release_browse_url
 
 
 @given(snapshot())
 def test_snapshot_id_browse(client, snapshot):
     swhid = gen_swhid(SNAPSHOT, snapshot)
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     snapshot_browse_url = reverse("browse-snapshot", url_args={"snapshot_id": snapshot})
 
     resp = check_html_get_response(client, url, status_code=302)
     assert resp["location"] == snapshot_browse_url
 
     query_params = {"origin_url": "https://github.com/user/repo"}
 
     url = reverse("browse-swhid", url_args={"swhid": swhid}, query_params=query_params)
 
     release_browse_url = reverse(
         "browse-snapshot", url_args={"snapshot_id": snapshot}, query_params=query_params
     )
 
     resp = check_html_get_response(client, url, status_code=302)
     assert resp["location"] == release_browse_url
 
 
 @given(release())
 def test_bad_id_browse(client, release):
     swhid = f"swh:1:foo:{release}"
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     check_html_get_response(client, url, status_code=400)
 
 
 @given(content())
 def test_content_id_optional_parts_browse(client, archive_data, content):
     cnt_sha1_git = content["sha1_git"]
     origin_url = "https://github.com/user/repo"
 
     archive_data.origin_add([Origin(url=origin_url)])
 
     swhid = gen_swhid(
         CONTENT, cnt_sha1_git, metadata={"lines": "4-20", "origin": origin_url},
     )
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     query_string = "sha1_git:" + cnt_sha1_git
     content_browse_url = reverse(
         "browse-content",
         url_args={"query_string": query_string},
         query_params={"origin_url": origin_url},
     )
     content_browse_url += "#L4-L20"
 
     resp = check_html_get_response(client, url, status_code=302)
     assert resp["location"] == content_browse_url
 
 
 @given(release())
 def test_origin_id_not_resolvable(client, release):
     swhid = "swh:1:ori:8068d0075010b590762c6cb5682ed53cb3c13deb"
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     check_html_get_response(client, url, status_code=400)
 
 
 @given(origin())
 def test_legacy_swhid_browse(archive_data, client, origin):
     snapshot = archive_data.snapshot_get_latest(origin["url"])
     revision = archive_data.snapshot_get_head(snapshot)
     directory = archive_data.revision_get(revision)["directory"]
     directory_content = archive_data.directory_ls(directory)
     directory_file = random.choice(
         [e for e in directory_content if e["type"] == "file"]
     )
     legacy_swhid = gen_swhid(
         CONTENT,
         directory_file["checksums"]["sha1_git"],
         metadata={"origin": origin["url"]},
     )
 
     url = reverse("browse-swhid", url_args={"swhid": legacy_swhid})
 
     resp = check_html_get_response(client, url, status_code=302)
     resp = check_html_get_response(
         client, resp["location"], status_code=200, template_used="browse/content.html"
     )
 
     swhid = gen_swhid(
         CONTENT,
         directory_file["checksums"]["sha1_git"],
         metadata={
             "origin": origin["url"],
-            "visit": gen_swhid(SNAPSHOT, snapshot),
+            "visit": gen_swhid(SNAPSHOT, snapshot["id"]),
             "anchor": gen_swhid(REVISION, revision),
         },
     )
 
     assert_contains(resp, swhid)
 
 
 @given(directory())
 def test_browse_swhid_special_characters_escaping(client, archive_data, directory):
     origin = "http://example.org/?project=abc;"
     archive_data.origin_add([Origin(url=origin)])
     origin_swhid_escaped = quote(origin, safe="/?:@&")
     origin_swhid_url_escaped = quote(origin, safe="/:@;")
     swhid = gen_swhid(DIRECTORY, directory, metadata={"origin": origin_swhid_escaped})
     url = reverse("browse-swhid", url_args={"swhid": swhid})
 
     resp = check_html_get_response(client, url, status_code=302)
     assert origin_swhid_url_escaped in resp["location"]