@reventlessdev/reventless-seed 1.0.0-alpha.2 → 1.0.0-alpha.21

package/lib/bs/tests/Seed_PromptTest.res

@@ -0,0 +1,55 @@
+open JestGlobals
+
+// `isAffirmative` is the one vocabulary for "yes", shared by a typed `[y/N]`
+// reply and by the env var that stands in for it on a run with no terminal.
+//
+// It exists because those two drifted: the prompt took `y`, the env var took
+// only the literals `1` and `yes`, and every other value — `y` included, and an
+// explicit `no` with it — fell through to the interactive branch, which throws
+// when there is no TTY. So the variable that exists to make the tool
+// non-interactive had two spellings that worked and a crash for the rest.
+//
+// The suite is written around the shape of that bug rather than around the
+// function: what must confirm, what must decline, and — the case that actually
+// broke CI — that declining is a normal answer and not a fall-through.
+
+describe("Seed_Prompt.isAffirmative:", () => {
+  testSync("takes the three spellings of yes", () => {
+    ["y", "yes", "1"]->Array.forEach(v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true))
+  })
+
+  // A prompt that prints `[y/N]` invites a capital as readily as a lowercase
+  // one, and an env var set by hand is written however the hand felt.
+  testSync("ignores case, so Y and YES answer as y does", () => {
+    ["Y", "Yes", "YES"]->Array.forEach(v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true))
+  })
+
+  testSync("ignores surrounding space", () => {
+    [" y", "y ", "  yes  "]->Array.forEach(
+      v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true),
+    )
+  })
+
+  // The half that matters most: every one of these is an ANSWER, and the caller
+  // reads it as "no". None may be mistaken for "nothing was said", which is what
+  // sent the old code to a prompt it could not open.
+  testSync("declines every spelling of no, capital N included", () => {
+    ["n", "N", "no", "No", "NO"]->Array.forEach(
+      v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false),
+    )
+  })
+
+  testSync("declines anything it does not recognise", () => {
+    ["", "  ", "0", "true", "yep", "y.", "yesplease", "affirmative"]->Array.forEach(
+      v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false),
+    )
+  })
+
+  // `true` is deliberately absent from the vocabulary above. Named here so that
+  // adding it is a decision someone takes against a failing test rather than a
+  // kindness someone slips in: the prompt this stands in for asks `[y/N]`, and a
+  // reply nobody would type at that prompt should not work around it either.
+  testSync("does not quietly grow a fourth spelling", () => {
+    expect(Seed_Prompt.isAffirmative("true"))->Expect.toBe(false)
+  })
+})

package/lib/bs/tests/Seed_PromptTest.res.mjs

@@ -0,0 +1,63 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Seed_Prompt$ReventlessSeed from "../src/Seed_Prompt.res.mjs";
+
+globalThis.describe("Seed_Prompt.isAffirmative:", () => {
+  globalThis.test("takes the three spellings of yes", () => {
+    [
+      "y",
+      "yes",
+      "1"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(true);
+    });
+  });
+  globalThis.test("ignores case, so Y and YES answer as y does", () => {
+    [
+      "Y",
+      "Yes",
+      "YES"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(true);
+    });
+  });
+  globalThis.test("ignores surrounding space", () => {
+    [
+      " y",
+      "y ",
+      "  yes  "
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(true);
+    });
+  });
+  globalThis.test("declines every spelling of no, capital N included", () => {
+    [
+      "n",
+      "N",
+      "no",
+      "No",
+      "NO"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(false);
+    });
+  });
+  globalThis.test("declines anything it does not recognise", () => {
+    [
+      "",
+      "  ",
+      "0",
+      "true",
+      "yep",
+      "y.",
+      "yesplease",
+      "affirmative"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(false);
+    });
+  });
+  globalThis.test("does not quietly grow a fourth spelling", () => {
+    globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative("true")).toBe(false);
+  });
+});
+
+/*  Not a pure module */

