diff --git a/swh/web/api/utils.py b/swh/web/api/utils.py
index 9f22fab6..c6e00b00 100644
--- a/swh/web/api/utils.py
+++ b/swh/web/api/utils.py
@@ -1,335 +1,335 @@
 # 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
 
 from typing import Any, Dict, Optional
 
 from django.http import HttpRequest
 
 from swh.web.common.query import parse_hash
 from swh.web.common.utils import resolve_branch_alias, reverse
 
 
 def filter_field_keys(data, field_keys):
     """Given an object instance (directory or list), and a csv field keys
     to filter on.
 
     Return the object instance with filtered keys.
 
     Note: Returns obj as is if it's an instance of types not in (dictionary,
     list)
 
     Args:
         - data: one object (dictionary, list...) to filter.
         - field_keys: csv or set of keys to filter the object on
 
     Returns:
         obj filtered on field_keys
 
     """
     if isinstance(data, map):
         return map(lambda x: filter_field_keys(x, field_keys), data)
     if isinstance(data, list):
         return [filter_field_keys(x, field_keys) for x in data]
     if isinstance(data, dict):
         return {k: v for (k, v) in data.items() if k in field_keys}
     return data
 
 
 def person_to_string(person):
     """Map a person (person, committer, tagger, etc...) to a string.
 
     """
     return "".join([person["name"], " <", person["email"], ">"])
 
 
 def enrich_object(
     object: Dict[str, str], request: Optional[HttpRequest] = None
 ) -> Dict[str, str]:
     """Enrich an object (revision, release) with link to the 'target' of
     type 'target_type'.
 
     Args:
         object: An object with target and target_type keys
         (e.g. release, revision)
         request: Absolute URIs will be generated if provided
 
     Returns:
         Object enriched with target object url (revision, release, content,
         directory)
 
     """
     if "target" in object and "target_type" in object:
         if object["target_type"] in ("revision", "release", "directory"):
             object["target_url"] = reverse(
                 "api-1-%s" % object["target_type"],
                 url_args={"sha1_git": object["target"]},
                 request=request,
             )
         elif object["target_type"] == "content":
             object["target_url"] = reverse(
                 "api-1-content",
                 url_args={"q": "sha1_git:" + object["target"]},
                 request=request,
             )
         elif object["target_type"] == "snapshot":
             object["target_url"] = reverse(
                 "api-1-snapshot",
                 url_args={"snapshot_id": object["target"]},
                 request=request,
             )
 
     return object
 
 
 enrich_release = enrich_object
 
 
