test: merge allowlist config helper cases

src/plugin-sdk/allowlist-config-edit.test.ts

@@ -17,47 +17,65 @@ describe("readConfiguredAllowlistEntries", () => {
 });
 
 describe("collectAllowlistOverridesFromRecord", () => {
-  it("collects only non-empty overrides from a flat record", () => {
+  it.each([
+    {
+      name: "collects only non-empty overrides from a flat record",
+      record: {
+        room1: { users: ["a", "b"] },
+        room2: { users: [] },
+      },
+      expected: [{ label: "room1", entries: ["a", "b"] }],
+    },
+  ])("$name", ({ record, expected }) => {
     expect(
       collectAllowlistOverridesFromRecord({
-        record: {
-          room1: { users: ["a", "b"] },
-          room2: { users: [] },
-        },
+        record,
         label: (key) => key,
         resolveEntries: (value) => value.users,
       }),
-    ).toEqual([{ label: "room1", entries: ["a", "b"] }]);
+    ).toEqual(expected);
   });
 });
 
 describe("collectNestedAllowlistOverridesFromRecord", () => {
-  it("collects outer and nested overrides from a hierarchical record", () => {
-    expect(
-      collectNestedAllowlistOverridesFromRecord({
-        record: {
-          guild1: {
-            users: ["owner"],
-            channels: {
-              chan1: { users: ["member"] },
-            },
+  it.each([
+    {
+      name: "collects outer and nested overrides from a hierarchical record",
+      record: {
+        guild1: {
+          users: ["owner"],
+          channels: {
+            chan1: { users: ["member"] },
           },
         },
+      },
+      expected: [
+        { label: "guild guild1", entries: ["owner"] },
+        { label: "guild guild1 / channel chan1", entries: ["member"] },
+      ],
+    },
+  ])("$name", ({ record, expected }) => {
+    expect(
+      collectNestedAllowlistOverridesFromRecord({
+        record,
         outerLabel: (key) => `guild ${key}`,
         resolveOuterEntries: (value) => value.users,
         resolveChildren: (value) => value.channels,
         innerLabel: (outerKey, innerKey) => `guild ${outerKey} / channel ${innerKey}`,
         resolveInnerEntries: (value) => value.users,
       }),
-    ).toEqual([
-      { label: "guild guild1", entries: ["owner"] },
-      { label: "guild guild1 / channel chan1", entries: ["member"] },
-    ]);
+    ).toEqual(expected);
   });
 });
 
 describe("createFlatAllowlistOverrideResolver", () => {
-  it("builds an account-scoped flat override resolver", () => {
+  it.each([
+    {
+      name: "builds an account-scoped flat override resolver",
+      account: { channels: { room1: { users: ["a"] } } },
+      expected: [{ label: "room1", entries: ["a"] }],
+    },
+  ])("$name", ({ account, expected }) => {
     const resolveOverrides = createFlatAllowlistOverrideResolver({
       resolveRecord: (account: { channels?: Record<string, { users: string[] }> }) =>
         account.channels,
@@ -65,14 +83,25 @@ describe("createFlatAllowlistOverrideResolver", () => {
       resolveEntries: (value) => value.users,
     });
 
-    expect(resolveOverrides({ channels: { room1: { users: ["a"] } } })).toEqual([
-      { label: "room1", entries: ["a"] },
-    ]);
+    expect(resolveOverrides(account)).toEqual(expected);
   });
 });
 
 describe("createNestedAllowlistOverrideResolver", () => {
-  it("builds an account-scoped nested override resolver", () => {
+  it.each([
+    {
+      name: "builds an account-scoped nested override resolver",
+      account: {
+        groups: {
+          g1: { allowFrom: ["owner"], topics: { t1: { allowFrom: ["member"] } } },
+        },
+      },
+      expected: [
+        { label: "g1", entries: ["owner"] },
+        { label: "g1 topic t1", entries: ["member"] },
+      ],
+    },
+  ])("$name", ({ account, expected }) => {
     const resolveOverrides = createNestedAllowlistOverrideResolver({
       resolveRecord: (account: {
         groups?: Record<
@@ -87,16 +116,7 @@ describe("createNestedAllowlistOverrideResolver", () => {
       resolveInnerEntries: (topic) => topic.allowFrom,
     });
 
-    expect(
-      resolveOverrides({
-        groups: {
-          g1: { allowFrom: ["owner"], topics: { t1: { allowFrom: ["member"] } } },
-        },
-      }),
-    ).toEqual([
-      { label: "g1", entries: ["owner"] },
-      { label: "g1 topic t1", entries: ["member"] },
-    ]);
+    expect(resolveOverrides(account)).toEqual(expected);
   });
 });