Turn derivation unit tests into unit characterization tests

The brings a number of advantages, including:

- Easier to update test data if design changes (and I do think our
  derivation JSON is not yet complaint with the guidelines).

- Easier to reuse test data in other implementations, inching closer to
  compliance tests for Nix *the concept* rather than any one
  implementation.

src/libstore/tests/characterization.hh

@@ -20,4 +20,9 @@ static bool testAccept() {
     return getEnv("_NIX_TEST_ACCEPT") == "1";
 }
 
+constexpr std::string_view cannotReadGoldenMaster =
+    "Cannot read golden master because another test is also updating it";
+
+constexpr std::string_view updatingGoldenMaster =
+    "Updating golden master";
 }

src/libstore/tests/common-protocol.cc

@@ -24,14 +24,14 @@ public:
     {
         if (testAccept())
         {
-            GTEST_SKIP() << "Cannot read golden master because another test is also updating it";
+            GTEST_SKIP() << cannotReadGoldenMaster;
         }
         else
         {
-            auto expected = readFile(goldenMaster(testStem));
+            auto encoded = readFile(goldenMaster(testStem));
 
             T got = ({
-                StringSource from { expected };
+                StringSource from { encoded };
                 CommonProto::Serialise<T>::read(
                     *store,
                     CommonProto::ReadConn { .from = from });
@@ -59,7 +59,7 @@ public:
         {
             createDirs(dirOf(file));
             writeFile(file, to.s);
-            GTEST_SKIP() << "Updating golden master";
+            GTEST_SKIP() << updatingGoldenMaster;
         }
         else
         {

src/libstore/tests/derivation.cc

@@ -5,9 +5,12 @@
 #include "derivations.hh"
 
 #include "tests/libstore.hh"
+#include "tests/characterization.hh"
 
 namespace nix {
 
+using nlohmann::json;
+
 class DerivationTest : public LibStoreTest
 {
 public:
@@ -16,6 +19,12 @@ public:
      * to worry about race conditions if the tests run concurrently.
      */
     ExperimentalFeatureSettings mockXpSettings;
+
+    Path unitTestData = getUnitTestData() + "/libstore/derivation";
+
+    Path goldenMaster(std::string_view testStem) {
+        return unitTestData + "/" + testStem;
+    }
 };
 
 class CaDerivationTest : public DerivationTest
@@ -46,7 +55,7 @@ TEST_F(DerivationTest, BadATerm_version) {
     ASSERT_THROW(
         parseDerivation(
             *store,
-            R"(DrvWithVersion("invalid-version",[],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",["cat","dog"])],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")]))",
+            readFile(goldenMaster("bad-version.drv")),
             "whatever",
             mockXpSettings),
         FormatError);
@@ -56,50 +65,61 @@ TEST_F(DynDerivationTest, BadATerm_oldVersionDynDeps) {
     ASSERT_THROW(
         parseDerivation(
             *store,
-            R"(Derive([],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",(["cat","dog"],[("cat",["kitten"]),("goose",["gosling"])]))],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")]))",
+            readFile(goldenMaster("bad-old-version-dyn-deps.drv")),
             "dyn-dep-derivation",
             mockXpSettings),
         FormatError);
 }
 
-#define TEST_JSON(FIXTURE, NAME, STR, VAL, DRV_NAME, OUTPUT_NAME) \
+#define TEST_JSON(FIXTURE, NAME, VAL, DRV_NAME, OUTPUT_NAME)              \
-    TEST_F(FIXTURE, DerivationOutput_ ## NAME ## _to_json) {    \
-        using nlohmann::literals::operator "" _json;           \
-        ASSERT_EQ(                                             \
-            STR ## _json,                                      \
-            (DerivationOutput { VAL }).toJSON(                 \
-                *store,                                        \
-                DRV_NAME,                                      \
-                OUTPUT_NAME));                                 \
-    }                                                          \
-                                                               \
     TEST_F(FIXTURE, DerivationOutput_ ## NAME ## _from_json) {            \
-        using nlohmann::literals::operator "" _json;           \
+        if (testAccept())                                                 \
-        ASSERT_EQ(                                             \
+        {                                                                 \
-            DerivationOutput { VAL },                          \
+            GTEST_SKIP() << cannotReadGoldenMaster;                       \
-            DerivationOutput::fromJSON(                        \
+        }                                                                 \
+        else                                                              \
+        {                                                                 \
+            auto encoded = json::parse(                                   \
+                readFile(goldenMaster("output-" #NAME ".json")));         \
+            DerivationOutput got = DerivationOutput::fromJSON(            \
                 *store,                                                   \
                 DRV_NAME,                                                 \
                 OUTPUT_NAME,                                              \
-                STR ## _json,                                  \
+                encoded,                                                  \
-                mockXpSettings));                              \
+                mockXpSettings);                                          \
+            DerivationOutput expected { VAL };                            \
+            ASSERT_EQ(got, expected);                                     \
+        }                                                                 \
+    }                                                                     \
+                                                                          \
+    TEST_F(FIXTURE, DerivationOutput_ ## NAME ## _to_json) {              \
+        auto file = goldenMaster("output-" #NAME ".json");                \
+                                                                          \
+        json got = DerivationOutput { VAL }.toJSON(                       \
+            *store,                                                       \
+            DRV_NAME,                                                     \
+            OUTPUT_NAME);                                                 \
+                                                                          \
+        if (testAccept())                                                 \
+        {                                                                 \
+            createDirs(dirOf(file));                                      \
+            writeFile(file, got.dump(2) + "\n");                          \
+            GTEST_SKIP() << updatingGoldenMaster;                         \
+        }                                                                 \
+        else                                                              \
+        {                                                                 \
+            auto expected = json::parse(readFile(file));                  \
+            ASSERT_EQ(got, expected);                                     \
+        }                                                                 \
     }
 
 TEST_JSON(DerivationTest, inputAddressed,
-    R"({
-        "path": "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-drv-name-output-name"
-    })",
     (DerivationOutput::InputAddressed {
         .path = store->parseStorePath("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-drv-name-output-name"),
     }),
     "drv-name", "output-name")
 
 TEST_JSON(DerivationTest, caFixedFlat,
-    R"({
-        "hashAlgo": "sha256",
-        "hash": "894517c9163c896ec31a2adbd33c0681fd5f45b2c0ef08a64c92a03fb97f390f",
-        "path": "/nix/store/rhcg9h16sqvlbpsa6dqm57sbr2al6nzg-drv-name-output-name"
-    })",
     (DerivationOutput::CAFixed {
         .ca = {
             .method = FileIngestionMethod::Flat,
@@ -109,11 +129,6 @@ TEST_JSON(DerivationTest, caFixedFlat,
     "drv-name", "output-name")
 
 TEST_JSON(DerivationTest, caFixedNAR,
-    R"({
-        "hashAlgo": "r:sha256",
-        "hash": "894517c9163c896ec31a2adbd33c0681fd5f45b2c0ef08a64c92a03fb97f390f",
-        "path": "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-drv-name-output-name"
-    })",
     (DerivationOutput::CAFixed {
         .ca = {
             .method = FileIngestionMethod::Recursive,
@@ -123,11 +138,6 @@ TEST_JSON(DerivationTest, caFixedNAR,
     "drv-name", "output-name")
 
 TEST_JSON(DynDerivationTest, caFixedText,
-    R"({
-        "hashAlgo": "text:sha256",
-        "hash": "894517c9163c896ec31a2adbd33c0681fd5f45b2c0ef08a64c92a03fb97f390f",
-        "path": "/nix/store/6s1zwabh956jvhv4w9xcdb5jiyanyxg1-drv-name-output-name"
-    })",
     (DerivationOutput::CAFixed {
         .ca = {
             .hash = Hash::parseAnyPrefixed("sha256-iUUXyRY8iW7DGirb0zwGgf1fRbLA7wimTJKgP7l/OQ8="),
@@ -136,9 +146,6 @@ TEST_JSON(DynDerivationTest, caFixedText,
     "drv-name", "output-name")
 
 TEST_JSON(CaDerivationTest, caFloating,
-    R"({
-        "hashAlgo": "r:sha256"
-    })",
     (DerivationOutput::CAFloating {
         .method = FileIngestionMethod::Recursive,
         .hashType = htSHA256,
@@ -146,15 +153,10 @@ TEST_JSON(CaDerivationTest, caFloating,
     "drv-name", "output-name")
 
 TEST_JSON(DerivationTest, deferred,
-    R"({ })",
     DerivationOutput::Deferred { },
     "drv-name", "output-name")
 
 TEST_JSON(ImpureDerivationTest, impure,
-    R"({
-        "hashAlgo": "r:sha256",
-        "impure": true
-    })",
     (DerivationOutput::Impure {
         .method = FileIngestionMethod::Recursive,
         .hashType = htSHA256,
@@ -163,43 +165,79 @@ TEST_JSON(ImpureDerivationTest, impure,
 
 #undef TEST_JSON
 
-#define TEST_JSON(FIXTURE, NAME, STR, VAL)                       \
+#define TEST_JSON(FIXTURE, NAME, VAL)                                     \
-    TEST_F(FIXTURE, Derivation_ ## NAME ## _to_json) {           \
+    TEST_F(FIXTURE, Derivation_ ## NAME ## _from_json) {                  \
-        using nlohmann::literals::operator "" _json;             \
+        if (testAccept())                                                 \
-        ASSERT_EQ(                                               \
+        {                                                                 \
-            STR ## _json,                                        \
+            GTEST_SKIP() << cannotReadGoldenMaster;                       \
-            (VAL).toJSON(*store));                               \
+        }                                                                 \
+        else                                                              \
+        {                                                                 \
+            auto encoded = json::parse(                                   \
+                readFile(goldenMaster( #NAME ".json")));                  \
+            Derivation expected { VAL };                                  \
+            Derivation got = Derivation::fromJSON(                        \
+                *store,                                                   \
+                encoded,                                                  \
+                mockXpSettings);                                          \
+            ASSERT_EQ(got, expected);                                     \
+        }                                                                 \
     }                                                                     \
                                                                           \
-    TEST_F(FIXTURE, Derivation_ ## NAME ## _from_json) {         \
+    TEST_F(FIXTURE, Derivation_ ## NAME ## _to_json) {                    \
-        using nlohmann::literals::operator "" _json;             \
+        auto file = goldenMaster( #NAME ".json");                         \
-        ASSERT_EQ(                                               \
+                                                                          \
-            (VAL),                                               \
+        json got = Derivation { VAL }.toJSON(*store);                     \
-            Derivation::fromJSON(                                \
+                                                                          \
-                *store,                                          \
+        if (testAccept())                                                 \
-                STR ## _json,                                    \
+        {                                                                 \
-                mockXpSettings));                                \
+            createDirs(dirOf(file));                                      \
+            writeFile(file, got.dump(2) + "\n");                          \
+            GTEST_SKIP() << updatingGoldenMaster;                         \
+        }                                                                 \
+        else                                                              \
+        {                                                                 \
+            auto expected = json::parse(readFile(file));                  \
+            ASSERT_EQ(got, expected);                                     \
+        }                                                                 \
     }
 
-#define TEST_ATERM(FIXTURE, NAME, STR, VAL, DRV_NAME)            \
+#define TEST_ATERM(FIXTURE, NAME, VAL, DRV_NAME)                          \
-    TEST_F(FIXTURE, Derivation_ ## NAME ## _to_aterm) {          \
-        ASSERT_EQ(                                               \
-            STR,                                                 \
-            (VAL).unparse(*store, false));                       \
-    }                                                            \
-                                                                 \
     TEST_F(FIXTURE, Derivation_ ## NAME ## _from_aterm) {                 \
-        auto parsed = parseDerivation(                           \
+        if (testAccept())                                                 \
+        {                                                                 \
+            GTEST_SKIP() << cannotReadGoldenMaster;                       \
+        }                                                                 \
+        else                                                              \
+        {                                                                 \
+            auto encoded = readFile(goldenMaster( #NAME ".drv"));         \
+            Derivation expected { VAL };                                  \
+            auto got = parseDerivation(                                   \
                 *store,                                                   \
-            STR,                                                 \
+                std::move(encoded),                                       \
                 DRV_NAME,                                                 \
                 mockXpSettings);                                          \
-        ASSERT_EQ(                                               \
+            ASSERT_EQ(got.toJSON(*store), expected.toJSON(*store)) ;      \
-            (VAL).toJSON(*store),                                \
+            ASSERT_EQ(got, expected);                                     \
-            parsed.toJSON(*store));                              \
+        }                                                                 \
-        ASSERT_EQ(                                               \
+    }                                                                     \
-            (VAL),                                               \
+                                                                          \
-            parsed);                                             \
+    TEST_F(FIXTURE, Derivation_ ## NAME ## _to_aterm) {                   \
+        auto file = goldenMaster( #NAME ".drv");                          \
+                                                                          \
+        auto got = (VAL).unparse(*store, false);                          \
+                                                                          \
+        if (testAccept())                                                 \
+        {                                                                 \
+            createDirs(dirOf(file));                                      \
+            writeFile(file, got);                                         \
+            GTEST_SKIP() << updatingGoldenMaster;                         \
+        }                                                                 \
+        else                                                              \
+        {                                                                 \
+            auto expected = readFile(file);                               \
+            ASSERT_EQ(got, expected);                                     \
+        }                                                                 \
     }
 
 Derivation makeSimpleDrv(const Store & store) {
@@ -236,36 +274,9 @@ Derivation makeSimpleDrv(const Store & store) {
     return drv;
 }
 
-TEST_JSON(DerivationTest, simple,
+TEST_JSON(DerivationTest, simple, makeSimpleDrv(*store))
-    R"({
-      "name": "simple-derivation",
-      "inputSrcs": [
-        "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"
-      ],
-      "inputDrvs": {
-        "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv": {
-          "dynamicOutputs": {},
-          "outputs": [
-            "cat",
-            "dog"
-          ]
-        }
-      },
-      "system": "wasm-sel4",
-      "builder": "foo",
-      "args": [
-        "bar",
-        "baz"
-      ],
-      "env": {
-        "BIG_BAD": "WOLF"
-      },
-      "outputs": {}
-    })",
-    makeSimpleDrv(*store))
 
 TEST_ATERM(DerivationTest, simple,
-    R"(Derive([],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",["cat","dog"])],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")]))",
     makeSimpleDrv(*store),
     "simple-derivation")
 
@@ -321,45 +332,9 @@ Derivation makeDynDepDerivation(const Store & store) {
     return drv;
 }
 
-TEST_JSON(DynDerivationTest, dynDerivationDeps,
+TEST_JSON(DynDerivationTest, dynDerivationDeps, makeDynDepDerivation(*store))
-    R"({
-      "name": "dyn-dep-derivation",
-      "inputSrcs": [
-        "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"
-      ],
-      "inputDrvs": {
-        "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv": {
-          "dynamicOutputs": {
-            "cat": {
-              "dynamicOutputs": {},
-              "outputs": ["kitten"]
-            },
-            "goose": {
-              "dynamicOutputs": {},
-              "outputs": ["gosling"]
-            }
-          },
-          "outputs": [
-            "cat",
-            "dog"
-          ]
-        }
-      },
-      "system": "wasm-sel4",
-      "builder": "foo",
-      "args": [
-        "bar",
-        "baz"
-      ],
-      "env": {
-        "BIG_BAD": "WOLF"
-      },
-      "outputs": {}
-    })",
-    makeDynDepDerivation(*store))
 
 TEST_ATERM(DynDerivationTest, dynDerivationDeps,
-    R"(DrvWithVersion("xp-dyn-drv",[],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",(["cat","dog"],[("cat",["kitten"]),("goose",["gosling"])]))],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")]))",
     makeDynDepDerivation(*store),
     "dyn-dep-derivation")
 

src/libstore/tests/protocol.hh

@@ -29,7 +29,7 @@ public:
     {
         if (testAccept())
         {
-            GTEST_SKIP() << "Cannot read golden master because another test is also updating it";
+            GTEST_SKIP() << cannotReadGoldenMaster;
         }
         else
         {
@@ -70,7 +70,7 @@ public:
         {
             createDirs(dirOf(file));
             writeFile(file, to.s);
-            GTEST_SKIP() << "Updating golden master";
+            GTEST_SKIP() << updatingGoldenMaster;
         }
         else
         {

unit-test-data/libstore/derivation/bad-old-version-dyn-deps.drv

@@ -0,0 +1 @@
+Derive([],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",(["cat","dog"],[("cat",["kitten"]),("goose",["gosling"])]))],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")])

unit-test-data/libstore/derivation/bad-version.drv

@@ -0,0 +1 @@
+DrvWithVersion("invalid-version",[],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",["cat","dog"])],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")])

unit-test-data/libstore/derivation/dynDerivationDeps.drv

@@ -0,0 +1 @@
+DrvWithVersion("xp-dyn-drv",[],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",(["cat","dog"],[("cat",["kitten"]),("goose",["gosling"])]))],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")])

unit-test-data/libstore/derivation/dynDerivationDeps.json

@@ -0,0 +1,38 @@
+{
+  "args": [
+    "bar",
+    "baz"
+  ],
+  "builder": "foo",
+  "env": {
+    "BIG_BAD": "WOLF"
+  },
+  "inputDrvs": {
+    "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv": {
+      "dynamicOutputs": {
+        "cat": {
+          "dynamicOutputs": {},
+          "outputs": [
+            "kitten"
+          ]
+        },
+        "goose": {
+          "dynamicOutputs": {},
+          "outputs": [
+            "gosling"
+          ]
+        }
+      },
+      "outputs": [
+        "cat",
+        "dog"
+      ]
+    }
+  },
+  "inputSrcs": [
+    "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"
+  ],
+  "name": "dyn-dep-derivation",
+  "outputs": {},
+  "system": "wasm-sel4"
+}

unit-test-data/libstore/derivation/output-caFixedFlat.json

@@ -0,0 +1,5 @@
+{
+  "hash": "894517c9163c896ec31a2adbd33c0681fd5f45b2c0ef08a64c92a03fb97f390f",
+  "hashAlgo": "sha256",
+  "path": "/nix/store/rhcg9h16sqvlbpsa6dqm57sbr2al6nzg-drv-name-output-name"
+}

unit-test-data/libstore/derivation/output-caFixedNAR.json

@@ -0,0 +1,5 @@
+{
+  "hash": "894517c9163c896ec31a2adbd33c0681fd5f45b2c0ef08a64c92a03fb97f390f",
+  "hashAlgo": "r:sha256",
+  "path": "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-drv-name-output-name"
+}

unit-test-data/libstore/derivation/output-caFixedText.json

@@ -0,0 +1,5 @@
+{
+  "hash": "894517c9163c896ec31a2adbd33c0681fd5f45b2c0ef08a64c92a03fb97f390f",
+  "hashAlgo": "text:sha256",
+  "path": "/nix/store/6s1zwabh956jvhv4w9xcdb5jiyanyxg1-drv-name-output-name"
+}

unit-test-data/libstore/derivation/output-caFloating.json

@@ -0,0 +1,3 @@
+{
+  "hashAlgo": "r:sha256"
+}

unit-test-data/libstore/derivation/output-deferred.json

@@ -0,0 +1 @@
+{}

unit-test-data/libstore/derivation/output-impure.json

@@ -0,0 +1,4 @@
+{
+  "hashAlgo": "r:sha256",
+  "impure": true
+}

unit-test-data/libstore/derivation/output-inputAddressed.json

@@ -0,0 +1,3 @@
+{
+  "path": "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-drv-name-output-name"
+}

unit-test-data/libstore/derivation/simple.drv

@@ -0,0 +1 @@
+Derive([],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",["cat","dog"])],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")])

unit-test-data/libstore/derivation/simple.json

@@ -0,0 +1,25 @@
+{
+  "args": [
+    "bar",
+    "baz"
+  ],
+  "builder": "foo",
+  "env": {
+    "BIG_BAD": "WOLF"
+  },
+  "inputDrvs": {
+    "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv": {
+      "dynamicOutputs": {},
+      "outputs": [
+        "cat",
+        "dog"
+      ]
+    }
+  },
+  "inputSrcs": [
+    "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"
+  ],
+  "name": "simple-derivation",
+  "outputs": {},
+  "system": "wasm-sel4"
+}