package/lib/bs/tests/Seed_RandomTest.res

@@ -0,0 +1,200 @@
+open JestGlobals
+
+// `Seed_Random` exists so that two seed runs against a fresh store produce the
+// same data — that is what makes a seeded store usable as a screenshot baseline
+// or a comparison target. Its correctness is therefore not "looks random" but
+// "repeats exactly, and stays inside the bounds it advertises".
+//
+// The suite is written around that: every case below fails for a generator that
+// is subtly non-reproducible or that walks out of its range, and none of them
+// would notice a change of algorithm that kept both properties.
+
+describe("Seed_Random:", () => {
+  let take = (~seed, ~n) => {
+    let r = Seed_Random.make(~seed)
+    Array.make(~length=n, 0.0)->Array.map(_ => Seed_Random.float(r))
+  }
+
+  describe("reproducibility — the reason this module exists:", () => {
+    testSync(
+      "the same seed replays the same sequence",
+      () => expect(take(~seed=42, ~n=25))->toEqual(take(~seed=42, ~n=25)),
+    )
+
+    // Without this, a generator that returned a constant would satisfy the
+    // case above and nothing else in the suite would catch it.
+    testSync(
+      "different seeds diverge",
+      () => expect(take(~seed=42, ~n=25) == take(~seed=43, ~n=25))->toBe(false),
+    )
+
+    testSync(
+      "a fresh generator does not continue the previous one",
+      () => {
+        let r = Seed_Random.make(~seed=7)
+        let first = Seed_Random.float(r)
+        let _ = Seed_Random.float(r)
+        expect(Seed_Random.float(Seed_Random.make(~seed=7)))->toEqual(first)
+      },
+    )
+  })
+
+  describe("float stays a unit interval:", () => {
+    // mulberry32's last step is a signed 32-bit value folded back to unsigned.
+    // Get that fold wrong and roughly half the draws come out negative, which
+    // every consumer below (int, pick, sampleWeighted) silently mis-scales.
+    testSync(
+      "every draw is in [0, 1)",
+      () => expect(take(~seed=99, ~n=500)->Array.every(f => f >= 0.0 && f < 1.0))->toBe(true),
+    )
+
+    testSync(
+      "and the draws are not all the same value",
+      () => {
+        let draws = take(~seed=99, ~n=100)
+        expect(draws->Array.some(f => f != draws->Array.getUnsafe(0)))->toBe(true)
+      },
+    )
+  })
+
+  describe("int is inclusive on both ends, as documented:", () => {
+    let draws = (~min, ~max, ~n) => {
+      let r = Seed_Random.make(~seed=5)
+      Array.make(~length=n, 0)->Array.map(_ => Seed_Random.int(r, ~min, ~max))
+    }
+
+    testSync(
+      "never escapes the range",
+      () => expect(draws(~min=3, ~max=7, ~n=500)->Array.every(i => i >= 3 && i <= 7))->toBe(true),
+    )
+
+    // The documented contract is "inclusive on both ends"; an off-by-one in the
+    // `max - min + 1` scaling shows up as a bound that is never drawn.
+    testSync(
+      "reaches both bounds",
+      () => {
+        let d = draws(~min=3, ~max=7, ~n=500)
+        expect((d->Array.includes(3), d->Array.includes(7)))->toEqual((true, true))
+      },
+    )
+
+    testSync(
+      "a single-value range is that value",
+      () => expect(draws(~min=4, ~max=4, ~n=10)->Array.every(i => i == 4))->toBe(true),
+    )
+  })
+
+  describe("pick:", () => {
+    testSync(
+      "returns None for an empty array",
+      () => expect(Seed_Random.make(~seed=1)->Seed_Random.pick([]))->toEqual(None),
+    )
+
+    testSync(
+      "always lands on a member",
+      () => {
+        let r = Seed_Random.make(~seed=2)
+        let xs = ["a", "b", "c", "d"]
+        let hits =
+          Array.make(~length=200, "")->Array.map(_ => r->Seed_Random.pickOr(~fallback="MISS", xs))
+        expect(hits->Array.every(h => xs->Array.includes(h)))->toBe(true)
+      },
+    )
+
+    testSync(
+      "pickOr falls back only when there is nothing to pick",
+      () =>
+        expect(Seed_Random.make(~seed=3)->Seed_Random.pickOr(~fallback="fallback", []))->toBe(
+          "fallback",
+        ),
+    )
+  })
+
+  describe("sampleWeighted is without replacement:", () => {
+    let equal = xs => xs->Array.map(x => (x, 1.0))
+
+    // The documented shuffle use: equal weights, count = length. If sampling
+    // ever replaced instead of removing, duplicates would appear here.
+    testSync(
+      "count = length yields a permutation, not a multiset",
+      () => {
+        let xs = ["a", "b", "c", "d", "e"]
+        let out = Seed_Random.make(~seed=11)->Seed_Random.sampleWeighted(equal(xs), ~count=5)
+        let sorted = out->Array.toSorted(String.compare)
+        expect((out->Array.length, sorted))->toEqual((5, ["a", "b", "c", "d", "e"]))
+      },
+    )
+
+    testSync(
+      "count < length returns exactly count distinct items",
+      () => {
+        let xs = ["a", "b", "c", "d", "e"]
+        let out = Seed_Random.make(~seed=12)->Seed_Random.sampleWeighted(equal(xs), ~count=3)
+        let distinct = Set.fromArray(out)->Set.size
+        expect((out->Array.length, distinct))->toEqual((3, 3))
+      },
+    )
+
+    testSync(
+      "count > length clamps to the pool",
+      () =>
+        expect(
+          Seed_Random.make(~seed=13)
+          ->Seed_Random.sampleWeighted(equal(["a", "b"]), ~count=99)
+          ->Array.length,
+        )->toBe(2),
+    )
+
+    testSync(
+      "a zero-weight entry is never chosen while others remain",
+      () => {
+        let out =
+          Seed_Random.make(~seed=14)->Seed_Random.sampleWeighted(
+            [("never", 0.0), ("a", 1.0), ("b", 1.0)],
+            ~count=2,
+          )
+        expect(out->Array.includes("never"))->toBe(false)
+      },
+    )
+
+    testSync(
+      "is reproducible for a given seed",
+      () => {
+        let run = () =>
+          Seed_Random.make(~seed=15)->Seed_Random.sampleWeighted(
+            equal(["a", "b", "c", "d", "e", "f"]),
+            ~count=4,
+          )
+        expect(run())->toEqual(run())
+      },
+    )
+  })
+
+  describe("zipfWeights skews toward the head:", () => {
+    let weights = Seed_Random.zipfWeights(["a", "b", "c", "d", "e"], ~exponent=1.1)
+
+    testSync(
+      "keeps every item, in order",
+      () => expect(weights->Array.map(((item, _)) => item))->toEqual(["a", "b", "c", "d", "e"]),
+    )
+
+    testSync(
+      "weight decreases monotonically with rank",
+      () => {
+        let ws = weights->Array.map(((_, w)) => w)
+        let decreasing =
+          ws->Array.everyWithIndex((w, i) => i == 0 || w < ws->Array.getUnsafe(i - 1))
+        expect(decreasing)->toBe(true)
+      },
+    )
+
+    testSync(
+      "the leader is clear — first outweighs last several times over",
+      () => {
+        let first = weights->Array.get(0)->Option.mapOr(0.0, ((_, w)) => w)
+        let last = weights->Array.get(4)->Option.mapOr(0.0, ((_, w)) => w)
+        expect(first > last *. 3.0)->toBe(true)
+      },
+    )
+  })
+})

