diff --git a/requirements-swh.txt b/requirements-swh.txt
index ee56e6b8..848726b1 100644
--- a/requirements-swh.txt
+++ b/requirements-swh.txt
@@ -1,7 +1,7 @@
 swh.core >= 0.0.95
 swh.indexer >= 0.0.171
 swh.model >= 0.3.0
 swh.scheduler >= 0.1.1
 swh.search >= 0.0.4
-swh.storage >= 0.1.1
-swh.vault >= 0.0.33
\ No newline at end of file
+swh.storage >= 0.2.0
+swh.vault >= 0.0.33
diff --git a/swh/web/tests/api/views/test_origin.py b/swh/web/tests/api/views/test_origin.py
index f484d096..6d0b5f28 100644
--- a/swh/web/tests/api/views/test_origin.py
+++ b/swh/web/tests/api/views/test_origin.py
@@ -1,709 +1,731 @@
-# Copyright (C) 2015-2019  The Software Heritage developers
+# Copyright (C) 2015-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from hypothesis import given
 import pytest
 from requests.utils import parse_header_links
 
-from swh.model.model import Origin
+from swh.model.model import Origin, OriginVisitStatus
 
 from swh.storage.exc import StorageDBError, StorageAPIError
+from swh.storage.utils import now
 
 from swh.web.api.utils import enrich_origin_visit, enrich_origin
 from swh.web.common.exc import BadInputExc
 from swh.web.common.utils import reverse
 from swh.web.common.origin_visits import get_origin_visits
 from swh.web.tests.strategies import origin, new_origin, visit_dates, new_snapshots
 
 
 def _scroll_results(api_client, url):
     """Iterates through pages of results, and returns them all."""
     results = []
 
     while True:
         rv = api_client.get(url)
         assert rv.status_code == 200, rv.data
         assert rv["Content-Type"] == "application/json"
 
         results.extend(rv.data)
 
         if "Link" in rv:
             for link in parse_header_links(rv["Link"]):
                 if link["rel"] == "next":
                     # Found link to next page of results
                     url = link["url"]
                     break
             else:
                 # No link with 'rel=next'
                 break
         else:
             # No Link header
             break
 
     return results
 
 
 def test_api_lookup_origin_visits_raise_error(api_client, mocker):
     mock_get_origin_visits = mocker.patch("swh.web.api.views.origin.get_origin_visits")
     err_msg = "voluntary error to check the bad request middleware."
 
     mock_get_origin_visits.side_effect = BadInputExc(err_msg)
 
     url = reverse("api-1-origin-visits", url_args={"origin_url": "http://foo"})
     rv = api_client.get(url)
 
     assert rv.status_code == 400, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {"exception": "BadInputExc", "reason": err_msg}
 
 
 def test_api_lookup_origin_visits_raise_swh_storage_error_db(api_client, mocker):
     mock_get_origin_visits = mocker.patch("swh.web.api.views.origin.get_origin_visits")
     err_msg = "Storage exploded! Will be back online shortly!"
 
     mock_get_origin_visits.side_effect = StorageDBError(err_msg)
 
     url = reverse("api-1-origin-visits", url_args={"origin_url": "http://foo"})
     rv = api_client.get(url)
 
     assert rv.status_code == 503, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "exception": "StorageDBError",
         "reason": "An unexpected error occurred in the backend: %s" % err_msg,
     }
 
 
 def test_api_lookup_origin_visits_raise_swh_storage_error_api(api_client, mocker):
     mock_get_origin_visits = mocker.patch("swh.web.api.views.origin.get_origin_visits")
     err_msg = "Storage API dropped dead! Will resurrect asap!"
 
     mock_get_origin_visits.side_effect = StorageAPIError(err_msg)
 
     url = reverse("api-1-origin-visits", url_args={"origin_url": "http://foo"})
     rv = api_client.get(url)
 
     assert rv.status_code == 503, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "exception": "StorageAPIError",
         "reason": "An unexpected error occurred in the api backend: %s" % err_msg,
     }
 
 
 @given(new_origin(), visit_dates(3), new_snapshots(3))
 def test_api_lookup_origin_visits(
     api_client, archive_data, new_origin, visit_dates, new_snapshots
 ):
 
     archive_data.origin_add_one(new_origin)
     for i, visit_date in enumerate(visit_dates):
         origin_visit = archive_data.origin_visit_add(
             new_origin.url, visit_date, type="git"
         )
         archive_data.snapshot_add([new_snapshots[i]])
