diff --git a/Makefile b/Makefile
index 31b54b93d203..2eabeb077477 100644
--- a/Makefile
+++ b/Makefile
@@ -22,6 +22,7 @@ makefiles = \
 -include Makefile.config
 
 ifeq ($(tests), yes)
+UNIT_TEST_ENV = _NIX_TEST_UNIT_DATA=unit-test-data
 makefiles += \
   src/libutil/tests/local.mk \
   src/libstore/tests/local.mk \
diff --git a/doc/manual/src/contributing/testing.md b/doc/manual/src/contributing/testing.md
index cd94d5cfbafb..e7a69b57506e 100644
--- a/doc/manual/src/contributing/testing.md
+++ b/doc/manual/src/contributing/testing.md
@@ -10,6 +10,13 @@ under `src/{library_name}/tests` using the
 You can run the whole testsuite with `make check`, or the tests for a specific component with `make libfoo-tests_RUN`.
 Finer-grained filtering is also possible using the [--gtest_filter](https://google.github.io/googletest/advanced.html#running-a-subset-of-the-tests) command-line option, or the `GTEST_FILTER` environment variable.
 
+### Characterization testing
+
+See below for a broder discussion.
+`_NIX_TEST_ACCEPT=1` is also used.
+The data is in `unit-test-data`;
+the path to that directory is passed to the unit test executable with the environment variable `UNIT_TEST_ENV`.
+
 ## Functional tests
 
 The functional tests reside under the `tests` directory and are listed in `tests/local.mk`.
diff --git a/mk/programs.mk b/mk/programs.mk
index 1ee1d3fa5de8..a88d9d949849 100644
--- a/mk/programs.mk
+++ b/mk/programs.mk
@@ -87,6 +87,6 @@ define build-program
   # Phony target to run this program (typically as a dependency of 'check').
   .PHONY: $(1)_RUN
   $(1)_RUN: $$($(1)_PATH)
-	$(trace-test) $$($(1)_PATH)
+	$(trace-test) $$(UNIT_TEST_ENV) $$($(1)_PATH)
 
 endef
diff --git a/src/libstore/tests/worker-protocol.cc b/src/libstore/tests/worker-protocol.cc
new file mode 100644
index 000000000000..ab7fef3a6938
--- /dev/null
+++ b/src/libstore/tests/worker-protocol.cc
@@ -0,0 +1,139 @@
+#include <regex>
+
+#include <nlohmann/json.hpp>
+#include <gtest/gtest.h>
+
+#include "worker-protocol.hh"
+#include "worker-protocol-impl.hh"
+#include "derived-path.hh"
+#include "tests/libstore.hh"
+
+namespace nix {
+
+class WorkerProtoTest : public LibStoreTest
+{
+public:
+    Path unitTestData = getEnv("_NIX_TEST_UNIT_DATA").value() + "/libstore/worker-protocol";
+
+    bool testAccept() {
+        return getEnv("_NIX_TEST_ACCEPT") == "1";
+    }
+
+    Path goldenMaster(std::string_view testStem) {
+        return unitTestData + "/" + testStem + ".bin";
+    }
+
+    /**
+     * Golden test for `T` reading
+     */
+    template<typename T>
+    void readTest(PathView testStem, T value)
+    {
+        if (testAccept())
+        {
+            GTEST_SKIP() << "Cant read because updating golden master";
+        }
+        else
+        {
+            auto expected = readFile(goldenMaster(testStem));
+
+            T got = ({
+                StringSource from { expected };
+                WorkerProto::Serialise<T>::read(
+                    *store,
+                    WorkerProto::ReadConn { .from = from });
+            });
+
+            ASSERT_EQ(got, value);
+        }
+    }
+
+    /**
+     * Golden test for `T` write
+     */
+    template<typename T>
+    void writeTest(PathView testStem, const T & value)
+    {
+        auto file = goldenMaster(testStem);
+
+        StringSink to;
+        WorkerProto::write(
+            *store,
+            WorkerProto::WriteConn { .to = to },
+            value);
+
+        if (testAccept())
+        {
+            createDirs(dirOf(file));
+            writeFile(file, to.s);
+            GTEST_SKIP() << "updating golden master";
+        }
+        else
+        {
+            auto expected = readFile(file);
+            ASSERT_EQ(to.s, expected);
+        }
+    }
+};
+
+#define GOLDEN_MASTER_TEST(NAME, STEM, VALUE)  \
+    TEST_F(WorkerProtoTest, NAME ## _read) {   \
+        readTest(STEM, VALUE);                 \
+    }                                          \
+    TEST_F(WorkerProtoTest, NAME ## _write) {  \
+        writeTest(STEM, VALUE);                \
+    }
+
+GOLDEN_MASTER_TEST(
+    string,
+    "string",
+    (std::tuple<std::string, std::string, std::string, std::string, std::string> {
+        "",
+        "hi",
+        "white rabbit",
+        "大白兔",
+        "oh no \0\0\0 what was that!",
+    }))
+
+GOLDEN_MASTER_TEST(
+    storePath,
+    "store-path",
+    (std::tuple<StorePath, StorePath> {
+        StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
+        StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar" },
+    }))
+
+GOLDEN_MASTER_TEST(
+    contentAddress,
+    "content-address",
+    (std::tuple<ContentAddress, ContentAddress, ContentAddress> {
+        ContentAddress {
+            .method = TextIngestionMethod {},
+            .hash = hashString(HashType::htSHA256, "Derive(...)"),
+        },
+        ContentAddress {
+            .method = FileIngestionMethod::Flat,
+            .hash = hashString(HashType::htSHA1, "blob blob..."),
+        },
+        ContentAddress {
+            .method = FileIngestionMethod::Recursive,
+            .hash = hashString(HashType::htSHA256, "(...)"),
+        },
+    }))
+
+GOLDEN_MASTER_TEST(
+    derivedPath,
+    "derived-path",
+    (std::tuple<DerivedPath, DerivedPath> {
+        DerivedPath::Opaque {
+            .path = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
+        },
+        DerivedPath::Built {
+            .drvPath = makeConstantStorePathRef(StorePath {
+                "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
+            }),
+            .outputs = OutputsSpec::Names { "x", "y" },
+        },
+    }))
+
+}
diff --git a/src/libstore/worker-protocol-impl.hh b/src/libstore/worker-protocol-impl.hh
index d3d2792ff527..4f797f95a0f1 100644
--- a/src/libstore/worker-protocol-impl.hh
+++ b/src/libstore/worker-protocol-impl.hh
@@ -75,4 +75,20 @@ void WorkerProto::Serialise<std::map<K, V>>::write(const Store & store, WorkerPr
     }
 }
 