package/lib/bs/tests/Seed_RandomTest.res.mjs

@@ -0,0 +1,208 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Seed_Random$ReventlessSeed from "../src/Seed_Random.res.mjs";
+
+globalThis.describe("Seed_Random:", () => {
+  let take = (seed, n) => {
+    let r = Seed_Random$ReventlessSeed.make(seed);
+    return Stdlib_Array.make(n, 0.0).map(param => Seed_Random$ReventlessSeed.float(r));
+  };
+  globalThis.describe("reproducibility — the reason this module exists:", () => {
+    globalThis.test("the same seed replays the same sequence", () => {
+      globalThis.expect(take(42, 25)).toEqual(take(42, 25));
+    });
+    globalThis.test("different seeds diverge", () => {
+      globalThis.expect(Primitive_object.equal(take(42, 25), take(43, 25))).toBe(false);
+    });
+    globalThis.test("a fresh generator does not continue the previous one", () => {
+      let r = Seed_Random$ReventlessSeed.make(7);
+      let first = Seed_Random$ReventlessSeed.float(r);
+      Seed_Random$ReventlessSeed.float(r);
+      globalThis.expect(Seed_Random$ReventlessSeed.float(Seed_Random$ReventlessSeed.make(7))).toEqual(first);
+    });
+  });
+  globalThis.describe("float stays a unit interval:", () => {
+    globalThis.test("every draw is in [0, 1)", () => {
+      globalThis.expect(take(99, 500).every(f => {
+        if (f >= 0.0) {
+          return f < 1.0;
+        } else {
+          return false;
+        }
+      })).toBe(true);
+    });
+    globalThis.test("and the draws are not all the same value", () => {
+      let draws = take(99, 100);
+      globalThis.expect(draws.some(f => f !== draws[0])).toBe(true);
+    });
+  });
+  globalThis.describe("int is inclusive on both ends, as documented:", () => {
+    let draws = (min, max, n) => {
+      let r = Seed_Random$ReventlessSeed.make(5);
+      return Stdlib_Array.make(n, 0).map(param => Seed_Random$ReventlessSeed.int(r, min, max));
+    };
+    globalThis.test("never escapes the range", () => {
+      globalThis.expect(draws(3, 7, 500).every(i => {
+        if (i >= 3) {
+          return i <= 7;
+        } else {
+          return false;
+        }
+      })).toBe(true);
+    });
+    globalThis.test("reaches both bounds", () => {
+      let d = draws(3, 7, 500);
+      globalThis.expect([
+        d.includes(3),
+        d.includes(7)
+      ]).toEqual([
+        true,
+        true
+      ]);
+    });
+    globalThis.test("a single-value range is that value", () => {
+      globalThis.expect(draws(4, 4, 10).every(i => i === 4)).toBe(true);
+    });
+  });
+  globalThis.describe("pick:", () => {
+    globalThis.test("returns None for an empty array", () => {
+      globalThis.expect(Seed_Random$ReventlessSeed.pick(Seed_Random$ReventlessSeed.make(1), [])).toEqual(undefined);
+    });
+    globalThis.test("always lands on a member", () => {
+      let r = Seed_Random$ReventlessSeed.make(2);
+      let xs = [
+        "a",
+        "b",
+        "c",
+        "d"
+      ];
+      let hits = Stdlib_Array.make(200, "").map(param => Seed_Random$ReventlessSeed.pickOr(r, "MISS", xs));
+      globalThis.expect(hits.every(h => xs.includes(h))).toBe(true);
+    });
+    globalThis.test("pickOr falls back only when there is nothing to pick", () => {
+      globalThis.expect(Seed_Random$ReventlessSeed.pickOr(Seed_Random$ReventlessSeed.make(3), "fallback", [])).toBe("fallback");
+    });
+  });
+  globalThis.describe("sampleWeighted is without replacement:", () => {
+    let equal = xs => xs.map(x => [
+      x,
+      1.0
+    ]);
+    globalThis.test("count = length yields a permutation, not a multiset", () => {
+      let xs = [
+        "a",
+        "b",
+        "c",
+        "d",
+        "e"
+      ];
+      let out = Seed_Random$ReventlessSeed.sampleWeighted(Seed_Random$ReventlessSeed.make(11), equal(xs), 5);
+      let sorted = out.toSorted(Primitive_string.compare);
+      globalThis.expect([
+        out.length,
+        sorted
+      ]).toEqual([
+        5,
+        [
+          "a",
+          "b",
+          "c",
+          "d",
+          "e"
+        ]
+      ]);
+    });
+    globalThis.test("count < length returns exactly count distinct items", () => {
+      let xs = [
+        "a",
+        "b",
+        "c",
+        "d",
+        "e"
+      ];
+      let out = Seed_Random$ReventlessSeed.sampleWeighted(Seed_Random$ReventlessSeed.make(12), equal(xs), 3);
+      let distinct = new Set(out).size;
+      globalThis.expect([
+        out.length,
+        distinct
+      ]).toEqual([
+        3,
+        3
+      ]);
+    });
+    globalThis.test("count > length clamps to the pool", () => {
+      globalThis.expect(Seed_Random$ReventlessSeed.sampleWeighted(Seed_Random$ReventlessSeed.make(13), equal([
+        "a",
+        "b"
+      ]), 99).length).toBe(2);
+    });
+    globalThis.test("a zero-weight entry is never chosen while others remain", () => {
+      let out = Seed_Random$ReventlessSeed.sampleWeighted(Seed_Random$ReventlessSeed.make(14), [
+        [
+          "never",
+          0.0
+        ],
+        [
+          "a",
+          1.0
+        ],
+        [
+          "b",
+          1.0
+        ]
+      ], 2);
+      globalThis.expect(out.includes("never")).toBe(false);
+    });
+    globalThis.test("is reproducible for a given seed", () => {
+      let run = () => Seed_Random$ReventlessSeed.sampleWeighted(Seed_Random$ReventlessSeed.make(15), equal([
+        "a",
+        "b",
+        "c",
+        "d",
+        "e",
+        "f"
+      ]), 4);
+      globalThis.expect(run()).toEqual(run());
+    });
+  });
+  globalThis.describe("zipfWeights skews toward the head:", () => {
+    let weights = Seed_Random$ReventlessSeed.zipfWeights([
+      "a",
+      "b",
+      "c",
+      "d",
+      "e"
+    ], 1.1);
+    globalThis.test("keeps every item, in order", () => {
+      globalThis.expect(weights.map(param => param[0])).toEqual([
+        "a",
+        "b",
+        "c",
+        "d",
+        "e"
+      ]);
+    });
+    globalThis.test("weight decreases monotonically with rank", () => {
+      let ws = weights.map(param => param[1]);
+      let decreasing = ws.every((w, i) => {
+        if (i === 0) {
+          return true;
+        } else {
+          return w < ws[i - 1 | 0];
+        }
+      });
+      globalThis.expect(decreasing).toBe(true);
+    });
+    globalThis.test("the leader is clear — first outweighs last several times over", () => {
+      let first = Stdlib_Option.mapOr(weights[0], 0.0, param => param[1]);
+      let last = Stdlib_Option.mapOr(weights[4], 0.0, param => param[1]);
+      globalThis.expect(first > last * 3.0).toBe(true);
+    });
+  });
+});
+
+/*  Not a pure module */

