@reventlessdev/reventless-aws 3.0.0-alpha.253 → 3.0.0-alpha.255

package/tests/Util_LogRetentionTest.res

@@ -0,0 +1,122 @@
+open JestGlobals
+
+let prodStacks = Util_HostUiDomain.defaultProdStacks
+
+describe("Util_LogRetention.retentionDaysFor", () => {
+  testSync("prod keeps logs a year", () =>
+    expect(Util_LogRetention.retentionDaysFor(~stack="prod", ~prodStacks))->toBe(365)
+  )
+
+  testSync("'main' is production too, by the shared prod list", () =>
+    expect(Util_LogRetention.retentionDaysFor(~stack="main", ~prodStacks))->toBe(365)
+  )
+
+  testSync("beta keeps a month of pre-prod history", () =>
+    expect(Util_LogRetention.retentionDaysFor(~stack="beta", ~prodStacks))->toBe(30)
+  )
+
+  testSync("a PR stack keeps the minimum — torn down quickly", () =>
+    expect(Util_LogRetention.retentionDaysFor(~stack="pr-1234", ~prodStacks))->toBe(3)
+  )
+
+  testSync("alpha keeps a week — active development, consumed within hours", () =>
+    expect(Util_LogRetention.retentionDaysFor(~stack="alpha", ~prodStacks))->toBe(7)
+  )
+
+  // Same fail-open as the store-layout allow-list: an unlisted production name
+  // silently gets the dev tier. Asserted so it is a decision on record and the
+  // config override is the documented fix.
+  testSync("an unlisted stack falls open to the dev tier", () =>
+    expect(Util_LogRetention.retentionDaysFor(~stack="production", ~prodStacks))->toBe(7)
+  )
+
+  testSync("adding it to the prod list is the fix", () =>
+    expect(
+      Util_LogRetention.retentionDaysFor(~stack="production", ~prodStacks=["prod", "production"]),
+    )->toBe(365)
+  )
+
+  // The config key is the escape hatch — a stack dialled without a code change,
+  // including `0` (never expire) as an explicit opt-in.
+  testSync("a config override wins over the tier default", () =>
+    expect(Util_LogRetention.retentionDaysFor(~stack="alpha", ~prodStacks, ~configOverride=14))->toBe(14)
+  )
+
+  testSync("0 = never expire is expressible via the override", () =>
+    expect(Util_LogRetention.retentionDaysFor(~stack="prod", ~prodStacks, ~configOverride=0))->toBe(0)
+  )
+})
+
+describe("Util_LogRetention.logLevelFor", () => {
+  // Retention and level pull in opposite directions: prod is long-lived AND
+  // quiet; the dev stacks are short-lived AND loud.
+  testSync("prod is quiet — info, no debug noise or payload leakage", () =>
+    expect(Util_LogRetention.logLevelFor(~stack="prod", ~prodStacks))->toBe("info")
+  )
+
+  testSync("beta mirrors prod so pre-prod behaves like prod", () =>
+    expect(Util_LogRetention.logLevelFor(~stack="beta", ~prodStacks))->toBe("info")
+  )
+
+  testSync("alpha is verbose — debug feedback during active development", () =>
+    expect(Util_LogRetention.logLevelFor(~stack="alpha", ~prodStacks))->toBe("debug")
+  )
+
+  testSync("a PR stack is verbose too", () =>
+    expect(Util_LogRetention.logLevelFor(~stack="pr-7", ~prodStacks))->toBe("debug")
+  )
+
+  testSync("a config override wins over the tier default", () =>
+    expect(
+      Util_LogRetention.logLevelFor(~stack="prod", ~prodStacks, ~configOverride="debug"),
+    )->toBe("debug")
+  )
+})
+
+describe("Util_LogRetention.managesLogGroup", () => {
+  // Managed for every stack by default — a stack deployed on this framework gets
+  // its groups from Pulumi before Lambda/AppSync would auto-create them, so a
+  // fresh stack has nothing to adopt.
+  testSync("alpha is managed", () =>
+    expect(Util_LogRetention.managesLogGroup(~stack="alpha"))->toBe(true)
+  )
+
+  testSync("a PR stack is managed", () =>
+    expect(Util_LogRetention.managesLogGroup(~stack="pr-42"))->toBe(true)
+  )
+
+  testSync("prod is managed too — a fresh prod stack has no group to adopt", () =>
+    expect(Util_LogRetention.managesLogGroup(~stack="prod"))->toBe(true)
+  )
+
+  testSync("beta is managed too", () =>
+    expect(Util_LogRetention.managesLogGroup(~stack="beta"))->toBe(true)
+  )
+
+  // The escape hatch: a stack pending a `pulumi import` stays on auto-created
+  // groups until the import is done — a config flip, not a code change.
+  testSync("a stack named in unmanagedLogGroupStacks is left auto-created", () =>
+    expect(
+      Util_LogRetention.managesLogGroup(~stack="legacy-prod", ~unmanagedStacks=["legacy-prod"]),
+    )->toBe(false)
+  )
+
+  testSync("only the named stacks are excluded — others stay managed", () =>
+    expect(
+      Util_LogRetention.managesLogGroup(~stack="alpha", ~unmanagedStacks=["legacy-prod"]),
+    )->toBe(true)
+  )
+})
+
+describe("Util_LogRetention.parseUnmanagedStacks", () => {
+  testSync("empty config manages every stack", () =>
+    expect(Util_LogRetention.parseUnmanagedStacks(""))->toEqual([])
+  )
+
+  testSync("CSV is trimmed and empty entries dropped", () =>
+    expect(Util_LogRetention.parseUnmanagedStacks(" legacy-prod , , old-beta "))->toEqual([
+      "legacy-prod",
+      "old-beta",
+    ])
+  )
+})