-        archive_data.origin_visit_update(
-            new_origin.url,
-            origin_visit.visit,
+        visit_status = OriginVisitStatus(
+            origin=new_origin.url,
+            visit=origin_visit.visit,
+            date=now(),
             status="full",
             snapshot=new_snapshots[i].id,
         )
+        archive_data.origin_visit_status_add([visit_status])
 
     all_visits = list(reversed(get_origin_visits(new_origin.to_dict())))
 
     for last_visit, expected_visits in (
         (None, all_visits[:2]),
         (all_visits[1]["visit"], all_visits[2:]),
     ):
 
         url = reverse(
             "api-1-origin-visits",
             url_args={"origin_url": new_origin.url},
             query_params={"per_page": 2, "last_visit": last_visit},
         )
 
         rv = api_client.get(url)
 
         assert rv.status_code == 200, rv.data
         assert rv["Content-Type"] == "application/json"
 
         for i in range(len(expected_visits)):
             expected_visits[i] = enrich_origin_visit(
                 expected_visits[i],
                 with_origin_link=False,
                 with_origin_visit_link=True,
                 request=rv.wsgi_request,
             )
 
         assert rv.data == expected_visits
 
 
 @given(new_origin(), visit_dates(3), new_snapshots(3))
 def test_api_lookup_origin_visits_by_id(
     api_client, archive_data, new_origin, visit_dates, new_snapshots
 ):
     archive_data.origin_add_one(new_origin)
     for i, visit_date in enumerate(visit_dates):
         origin_visit = archive_data.origin_visit_add(
             new_origin.url, visit_date, type="git"
         )
         archive_data.snapshot_add([new_snapshots[i]])
-        archive_data.origin_visit_update(
-            new_origin.url,
-            origin_visit.visit,
+        visit_status = OriginVisitStatus(
+            origin=new_origin.url,
+            visit=origin_visit.visit,
+            date=now(),
             status="full",
             snapshot=new_snapshots[i].id,
         )
+        archive_data.origin_visit_status_add([visit_status])
 
     all_visits = list(reversed(get_origin_visits(new_origin.to_dict())))
 
     for last_visit, expected_visits in (
         (None, all_visits[:2]),
         (all_visits[1]["visit"], all_visits[2:4]),
     ):
 
         url = reverse(
             "api-1-origin-visits",
             url_args={"origin_url": new_origin.url},
             query_params={"per_page": 2, "last_visit": last_visit},
         )
 
         rv = api_client.get(url)
 
         assert rv.status_code == 200, rv.data
         assert rv["Content-Type"] == "application/json"
 
         for i in range(len(expected_visits)):
             expected_visits[i] = enrich_origin_visit(
                 expected_visits[i],
                 with_origin_link=False,
                 with_origin_visit_link=True,
                 request=rv.wsgi_request,
             )
 
         assert rv.data == expected_visits
 
 
 @given(new_origin(), visit_dates(3), new_snapshots(3))
 def test_api_lookup_origin_visit(
     api_client, archive_data, new_origin, visit_dates, new_snapshots
 ):
     archive_data.origin_add_one(new_origin)
     for i, visit_date in enumerate(visit_dates):
         origin_visit = archive_data.origin_visit_add(
             new_origin.url, visit_date, type="git"
         )
         visit_id = origin_visit.visit
         archive_data.snapshot_add([new_snapshots[i]])
-        archive_data.origin_visit_update(
-            new_origin.url, visit_id, status="full", snapshot=new_snapshots[i].id
+        visit_status = OriginVisitStatus(
+            origin=new_origin.url,
+            visit=origin_visit.visit,
+            date=now(),
+            status="full",
+            snapshot=new_snapshots[i].id,
         )
+        archive_data.origin_visit_status_add([visit_status])
         url = reverse(
             "api-1-origin-visit",
             url_args={"origin_url": new_origin.url, "visit_id": visit_id},
         )
 
         rv = api_client.get(url)
         assert rv.status_code == 200, rv.data
         assert rv["Content-Type"] == "application/json"
 
         expected_visit = archive_data.origin_visit_get_by(new_origin.url, visit_id)
 
         expected_visit = enrich_origin_visit(
             expected_visit,
             with_origin_link=True,
             with_origin_visit_link=False,
             request=rv.wsgi_request,
         )
 
         assert rv.data == expected_visit
 
 
 @given(new_origin())
 def test_api_lookup_origin_visit_latest_no_visit(api_client, archive_data, new_origin):
     archive_data.origin_add_one(new_origin)
 
     url = reverse("api-1-origin-visit-latest", url_args={"origin_url": new_origin.url})
 
     rv = api_client.get(url)
     assert rv.status_code == 404, rv.data
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "No visit for origin %s found" % new_origin.url,
     }
 
 
 @given(new_origin(), visit_dates(2), new_snapshots(1))
 def test_api_lookup_origin_visit_latest(
     api_client, archive_data, new_origin, visit_dates, new_snapshots
 ):
     archive_data.origin_add_one(new_origin)
     visit_dates.sort()
     visit_ids = []
     for i, visit_date in enumerate(visit_dates):
         origin_visit = archive_data.origin_visit_add(
             new_origin.url, visit_date, type="git"
         )
         visit_ids.append(origin_visit.visit)
 
     archive_data.snapshot_add([new_snapshots[0]])
-    archive_data.origin_visit_update(
-        new_origin.url, visit_ids[0], status="full", snapshot=new_snapshots[0].id
+
+    visit_status = OriginVisitStatus(
+        origin=new_origin.url,
+        visit=visit_ids[0],
+        date=now(),
+        status="full",
+        snapshot=new_snapshots[0].id,
     )
+    archive_data.origin_visit_status_add([visit_status])
 
     url = reverse("api-1-origin-visit-latest", url_args={"origin_url": new_origin.url})
 
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
 
     expected_visit = archive_data.origin_visit_get_by(new_origin.url, visit_ids[1])
 
     expected_visit = enrich_origin_visit(
         expected_visit,
         with_origin_link=True,
         with_origin_visit_link=False,
         request=rv.wsgi_request,
     )
 
     assert rv.data == expected_visit
 
 
 @given(new_origin(), visit_dates(2), new_snapshots(1))
 def test_api_lookup_origin_visit_latest_with_snapshot(
     api_client, archive_data, new_origin, visit_dates, new_snapshots
 ):
     archive_data.origin_add_one(new_origin)
     visit_dates.sort()
     visit_ids = []
     for i, visit_date in enumerate(visit_dates):
         origin_visit = archive_data.origin_visit_add(
             new_origin.url, visit_date, type="git"
         )
         visit_ids.append(origin_visit.visit)
 
     archive_data.snapshot_add([new_snapshots[0]])
-    archive_data.origin_visit_update(
-        new_origin.url, visit_ids[0], status="full", snapshot=new_snapshots[0].id
+
+    visit_status = OriginVisitStatus(
+        origin=new_origin.url,
+        visit=visit_ids[0],
+        date=now(),
+        status="full",
+        snapshot=new_snapshots[0].id,
     )
+    archive_data.origin_visit_status_add([visit_status])
 
     url = reverse(
         "api-1-origin-visit-latest",
         url_args={"origin_url": new_origin.url},
         query_params={"require_snapshot": True},
     )
 
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
 
     expected_visit = archive_data.origin_visit_get_by(new_origin.url, visit_ids[0])
 
     expected_visit = enrich_origin_visit(
         expected_visit,
         with_origin_link=True,
         with_origin_visit_link=False,
         request=rv.wsgi_request,
     )
 
     assert rv.data == expected_visit
 
 
 @given(origin())
 def test_api_lookup_origin_visit_not_found(api_client, origin):
 
     all_visits = list(reversed(get_origin_visits(origin)))
 
     max_visit_id = max([v["visit"] for v in all_visits])
 
     url = reverse(
         "api-1-origin-visit",
         url_args={"origin_url": origin["url"], "visit_id": max_visit_id + 1},
     )
 
     rv = api_client.get(url)
 
     assert rv.status_code == 404, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "Origin %s or its visit with id %s not found!"
         % (origin["url"], max_visit_id + 1),
     }
 
 
 def test_api_origins(api_client, archive_data):
     origins = list(archive_data.origin_get_range(0, 10000))
     origin_urls = {origin["url"] for origin in origins}
 
     # Get only one
     url = reverse("api-1-origins", query_params={"origin_count": 1})
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert len(rv.data) == 1
     assert {origin["url"] for origin in rv.data} <= origin_urls
 
     # Get all
     url = reverse("api-1-origins", query_params={"origin_count": len(origins)})
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert len(rv.data) == len(origins)
     assert {origin["url"] for origin in rv.data} == origin_urls
 
     # Get "all + 10"
     url = reverse("api-1-origins", query_params={"origin_count": len(origins) + 10})
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert len(rv.data) == len(origins)
     assert {origin["url"] for origin in rv.data} == origin_urls
 
 
 @pytest.mark.parametrize("origin_count", [1, 2, 10, 100])
 def test_api_origins_scroll(api_client, archive_data, origin_count):
     origins = list(archive_data.origin_get_range(0, 10000))
     origin_urls = {origin["url"] for origin in origins}
 
     url = reverse("api-1-origins", query_params={"origin_count": origin_count})
 
     results = _scroll_results(api_client, url)
 
     assert len(results) == len(origins)
     assert {origin["url"] for origin in results} == origin_urls
 
 
 @given(origin())
 def test_api_origin_by_url(api_client, archive_data, origin):
     url = reverse("api-1-origin", url_args={"origin_url": origin["url"]})
     rv = api_client.get(url)
 
     expected_origin = archive_data.origin_get(origin)
 
     expected_origin = enrich_origin(expected_origin, rv.wsgi_request)
 
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == expected_origin
 
 
 @given(new_origin())
 def test_api_origin_not_found(api_client, new_origin):
 
     url = reverse("api-1-origin", url_args={"origin_url": new_origin.url})
     rv = api_client.get(url)
 
     assert rv.status_code == 404, rv.data
     assert rv["Content-Type"] == "application/json"
     assert rv.data == {
         "exception": "NotFoundExc",
         "reason": "Origin with url %s not found!" % new_origin.url,
     }
 
 
 @pytest.mark.parametrize("backend", ["swh-search", "swh-storage"])
 def test_api_origin_search(api_client, mocker, backend):
     if backend != "swh-search":
         # equivalent to not configuring search in the config
         mocker.patch("swh.web.common.service.search", None)
 
     expected_origins = {
         "https://github.com/wcoder/highlightjs-line-numbers.js",
         "https://github.com/memononen/libtess2",
     }
 
     # Search for 'github.com', get only one
     url = reverse(
         "api-1-origin-search",
         url_args={"url_pattern": "github.com"},
         query_params={"limit": 1},
     )
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert len(rv.data) == 1
     assert {origin["url"] for origin in rv.data} <= expected_origins
 
     # Search for 'github.com', get all
     url = reverse(
         "api-1-origin-search",
         url_args={"url_pattern": "github.com"},
         query_params={"limit": 2},
     )
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert {origin["url"] for origin in rv.data} == expected_origins
 
     # Search for 'github.com', get more than available
     url = reverse(
         "api-1-origin-search",
         url_args={"url_pattern": "github.com"},
         query_params={"limit": 10},
     )
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert {origin["url"] for origin in rv.data} == expected_origins
 
 
 @pytest.mark.parametrize("backend", ["swh-search", "swh-storage"])
 def test_api_origin_search_words(api_client, mocker, backend):
     if backend != "swh-search":
         # equivalent to not configuring search in the config
         mocker.patch("swh.web.common.service.search", None)
 
     expected_origins = {
         "https://github.com/wcoder/highlightjs-line-numbers.js",
         "https://github.com/memononen/libtess2",
     }
 
     url = reverse(
         "api-1-origin-search",
         url_args={"url_pattern": "github com"},
         query_params={"limit": 2},
     )
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert {origin["url"] for origin in rv.data} == expected_origins
 
     url = reverse(
         "api-1-origin-search",
         url_args={"url_pattern": "com github"},
         query_params={"limit": 2},
     )
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert {origin["url"] for origin in rv.data} == expected_origins
 
     url = reverse(
         "api-1-origin-search",
         url_args={"url_pattern": "memononen libtess2"},
         query_params={"limit": 2},
     )
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert len(rv.data) == 1
     assert {origin["url"] for origin in rv.data} == {
         "https://github.com/memononen/libtess2"
     }
 
     url = reverse(
         "api-1-origin-search",
         url_args={"url_pattern": "libtess2 memononen"},
         query_params={"limit": 2},
     )
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert len(rv.data) == 1
     assert {origin["url"] for origin in rv.data} == {
         "https://github.com/memononen/libtess2"
     }
 
 
 @pytest.mark.parametrize("backend", ["swh-search", "swh-storage"])
 @pytest.mark.parametrize("limit", [1, 2, 3, 10])
 def test_api_origin_search_scroll(api_client, archive_data, mocker, limit, backend):
 
     if backend != "swh-search":
         # equivalent to not configuring search in the config
         mocker.patch("swh.web.common.service.search", None)
 
     expected_origins = {
         "https://github.com/wcoder/highlightjs-line-numbers.js",
         "https://github.com/memononen/libtess2",
     }
 
     url = reverse(
         "api-1-origin-search",
         url_args={"url_pattern": "github.com"},
         query_params={"limit": limit},
     )
 
     results = _scroll_results(api_client, url)
 
     assert {origin["url"] for origin in results} == expected_origins
 
 
 @pytest.mark.parametrize("backend", ["swh-search", "swh-storage"])
 def test_api_origin_search_limit(api_client, archive_data, tests_data, mocker, backend):
     if backend == "swh-search":
         tests_data["search"].origin_update(
             [{"url": "http://foobar/{}".format(i)} for i in range(2000)]
         )
     else:
         # equivalent to not configuring search in the config
         mocker.patch("swh.web.common.service.search", None)
 
         archive_data.origin_add(
             [Origin(url="http://foobar/{}".format(i)) for i in range(2000)]
         )
 
     url = reverse(
         "api-1-origin-search",
         url_args={"url_pattern": "foobar"},
         query_params={"limit": 1050},
     )
     rv = api_client.get(url)
     assert rv.status_code == 200, rv.data
     assert rv["Content-Type"] == "application/json"
     assert len(rv.data) == 1000
 
 
 @given(origin())
 def test_api_origin_metadata_search(api_client, mocker, origin):
     mock_idx_storage = mocker.patch("swh.web.common.service.idx_storage")
     oimsft = mock_idx_storage.origin_intrinsic_metadata_search_fulltext
     oimsft.side_effect = lambda conjunction, limit: [
         {
             "from_revision": (
                 b"p&\xb7\xc1\xa2\xafVR\x1e\x95\x1c\x01\xed " b"\xf2U\xfa\x05B8"
             ),
             "metadata": {"author": "Jane Doe"},
             "id": origin["url"],
             "tool": {
                 "configuration": {
                     "context": ["NpmMapping", "CodemetaMapping"],
                     "type": "local",
                 },
                 "id": 3,
                 "name": "swh-metadata-detector",
                 "version": "0.0.1",
             },
         }
     ]
 
     url = reverse("api-1-origin-metadata-search", query_params={"fulltext": "Jane Doe"})
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.content
     assert rv["Content-Type"] == "application/json"
     expected_data = [
         {
             "url": origin["url"],
             "metadata": {
                 "metadata": {"author": "Jane Doe"},
                 "from_revision": ("7026b7c1a2af56521e951c01ed20f255fa054238"),
                 "tool": {
                     "configuration": {
                         "context": ["NpmMapping", "CodemetaMapping"],
                         "type": "local",
                     },
                     "id": 3,
                     "name": "swh-metadata-detector",
                     "version": "0.0.1",
                 },
             },
         }
     ]
 
     assert rv.data == expected_data
     oimsft.assert_called_with(conjunction=["Jane Doe"], limit=70)
 
 
 @given(origin())
 def test_api_origin_metadata_search_limit(api_client, mocker, origin):
     mock_idx_storage = mocker.patch("swh.web.common.service.idx_storage")
     oimsft = mock_idx_storage.origin_intrinsic_metadata_search_fulltext
 
     oimsft.side_effect = lambda conjunction, limit: [
         {
             "from_revision": (
                 b"p&\xb7\xc1\xa2\xafVR\x1e\x95\x1c\x01\xed " b"\xf2U\xfa\x05B8"
             ),
             "metadata": {"author": "Jane Doe"},
             "id": origin["url"],
             "tool": {
                 "configuration": {
                     "context": ["NpmMapping", "CodemetaMapping"],
                     "type": "local",
                 },
                 "id": 3,
                 "name": "swh-metadata-detector",
                 "version": "0.0.1",
             },
         }
     ]
 
     url = reverse("api-1-origin-metadata-search", query_params={"fulltext": "Jane Doe"})
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.content
     assert rv["Content-Type"] == "application/json"
     assert len(rv.data) == 1
     oimsft.assert_called_with(conjunction=["Jane Doe"], limit=70)
 
     url = reverse(
         "api-1-origin-metadata-search",
         query_params={"fulltext": "Jane Doe", "limit": 10},
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.content
     assert rv["Content-Type"] == "application/json"
     assert len(rv.data) == 1
     oimsft.assert_called_with(conjunction=["Jane Doe"], limit=10)
 
     url = reverse(
         "api-1-origin-metadata-search",
         query_params={"fulltext": "Jane Doe", "limit": 987},
     )
     rv = api_client.get(url)
 
     assert rv.status_code == 200, rv.content
     assert rv["Content-Type"] == "application/json"
     assert len(rv.data) == 1
     oimsft.assert_called_with(conjunction=["Jane Doe"], limit=100)
 
 
 @given(origin())
 def test_api_origin_intrinsic_metadata(api_client, mocker, origin):
     mock_idx_storage = mocker.patch("swh.web.common.service.idx_storage")
     oimg = mock_idx_storage.origin_intrinsic_metadata_get
     oimg.side_effect = lambda origin_urls: [
         {
             "from_revision": (
                 b"p&\xb7\xc1\xa2\xafVR\x1e\x95\x1c\x01\xed " b"\xf2U\xfa\x05B8"
             ),
             "metadata": {"author": "Jane Doe"},
             "id": origin["url"],
             "tool": {
                 "configuration": {
                     "context": ["NpmMapping", "CodemetaMapping"],
                     "type": "local",
                 },
                 "id": 3,
                 "name": "swh-metadata-detector",
                 "version": "0.0.1",
             },
         }
     ]
 
     url = reverse(
         "api-origin-intrinsic-metadata", url_args={"origin_url": origin["url"]}
     )
     rv = api_client.get(url)
 
     oimg.assert_called_once_with([origin["url"]])
     assert rv.status_code == 200, rv.content
     assert rv["Content-Type"] == "application/json"
     expected_data = {"author": "Jane Doe"}
     assert rv.data == expected_data
 
 
 def test_api_origin_metadata_search_invalid(api_client, mocker):
     mock_idx_storage = mocker.patch("swh.web.common.service.idx_storage")
     url = reverse("api-1-origin-metadata-search")
     rv = api_client.get(url)
 
     assert rv.status_code == 400, rv.content
     mock_idx_storage.assert_not_called()
diff --git a/swh/web/tests/browse/views/test_origin.py b/swh/web/tests/browse/views/test_origin.py
index f205ae1b..7e5c4ef5 100644
--- a/swh/web/tests/browse/views/test_origin.py
+++ b/swh/web/tests/browse/views/test_origin.py
@@ -1,1290 +1,1305 @@
 # 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
 
-from datetime import datetime, timezone
 import random
 import re
 import string
 import textwrap
 
 from django.utils.html import escape
 
 from hypothesis import given
 
+from swh.storage.utils import now
+
 from swh.model.hashutil import hash_to_bytes
 from swh.model.identifiers import CONTENT, DIRECTORY, RELEASE, REVISION, SNAPSHOT
-from swh.model.model import (
-    Snapshot,
-    SnapshotBranch,
-    TargetType,
-)
+from swh.model.model import Snapshot, SnapshotBranch, TargetType, OriginVisitStatus
 from swh.web.browse.snapshot_context import process_snapshot_branches
 from swh.web.common.exc import NotFoundExc
 from swh.web.common.identifiers import get_swh_persistent_id
 from swh.web.common.utils import (
     reverse,
     gen_path_info,
     format_utc_iso_date,
     parse_timestamp,
 )
 from swh.web.tests.data import get_content, random_sha1
 from swh.web.tests.django_asserts import assert_contains, assert_template_used
 from swh.web.tests.strategies import (
     origin,
     origin_with_multiple_visits,
     new_origin,
     new_snapshot,
     visit_dates,
     revisions,
     origin_with_releases,
     release as existing_release,
     unknown_revision,
 )
 
 
 @given(origin_with_multiple_visits())
 def test_origin_visits_browse(client, archive_data, origin):
     url = reverse("browse-origin-visits", query_params={"origin_url": origin["url"]})
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/origin-visits.html")
 
     url = reverse("browse-origin-visits", query_params={"origin_url": origin["url"]})
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/origin-visits.html")
 
     visits = archive_data.origin_visit_get(origin["url"])
 
     for v in visits:
         vdate = format_utc_iso_date(v["date"], "%Y-%m-%dT%H:%M:%SZ")
         browse_dir_url = reverse(
             "browse-origin-directory",
             query_params={"origin_url": origin["url"], "timestamp": vdate},
         )
         assert_contains(resp, browse_dir_url)
 
     _check_origin_view_title(resp, origin["url"], "visits")
 
 
 @given(origin_with_multiple_visits())
 def test_origin_content_view(client, archive_data, origin):
     origin_visits = archive_data.origin_visit_get(origin["url"])
 
     def _get_archive_data(visit_idx):
         snapshot = archive_data.snapshot_get(origin_visits[visit_idx]["snapshot"])
         head_rev_id = archive_data.snapshot_get_head(snapshot)
         head_rev = archive_data.revision_get(head_rev_id)
         dir_content = archive_data.directory_ls(head_rev["directory"])
         dir_files = [e for e in dir_content if e["type"] == "file"]
         dir_file = random.choice(dir_files)
         branches, releases = process_snapshot_branches(snapshot)
         return {
             "branches": branches,
             "releases": releases,
             "root_dir_sha1": head_rev["directory"],
             "content": get_content(dir_file["checksums"]["sha1"]),
             "visit": origin_visits[visit_idx],
         }
 
     tdata = _get_archive_data(-1)
 
     _origin_content_view_test_helper(
         client,
         archive_data,
         origin,
         origin_visits[-1],
         tdata["branches"],
         tdata["releases"],
         tdata["root_dir_sha1"],
         tdata["content"],
     )
 
     _origin_content_view_test_helper(
         client,
         archive_data,
         origin,
         origin_visits[-1],
         tdata["branches"],
         tdata["releases"],
         tdata["root_dir_sha1"],
         tdata["content"],
         timestamp=tdata["visit"]["date"],
     )
 
     visit_unix_ts = parse_timestamp(tdata["visit"]["date"]).timestamp()
     visit_unix_ts = int(visit_unix_ts)
 
     _origin_content_view_test_helper(
         client,
         archive_data,
         origin,
         origin_visits[-1],
         tdata["branches"],
         tdata["releases"],
         tdata["root_dir_sha1"],
         tdata["content"],
         timestamp=visit_unix_ts,
     )
 
     _origin_content_view_test_helper(
         client,
         archive_data,
         origin,
         origin_visits[-1],
         tdata["branches"],
         tdata["releases"],
         tdata["root_dir_sha1"],
         tdata["content"],
         snapshot_id=tdata["visit"]["snapshot"],
     )
 
     tdata = _get_archive_data(0)
 
     _origin_content_view_test_helper(
         client,
         archive_data,
         origin,
         origin_visits[0],
         tdata["branches"],
         tdata["releases"],
         tdata["root_dir_sha1"],
         tdata["content"],
         visit_id=tdata["visit"]["visit"],
     )
 
     _origin_content_view_test_helper(
         client,
         archive_data,
         origin,
         origin_visits[0],
         tdata["branches"],
         tdata["releases"],
         tdata["root_dir_sha1"],
         tdata["content"],
         snapshot_id=tdata["visit"]["snapshot"],
     )
 
 
 @given(origin())
 def test_origin_root_directory_view(client, archive_data, origin):
     origin_visits = archive_data.origin_visit_get(origin["url"])
 
     visit = origin_visits[-1]
     snapshot = archive_data.snapshot_get(visit["snapshot"])
     head_rev_id = archive_data.snapshot_get_head(snapshot)
     head_rev = archive_data.revision_get(head_rev_id)
     root_dir_sha1 = head_rev["directory"]
     dir_content = archive_data.directory_ls(root_dir_sha1)
     branches, releases = process_snapshot_branches(snapshot)
     visit_unix_ts = parse_timestamp(visit["date"]).timestamp()
     visit_unix_ts = int(visit_unix_ts)
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         dir_content,
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         dir_content,
         visit_id=visit["visit"],
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         dir_content,
         timestamp=visit_unix_ts,
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         dir_content,
         timestamp=visit["date"],
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         dir_content,
         snapshot_id=visit["snapshot"],
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         dir_content,
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         dir_content,
         visit_id=visit["visit"],
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         dir_content,
         timestamp=visit_unix_ts,
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         dir_content,
         timestamp=visit["date"],
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         dir_content,
         snapshot_id=visit["snapshot"],
     )
 
 
 @given(origin())
 def test_origin_sub_directory_view(client, archive_data, origin):
     origin_visits = archive_data.origin_visit_get(origin["url"])
 
     visit = origin_visits[-1]
     snapshot = archive_data.snapshot_get(visit["snapshot"])
     head_rev_id = archive_data.snapshot_get_head(snapshot)
     head_rev = archive_data.revision_get(head_rev_id)
     root_dir_sha1 = head_rev["directory"]
     subdirs = [
         e for e in archive_data.directory_ls(root_dir_sha1) if e["type"] == "dir"
     ]
     branches, releases = process_snapshot_branches(snapshot)
     visit_unix_ts = parse_timestamp(visit["date"]).timestamp()
     visit_unix_ts = int(visit_unix_ts)
 
     if len(subdirs) == 0:
         return
 
     subdir = random.choice(subdirs)
     subdir_content = archive_data.directory_ls(subdir["target"])
     subdir_path = subdir["name"]
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         subdir_content,
         path=subdir_path,
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         subdir_content,
         path=subdir_path,
         visit_id=visit["visit"],
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         subdir_content,
         path=subdir_path,
         timestamp=visit_unix_ts,
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         subdir_content,
         path=subdir_path,
         timestamp=visit["date"],
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         subdir_content,
         path=subdir_path,
         snapshot_id=visit["snapshot"],
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         subdir_content,
         path=subdir_path,
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         subdir_content,
         path=subdir_path,
         visit_id=visit["visit"],
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         subdir_content,
         path=subdir_path,
         timestamp=visit_unix_ts,
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         subdir_content,
         path=subdir_path,
         timestamp=visit["date"],
     )
 
     _origin_directory_view_test_helper(
         client,
         archive_data,
         origin,
         visit,
         branches,
         releases,
         root_dir_sha1,
         subdir_content,
         path=subdir_path,
         snapshot_id=visit["snapshot"],
     )
 
 
 @given(origin())
 def test_origin_branches(client, archive_data, origin):
     origin_visits = archive_data.origin_visit_get(origin["url"])
 
     visit = origin_visits[-1]
     snapshot = archive_data.snapshot_get(visit["snapshot"])
     snapshot_content = process_snapshot_branches(snapshot)
 
     _origin_branches_test_helper(client, origin, snapshot_content)
 
     _origin_branches_test_helper(
         client, origin, snapshot_content, snapshot_id=visit["snapshot"]
     )
 
 
 @given(origin())
 def test_origin_releases(client, archive_data, origin):
     origin_visits = archive_data.origin_visit_get(origin["url"])
 
     visit = origin_visits[-1]
     snapshot = archive_data.snapshot_get(visit["snapshot"])
     snapshot_content = process_snapshot_branches(snapshot)
 
     _origin_releases_test_helper(client, origin, snapshot_content)
 
     _origin_releases_test_helper(
         client, origin, snapshot_content, snapshot_id=visit["snapshot"]
     )
 
 
 @given(
     new_origin(),
     new_snapshot(min_size=4, max_size=4),
     visit_dates(),
     revisions(min_size=3, max_size=3),
 )
 def test_origin_snapshot_null_branch(
     client, archive_data, new_origin, new_snapshot, visit_dates, revisions
 ):
     snp_dict = new_snapshot.to_dict()
     new_origin = archive_data.origin_add([new_origin])[0]
     for i, branch in enumerate(snp_dict["branches"].keys()):
         if i == 0:
             snp_dict["branches"][branch] = None
         else:
             snp_dict["branches"][branch] = {
                 "target_type": "revision",
                 "target": hash_to_bytes(revisions[i - 1]),
             }
 
     archive_data.snapshot_add([Snapshot.from_dict(snp_dict)])
     visit = archive_data.origin_visit_add(new_origin["url"], visit_dates[0], type="git")
-    archive_data.origin_visit_update(
-        new_origin["url"], visit.visit, status="partial", snapshot=snp_dict["id"]
+    visit_status = OriginVisitStatus(
+        origin=new_origin["url"],
+        visit=visit.visit,
+        date=now(),
+        status="partial",
+        snapshot=snp_dict["id"],
     )
+    archive_data.origin_visit_status_add([visit_status])
 
     url = reverse(
         "browse-origin-directory", query_params={"origin_url": new_origin["url"]}
     )
     rv = client.get(url)
     assert rv.status_code == 200
 
 
 @given(
     new_origin(),
     new_snapshot(min_size=4, max_size=4),
     visit_dates(),
     revisions(min_size=4, max_size=4),
 )
 def test_origin_snapshot_invalid_branch(
     client, archive_data, new_origin, new_snapshot, visit_dates, revisions
 ):
     snp_dict = new_snapshot.to_dict()
     new_origin = archive_data.origin_add([new_origin])[0]
     for i, branch in enumerate(snp_dict["branches"].keys()):
         snp_dict["branches"][branch] = {
             "target_type": "revision",
             "target": hash_to_bytes(revisions[i]),
         }
 
     archive_data.snapshot_add([Snapshot.from_dict(snp_dict)])
     visit = archive_data.origin_visit_add(new_origin["url"], visit_dates[0], type="git")
-    archive_data.origin_visit_update(
-        new_origin["url"], visit.visit, status="full", snapshot=snp_dict["id"]
+    visit_status = OriginVisitStatus(
+        origin=new_origin["url"],
+        visit=visit.visit,
+        date=now(),
+        status="full",
+        snapshot=snp_dict["id"],
     )
+    archive_data.origin_visit_status_add([visit_status])
 
     url = reverse(
         "browse-origin-directory",
         query_params={"origin_url": new_origin["url"], "branch": "invalid_branch"},
     )
     rv = client.get(url)
     assert rv.status_code == 404
 
 
 @given(new_origin())
 def test_browse_visits_origin_not_found(client, new_origin):
     url = reverse("browse-origin-visits", query_params={"origin_url": new_origin.url})
     resp = client.get(url)
     assert resp.status_code == 404
     assert_template_used(resp, "error.html")
     assert_contains(
         resp, f"Origin with url {new_origin.url} not found", status_code=404
     )
 
 
 @given(origin())
 def test_browse_origin_directory_no_visit(client, mocker, origin):
     mock_get_origin_visits = mocker.patch(
         "swh.web.common.origin_visits.get_origin_visits"
     )
     mock_get_origin_visits.return_value = []
     url = reverse("browse-origin-directory", query_params={"origin_url": origin["url"]})
     resp = client.get(url)
     assert resp.status_code == 404
     assert_template_used(resp, "error.html")
     assert_contains(resp, "No visit", status_code=404)
     assert mock_get_origin_visits.called
 
 
 @given(origin())
 def test_browse_origin_directory_unknown_visit(client, mocker, origin):
     mock_get_origin_visits = mocker.patch(
         "swh.web.common.origin_visits.get_origin_visits"
     )
     mock_get_origin_visits.return_value = [{"visit": 1}]
 
     url = reverse(
         "browse-origin-directory",
         query_params={"origin_url": origin["url"], "visit_id": 2},
     )
     resp = client.get(url)
     assert resp.status_code == 404
     assert_template_used(resp, "error.html")
     assert re.search("Visit.*not found", resp.content.decode("utf-8"))
     assert mock_get_origin_visits.called
 
 
 @given(origin())
 def test_browse_origin_directory_not_found(client, origin):
     url = reverse(
         "browse-origin-directory",
         query_params={"origin_url": origin["url"], "path": "/invalid/dir/path/"},
     )
     resp = client.get(url)
     assert resp.status_code == 404
     assert_template_used(resp, "error.html")
     assert re.search("Directory.*not found", resp.content.decode("utf-8"))
 
 
 @given(origin())
 def test_browse_origin_content_no_visit(client, mocker, origin):
     mock_get_origin_visits = mocker.patch(
         "swh.web.common.origin_visits.get_origin_visits"
     )
     mock_get_origin_visits.return_value = []
     url = reverse(
         "browse-origin-content",
         query_params={"origin_url": origin["url"], "path": "foo"},
     )
     resp = client.get(url)
     assert resp.status_code == 404
     assert_template_used(resp, "error.html")
     assert_contains(resp, "No visit", status_code=404)
     assert mock_get_origin_visits.called
 
 
 @given(origin())
 def test_browse_origin_content_unknown_visit(client, mocker, origin):
     mock_get_origin_visits = mocker.patch(
         "swh.web.common.origin_visits.get_origin_visits"
     )
     mock_get_origin_visits.return_value = [{"visit": 1}]
 
     url = reverse(
         "browse-origin-content",
         query_params={"origin_url": origin["url"], "path": "foo", "visit_id": 2},
     )
     resp = client.get(url)
     assert resp.status_code == 404
     assert_template_used(resp, "error.html")
     assert re.search("Visit.*not found", resp.content.decode("utf-8"))
     assert mock_get_origin_visits.called
 
 
 @given(origin())
 def test_browse_origin_content_directory_empty_snapshot(client, mocker, origin):
     mock_snapshot_service = mocker.patch("swh.web.browse.snapshot_context.service")
     mock_get_origin_visit_snapshot = mocker.patch(
         "swh.web.browse.snapshot_context.get_origin_visit_snapshot"
     )
     mock_get_origin_visit_snapshot.return_value = ([], [])
     mock_snapshot_service.lookup_origin.return_value = origin
     mock_snapshot_service.lookup_snapshot_sizes.return_value = {
         "revision": 0,
         "release": 0,
     }
 
     for browse_context in ("content", "directory"):
 
         url = reverse(
             f"browse-origin-{browse_context}",
             query_params={"origin_url": origin["url"], "path": "baz"},
         )
         resp = client.get(url)
         assert resp.status_code == 200
         assert_template_used(resp, f"browse/{browse_context}.html")
         assert re.search("snapshot.*is empty", resp.content.decode("utf-8"))
         assert mock_get_origin_visit_snapshot.called
         assert mock_snapshot_service.lookup_origin.called
         assert mock_snapshot_service.lookup_snapshot_sizes.called
 
 
 @given(origin())
 def test_browse_origin_content_not_found(client, origin):
     url = reverse(
         "browse-origin-content",
         query_params={"origin_url": origin["url"], "path": "/invalid/file/path"},
     )
     resp = client.get(url)
     assert resp.status_code == 404
     assert_template_used(resp, "error.html")
     assert re.search("Directory entry.*not found", resp.content.decode("utf-8"))
 
 
 @given(origin())
 def test_browse_directory_snapshot_not_found(client, mocker, origin):
     mock_get_snapshot_context = mocker.patch(
         "swh.web.browse.snapshot_context.get_snapshot_context"
     )
     mock_get_snapshot_context.side_effect = NotFoundExc("Snapshot not found")
     url = reverse("browse-origin-directory", query_params={"origin_url": origin["url"]})
     resp = client.get(url)
     assert resp.status_code == 404
     assert_template_used(resp, "error.html")
     assert_contains(resp, "Snapshot not found", status_code=404)
     assert mock_get_snapshot_context.called
 
 
 @given(origin())
 def test_origin_empty_snapshot(client, mocker, origin):
     mock_service = mocker.patch("swh.web.browse.snapshot_context.service")
     mock_get_origin_visit_snapshot = mocker.patch(
         "swh.web.browse.snapshot_context.get_origin_visit_snapshot"
     )
     mock_get_origin_visit_snapshot.return_value = ([], [])
     mock_service.lookup_snapshot_sizes.return_value = {
         "revision": 0,
         "release": 0,
     }
     mock_service.lookup_origin.return_value = origin
     url = reverse("browse-origin-directory", query_params={"origin_url": origin["url"]})
     resp = client.get(url)
     assert resp.status_code == 200
     assert_template_used(resp, "browse/directory.html")
     resp_content = resp.content.decode("utf-8")
     assert re.search("snapshot.*is empty", resp_content)
     assert not re.search("swh-tr-link", resp_content)
     assert mock_get_origin_visit_snapshot.called
     assert mock_service.lookup_snapshot_sizes.called
 
 
 @given(origin_with_releases())
 def test_origin_release_browse(client, archive_data, origin):
     snapshot = archive_data.snapshot_get_latest(origin["url"])
     release = [
         b for b in snapshot["branches"].values() if b["target_type"] == "release"
     ][-1]
     release_data = archive_data.release_get(release["target"])
     revision_data = archive_data.revision_get(release_data["target"])
     url = reverse(
         "browse-origin-directory",
         query_params={"origin_url": origin["url"], "release": release_data["name"]},
     )
 
     resp = client.get(url)
     assert resp.status_code == 200
     assert_contains(resp, release_data["name"])
     assert_contains(resp, release["target"])
 
     swhid_context = {
         "origin": origin["url"],
         "visit": get_swh_persistent_id(SNAPSHOT, snapshot["id"]),
         "anchor": get_swh_persistent_id(RELEASE, release_data["id"]),
         "path": "/",
     }
 
     swh_dir_id = get_swh_persistent_id(
         DIRECTORY, revision_data["directory"], metadata=swhid_context
     )
     swh_dir_id_url = reverse("browse-swh-id", url_args={"swh_id": swh_dir_id})
     assert_contains(resp, swh_dir_id)
     assert_contains(resp, swh_dir_id_url)
 
 
 @given(origin_with_releases())
 def test_origin_release_browse_not_found(client, origin):
 
     invalid_release_name = "swh-foo-bar"
     url = reverse(
         "browse-origin-directory",
         query_params={"origin_url": origin["url"], "release": invalid_release_name},
     )
 
     resp = client.get(url)
     assert resp.status_code == 404
     assert re.search(
         f"Release {invalid_release_name}.*not found", resp.content.decode("utf-8")
     )
 
 
 @given(new_origin(), unknown_revision())
 def test_origin_browse_directory_branch_with_non_resolvable_revision(
     client, archive_data, new_origin, unknown_revision
 ):
     branch_name = "master"
     snapshot = Snapshot(
         branches={
             branch_name.encode(): SnapshotBranch(
                 target=hash_to_bytes(unknown_revision), target_type=TargetType.REVISION,
             )
         }
     )
     new_origin = archive_data.origin_add([new_origin])[0]
     archive_data.snapshot_add([snapshot])
-    visit = archive_data.origin_visit_add(
-        new_origin["url"], datetime.now(tz=timezone.utc), type="git"
-    )
-    archive_data.origin_visit_update(
-        new_origin["url"], visit.visit, status="full", snapshot=snapshot.id
+    visit = archive_data.origin_visit_add(new_origin["url"], now(), type="git")
+    visit_status = OriginVisitStatus(
+        origin=new_origin["url"],
+        visit=visit.visit,
+        date=now(),
+        status="partial",
+        snapshot=snapshot.id,
     )
+    archive_data.origin_visit_status_add([visit_status])
 
     url = reverse(
         "browse-origin-directory",
         query_params={"origin_url": new_origin["url"], "branch": branch_name},
     )
 
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert_contains(
         resp, f"Revision {unknown_revision } could not be found in the archive."
     )
 
 
 @given(origin())
 def test_origin_content_no_path(client, origin):
     url = reverse("browse-origin-content", query_params={"origin_url": origin["url"]})
 
     resp = client.get(url)
 
     assert resp.status_code == 400
     assert_contains(
         resp, "The path of a content must be given as query parameter.", status_code=400
     )
 
 
 def test_origin_views_no_url_query_parameter(client):
     for browse_context in (
         "content",
         "directory",
         "log",
         "branches",
         "releases",
         "visits",
     ):
         url = reverse(f"browse-origin-{browse_context}")
         resp = client.get(url)
         assert resp.status_code == 400
         assert_contains(
             resp, "An origin URL must be provided as query parameter.", status_code=400
         )
 
 
 def _origin_content_view_test_helper(
     client,
     archive_data,
     origin_info,
     origin_visit,
     origin_branches,
     origin_releases,
     root_dir_sha1,
     content,
     visit_id=None,
     timestamp=None,
     snapshot_id=None,
 ):
     content_path = "/".join(content["path"].split("/")[1:])
 
     if not visit_id and not snapshot_id:
         visit_id = origin_visit["visit"]
 
     query_params = {"origin_url": origin_info["url"], "path": content_path}
 
     if timestamp:
         query_params["timestamp"] = timestamp
 
     if visit_id:
         query_params["visit_id"] = visit_id
     elif snapshot_id:
         query_params["snapshot"] = snapshot_id
 
     url = reverse("browse-origin-content", query_params=query_params)
 
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
 
     assert type(content["data"]) == str
 
     assert_contains(resp, '<code class="%s">' % content["hljs_language"])
     assert_contains(resp, escape(content["data"]))
 
     split_path = content_path.split("/")
 
     filename = split_path[-1]
     path = content_path.replace(filename, "")[:-1]
 
     path_info = gen_path_info(path)
 
     del query_params["path"]
 
     if timestamp:
         query_params["timestamp"] = format_utc_iso_date(
             parse_timestamp(timestamp).isoformat(), "%Y-%m-%dT%H:%M:%SZ"
         )
 
     root_dir_url = reverse("browse-origin-directory", query_params=query_params)
 
     assert_contains(resp, '<li class="swh-path">', count=len(path_info) + 1)
 
     assert_contains(resp, '<a href="%s">%s</a>' % (root_dir_url, root_dir_sha1[:7]))
 
     for p in path_info:
         query_params["path"] = p["path"]
         dir_url = reverse("browse-origin-directory", query_params=query_params)
         assert_contains(resp, '<a href="%s">%s</a>' % (dir_url, p["name"]))
 
     assert_contains(resp, "<li>%s</li>" % filename)
 
     query_string = "sha1_git:" + content["sha1_git"]
 
     url_raw = reverse(
         "browse-content-raw",
         url_args={"query_string": query_string},
         query_params={"filename": filename},
     )
     assert_contains(resp, url_raw)
 
     if "path" in query_params:
         del query_params["path"]
 
     origin_branches_url = reverse("browse-origin-branches", query_params=query_params)
 
     assert_contains(
         resp,
         '<a href="%s">Branches (%s)</a>'
         % (escape(origin_branches_url), len(origin_branches)),
     )
 
     origin_releases_url = reverse("browse-origin-releases", query_params=query_params)
 
     assert_contains(
         resp,
         '<a href="%s">Releases (%s)</a>'
         % (escape(origin_releases_url), len(origin_releases)),
     )
 
     assert_contains(resp, '<li class="swh-branch">', count=len(origin_branches))
 
     query_params["path"] = content_path
 
     for branch in origin_branches:
         root_dir_branch_url = reverse(
             "browse-origin-content",
             query_params={"branch": branch["name"], **query_params},
         )
 
         assert_contains(resp, '<a href="%s">' % root_dir_branch_url)
 
     assert_contains(resp, '<li class="swh-release">', count=len(origin_releases))
 
     query_params["branch"] = None
     for release in origin_releases:
         root_dir_release_url = reverse(
             "browse-origin-content",
             query_params={"release": release["name"], **query_params},
         )
 
         assert_contains(resp, '<a href="%s">' % root_dir_release_url)
 
     url = reverse("browse-origin-content", query_params=query_params)
 
     resp = client.get(url)
     assert resp.status_code == 200
     assert_template_used(resp, "browse/content.html")
 
     snapshot = archive_data.snapshot_get(origin_visit["snapshot"])
     head_rev_id = archive_data.snapshot_get_head(snapshot)
 
     swhid_context = {
         "origin": origin_info["url"],
         "visit": get_swh_persistent_id(SNAPSHOT, snapshot["id"]),
         "anchor": get_swh_persistent_id(REVISION, head_rev_id),
         "path": f"/{content_path}",
     }
 
     swh_cnt_id = get_swh_persistent_id(
         CONTENT, content["sha1_git"], metadata=swhid_context
     )
     swh_cnt_id_url = reverse("browse-swh-id", url_args={"swh_id": swh_cnt_id})
     assert_contains(resp, swh_cnt_id)
     assert_contains(resp, swh_cnt_id_url)
 
     assert_contains(resp, "swh-take-new-snapshot")
 
     _check_origin_view_title(resp, origin_info["url"], "content")
 
 
 def _origin_directory_view_test_helper(
     client,
     archive_data,
     origin_info,
     origin_visit,
     origin_branches,
     origin_releases,
     root_directory_sha1,
     directory_entries,
     visit_id=None,
     timestamp=None,
     snapshot_id=None,
     path=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"]
 
     if not visit_id and not snapshot_id:
         visit_id = origin_visit["visit"]
 
     query_params = {"origin_url": origin_info["url"]}
 
     if timestamp:
         query_params["timestamp"] = timestamp
     elif visit_id:
         query_params["visit_id"] = visit_id
     else:
         query_params["snapshot"] = snapshot_id
 
     if path:
         query_params["path"] = path
 
     url = reverse("browse-origin-directory", query_params=query_params)
 
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/directory.html")
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/directory.html")
 
     assert_contains(resp, '<td class="swh-directory">', count=len(dirs))
     assert_contains(resp, '<td class="swh-content">', count=len(files))
 
     if timestamp:
         query_params["timestamp"] = format_utc_iso_date(
             parse_timestamp(timestamp).isoformat(), "%Y-%m-%dT%H:%M:%SZ"
         )
 
     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"])
             query_params["path"] = dir_path
             dir_url = reverse("browse-origin-directory", query_params=query_params,)
         assert_contains(resp, dir_url)
 
     for f in files:
         file_path = f["name"]
         if path:
             file_path = "%s/%s" % (path, f["name"])
         query_params["path"] = file_path
         file_url = reverse("browse-origin-content", query_params=query_params)
         assert_contains(resp, file_url)
 
     if "path" in query_params:
         del query_params["path"]
 
     root_dir_branch_url = reverse("browse-origin-directory", query_params=query_params)
 
     nb_bc_paths = 1
     if path:
         nb_bc_paths = len(path.split("/")) + 1
 
     assert_contains(resp, '<li class="swh-path">', count=nb_bc_paths)
     assert_contains(
         resp, '<a href="%s">%s</a>' % (root_dir_branch_url, root_directory_sha1[:7])
     )
 
     origin_branches_url = reverse("browse-origin-branches", query_params=query_params)
 
     assert_contains(
         resp,
         '<a href="%s">Branches (%s)</a>'
         % (escape(origin_branches_url), len(origin_branches)),
     )
 
     origin_releases_url = reverse("browse-origin-releases", query_params=query_params)
 
     nb_releases = len(origin_releases)
     if nb_releases > 0:
         assert_contains(
             resp,
             '<a href="%s">Releases (%s)</a>'
             % (escape(origin_releases_url), nb_releases),
         )
 
     if path:
         query_params["path"] = path
 
     assert_contains(resp, '<li class="swh-branch">', count=len(origin_branches))
 
     for branch in origin_branches:
         query_params["branch"] = branch["name"]
         root_dir_branch_url = reverse(
             "browse-origin-directory", query_params=query_params
         )
 
         assert_contains(resp, '<a href="%s">' % root_dir_branch_url)
 
     assert_contains(resp, '<li class="swh-release">', count=len(origin_releases))
 
     query_params["branch"] = None
     for release in origin_releases:
         query_params["release"] = release["name"]
         root_dir_release_url = reverse(
             "browse-origin-directory", query_params=query_params
         )
 
         assert_contains(resp, '<a href="%s">' % root_dir_release_url)
 
     assert_contains(resp, "vault-cook-directory")
     assert_contains(resp, "vault-cook-revision")
 
     snapshot = archive_data.snapshot_get(origin_visit["snapshot"])
     head_rev_id = archive_data.snapshot_get_head(snapshot)
 
     swhid_context = {
         "origin": origin_info["url"],
         "visit": get_swh_persistent_id(SNAPSHOT, snapshot["id"]),
         "anchor": get_swh_persistent_id(REVISION, head_rev_id),
         "path": f"/{path}" if path else "/",
     }
 
     swh_dir_id = get_swh_persistent_id(
         DIRECTORY, directory_entries[0]["dir_id"], metadata=swhid_context
     )
     swh_dir_id_url = reverse("browse-swh-id", url_args={"swh_id": swh_dir_id})
     assert_contains(resp, swh_dir_id)
     assert_contains(resp, swh_dir_id_url)
 
     assert_contains(resp, "swh-take-new-snapshot")
 
     _check_origin_view_title(resp, origin_info["url"], "directory")
 
 
 def _origin_branches_test_helper(
     client, origin_info, origin_snapshot, snapshot_id=None
 ):
     query_params = {"origin_url": origin_info["url"], "snapshot": snapshot_id}
 
     url = reverse("browse-origin-branches", query_params=query_params)
 
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert_template_used(resp, "browse/branches.html")
 
     origin_branches = origin_snapshot[0]
     origin_releases = origin_snapshot[1]
 
     origin_branches_url = reverse("browse-origin-branches", query_params=query_params)
 
     assert_contains(
         resp,
         '<a href="%s">Branches (%s)</a>'
         % (escape(origin_branches_url), len(origin_branches)),
     )
 
     origin_releases_url = reverse("browse-origin-releases", query_params=query_params)
 
     nb_releases = len(origin_releases)
     if nb_releases > 0:
         assert_contains(
             resp,
             '<a href="%s">Releases (%s)</a>'
             % (escape(origin_releases_url), nb_releases),
         )
 
     assert_contains(resp, '<tr class="swh-branch-entry', count=len(origin_branches))
 
     for branch in origin_branches:
         browse_branch_url = reverse(
             "browse-origin-directory",
             query_params={"branch": branch["name"], **query_params},
         )
         assert_contains(resp, '<a href="%s">' % escape(browse_branch_url))
 
         browse_revision_url = reverse(
             "browse-revision",
             url_args={"sha1_git": branch["revision"]},
             query_params=query_params,
         )
         assert_contains(resp, '<a href="%s">' % escape(browse_revision_url))
 
     _check_origin_view_title(resp, origin_info["url"], "branches")
 
 
 def _origin_releases_test_helper(
     client, origin_info, origin_snapshot, snapshot_id=None
 ):
     query_params = {"origin_url": origin_info["url"], "snapshot": snapshot_id}
 
     url = reverse("browse-origin-releases", query_params=query_params)
 
     resp = client.get(url)
     assert resp.status_code == 200
     assert_template_used(resp, "browse/releases.html")
 
     origin_branches = origin_snapshot[0]
     origin_releases = origin_snapshot[1]
 
     origin_branches_url = reverse("browse-origin-branches", query_params=query_params)
 
     assert_contains(
         resp,
         '<a href="%s">Branches (%s)</a>'
         % (escape(origin_branches_url), len(origin_branches)),
     )
 
     origin_releases_url = reverse("browse-origin-releases", query_params=query_params)
 
     nb_releases = len(origin_releases)
     if nb_releases > 0:
         assert_contains(
             resp,
             '<a href="%s">Releases (%s)</a>'
             % (escape(origin_releases_url), nb_releases),
         )
 
     assert_contains(resp, '<tr class="swh-release-entry', count=nb_releases)
 
     for release in origin_releases:
         browse_release_url = reverse(
             "browse-release",
             url_args={"sha1_git": release["id"]},
             query_params=query_params,
         )
         browse_revision_url = reverse(
             "browse-revision",
             url_args={"sha1_git": release["target"]},
             query_params=query_params,
         )
 
         assert_contains(resp, '<a href="%s">' % escape(browse_release_url))
         assert_contains(resp, '<a href="%s">' % escape(browse_revision_url))
 
     _check_origin_view_title(resp, origin_info["url"], "releases")
 
 
 @given(
     new_origin(), visit_dates(), revisions(min_size=10, max_size=10), existing_release()
 )
 def test_origin_branches_pagination_with_alias(
     client, archive_data, mocker, new_origin, visit_dates, revisions, existing_release
 ):
     """
     When a snapshot contains a branch or a release alias, pagination links
     in the branches / releases view should be displayed.
     """
     mocker.patch("swh.web.browse.snapshot_context.PER_PAGE", len(revisions) / 2)
     snp_dict = {"branches": {}, "id": hash_to_bytes(random_sha1())}
     for i in range(len(revisions)):
         branch = "".join(random.choices(string.ascii_lowercase, k=8))
         snp_dict["branches"][branch.encode()] = {
             "target_type": "revision",
             "target": hash_to_bytes(revisions[i]),
         }
     release = "".join(random.choices(string.ascii_lowercase, k=8))
     snp_dict["branches"][b"RELEASE_ALIAS"] = {
         "target_type": "alias",
         "target": release.encode(),
     }
     snp_dict["branches"][release.encode()] = {
         "target_type": "release",
         "target": hash_to_bytes(existing_release),
     }
     new_origin = archive_data.origin_add([new_origin])[0]
     archive_data.snapshot_add([Snapshot.from_dict(snp_dict)])
     visit = archive_data.origin_visit_add(new_origin["url"], visit_dates[0], type="git")
-    archive_data.origin_visit_update(
-        new_origin["url"], visit.visit, status="full", snapshot=snp_dict["id"]
-    )
+    visit_status = OriginVisitStatus(
+        origin=new_origin["url"],
+        visit=visit.visit,
+        date=now(),
+        status="full",
+        snapshot=snp_dict["id"],
+    )
+    archive_data.origin_visit_status_add([visit_status])
 
     url = reverse(
         "browse-origin-branches", query_params={"origin_url": new_origin["url"]}
     )
     resp = client.get(url)
     assert resp.status_code == 200
     assert_template_used(resp, "browse/branches.html")
     assert_contains(resp, '<ul class="pagination')
 
 
 def _check_origin_view_title(resp, origin_url, object_type):
     browse_origin_url = reverse(
         "browse-origin", query_params={"origin_url": origin_url}
     )
 
     assert_contains(
         resp,
         textwrap.indent(
             (
                 f"Browse archived {object_type} for origin\n"
                 f'<a href="{browse_origin_url}">\n'
                 f"  {origin_url}\n"
                 f"</a>"
             ),
             " " * 6,
         ),
     )
diff --git a/swh/web/tests/data.py b/swh/web/tests/data.py
index c5fb392a..02d61643 100644
--- a/swh/web/tests/data.py
+++ b/swh/web/tests/data.py
@@ -1,353 +1,357 @@
 # 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 datetime
 import os
 import random
 
 from copy import deepcopy
 
 from swh.indexer.fossology_license import FossologyLicenseIndexer
 from swh.indexer.mimetype import MimetypeIndexer
 from swh.indexer.ctags import CtagsIndexer
 from swh.indexer.storage import get_indexer_storage
-from swh.model.model import Content
+from swh.model.model import Content, OriginVisitStatus
 from swh.model.hashutil import hash_to_hex, hash_to_bytes, DEFAULT_ALGORITHMS
 from swh.model.model import Directory, Origin
 from swh.loader.git.from_disk import GitLoaderFromArchive
 from swh.search import get_search
 from swh.storage.algos.dir_iterators import dir_iterator
 from swh.web import config
 from swh.web.browse.utils import (
     get_mimetype_and_encoding_for_content,
     prepare_content_for_display,
     _re_encode_content,
 )
 from swh.web.common import service
 
 # Module used to initialize data that will be provided as tests input
 
 # Configuration for git loader
 _TEST_LOADER_CONFIG = {
     "storage": {"cls": "memory",},
     "save_data": False,
     "max_content_size": 100 * 1024 * 1024,
 }
 
 # Base content indexer configuration
 _TEST_INDEXER_BASE_CONFIG = {
     "storage": {"cls": "memory"},
     "objstorage": {"cls": "memory", "args": {},},
     "indexer_storage": {"cls": "memory", "args": {},},
 }
 
 
 def random_sha1():
     return hash_to_hex(bytes(random.randint(0, 255) for _ in range(20)))
 
 
 def random_sha256():
     return hash_to_hex(bytes(random.randint(0, 255) for _ in range(32)))
 
 
 def random_blake2s256():
     return hash_to_hex(bytes(random.randint(0, 255) for _ in range(32)))
 
 
 def random_content():
     return {
         "sha1": random_sha1(),
         "sha1_git": random_sha1(),
         "sha256": random_sha256(),
         "blake2s256": random_blake2s256(),
     }
 
 
 # MimetypeIndexer with custom configuration for tests
 class _MimetypeIndexer(MimetypeIndexer):
     def parse_config_file(self, *args, **kwargs):
         return {
             **_TEST_INDEXER_BASE_CONFIG,
             "tools": {
                 "name": "file",
                 "version": "1:5.30-1+deb9u1",
                 "configuration": {"type": "library", "debian-package": "python3-magic"},
             },
         }
 
 
 # FossologyLicenseIndexer with custom configuration for tests
 class _FossologyLicenseIndexer(FossologyLicenseIndexer):
     def parse_config_file(self, *args, **kwargs):
         return {
             **_TEST_INDEXER_BASE_CONFIG,
             "workdir": "/tmp/swh/indexer.fossology.license",
             "tools": {
                 "name": "nomos",
                 "version": "3.1.0rc2-31-ga2cbb8c",
                 "configuration": {"command_line": "nomossa <filepath>",},
             },
         }
 
 
 # CtagsIndexer with custom configuration for tests
 class _CtagsIndexer(CtagsIndexer):
     def parse_config_file(self, *args, **kwargs):
         return {
             **_TEST_INDEXER_BASE_CONFIG,
             "workdir": "/tmp/swh/indexer.ctags",
             "languages": {"c": "c"},
             "tools": {
                 "name": "universal-ctags",
                 "version": "~git7859817b",
                 "configuration": {
                     "command_line": """ctags --fields=+lnz --sort=no --links=no """
                     """--output-format=json <filepath>"""
                 },
             },
         }
 
 
 # Lightweight git repositories that will be loaded to generate
 # input data for tests
 _TEST_ORIGINS = [
     {
         "type": "git",
         "url": "https://github.com/wcoder/highlightjs-line-numbers.js",
         "archives": [
             "highlightjs-line-numbers.js.zip",
             "highlightjs-line-numbers.js_visit2.zip",
         ],
         "visit_date": ["Dec 1 2018, 01:00 UTC", "Jan 20 2019, 15:00 UTC"],
     },
     {
         "type": "git",
         "url": "https://github.com/memononen/libtess2",
         "archives": ["libtess2.zip"],
         "visit_date": ["May 25 2018, 01:00 UTC"],
     },
     {
         "type": "git",
         "url": "repo_with_submodules",
         "archives": ["repo_with_submodules.tgz"],
         "visit_date": ["Jan 1 2019, 01:00 UTC"],
     },
 ]
 
 _contents = {}
 
 
 def _add_extra_contents(storage, contents):
     pbm_image_data = b"""P1
 # PBM example
 24 7
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 1 1 0
 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0
 0 1 1 1 0 0 0 1 1 1 0 0 0 1 1 1 0 0 0 1 1 1 1 0
 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
 0 1 0 0 0 0 0 1 1 1 1 0 0 1 1 1 1 0 0 1 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"""
 
     # add file with mimetype image/x-portable-bitmap in the archive content
     pbm_content = Content.from_data(pbm_image_data)
     storage.content_add([pbm_content])
     contents.add(pbm_content.sha1)
 
 
 # Tests data initialization
 def _init_tests_data():
     # To hold reference to the memory storage
     storage = None
 
     # Create search instance
     search = get_search("memory", {})
     search.initialize()
     search.origin_update({"url": origin["url"]} for origin in _TEST_ORIGINS)
 
     # Load git repositories from archives
     for origin in _TEST_ORIGINS:
         for i, archive in enumerate(origin["archives"]):
             origin_repo_archive = os.path.join(
                 os.path.dirname(__file__), "resources/repos/%s" % archive
             )
             loader = GitLoaderFromArchive(
                 origin["url"],
                 archive_path=origin_repo_archive,
                 config=_TEST_LOADER_CONFIG,
                 visit_date=origin["visit_date"][i],
             )
             if storage is None:
                 storage = loader.storage
             else:
                 loader.storage = storage
             loader.load()
 
         origin.update(storage.origin_get(origin))  # add an 'id' key if enabled
         search.origin_update([{"url": origin["url"], "has_visits": True}])
 
     for i in range(250):
         url = "https://many.origins/%d" % (i + 1)
         # storage.origin_add([{'url': url}])
         storage.origin_add([Origin(url=url)])
         search.origin_update([{"url": url, "has_visits": True}])
-        visit = storage.origin_visit_add(url, "2019-12-03 13:55:05Z", "tar")
-        storage.origin_visit_update(
-            url,
-            visit.visit,
+        date = datetime.datetime(2019, 12, 3, 13, 55, 5, tzinfo=datetime.timezone.utc)
+        visit = storage.origin_visit_add(url, date, "tar")
+        visit_status = OriginVisitStatus(
+            origin=url,
+            visit=visit.visit,
+            date=date,
             status="full",
             snapshot=hash_to_bytes("1a8893e6a86f444e8be8e7bda6cb34fb1735a00e"),
         )
+        storage.origin_visit_status_add([visit_status])
 
     contents = set()
     directories = set()
     revisions = set()
     releases = set()
     snapshots = set()
 
     content_path = {}
 
     # Get all objects loaded into the test archive
     for origin in _TEST_ORIGINS:
         snp = storage.snapshot_get_latest(origin["url"])
         snapshots.add(hash_to_hex(snp["id"]))
         for branch_name, branch_data in snp["branches"].items():
             if branch_data["target_type"] == "revision":
                 revisions.add(branch_data["target"])
             elif branch_data["target_type"] == "release":
                 release = next(storage.release_get([branch_data["target"]]))
                 revisions.add(release["target"])
                 releases.add(hash_to_hex(branch_data["target"]))
 
         for rev_log in storage.revision_shortlog(set(revisions)):
             rev_id = rev_log[0]
             revisions.add(rev_id)
 
         for rev in storage.revision_get(revisions):
             dir_id = rev["directory"]
             directories.add(hash_to_hex(dir_id))
             for entry in dir_iterator(storage, dir_id):
                 if entry["type"] == "file":
                     contents.add(entry["sha1"])
                     content_path[entry["sha1"]] = "/".join(
                         [hash_to_hex(dir_id), entry["path"].decode("utf-8")]
                     )
                 elif entry["type"] == "dir":
                     directories.add(hash_to_hex(entry["target"]))
 
     _add_extra_contents(storage, contents)
 
     # Get all checksums for each content
     result = storage.content_get_metadata(contents)
     contents = []
     for sha1, contents_metadata in result.items():
         sha1 = contents_metadata[0]["sha1"]
         content_metadata = {
             algo: hash_to_hex(contents_metadata[0][algo]) for algo in DEFAULT_ALGORITHMS
         }
 
         path = ""
         if sha1 in content_path:
             path = content_path[sha1]
         cnt = next(storage.content_get([sha1]))
         mimetype, encoding = get_mimetype_and_encoding_for_content(cnt["data"])
         _, _, cnt["data"] = _re_encode_content(mimetype, encoding, cnt["data"])
         content_display_data = prepare_content_for_display(cnt["data"], mimetype, path)
 
         content_metadata.update(
             {
                 "path": path,
                 "mimetype": mimetype,
                 "encoding": encoding,
                 "hljs_language": content_display_data["language"],
                 "data": content_display_data["content_data"],
             }
         )
         _contents[hash_to_hex(sha1)] = content_metadata
         contents.append(content_metadata)
 
     # Create indexer storage instance that will be shared by indexers
     idx_storage = get_indexer_storage("memory", {})
 
     # Add the empty directory to the test archive
     storage.directory_add([Directory(entries=())])
 
     # Return tests data
     return {
         "search": search,
         "storage": storage,
         "idx_storage": idx_storage,
         "origins": _TEST_ORIGINS,
         "contents": contents,
         "directories": list(directories),
         "releases": list(releases),
         "revisions": list(map(hash_to_hex, revisions)),
         "snapshots": list(snapshots),
         "generated_checksums": set(),
     }
 
 
 def _init_indexers(tests_data):
     # Instantiate content indexers that will be used in tests
     # and force them to use the memory storages
     indexers = {}
     for idx_name, idx_class in (
         ("mimetype_indexer", _MimetypeIndexer),
         ("license_indexer", _FossologyLicenseIndexer),
         ("ctags_indexer", _CtagsIndexer),
     ):
         idx = idx_class()
         idx.storage = tests_data["storage"]
         idx.objstorage = tests_data["storage"].objstorage
         idx.idx_storage = tests_data["idx_storage"]
         idx.register_tools(idx.config["tools"])
         indexers[idx_name] = idx
 
     return indexers
 
 
 def get_content(content_sha1):
     return _contents.get(content_sha1)
 
 
 _tests_data = None
 _current_tests_data = None
 _indexer_loggers = {}
 
 
 def get_tests_data(reset=False):
     """
     Initialize tests data and return them in a dict.
     """
     global _tests_data, _current_tests_data
     if _tests_data is None:
         _tests_data = _init_tests_data()
         indexers = _init_indexers(_tests_data)
         for (name, idx) in indexers.items():
             # pytest makes the loggers use a temporary file; and deepcopy
             # requires serializability. So we remove them, and add them
             # back after the copy.
             _indexer_loggers[name] = idx.log
             del idx.log
         _tests_data.update(indexers)
     if reset or _current_tests_data is None:
         _current_tests_data = deepcopy(_tests_data)
         for (name, logger) in _indexer_loggers.items():
             _current_tests_data[name].log = logger
     return _current_tests_data
 
 
 def override_storages(storage, idx_storage, search):
     """
     Helper function to replace the storages from which archive data
     are fetched.
     """
     swh_config = config.get_config()
     swh_config.update(
         {"storage": storage, "indexer_storage": idx_storage, "search": search,}
     )
 
     service.storage = storage
     service.idx_storage = idx_storage
     service.search = search