-def enrich_directory(
+def enrich_directory_entry(
     directory: Dict[str, str], request: Optional[HttpRequest] = None
 ) -> Dict[str, str]:
-    """Enrich directory with url to content or directory.
+    """Enrich directory entry with url to target.
 
     Args:
-        directory: dict of data associated to a swh directory object
+        directory: dict of data associated to a swh directory entry
         request: Absolute URIs will be generated if provided
 
     Returns:
-        An enriched directory dict filled with additional urls
+        An enriched directory dict filled with additional url
     """
     if "type" in directory:
         target_type = directory["type"]
         target = directory["target"]
         if target_type == "file":
             directory["target_url"] = reverse(
                 "api-1-content", url_args={"q": "sha1_git:%s" % target}, request=request
             )
         elif target_type == "dir":
             directory["target_url"] = reverse(
                 "api-1-directory", url_args={"sha1_git": target}, request=request
             )
         else:
             directory["target_url"] = reverse(
                 "api-1-revision", url_args={"sha1_git": target}, request=request
             )
 
     return directory
 
 
 def enrich_metadata_endpoint(
     content_metadata: Dict[str, str], request: Optional[HttpRequest] = None
 ) -> Dict[str, str]:
     """Enrich content metadata dict with link to the upper metadata endpoint.
 
     Args:
         content_metadata: dict of data associated to a swh content metadata
         request: Absolute URIs will be generated if provided
 
     Returns:
         An enriched content metadata dict filled with an additional url
     """
     c = content_metadata
     c["content_url"] = reverse(
         "api-1-content", url_args={"q": "sha1:%s" % c["id"]}, request=request
     )
     return c
 
 
 def enrich_content(
     content: Dict[str, Any],
     top_url: Optional[bool] = False,
     query_string: Optional[str] = None,
     request: Optional[HttpRequest] = None,
 ) -> Dict[str, str]:
     """Enrich content with links to:
         - data_url: its raw data
         - filetype_url: its filetype information
         - language_url: its programming language information
         - license_url: its licensing information
 
     Args:
         content: dict of data associated to a swh content object
         top_url: whether or not to include the content url in
             the enriched data
         query_string: optional query string of type '<algo>:<hash>'
             used when requesting the content, it acts as a hint
             for picking the same hash method when computing
             the url listed above
         request: Absolute URIs will be generated if provided
 
     Returns:
         An enriched content dict filled with additional urls
 
     """
     checksums = content
     if "checksums" in content:
         checksums = content["checksums"]
     hash_algo = "sha1"
     if query_string:
         hash_algo = parse_hash(query_string)[0]
     if hash_algo in checksums:
         q = "%s:%s" % (hash_algo, checksums[hash_algo])
         if top_url:
             content["content_url"] = reverse("api-1-content", url_args={"q": q})
         content["data_url"] = reverse(
             "api-1-content-raw", url_args={"q": q}, request=request
         )
         content["filetype_url"] = reverse(
             "api-1-content-filetype", url_args={"q": q}, request=request
         )
         content["language_url"] = reverse(
             "api-1-content-language", url_args={"q": q}, request=request
         )
         content["license_url"] = reverse(
             "api-1-content-license", url_args={"q": q}, request=request
         )
 
     return content
 
 
 def enrich_revision(
     revision: Dict[str, Any], request: Optional[HttpRequest] = None
 ) -> Dict[str, Any]:
     """Enrich revision with links where it makes sense (directory, parents).
     Keep track of the navigation breadcrumbs if they are specified.
 
     Args:
         revision: the revision as a dict
         request: Absolute URIs will be generated if provided
 
     Returns:
         An enriched revision dict filled with additional urls
     """
 
     revision["url"] = reverse(
         "api-1-revision", url_args={"sha1_git": revision["id"]}, request=request
     )
     revision["history_url"] = reverse(
         "api-1-revision-log", url_args={"sha1_git": revision["id"]}, request=request
     )
 
     if "directory" in revision:
         revision["directory_url"] = reverse(
             "api-1-directory",
             url_args={"sha1_git": revision["directory"]},
             request=request,
         )
 
     if "parents" in revision:
         parents = []
         for parent in revision["parents"]:
             parents.append(
                 {
                     "id": parent,
                     "url": reverse(
                         "api-1-revision", url_args={"sha1_git": parent}, request=request
                     ),
                 }
             )
 
         revision["parents"] = tuple(parents)
 
     if "children" in revision:
         children = []
         for child in revision["children"]:
             children.append(
                 reverse("api-1-revision", url_args={"sha1_git": child}, request=request)
             )
         revision["children_urls"] = children
 
     if "decoding_failures" in revision and "message" in revision["decoding_failures"]:
         revision["message_url"] = reverse(
             "api-1-revision-raw-message",
             url_args={"sha1_git": revision["id"]},
             request=request,
         )
 
     return revision
 
 
 def enrich_snapshot(
     snapshot: Dict[str, Any], request: Optional[HttpRequest] = None
 ) -> Dict[str, Any]:
     """Enrich snapshot with links to the branch targets
 
     Args:
         snapshot: the snapshot as a dict
         request: Absolute URIs will be generated if provided
 
     Returns:
         An enriched snapshot dict filled with additional urls
     """
     if "branches" in snapshot:
         snapshot["branches"] = {
             k: enrich_object(v, request) if v else None
             for k, v in snapshot["branches"].items()
         }
         for k, v in snapshot["branches"].items():
             if v and v["target_type"] == "alias":
                 branch = resolve_branch_alias(snapshot, v)
                 if branch:
                     branch = enrich_object(branch, request)
                     v["target_url"] = branch["target_url"]
     return snapshot
 
 
 def enrich_origin(
     origin: Dict[str, Any], request: Optional[HttpRequest] = None
 ) -> Dict[str, Any]:
     """Enrich origin dict with link to its visits
 
     Args:
         origin: the origin as a dict
         request: Absolute URIs will be generated if provided
 
     Returns:
         An enriched origin dict filled with an additional url
     """
     if "url" in origin:
         origin["origin_visits_url"] = reverse(
             "api-1-origin-visits",
             url_args={"origin_url": origin["url"]},
             request=request,
         )
 
     return origin
 
 
 def enrich_origin_visit(
     origin_visit: Dict[str, Any],
     *,
     with_origin_link: bool,
     with_origin_visit_link: bool,
     request: Optional[HttpRequest] = None,
 ) -> Dict[str, Any]:
     """Enrich origin visit dict with additional links
 
     Args:
         origin_visit: the origin visit as a dict
         with_origin_link: whether to add link to origin
         with_origin_visit_link: whether to add link to origin visit
         request: Absolute URIs will be generated if provided
 
     Returns:
         An enriched origin visit dict filled with additional urls
     """
     ov = origin_visit
     if with_origin_link:
         ov["origin_url"] = reverse(
             "api-1-origin", url_args={"origin_url": ov["origin"]}, request=request
         )
     if with_origin_visit_link:
         ov["origin_visit_url"] = reverse(
             "api-1-origin-visit",
             url_args={"origin_url": ov["origin"], "visit_id": ov["visit"]},
             request=request,
         )
     snapshot = ov["snapshot"]
     if snapshot:
         ov["snapshot_url"] = reverse(
             "api-1-snapshot", url_args={"snapshot_id": snapshot}, request=request
         )
     else:
         ov["snapshot_url"] = None
     return ov
diff --git a/swh/web/api/views/directory.py b/swh/web/api/views/directory.py
index 73668262..00d3c95d 100644
--- a/swh/web/api/views/directory.py
+++ b/swh/web/api/views/directory.py
@@ -1,93 +1,93 @@
 # 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
 
 from swh.web.api import utils
 from swh.web.api.apidoc import api_doc, format_docstring
 from swh.web.api.apiurls import api_route
 from swh.web.api.views.utils import api_lookup
 from swh.web.common import archive
 
 
 @api_route(
     r"/directory/(?P<sha1_git>[0-9a-f]+)/",
     "api-1-directory",
     checksum_args=["sha1_git"],
 )
 @api_route(
     r"/directory/(?P<sha1_git>[0-9a-f]+)/(?P<path>.+)/",
     "api-1-directory",
     checksum_args=["sha1_git"],
 )
 @api_doc("/directory/")
 @format_docstring()
 def api_directory(request, sha1_git, path=None):
     """
     .. http:get:: /api/1/directory/(sha1_git)/[(path)/]
 
         Get information about directory objects.
         Directories are identified by **sha1** checksums, compatible with Git
         directory identifiers.
         See :func:`swh.model.identifiers.directory_identifier` in our data model
         module for details about how they are computed.
 
         When given only a directory identifier, this endpoint returns information
         about the directory itself, returning its content (usually a list of directory
         entries). When given a directory identifier and a path, this endpoint returns
         information about the directory entry pointed by the relative path, starting
         path resolution from the given directory.
 
         :param string sha1_git: hexadecimal representation of the directory
             **sha1_git** identifier
         :param string path: optional parameter to get information about the
             directory entry pointed by that relative path
 
         {common_headers}
 
         :>jsonarr object checksums: object holding the computed checksum values for
             a directory entry (only for file entries)
         :>jsonarr string dir_id: **sha1_git** identifier of the requested directory
         :>jsonarr number length: length of a directory entry in bytes (only for file
             entries) for getting information about the content MIME type
         :>jsonarr string name: the directory entry name
         :>jsonarr number perms: permissions for the directory entry
         :>jsonarr string target: **sha1_git** identifier of the directory entry
         :>jsonarr string target_url: link to
             :http:get:`/api/1/content/[(hash_type):](hash)/`
             or :http:get:`/api/1/directory/(sha1_git)/[(path)/]`
             depending on the directory entry type
         :>jsonarr string type: the type of the directory entry, can be either
             ``dir``, ``file`` or ``rev``
 
         :statuscode 200: no error
         :statuscode 400: an invalid **hash_type** or **hash** has been provided
         :statuscode 404: requested directory can not be found in the archive
 
         **Example:**
 
         .. parsed-literal::
 
             :swh_web_api:`directory/977fc4b98c0e85816348cebd3b12026407c368b6/`
     """
     if path:
         error_msg_path = (
             "Entry with path %s relative to directory " "with sha1_git %s not found."
         ) % (path, sha1_git)
         return api_lookup(
             archive.lookup_directory_with_path,
             sha1_git,
             path,
             notfound_msg=error_msg_path,
-            enrich_fn=utils.enrich_directory,
+            enrich_fn=utils.enrich_directory_entry,
             request=request,
         )
     else:
         error_msg_nopath = "Directory with sha1_git %s not found." % sha1_git
         return api_lookup(
             archive.lookup_directory,
             sha1_git,
             notfound_msg=error_msg_nopath,
-            enrich_fn=utils.enrich_directory,
+            enrich_fn=utils.enrich_directory_entry,
             request=request,
         )
diff --git a/swh/web/api/views/revision.py b/swh/web/api/views/revision.py
index 17cb1d25..75f7d30d 100644
--- a/swh/web/api/views/revision.py
+++ b/swh/web/api/views/revision.py
@@ -1,237 +1,237 @@
 # 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
 
 from django.http import HttpResponse
 
 from swh.web.api import utils
 from swh.web.api.apidoc import api_doc, format_docstring
 from swh.web.api.apiurls import api_route
 from swh.web.api.views.utils import api_lookup
 from swh.web.common import archive
 
 DOC_RETURN_REVISION = """
         :>json object author: information about the author of the revision
         :>json object committer: information about the committer of the
             revision
         :>json string committer_date: ISO representation of the commit date
             (in UTC)
         :>json string date: ISO representation of the revision date (in UTC)
         :>json string directory: the unique identifier that revision points to
         :>json string directory_url: link to
             :http:get:`/api/1/directory/(sha1_git)/[(path)/]` to get
             information about the directory associated to the revision
         :>json string id: the revision unique identifier
         :>json boolean merge: whether or not the revision corresponds to a
             merge commit
         :>json string message: the message associated to the revision
         :>json array parents: the parents of the revision, i.e. the previous
             revisions that head directly to it, each entry of that array
             contains an unique parent revision identifier but also a link to
             :http:get:`/api/1/revision/(sha1_git)/` to get more information
             about it
         :>json string type: the type of the revision
 """
 
 DOC_RETURN_REVISION_ARRAY = DOC_RETURN_REVISION.replace(":>json", ":>jsonarr")
 
 
 def _revision_directory_by(revision, path, request_path, limit=100, with_data=False):
     """
     Compute the revision matching criterion's directory or content data.
 
     Args:
         revision: dictionary of criterions representing a revision to lookup
         path: directory's path to lookup
         request_path: request path which holds the original context to
         limit: optional query parameter to limit the revisions log
         (default to 100). For now, note that this limit could impede the
         transitivity conclusion about sha1_git not being an ancestor of
         with_data: indicate to retrieve the content's raw data if path resolves
         to a content.
 
     """
 
-    def enrich_directory_local(dir, context_url=request_path):
-        return utils.enrich_directory(dir, context_url)
+    def enrich_directory_entry_local(dir, context_url=request_path):
+        return utils.enrich_directory_entry(dir, context_url)
 
     rev_id, result = archive.lookup_directory_through_revision(
         revision, path, limit=limit, with_data=with_data
     )
 
     content = result["content"]
     if result["type"] == "dir":  # dir_entries
-        result["content"] = list(map(enrich_directory_local, content))
+        result["content"] = list(map(enrich_directory_entry_local, content))
     elif result["type"] == "file":  # content
         result["content"] = utils.enrich_content(content)
     elif result["type"] == "rev":  # revision
         result["content"] = utils.enrich_revision(content)
 
     return result
 
 
 @api_route(
     r"/revision/(?P<sha1_git>[0-9a-f]+)/", "api-1-revision", checksum_args=["sha1_git"]
 )
 @api_doc("/revision/")
 @format_docstring(return_revision=DOC_RETURN_REVISION)
 def api_revision(request, sha1_git):
     """
     .. http:get:: /api/1/revision/(sha1_git)/
 
         Get information about a revision in the archive. Revisions are
         identified by **sha1** checksums, compatible with Git commit
         identifiers.
         See :func:`swh.model.identifiers.revision_identifier` in our data model
         module for details about how they are computed.
 
         :param string sha1_git: hexadecimal representation of the revision
             **sha1_git** identifier
 
         {common_headers}
 
         {return_revision}
 
         :statuscode 200: no error
         :statuscode 400: an invalid **sha1_git** value has been provided
         :statuscode 404: requested revision can not be found in the archive
 
         **Example:**
 
         .. parsed-literal::
 
             :swh_web_api:`revision/aafb16d69fd30ff58afdd69036a26047f3aebdc6/`
     """
     return api_lookup(
         archive.lookup_revision,
         sha1_git,
         notfound_msg="Revision with sha1_git {} not found.".format(sha1_git),
         enrich_fn=utils.enrich_revision,
         request=request,
     )
 
 
 @api_route(
     r"/revision/(?P<sha1_git>[0-9a-f]+)/raw/",
     "api-1-revision-raw-message",
     checksum_args=["sha1_git"],
 )
 @api_doc("/revision/raw/", tags=["hidden"])
 def api_revision_raw_message(request, sha1_git):
     """Return the raw data of the message of revision identified by sha1_git
     """
     raw = archive.lookup_revision_message(sha1_git)
     response = HttpResponse(raw["message"], content_type="application/octet-stream")
     response["Content-disposition"] = "attachment;filename=rev_%s_raw" % sha1_git
     return response
 
 
 @api_route(
     r"/revision/(?P<sha1_git>[0-9a-f]+)/directory/",
     "api-1-revision-directory",
     checksum_args=["sha1_git"],
 )
 @api_route(
     r"/revision/(?P<sha1_git>[0-9a-f]+)/directory/(?P<dir_path>.+)/",
     "api-1-revision-directory",
     checksum_args=["sha1_git"],
 )
 @api_doc("/revision/directory/")
 @format_docstring()
 def api_revision_directory(request, sha1_git, dir_path=None, with_data=False):
     """
     .. http:get:: /api/1/revision/(sha1_git)/directory/[(path)/]
 
         Get information about directory (entry) objects associated to revisions.
         Each revision is associated to a single "root" directory.
         This endpoint behaves like :http:get:`/api/1/directory/(sha1_git)/[(path)/]`,
         but operates on the root directory associated to a given revision.
 
         :param string sha1_git: hexadecimal representation of the revision
             **sha1_git** identifier
         :param string path: optional parameter to get information about the
             directory entry pointed by that relative path
 
         {common_headers}
 
         :>json array content: directory entries as returned by
             :http:get:`/api/1/directory/(sha1_git)/[(path)/]`
         :>json string path: path of directory from the revision root one
         :>json string revision: the unique revision identifier
         :>json string type: the type of the directory
 
         :statuscode 200: no error
         :statuscode 400: an invalid **sha1_git** value has been provided
         :statuscode 404: requested revision can not be found in the archive
 
         **Example:**
 
         .. parsed-literal::
 
             :swh_web_api:`revision/f1b94134a4b879bc55c3dacdb496690c8ebdc03f/directory/`
     """
     return _revision_directory_by(
         {"sha1_git": sha1_git}, dir_path, request.path, with_data=with_data
     )
 
 
 @api_route(
     r"/revision/(?P<sha1_git>[0-9a-f]+)/log/",
     "api-1-revision-log",
     checksum_args=["sha1_git"],
 )
 @api_doc("/revision/log/")
 @format_docstring(return_revision_array=DOC_RETURN_REVISION_ARRAY)
 def api_revision_log(request, sha1_git):
     """
     .. http:get:: /api/1/revision/(sha1_git)/log/
 
         Get a list of all revisions heading to a given one, in other words show
         the commit log.
 
         The revisions are returned in the breadth-first search order while
         visiting the revision graph. The number of revisions to return is also
         bounded by the **limit** query parameter.
 
         .. warning::
             To get the full BFS traversal of the revision graph when the
             total number of revisions is greater than 1000, it is up to
             the client to keep track of the multiple branches of history
             when there's merge revisions in the returned objects.
             In other words, identify all the continuation points that need
             to be followed to get the full history through recursion.
 
         :param string sha1_git: hexadecimal representation of the revision
             **sha1_git** identifier
         :query int limit: maximum number of revisions to return when performing
             BFS traversal on the revision graph (default to 10, can not exceed 1000)
 
         {common_headers}
 
         {return_revision_array}
 
         :statuscode 200: no error
         :statuscode 400: an invalid **sha1_git** value has been provided
         :statuscode 404: head revision can not be found in the archive
 
         **Example:**
 
         .. parsed-literal::
 
             :swh_web_api:`revision/e1a315fa3fa734e2a6154ed7b5b9ae0eb8987aad/log/`
     """
     limit = int(request.query_params.get("limit", "10"))
     limit = min(limit, 1000)
 
     error_msg = "Revision with sha1_git %s not found." % sha1_git
     revisions = api_lookup(
         archive.lookup_revision_log,
         sha1_git,
         limit,
         notfound_msg=error_msg,
         enrich_fn=utils.enrich_revision,
         request=request,
     )
 
     return {"results": revisions}
diff --git a/swh/web/tests/api/test_utils.py b/swh/web/tests/api/test_utils.py
index 530d19a2..47b21600 100644
--- a/swh/web/tests/api/test_utils.py
+++ b/swh/web/tests/api/test_utils.py
@@ -1,600 +1,600 @@
 # 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 random
 
 from hypothesis import given
 
 from swh.model.hashutil import DEFAULT_ALGORITHMS
 from swh.web.api import utils
 from swh.web.common.origin_visits import get_origin_visits
 from swh.web.common.utils import resolve_branch_alias, reverse
 from swh.web.tests.strategies import (
     content,
     directory,
     origin,
     release,
     revision,
     snapshot,
 )
 
 url_map = [
     {
         "rule": "/other/<slug>",
         "methods": set(["GET", "POST", "HEAD"]),
         "endpoint": "foo",
     },
     {
         "rule": "/some/old/url/<slug>",
         "methods": set(["GET", "POST"]),
         "endpoint": "blablafn",
     },
     {
         "rule": "/other/old/url/<int:id>",
         "methods": set(["GET", "HEAD"]),
         "endpoint": "bar",
     },
     {"rule": "/other", "methods": set([]), "endpoint": None},
     {"rule": "/other2", "methods": set([]), "endpoint": None},
 ]
 
 
 def test_filter_field_keys_dict_unknown_keys():
     actual_res = utils.filter_field_keys(
         {"directory": 1, "file": 2, "link": 3}, {"directory1", "file2"}
     )
 
     assert actual_res == {}
 
 
 def test_filter_field_keys_dict():
     actual_res = utils.filter_field_keys(
         {"directory": 1, "file": 2, "link": 3}, {"directory", "link"}
     )
 
     assert actual_res == {"directory": 1, "link": 3}
 
 
 def test_filter_field_keys_list_unknown_keys():
     actual_res = utils.filter_field_keys(
         [{"directory": 1, "file": 2, "link": 3}, {"1": 1, "2": 2, "link": 3}], {"d"}
     )
 
     assert actual_res == [{}, {}]
 
 
 def test_filter_field_keys_map():
     actual_res = utils.filter_field_keys(
         map(
             lambda x: {"i": x["i"] + 1, "j": x["j"]},
             [{"i": 1, "j": None}, {"i": 2, "j": None}, {"i": 3, "j": None}],
         ),
         {"i"},
     )
 
     assert list(actual_res) == [{"i": 2}, {"i": 3}, {"i": 4}]
 
 
 def test_filter_field_keys_list():
     actual_res = utils.filter_field_keys(
         [{"directory": 1, "file": 2, "link": 3}, {"dir": 1, "fil": 2, "lin": 3}],
         {"directory", "dir"},
     )
 
     assert actual_res == [{"directory": 1}, {"dir": 1}]
 
 
 def test_filter_field_keys_other():
     input_set = {1, 2}
 
     actual_res = utils.filter_field_keys(input_set, {"a", "1"})
 
     assert actual_res == input_set
 
 
 def test_person_to_string():
     assert (
         utils.person_to_string({"name": "raboof", "email": "foo@bar"})
         == "raboof <foo@bar>"
     )
 
 
 def test_enrich_release_empty():
     actual_release = utils.enrich_release({})
 
     assert actual_release == {}
 
 
 @given(release())
 def test_enrich_release_content_target(api_request_factory, archive_data, release):
 
     release_data = archive_data.release_get(release)
     release_data["target_type"] = "content"
 
     url = reverse("api-1-release", url_args={"sha1_git": release})
     request = api_request_factory.get(url)
 
     actual_release = utils.enrich_release(release_data, request)
 
     release_data["target_url"] = reverse(
         "api-1-content",
         url_args={"q": f'sha1_git:{release_data["target"]}'},
         request=request,
     )
 
     assert actual_release == release_data
 
 
 @given(release())
 def test_enrich_release_directory_target(api_request_factory, archive_data, release):
 
     release_data = archive_data.release_get(release)
     release_data["target_type"] = "directory"
 
     url = reverse("api-1-release", url_args={"sha1_git": release})
     request = api_request_factory.get(url)
 
     actual_release = utils.enrich_release(release_data, request)
 
     release_data["target_url"] = reverse(
         "api-1-directory",
         url_args={"sha1_git": release_data["target"]},
         request=request,
     )
 
     assert actual_release == release_data
 
 
 @given(release())
 def test_enrich_release_revision_target(api_request_factory, archive_data, release):
 
     release_data = archive_data.release_get(release)
     release_data["target_type"] = "revision"
 
     url = reverse("api-1-release", url_args={"sha1_git": release})
     request = api_request_factory.get(url)
 
     actual_release = utils.enrich_release(release_data, request)
 
     release_data["target_url"] = reverse(
         "api-1-revision", url_args={"sha1_git": release_data["target"]}, request=request
     )
 
     assert actual_release == release_data
 
 
 @given(release())
 def test_enrich_release_release_target(api_request_factory, archive_data, release):
 
     release_data = archive_data.release_get(release)
     release_data["target_type"] = "release"
 
     url = reverse("api-1-release", url_args={"sha1_git": release})
     request = api_request_factory.get(url)
 
     actual_release = utils.enrich_release(release_data, request)
 
     release_data["target_url"] = reverse(
         "api-1-release", url_args={"sha1_git": release_data["target"]}, request=request
     )
 
     assert actual_release == release_data
 
 
-def test_enrich_directory_no_type():
-    assert utils.enrich_directory({"id": "dir-id"}) == {"id": "dir-id"}
+def test_enrich_directory_entry_no_type():
+    assert utils.enrich_directory_entry({"id": "dir-id"}) == {"id": "dir-id"}
 
 
 @given(directory())
-def test_enrich_directory_with_type(api_request_factory, archive_data, directory):
+def test_enrich_directory_entry_with_type(api_request_factory, archive_data, directory):
 
     dir_content = archive_data.directory_ls(directory)
 
     dir_entry = random.choice(dir_content)
 
     url = reverse("api-1-directory", url_args={"sha1_git": directory})
     request = api_request_factory.get(url)
 
-    actual_directory = utils.enrich_directory(dir_entry, request)
+    actual_directory = utils.enrich_directory_entry(dir_entry, request)
 
     if dir_entry["type"] == "file":
         dir_entry["target_url"] = reverse(
             "api-1-content",
             url_args={"q": f'sha1_git:{dir_entry["target"]}'},
             request=request,
         )
 
     elif dir_entry["type"] == "dir":
         dir_entry["target_url"] = reverse(
             "api-1-directory",
             url_args={"sha1_git": dir_entry["target"]},
             request=request,
         )
 
     elif dir_entry["type"] == "rev":
         dir_entry["target_url"] = reverse(
             "api-1-revision",
             url_args={"sha1_git": dir_entry["target"]},
             request=request,
         )
 
     assert actual_directory == dir_entry
 
 
 def test_enrich_content_without_hashes():
     assert utils.enrich_content({"id": "123"}) == {"id": "123"}
 
 
 @given(content())
 def test_enrich_content_with_hashes(api_request_factory, content):
 
     for algo in DEFAULT_ALGORITHMS:
 
         content_data = dict(content)
 
         query_string = "%s:%s" % (algo, content_data[algo])
 
         url = reverse("api-1-content", url_args={"q": query_string})
         request = api_request_factory.get(url)
 
         enriched_content = utils.enrich_content(
             content_data, query_string=query_string, request=request
         )
 
         content_data["data_url"] = reverse(
             "api-1-content-raw", url_args={"q": query_string}, request=request
         )
 
         content_data["filetype_url"] = reverse(
             "api-1-content-filetype", url_args={"q": query_string}, request=request
         )
 
         content_data["language_url"] = reverse(
             "api-1-content-language", url_args={"q": query_string}, request=request
         )
 
         content_data["license_url"] = reverse(
             "api-1-content-license", url_args={"q": query_string}, request=request
         )
 
         assert enriched_content == content_data
 
 
 @given(content())
 def test_enrich_content_with_hashes_and_top_level_url(api_request_factory, content):
 
     for algo in DEFAULT_ALGORITHMS:
 
         content_data = dict(content)
 
         query_string = "%s:%s" % (algo, content_data[algo])
 
         url = reverse("api-1-content", url_args={"q": query_string})
         request = api_request_factory.get(url)
 
         enriched_content = utils.enrich_content(
             content_data, query_string=query_string, top_url=True, request=request
         )
 
         content_data["content_url"] = reverse(
             "api-1-content", url_args={"q": query_string}, request=request
         )
 
         content_data["data_url"] = reverse(
             "api-1-content-raw", url_args={"q": query_string}, request=request
         )
 
         content_data["filetype_url"] = reverse(
             "api-1-content-filetype", url_args={"q": query_string}, request=request
         )
 
         content_data["language_url"] = reverse(
             "api-1-content-language", url_args={"q": query_string}, request=request
         )
 
         content_data["license_url"] = reverse(
             "api-1-content-license", url_args={"q": query_string}, request=request
         )
 
         assert enriched_content == content_data
 
 
 @given(revision())
 def test_enrich_revision_without_children_or_parent(
     api_request_factory, archive_data, revision
 ):
 
     revision_data = archive_data.revision_get(revision)
     del revision_data["parents"]
 
     url = reverse("api-1-revision", url_args={"sha1_git": revision})
     request = api_request_factory.get(url)
 
     actual_revision = utils.enrich_revision(revision_data, request)
 
     revision_data["url"] = reverse(
         "api-1-revision", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["history_url"] = reverse(
         "api-1-revision-log", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["directory_url"] = reverse(
         "api-1-directory",
         url_args={"sha1_git": revision_data["directory"]},
         request=request,
     )
 
     assert actual_revision == revision_data
 
 
 @given(revision(), revision(), revision())
 def test_enrich_revision_with_children_and_parent_no_dir(
     api_request_factory, archive_data, revision, parent_revision, child_revision
 ):
 
     revision_data = archive_data.revision_get(revision)
     del revision_data["directory"]
     revision_data["parents"] = revision_data["parents"] + (parent_revision,)
     revision_data["children"] = child_revision
 
     url = reverse("api-1-revision", url_args={"sha1_git": revision})
     request = api_request_factory.get(url)
 
     actual_revision = utils.enrich_revision(revision_data, request)
 
     revision_data["url"] = reverse(
         "api-1-revision", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["history_url"] = reverse(
         "api-1-revision-log", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["parents"] = tuple(
         {
             "id": p["id"],
             "url": reverse(
                 "api-1-revision", url_args={"sha1_git": p["id"]}, request=request
             ),
         }
         for p in revision_data["parents"]
     )
 
     revision_data["children_urls"] = [
         reverse(
             "api-1-revision", url_args={"sha1_git": child_revision}, request=request
         )
     ]
 
     assert actual_revision == revision_data
 
 
 @given(revision(), revision(), revision())
 def test_enrich_revision_no_context(
     api_request_factory, revision, parent_revision, child_revision
 ):
 
     revision_data = {
         "id": revision,
         "parents": [parent_revision],
         "children": [child_revision],
     }
 
     url = reverse("api-1-revision", url_args={"sha1_git": revision})
     request = api_request_factory.get(url)
 
     actual_revision = utils.enrich_revision(revision_data, request)
 
     revision_data["url"] = reverse(
         "api-1-revision", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["history_url"] = reverse(
         "api-1-revision-log", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["parents"] = tuple(
         {
             "id": parent_revision,
             "url": reverse(
                 "api-1-revision",
                 url_args={"sha1_git": parent_revision},
                 request=request,
             ),
         }
     )
 
     revision_data["children_urls"] = [
         reverse(
             "api-1-revision", url_args={"sha1_git": child_revision}, request=request
         )
     ]
 
     assert actual_revision == revision_data
 
 
 @given(revision(), revision(), revision())
 def test_enrich_revision_with_no_message(
     api_request_factory, archive_data, revision, parent_revision, child_revision
 ):
 
     revision_data = archive_data.revision_get(revision)
     revision_data["message"] = None
     revision_data["parents"] = revision_data["parents"] + (parent_revision,)
     revision_data["children"] = child_revision
 
     url = reverse("api-1-revision", url_args={"sha1_git": revision})
     request = api_request_factory.get(url)
 
     actual_revision = utils.enrich_revision(revision_data, request)
 
     revision_data["url"] = reverse(
         "api-1-revision", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["directory_url"] = reverse(
         "api-1-directory",
         url_args={"sha1_git": revision_data["directory"]},
         request=request,
     )
 
     revision_data["history_url"] = reverse(
         "api-1-revision-log", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["parents"] = tuple(
         {
             "id": p["id"],
             "url": reverse(
                 "api-1-revision", url_args={"sha1_git": p["id"]}, request=request
             ),
         }
         for p in revision_data["parents"]
     )
 
     revision_data["children_urls"] = [
         reverse(
             "api-1-revision", url_args={"sha1_git": child_revision}, request=request
         )
     ]
 
     assert actual_revision == revision_data
 
 
 @given(revision(), revision(), revision())
 def test_enrich_revision_with_invalid_message(
     api_request_factory, archive_data, revision, parent_revision, child_revision
 ):
 
     revision_data = archive_data.revision_get(revision)
     revision_data["decoding_failures"] = ["message"]
     revision_data["parents"] = revision_data["parents"] + (parent_revision,)
     revision_data["children"] = child_revision
 
     url = reverse("api-1-revision", url_args={"sha1_git": revision})
     request = api_request_factory.get(url)
 
     actual_revision = utils.enrich_revision(revision_data, request)
 
     revision_data["url"] = reverse(
         "api-1-revision", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["message_url"] = reverse(
         "api-1-revision-raw-message", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["directory_url"] = reverse(
         "api-1-directory",
         url_args={"sha1_git": revision_data["directory"]},
         request=request,
     )
 
     revision_data["history_url"] = reverse(
         "api-1-revision-log", url_args={"sha1_git": revision}, request=request
     )
 
     revision_data["parents"] = tuple(
         {
             "id": p["id"],
             "url": reverse(
                 "api-1-revision", url_args={"sha1_git": p["id"]}, request=request
             ),
         }
         for p in revision_data["parents"]
     )
 
     revision_data["children_urls"] = [
         reverse(
             "api-1-revision", url_args={"sha1_git": child_revision}, request=request
         )
     ]
 
     assert actual_revision == revision_data
 
 
 @given(snapshot())
 def test_enrich_snapshot(api_request_factory, archive_data, snapshot):
     snapshot_data = archive_data.snapshot_get(snapshot)
 
     url = reverse("api-1-snapshot", url_args={"snapshot_id": snapshot})
     request = api_request_factory.get(url)
 
     actual_snapshot = utils.enrich_snapshot(snapshot_data, request)
 
     for _, b in snapshot_data["branches"].items():
         if b["target_type"] in ("directory", "revision", "release"):
             b["target_url"] = reverse(
                 f'api-1-{b["target_type"]}',
                 url_args={"sha1_git": b["target"]},
                 request=request,
             )
         elif b["target_type"] == "content":
             b["target_url"] = reverse(
                 "api-1-content",
                 url_args={"q": f'sha1_git:{b["target"]}'},
                 request=request,
             )
 
     for _, b in snapshot_data["branches"].items():
         if b["target_type"] == "alias":
             target = resolve_branch_alias(snapshot_data, b)
             b["target_url"] = target["target_url"]
 
     assert actual_snapshot == snapshot_data
 
 
 @given(origin())
 def test_enrich_origin(api_request_factory, archive_data, origin):
     url = reverse("api-1-origin", url_args={"origin_url": origin["url"]})
     request = api_request_factory.get(url)
 
     origin_data = {"url": origin["url"]}
     actual_origin = utils.enrich_origin(origin_data, request)
 
     origin_data["origin_visits_url"] = reverse(
         "api-1-origin-visits", url_args={"origin_url": origin["url"]}, request=request
     )
 
     assert actual_origin == origin_data
 
 
 @given(origin())
 def test_enrich_origin_visit(api_request_factory, archive_data, origin):
 
     origin_visit = random.choice(get_origin_visits(origin))
 
     url = reverse(
         "api-1-origin-visit",
         url_args={"origin_url": origin["url"], "visit_id": origin_visit["visit"]},
     )
     request = api_request_factory.get(url)
 
     actual_origin_visit = utils.enrich_origin_visit(
         origin_visit,
         with_origin_link=True,
         with_origin_visit_link=True,
         request=request,
     )
 
     origin_visit["origin_url"] = reverse(
         "api-1-origin", url_args={"origin_url": origin["url"]}, request=request
     )
 
     origin_visit["origin_visit_url"] = reverse(
         "api-1-origin-visit",
         url_args={"origin_url": origin["url"], "visit_id": origin_visit["visit"]},
         request=request,
     )
 
     origin_visit["snapshot_url"] = reverse(
         "api-1-snapshot",
         url_args={"snapshot_id": origin_visit["snapshot"]},
         request=request,
     )
 
     assert actual_origin_visit == origin_visit
diff --git a/swh/web/tests/api/views/test_directory.py b/swh/web/tests/api/views/test_directory.py
index 4540052d..fa53b92b 100644
--- a/swh/web/tests/api/views/test_directory.py
+++ b/swh/web/tests/api/views/test_directory.py
@@ -1,79 +1,79 @@
 # 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 random
 
 from hypothesis import given
 
-from swh.web.api.utils import enrich_directory
+from swh.web.api.utils import enrich_directory_entry
 from swh.web.common.utils import reverse
 from swh.web.tests.data import random_sha1
 from swh.web.tests.strategies import directory
 from swh.web.tests.utils import check_api_get_responses, check_http_get_response
 
 
 @given(directory())
 def test_api_directory(api_client, archive_data, directory):
 
     url = reverse("api-1-directory", url_args={"sha1_git": directory})
     rv = check_api_get_responses(api_client, url, status_code=200)
 
     dir_content = list(archive_data.directory_ls(directory))
     expected_data = list(
-        map(enrich_directory, dir_content, [rv.wsgi_request] * len(dir_content))
+        map(enrich_directory_entry, dir_content, [rv.wsgi_request] * len(dir_content))
     )
 
     assert rv.data == expected_data
 
 
 def test_api_directory_not_found(api_client):
     unknown_directory_ = random_sha1()
 
     url = reverse("api-1-directory", url_args={"sha1_git": unknown_directory_})
     rv = check_api_get_responses(api_client, url, status_code=404)
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "Directory with sha1_git %s not found" % unknown_directory_,
     }
 
 
 @given(directory())
 def test_api_directory_with_path_found(api_client, archive_data, directory):
 
     directory_content = archive_data.directory_ls(directory)
-    path = random.choice(directory_content)
+    dir_entry = random.choice(directory_content)
 
     url = reverse(
-        "api-1-directory", url_args={"sha1_git": directory, "path": path["name"]}
+        "api-1-directory", url_args={"sha1_git": directory, "path": dir_entry["name"]}
     )
     rv = check_api_get_responses(api_client, url, status_code=200)
-    assert rv.data == enrich_directory(path, rv.wsgi_request)
+    assert rv.data == enrich_directory_entry(dir_entry, rv.wsgi_request)
 
 
 @given(directory())
 def test_api_directory_with_path_not_found(api_client, directory):
 
     path = "some/path/to/nonexistent/dir/"
     url = reverse("api-1-directory", url_args={"sha1_git": directory, "path": path})
     rv = check_api_get_responses(api_client, url, status_code=404)
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": (
             "Directory entry with path %s from %s not found" % (path, directory)
         ),
     }
 
 
 @given(directory())
 def test_api_directory_uppercase(api_client, directory):
     url = reverse(
         "api-1-directory-uppercase-checksum", url_args={"sha1_git": directory.upper()}
     )
 
     resp = check_http_get_response(api_client, url, status_code=302)
 
     redirect_url = reverse("api-1-directory", url_args={"sha1_git": directory})
 
     assert resp["location"] == redirect_url