package/tests/Util_LogRetentionTest.res.mjs

@@ -0,0 +1,95 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Util_HostUiDomain$ReventlessAws from "../src/util/Util_HostUiDomain.res.mjs";
+import * as Util_LogRetention$ReventlessAws from "../src/util/Util_LogRetention.res.mjs";
+
+globalThis.describe("Util_LogRetention.retentionDaysFor", () => {
+  globalThis.test("prod keeps logs a year", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.retentionDaysFor("prod", Util_HostUiDomain$ReventlessAws.defaultProdStacks, undefined)).toBe(365);
+  });
+  globalThis.test("'main' is production too, by the shared prod list", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.retentionDaysFor("main", Util_HostUiDomain$ReventlessAws.defaultProdStacks, undefined)).toBe(365);
+  });
+  globalThis.test("beta keeps a month of pre-prod history", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.retentionDaysFor("beta", Util_HostUiDomain$ReventlessAws.defaultProdStacks, undefined)).toBe(30);
+  });
+  globalThis.test("a PR stack keeps the minimum — torn down quickly", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.retentionDaysFor("pr-1234", Util_HostUiDomain$ReventlessAws.defaultProdStacks, undefined)).toBe(3);
+  });
+  globalThis.test("alpha keeps a week — active development, consumed within hours", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.retentionDaysFor("alpha", Util_HostUiDomain$ReventlessAws.defaultProdStacks, undefined)).toBe(7);
+  });
+  globalThis.test("an unlisted stack falls open to the dev tier", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.retentionDaysFor("production", Util_HostUiDomain$ReventlessAws.defaultProdStacks, undefined)).toBe(7);
+  });
+  globalThis.test("adding it to the prod list is the fix", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.retentionDaysFor("production", [
+      "prod",
+      "production"
+    ], undefined)).toBe(365);
+  });
+  globalThis.test("a config override wins over the tier default", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.retentionDaysFor("alpha", Util_HostUiDomain$ReventlessAws.defaultProdStacks, 14)).toBe(14);
+  });
+  globalThis.test("0 = never expire is expressible via the override", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.retentionDaysFor("prod", Util_HostUiDomain$ReventlessAws.defaultProdStacks, 0)).toBe(0);
+  });
+});
+
+globalThis.describe("Util_LogRetention.logLevelFor", () => {
+  globalThis.test("prod is quiet — info, no debug noise or payload leakage", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.logLevelFor("prod", Util_HostUiDomain$ReventlessAws.defaultProdStacks, undefined)).toBe("info");
+  });
+  globalThis.test("beta mirrors prod so pre-prod behaves like prod", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.logLevelFor("beta", Util_HostUiDomain$ReventlessAws.defaultProdStacks, undefined)).toBe("info");
+  });
+  globalThis.test("alpha is verbose — debug feedback during active development", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.logLevelFor("alpha", Util_HostUiDomain$ReventlessAws.defaultProdStacks, undefined)).toBe("debug");
+  });
+  globalThis.test("a PR stack is verbose too", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.logLevelFor("pr-7", Util_HostUiDomain$ReventlessAws.defaultProdStacks, undefined)).toBe("debug");
+  });
+  globalThis.test("a config override wins over the tier default", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.logLevelFor("prod", Util_HostUiDomain$ReventlessAws.defaultProdStacks, "debug")).toBe("debug");
+  });
+});
+
+globalThis.describe("Util_LogRetention.managesLogGroup", () => {
+  globalThis.test("alpha is managed", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.managesLogGroup("alpha", undefined)).toBe(true);
+  });
+  globalThis.test("a PR stack is managed", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.managesLogGroup("pr-42", undefined)).toBe(true);
+  });
+  globalThis.test("prod is managed too — a fresh prod stack has no group to adopt", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.managesLogGroup("prod", undefined)).toBe(true);
+  });
+  globalThis.test("beta is managed too", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.managesLogGroup("beta", undefined)).toBe(true);
+  });
+  globalThis.test("a stack named in unmanagedLogGroupStacks is left auto-created", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.managesLogGroup("legacy-prod", ["legacy-prod"])).toBe(false);
+  });
+  globalThis.test("only the named stacks are excluded — others stay managed", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.managesLogGroup("alpha", ["legacy-prod"])).toBe(true);
+  });
+});
+
+globalThis.describe("Util_LogRetention.parseUnmanagedStacks", () => {
+  globalThis.test("empty config manages every stack", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.parseUnmanagedStacks("")).toEqual([]);
+  });
+  globalThis.test("CSV is trimmed and empty entries dropped", () => {
+    globalThis.expect(Util_LogRetention$ReventlessAws.parseUnmanagedStacks(" legacy-prod , , old-beta ")).toEqual([
+      "legacy-prod",
+      "old-beta"
+    ]);
+  });
+});
+
+let prodStacks = Util_HostUiDomain$ReventlessAws.defaultProdStacks;
+
+export {
+  prodStacks,
+}
+/*  Not a pure module */

