JSON impl and Schema for DummyStore

This is the "keystone" that puts most of the other store-layer JSON
formats together.

Also, add some documentation for JSON testing.

src/libstore-tests/dummy-store.cc

@@ -1,11 +1,32 @@
 #include <gtest/gtest.h>
+#include <nlohmann/json.hpp>
 
+#include "nix/util/memory-source-accessor.hh"
 #include "nix/store/dummy-store-impl.hh"
 #include "nix/store/globals.hh"
 #include "nix/store/realisation.hh"
 
+#include "nix/util/tests/json-characterization.hh"
+
 namespace nix {
 
+class DummyStoreTest : public virtual CharacterizationTest
+{
+    std::filesystem::path unitTestData = getUnitTestData() / "dummy-store";
+
+public:
+
+    std::filesystem::path goldenMaster(std::string_view testStem) const override
+    {
+        return unitTestData / testStem;
+    }
+
+    static void SetUpTestSuite()
+    {
+        initLibStore(false);
+    }
+};
+
 TEST(DummyStore, realisation_read)
 {
     initLibStore(/*loadConfig=*/false);
@@ -35,4 +56,96 @@ TEST(DummyStore, realisation_read)
     EXPECT_EQ(*value2, value);
 }
 
+/* ----------------------------------------------------------------------------
+ * JSON
+ * --------------------------------------------------------------------------*/
+
+using nlohmann::json;
+
+struct DummyStoreJsonTest : DummyStoreTest,
+                            JsonCharacterizationTest<ref<DummyStore>>,
+                            ::testing::WithParamInterface<std::pair<std::string_view, ref<DummyStore>>>
+{};
+
+TEST_P(DummyStoreJsonTest, from_json)
+{
+    auto & [name, expected] = GetParam();
+    using namespace nlohmann;
+    /* Cannot use `readJsonTest` because need to dereference the stores
+       for equality. */
+    readTest(Path{name} + ".json", [&](const auto & encodedRaw) {
+        auto encoded = json::parse(encodedRaw);
+        ref<DummyStore> decoded = adl_serializer<ref<DummyStore>>::from_json(encoded);
+        ASSERT_EQ(*decoded, *expected);
+    });
+}
+
+TEST_P(DummyStoreJsonTest, to_json)
+{
+    auto & [name, value] = GetParam();
+    writeJsonTest(name, value);
+}
+
+INSTANTIATE_TEST_SUITE_P(DummyStoreJSON, DummyStoreJsonTest, [] {
+    initLibStore(false);
+    auto writeCfg = make_ref<DummyStore::Config>(DummyStore::Config::Params{});
+    writeCfg->readOnly = false;
+    return ::testing::Values(
+        std::pair{
+            "empty",
+            make_ref<DummyStore::Config>(DummyStore::Config::Params{})->openDummyStore(),
+        },
+        std::pair{
+            "one-flat-file",
+            [&] {
+                auto store = writeCfg->openDummyStore();
+                store->addToStore(
+                    "my-file",
+                    SourcePath{
+                        [] {
+                            auto sc = make_ref<MemorySourceAccessor>();
+                            sc->root = MemorySourceAccessor::File{MemorySourceAccessor::File::Regular{
+                                .executable = false,
+                                .contents = "asdf",
+                            }};
+                            return sc;
+                        }(),
+                    },
+                    ContentAddressMethod::Raw::NixArchive,
+                    HashAlgorithm::SHA256);
+                return store;
+            }(),
+        },
+        std::pair{
+            "one-derivation",
+            [&] {
+                auto store = writeCfg->openDummyStore();
+                Derivation drv;
+                drv.name = "foo";
+                store->writeDerivation(drv);
+                return store;
+            }(),
+        },
+        std::pair{
+            "one-realisation",
+            [&] {
+                auto store = writeCfg->openDummyStore();
+                store->buildTrace.insert_or_assign(
+                    Hash::parseExplicitFormatUnprefixed(
+                        "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+                        HashAlgorithm::SHA256,
+                        HashFormat::Base16),
+                    std::map<std::string, UnkeyedRealisation>{
+                        {
+                            "out",
+                            UnkeyedRealisation{
+                                .outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
+                            },
+                        },
+                    });
+                return store;
+            }(),
+        });
+}());
+
 } // namespace nix