diff --git a/mypy.ini b/mypy.ini
--- a/mypy.ini
+++ b/mypy.ini
@@ -11,6 +11,9 @@
 [mypy-methodtools.*]
 ignore_missing_imports = True
 
+[mypy-msgpack.*]
+ignore_missing_imports = True
+
 [mypy-pkg_resources.*]
 ignore_missing_imports = True
 
diff --git a/requirements-test.txt b/requirements-test.txt
--- a/requirements-test.txt
+++ b/requirements-test.txt
@@ -1,2 +1,3 @@
 pytest
 swh.loader.git >= 0.8
+swh.journal >= 0.8
diff --git a/swh/provenance/tests/conftest.py b/swh/provenance/tests/conftest.py
--- a/swh/provenance/tests/conftest.py
+++ b/swh/provenance/tests/conftest.py
@@ -7,15 +7,16 @@
 import re
 from typing import Iterable, Iterator, List, Optional
 
+import msgpack
 import pytest
 from typing_extensions import TypedDict
 
-from swh.core.api.serializers import msgpack_loads
 from swh.core.db import BaseDb
-from swh.model.model import Content, Directory, DirectoryEntry, Revision
+from swh.journal.serializers import msgpack_ext_hook
 from swh.model.tests.swh_model_data import TEST_OBJECTS
 from swh.provenance.postgresql.archive import ArchivePostgreSQL
 from swh.provenance.storage.archive import ArchiveStorage
+from swh.storage.replay import process_replay_objects
 
 
 @pytest.fixture(params=["with-path", "without-path"])
@@ -88,10 +89,17 @@
 
 
 def load_repo_data(repo):
-    data = {"revision": [], "directory": [], "content": []}
+    data = {}
     with open(get_datafile(f"{repo}.msgpack"), "rb") as fobj:
-        for etype, value in msgpack_loads(fobj.read()):
-            data[etype].append(value)
+        unpacker = msgpack.Unpacker(
+            fobj,
+            raw=False,
+            ext_hook=msgpack_ext_hook,
+            strict_map_key=False,
+            timestamp=3,  # convert Timestamp in datetime objects (tz UTC)
+        )
+        for objtype, objd in unpacker:
+            data.setdefault(objtype, []).append(objd)
     return data
 
 
@@ -100,25 +108,7 @@
 
 
 def fill_storage(storage, data):
-    storage.content_add_metadata(
-        Content.from_dict(content) for content in data["content"]
-    )
-    storage.directory_add(
-        [
-            Directory(
-                entries=tuple(
-                    [
-                        DirectoryEntry.from_dict(
-                            filter_dict(entry, ("name", "type", "target", "perms"))
-                        )
-                        for entry in dir["entries"]
-                    ]
-                )
-            )
-            for dir in data["directory"]
-        ]
-    )
-    storage.revision_add(Revision.from_dict(revision) for revision in data["revision"])
+    process_replay_objects(data, storage=storage)
 
 
 class SynthRelation(TypedDict):
diff --git a/swh/provenance/tests/data/cmdbts2.msgpack b/swh/provenance/tests/data/cmdbts2.msgpack
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
GIT binary patch
literal 0
Hc$@<O00001

literal 0
Hc$@<O00001

diff --git a/swh/provenance/tests/data/generate_storage_from_git.py b/swh/provenance/tests/data/generate_storage_from_git.py
--- a/swh/provenance/tests/data/generate_storage_from_git.py
+++ b/swh/provenance/tests/data/generate_storage_from_git.py
@@ -5,16 +5,10 @@
 
 from datetime import datetime, timezone
 import os
-import re
-from subprocess import check_output
-from typing import Dict
 
 import click
 
-from swh.core.api.serializers import msgpack_dumps
 from swh.loader.git.from_disk import GitLoaderFromDisk
-from swh.model.hashutil import hash_to_bytes as h2b
-from swh.provenance.tests.test_provenance_db import ts2dt
 from swh.storage import get_storage
 
 
@@ -34,81 +28,23 @@
     return d
 
 
-def dump_file(hash, storage, cache):
-    if hash not in cache:
-        content = storage.content_find({"sha1_git": hash})[0]
-        cache[hash] = content
-        # we remove ctime to make the resulting data (eg. output msgpack file)
-        # independent from execution time
-        yield "content", pop_key(content.to_dict(), "ctime")
-
-
-def dump_directory(hash, storage, cache):
-    if hash not in cache:
-        dircontent = list(storage.directory_ls(hash))
-        cache[hash] = dircontent
-        yield "directory", {"id": hash, "entries": list(storage.directory_ls(hash))}
-        for direntry in dircontent:
-            if direntry["type"] == "dir":
-                yield from dump_directory(direntry["target"], storage, cache)
-            elif direntry["type"] == "file":
-                yield from dump_file(direntry["target"], storage, cache)
-            else:
-                raise ValueError("Unexpected directory entry type {direntry['type']}")
-
-
-def dump_git_revision(hash, storage, cache):
-    if hash not in cache:
-        rev = storage.revision_get([hash])[0]
-        revd = {
-            "id": rev.id,
-            "date": ts2dt(rev.date.to_dict()),
-            "parents": rev.parents,
-            "directory": rev.directory,
-        }
-        revd = rev.to_dict()
-        cache[hash] = revd
-        for parent in rev.parents:
-            yield from dump_git_revision(parent, storage, cache)
-        yield from dump_directory(rev.directory, storage, cache)
-    yield "revision", cache[hash]
-
-
 @click.command()
-@click.option(
-    "-r",
-    "--head",
-    default="master",
-    help="head revision to start from",
-)
 @click.option("-o", "--output", default=None, help="output file")
-@click.argument("git-repo")
-def main(head, output, git_repo):
+@click.argument("git-repo", type=click.Path(exists=True, file_okay=False))
+def main(output, git_repo):
     "simple tool to generate the git_repo.msgpack dataset file used in some tests"
-    sto = get_storage(cls="memory")
-    if git_repo.endswith("/"):
-        git_repo = git_repo[:-1]
-
-    reponame = os.path.basename(git_repo)
-    load_git_repo(f"https://{reponame}", git_repo, sto)
-
     if output is None:
         output = f"{git_repo}.msgpack"
-
-    if not re.match("[0-9a-fA-F]{40}", head):
-        headhash = (
-            check_output(["git", "-C", git_repo, "rev-parse", head]).decode().strip()
+    with open(output, "wb") as outstream:
+        sto = get_storage(
+            cls="memory", journal_writer={"cls": "stream", "output_stream": outstream}
         )
-        click.echo(f"Revision hash for {head} is {headhash}")
-    else:
-        headhash = head
-    cache: Dict[bytes, dict] = {}
-    outf = open(output, "wb")
-    outd = []
-    for e in dump_git_revision(h2b(headhash), storage=sto, cache=cache):
-        outd.append(e)
-    outf.write(msgpack_dumps(outd))
-    click.echo(f"Wrote {len(outd)} objects in {output}")
+        if git_repo.endswith("/"):
+            git_repo = git_repo[:-1]
+
+        reponame = os.path.basename(git_repo)
+        load_git_repo(f"https://{reponame}", git_repo, sto)
+    click.echo(f"Serialized the storage made from {reponame} in {output}")
 
 
 if __name__ == "__main__":
diff --git a/swh/provenance/tests/data/out-of-order.msgpack b/swh/provenance/tests/data/out-of-order.msgpack
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
GIT binary patch
literal 0
Hc$@<O00001

literal 0
Hc$@<O00001