package/tests/Util_StoreLayoutTest.res

@@ -240,3 +240,66 @@ describe("Util_StoreLayout.keyPrefixFor", () => {
     )->toBe(true)
   )
 })
+
+describe("Util_StoreLayout.pendingExpiryFor", () => {
+  // The default is the whole point: expiry is the one step in the mechanism that
+  // deletes objects, and it is only sound once reconciliation has confirmed the
+  // tagged set is the unreferenced set. A store nobody named accumulates.
+  testSync("no config at all means no store expires anything", () =>
+    expect(
+      Util_StoreLayout.pendingExpiryFor(~config=None, ~store="Catalog.productImages"),
+    )->toEqual(None)
+  )
+
+  testSync("a store the config does not name expires nothing", () =>
+    expect(
+      Util_StoreLayout.pendingExpiryFor(
+        ~config=Some("Ordering.receipts=14"),
+        ~store="Catalog.productImages",
+      ),
+    )->toEqual(None)
+  )
+
+  testSync("a named store takes its own retention", () =>
+    expect(
+      Util_StoreLayout.pendingExpiryFor(
+        ~config=Some("Catalog.productImages=30"),
+        ~store="Catalog.productImages",
+      ),
+    )->toEqual(Some(30))
+  )
+
+  // Per store, one at a time — the plan's sequencing expressed in the setting.
+  testSync("stores are enabled independently, with their own values", () => {
+    let config = Some("Catalog.productImages=30, Ordering.receipts=14")
+    expect((
+      Util_StoreLayout.pendingExpiryFor(~config, ~store="Catalog.productImages"),
+      Util_StoreLayout.pendingExpiryFor(~config, ~store="Ordering.receipts"),
+      Util_StoreLayout.pendingExpiryFor(~config, ~store="Catalog.other"),
+    ))->toEqual((Some(30), Some(14), None))
+  })
+
+  // Guessing at what a typo meant, in the one setting that deletes objects, is
+  // not a service — an unreadable entry leaves the store accumulating.
+  testSync("a malformed or non-positive entry is ignored, not defaulted", () => {
+    let of_ = c => Util_StoreLayout.pendingExpiryFor(~config=Some(c), ~store="Catalog.productImages")
+    expect((
+      of_("Catalog.productImages"),
+      of_("Catalog.productImages="),
+      of_("Catalog.productImages=soon"),
+      of_("Catalog.productImages=0"),
+      of_("Catalog.productImages=-1"),
+    ))->toEqual((None, None, None, None, None))
+  })
+
+  // The prefix is a platform-global namespace, so two plugins' stores are
+  // distinct keys — enabling one must not enable the other.
+  testSync("a store name is matched whole, not by prefix", () =>
+    expect(
+      Util_StoreLayout.pendingExpiryFor(
+        ~config=Some("Catalog.productImages=30"),
+        ~store="Catalog.productImagesArchive",
+      ),
+    )->toEqual(None)
+  )
+})