package/lib/bs/tests/Seed_UsersTest.res

@@ -0,0 +1,129 @@
+open JestGlobals
+
+// `.reventless/users.yaml` is hand-maintained and shared with the auth adapter,
+// so the seed reads it defensively: it must survive the comment blocks both
+// copies carry, must not reorder the accounts (the first one is the prompt's
+// default, so order IS the contract), and must never throw — a broken file costs
+// the menu, not the run.
+
+let document = `
+# Local dev users — a comment block like the real file carries.
+
+- username: admin
+  password: admin
+  groups: [Admin, Shopper]
+  userId: local-admin
+
+- username: shopper
+  password: Shopper-2026!
+  groups: [Shopper]
+
+- username: noGroups
+  password: pw
+`
+
+describe("Seed_Users.parseString:", () => {
+  testSync("reads every account, in the order the file defines them", () => {
+    let users = Seed_Users.parseString(document)
+    expect(users->Array.map(u => u.Seed_Users.username))->Expect.toEqual([
+      "admin",
+      "shopper",
+      "noGroups",
+    ])
+  })
+
+  testSync("carries the password beside the username", () => {
+    let users = Seed_Users.parseString(document)
+    expect(users->Array.map(u => u.Seed_Users.password))->Expect.toEqual([
+      "admin",
+      "Shopper-2026!",
+      "pw",
+    ])
+  })
+
+  testSync("keeps the groups, and reads a missing groups key as none", () => {
+    let users = Seed_Users.parseString(document)
+    expect(users->Array.map(u => u.Seed_Users.groups))->Expect.toEqual([
+      ["Admin", "Shopper"],
+      ["Shopper"],
+      [],
+    ])
+  })
+
+  // The half that was dropped, and the reason owner-scoped demo rows were keyed
+  // to ids nobody on a Cognito deployment holds: the file records the id the
+  // platform stamps, and reading it only for a password threw that away.
+  //
+  // Absent stays absent rather than defaulting to the username — a local file
+  // may omit it and let the auth adapter default it, and an AWS file records a
+  // sub no default could invent. Guessing here would look like an answer.
+  testSync("keeps the userId an entry declares, and reads a missing one as absent", () => {
+    let users = Seed_Users.parseString(document)
+    expect(users->Array.map(u => u.Seed_Users.userId))->Expect.toEqual([
+      Some("local-admin"),
+      None,
+      None,
+    ])
+  })
+
+  // An entry half-written by hand is the likely flaw in this file. Dropping it
+  // keeps the other accounts selectable; failing the parse would not.
+  testSync("skips an entry that names no password", () => {
+    let users = Seed_Users.parseString(`
+- username: admin
+  password: admin
+- username: halfWritten
+  groups: [Shopper]
+`)
+    expect(users->Array.map(u => u.Seed_Users.username))->Expect.toEqual(["admin"])
+  })
+
+  testSync("yields no accounts for a document that is not a list", () => {
+    expect(Seed_Users.parseString("users: {}")->Array.length)->Expect.toBe(0)
+  })
+
+  // The whole point of returning accounts rather than raising: the caller falls
+  // back to prompting, and it can only do that if nothing here escapes.
+  testSync("yields no accounts for malformed YAML instead of throwing", () => {
+    expect(Seed_Users.parseString("- username: [unclosed")->Array.length)->Expect.toBe(0)
+  })
+})
+
+describe("Seed_Users.load:", () => {
+  testSync("is silent about a file that is not there", () => {
+    expect(Seed_Users.load(~path="/nonexistent/.reventless/users.yaml"))->Expect.toBe(None)
+  })
+})
+
+describe("Seed_Users.label:", () => {
+  testSync("names the groups an account carries", () => {
+    expect(
+      Seed_Users.label({
+        username: "admin",
+        password: "x",
+        groups: ["Admin", "Shopper"],
+        userId: None,
+      }),
+    )->Expect.toBe("admin  [Admin, Shopper]")
+  })
+
+  testSync("is the bare username when the file records no groups", () => {
+    expect(
+      Seed_Users.label({username: "admin", password: "x", groups: [], userId: None}),
+    )->Expect.toBe("admin")
+  })
+
+  // The menu is unchanged by the id: an operator picks an account by name and
+  // membership, and a Cognito sub in the list would be noise at the one moment
+  // they are choosing a login.
+  testSync("says nothing about the userId", () => {
+    expect(
+      Seed_Users.label({
+        username: "admin",
+        password: "x",
+        groups: ["Admin"],
+        userId: Some("4275e4a4-00c1-70e1-1cb5-363b06b992b5"),
+      }),
+    )->Expect.toBe("admin  [Admin]")
+  })
+})