+template<typename... Ts>
+std::tuple<Ts...> WorkerProto::Serialise<std::tuple<Ts...>>::read(const Store & store, WorkerProto::ReadConn conn)
+{
+    return std::tuple<Ts...> {
+        WorkerProto::Serialise<Ts>::read(store, conn)...,
+    };
+}
+
+template<typename... Ts>
+void WorkerProto::Serialise<std::tuple<Ts...>>::write(const Store & store, WorkerProto::WriteConn conn, const std::tuple<Ts...> & res)
+{
+    std::apply([&]<typename... Us>(const Us &... args) {
+        (WorkerProto::Serialise<Us>::write(store, conn, args), ...);
+    }, res);
+}
+
 }
diff --git a/src/libstore/worker-protocol.hh b/src/libstore/worker-protocol.hh
index ff762c924ab1..70a5bddb988c 100644
--- a/src/libstore/worker-protocol.hh
+++ b/src/libstore/worker-protocol.hh
@@ -28,6 +28,8 @@ class Store;
 struct Source;
 
 // items being serialised
+class StorePath;
+struct ContentAddress;
 struct DerivedPath;
 struct DrvOutput;
 struct Realisation;
@@ -220,6 +222,8 @@ template<typename T>
 MAKE_WORKER_PROTO(std::vector<T>);
 template<typename T>
 MAKE_WORKER_PROTO(std::set<T>);
+template<typename... Ts>
+MAKE_WORKER_PROTO(std::tuple<Ts...>);
 
 template<typename K, typename V>
 #define X_ std::map<K, V>
diff --git a/unit-test-data/libstore/worker-protocol/content-address.bin b/unit-test-data/libstore/worker-protocol/content-address.bin
new file mode 100644
index 000000000000..8f14bcdb3e50
Binary files /dev/null and b/unit-test-data/libstore/worker-protocol/content-address.bin differ
diff --git a/unit-test-data/libstore/worker-protocol/derived-path.bin b/unit-test-data/libstore/worker-protocol/derived-path.bin
new file mode 100644
index 000000000000..bb1a81ac6d09
Binary files /dev/null and b/unit-test-data/libstore/worker-protocol/derived-path.bin differ
diff --git a/unit-test-data/libstore/worker-protocol/store-path.bin b/unit-test-data/libstore/worker-protocol/store-path.bin
new file mode 100644
index 000000000000..3fc05f2981d3
Binary files /dev/null and b/unit-test-data/libstore/worker-protocol/store-path.bin differ
diff --git a/unit-test-data/libstore/worker-protocol/string.bin b/unit-test-data/libstore/worker-protocol/string.bin
new file mode 100644
index 000000000000..aa7b5a604745
Binary files /dev/null and b/unit-test-data/libstore/worker-protocol/string.bin differ