package/tests/Util_StoreLayoutTest.res.mjs

@@ -121,6 +121,48 @@ globalThis.describe("Util_StoreLayout.keyPrefixFor", () => {
   });
 });
 
+globalThis.describe("Util_StoreLayout.pendingExpiryFor", () => {
+  globalThis.test("no config at all means no store expires anything", () => {
+    globalThis.expect(Util_StoreLayout$ReventlessAws.pendingExpiryFor(undefined, "Catalog.productImages")).toEqual(undefined);
+  });
+  globalThis.test("a store the config does not name expires nothing", () => {
+    globalThis.expect(Util_StoreLayout$ReventlessAws.pendingExpiryFor("Ordering.receipts=14", "Catalog.productImages")).toEqual(undefined);
+  });
+  globalThis.test("a named store takes its own retention", () => {
+    globalThis.expect(Util_StoreLayout$ReventlessAws.pendingExpiryFor("Catalog.productImages=30", "Catalog.productImages")).toEqual(30);
+  });
+  globalThis.test("stores are enabled independently, with their own values", () => {
+    let config = "Catalog.productImages=30, Ordering.receipts=14";
+    globalThis.expect([
+      Util_StoreLayout$ReventlessAws.pendingExpiryFor(config, "Catalog.productImages"),
+      Util_StoreLayout$ReventlessAws.pendingExpiryFor(config, "Ordering.receipts"),
+      Util_StoreLayout$ReventlessAws.pendingExpiryFor(config, "Catalog.other")
+    ]).toEqual([
+      30,
+      14,
+      undefined
+    ]);
+  });
+  globalThis.test("a malformed or non-positive entry is ignored, not defaulted", () => {
+    globalThis.expect([
+      Util_StoreLayout$ReventlessAws.pendingExpiryFor("Catalog.productImages", "Catalog.productImages"),
+      Util_StoreLayout$ReventlessAws.pendingExpiryFor("Catalog.productImages=", "Catalog.productImages"),
+      Util_StoreLayout$ReventlessAws.pendingExpiryFor("Catalog.productImages=soon", "Catalog.productImages"),
+      Util_StoreLayout$ReventlessAws.pendingExpiryFor("Catalog.productImages=0", "Catalog.productImages"),
+      Util_StoreLayout$ReventlessAws.pendingExpiryFor("Catalog.productImages=-1", "Catalog.productImages")
+    ]).toEqual([
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined
+    ]);
+  });
+  globalThis.test("a store name is matched whole, not by prefix", () => {
+    globalThis.expect(Util_StoreLayout$ReventlessAws.pendingExpiryFor("Catalog.productImages=30", "Catalog.productImagesArchive")).toEqual(undefined);
+  });
+});
+
 let prodStacks = Util_HostUiDomain$ReventlessAws.defaultProdStacks;
 
 export {