@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/dcb/DcbValidationTest.res.mjs

@@ -0,0 +1,476 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as DcbValidation$Reventless from "@reventlessdev/reventless-spec/src/components/DcbValidation.res.mjs";
+
+let producedASchema = S.union([
+  S.schema(s => ({
+    TAG: "ItemCreated",
+    itemId: s.m(DcbTag$Reventless.string),
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ItemRenamed",
+    itemId: s.m(DcbTag$Reventless.string),
+    newName: s.m(S.string)
+  }))
+]);
+
+let producedBSchema = S.schema(s => ({
+  TAG: "ItemArchived",
+  itemId: s.m(DcbTag$Reventless.string)
+}));
+
+let producedADuplicateSchema = S.schema(s => ({
+  TAG: "ItemCreated",
+  itemId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let producedAMismatchFieldsSchema = S.schema(s => ({
+  TAG: "ItemCreated",
+  itemId: s.m(DcbTag$Reventless.string)
+}));
+
+let producedAMismatchTagsSchema = S.schema(s => ({
+  TAG: "ItemCreated",
+  itemId: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let producedAMismatchTypeSchema = S.schema(s => ({
+  TAG: "ItemCreated",
+  itemId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.float)
+}));
+
+let consumedFullSchema = S.union([
+  S.schema(s => ({
+    TAG: "ItemCreated",
+    itemId: s.m(S.string),
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ItemRenamed",
+    itemId: s.m(S.string),
+    newName: s.m(S.string)
+  }))
+]);
+
+let consumedPartialSchema = S.schema(s => ({
+  TAG: "ItemCreated",
+  itemId: s.m(S.string)
+}));
+
+let consumedPayloadLessSchema = S.union([
+  S.literal("ItemCreated"),
+  S.literal("ItemArchived")
+]);
+
+let consumedDanglingSchema = S.schema(s => ({
+  TAG: "ItemDeleted",
+  itemId: s.m(S.string)
+}));
+
+let consumedBadFieldSchema = S.schema(s => ({
+  TAG: "ItemCreated",
+  itemId: s.m(S.string),
+  rating: s.m(S.float)
+}));
+
+let consumedBadTypeSchema = S.schema(s => ({
+  TAG: "ItemCreated",
+  itemId: s.m(S.string),
+  name: s.m(S.float)
+}));
+
+let recordDemandCommandSchema = S.schema(s => ({
+  TAG: "RecordDemand",
+  productId: s.m(DcbTag$Reventless.string),
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+let touchDemandCommandSchema = S.schema(s => ({
+  TAG: "TouchDemand",
+  productId: s.m(DcbTag$Reventless.string)
+}));
+
+let placeOrderCommandSchema = S.schema(s => ({
+  TAG: "PlaceOrder",
+  orderId: s.m(DcbTag$Reventless.string),
+  productIds: s.m(S.array(DcbTag$Reventless.stringForKey("productId")))
+}));
+
+let demandConsumedSchema = S.union([
+  S.schema(s => ({
+    TAG: "ProductDemandRecorded",
+    productId: s.m(S.string),
+    orderId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ProductDemandRevoked",
+    productId: s.m(S.string),
+    orderId: s.m(S.string)
+  }))
+]);
+
+let demandProducedSchema = S.union([
+  S.schema(s => ({
+    TAG: "ProductDemandRecorded",
+    productId: s.m(DcbTag$Reventless.string),
+    orderId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "ProductDemandRevoked",
+    productId: s.m(DcbTag$Reventless.string),
+    orderId: s.m(DcbTag$Reventless.string),
+    customerId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+function u(prim) {
+  return prim;
+}
+
+let producedTagKeys = DcbTag$Reventless.extractTagKeysByEventType(demandProducedSchema);
+
+let subscribedCrossPartitionSchema = S.schema(s => ({
+  TAG: "StudentSubscribed",
+  courseId: s.m(DcbTag$Reventless.partition),
+  studentId: s.m(DcbTag$Reventless.crossPartition)
+}));
+
+let unsubscribedCrossPartitionSchema = S.schema(s => ({
+  TAG: "StudentUnsubscribed",
+  courseId: s.m(DcbTag$Reventless.partition),
+  studentId: s.m(DcbTag$Reventless.crossPartition)
+}));
+
+let flaggedPartitionScopedSchema = S.schema(s => ({
+  TAG: "StudentFlagged",
+  studentId: s.m(DcbTag$Reventless.partition),
+  courseId: s.m(DcbTag$Reventless.string)
+}));
+
+globalThis.describe("DcbValidation:", () => {
+  globalThis.describe("validateProducedAndConsumed", () => {
+    globalThis.test("passes when all consumed events match produced events", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([
+        [
+          "AddItem",
+          producedASchema
+        ],
+        [
+          "ArchiveItem",
+          producedBSchema
+        ]
+      ], [[
+          "ItemView",
+          consumedFullSchema
+        ]]);
+      globalThis.expect(result).toEqual({
+        TAG: "Ok",
+        _0: undefined
+      });
+    });
+    globalThis.test("passes with partial field projection", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([[
+          "AddItem",
+          producedASchema
+        ]], [[
+          "CheckExists",
+          consumedPartialSchema
+        ]]);
+      globalThis.expect(result).toEqual({
+        TAG: "Ok",
+        _0: undefined
+      });
+    });
+    globalThis.test("passes with payload-less consumed events", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([
+        [
+          "AddItem",
+          producedASchema
+        ],
+        [
+          "ArchiveItem",
+          producedBSchema
+        ]
+      ], [[
+          "CheckExists",
+          consumedPayloadLessSchema
+        ]]);
+      globalThis.expect(result).toEqual({
+        TAG: "Ok",
+        _0: undefined
+      });
+    });
+    globalThis.test("passes when multiple producers have identical shapes and tags", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([
+        [
+          "AddItem",
+          producedASchema
+        ],
+        [
+          "CloneItem",
+          producedADuplicateSchema
+        ]
+      ], []);
+      globalThis.expect(result).toEqual({
+        TAG: "Ok",
+        _0: undefined
+      });
+    });
+    globalThis.test("fails when consumed event has no producer", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([[
+          "AddItem",
+          producedASchema
+        ]], [[
+          "DeleteHandler",
+          consumedDanglingSchema
+        ]]);
+      if (result.TAG === "Ok") {
+        return JestGlobals.fail("Expected validation error");
+      }
+      let errors = result._0;
+      globalThis.expect(errors.length).toBe(1);
+      let err = errors[0];
+      globalThis.expect(err.sliceName).toBe("DeleteHandler");
+      globalThis.expect(err.message.includes("ItemDeleted")).toBe(true);
+      globalThis.expect(err.message.includes("no slice produces it")).toBe(true);
+    });
+    globalThis.test("fails when consumed event references field not in produced shape", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([[
+          "AddItem",
+          producedASchema
+        ]], [[
+          "RatingView",
+          consumedBadFieldSchema
+        ]]);
+      if (result.TAG === "Ok") {
+        return JestGlobals.fail("Expected validation error");
+      }
+      let errors = result._0;
+      globalThis.expect(errors.length).toBe(1);
+      let err = errors[0];
+      globalThis.expect(err.sliceName).toBe("RatingView");
+      globalThis.expect(err.message.includes("rating")).toBe(true);
+      globalThis.expect(err.message.includes("no field")).toBe(true);
+    });
+    globalThis.test("fails when consumed field type mismatches produced field type", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([[
+          "AddItem",
+          producedASchema
+        ]], [[
+          "BadTypeView",
+          consumedBadTypeSchema
+        ]]);
+      if (result.TAG === "Ok") {
+        return JestGlobals.fail("Expected validation error");
+      }
+      let errors = result._0;
+      globalThis.expect(errors.length).toBe(1);
+      let err = errors[0];
+      globalThis.expect(err.sliceName).toBe("BadTypeView");
+      globalThis.expect(err.message.includes("name")).toBe(true);
+      globalThis.expect(err.message.includes("float")).toBe(true);
+      globalThis.expect(err.message.includes("string")).toBe(true);
+    });
+    globalThis.test("fails when producers have different fields for same TAG", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([
+        [
+          "AddItem",
+          producedASchema
+        ],
+        [
+          "ImportItem",
+          producedAMismatchFieldsSchema
+        ]
+      ], []);
+      if (result.TAG === "Ok") {
+        return JestGlobals.fail("Expected validation error");
+      }
+      let errors = result._0;
+      globalThis.expect(errors.length).toBeGreaterThanOrEqual(1);
+      let err = errors[0];
+      globalThis.expect(err.message.includes("AddItem")).toBe(true);
+      globalThis.expect(err.message.includes("ImportItem")).toBe(true);
+      globalThis.expect(err.message.includes("name")).toBe(true);
+    });
+    globalThis.test("fails when producers have different tag annotations for same TAG", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([
+        [
+          "AddItem",
+          producedASchema
+        ],
+        [
+          "UntaggerItem",
+          producedAMismatchTagsSchema
+        ]
+      ], []);
+      if (result.TAG === "Ok") {
+        return JestGlobals.fail("Expected validation error");
+      }
+      let errors = result._0;
+      globalThis.expect(errors.length).toBeGreaterThanOrEqual(1);
+      let hasTagError = errors.some(err => err.message.includes("tag annotations"));
+      globalThis.expect(hasTagError).toBe(true);
+    });
+    globalThis.test("fails when producers have different field types for same TAG", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([
+        [
+          "AddItem",
+          producedASchema
+        ],
+        [
+          "BadTypeItem",
+          producedAMismatchTypeSchema
+        ]
+      ], []);
+      if (result.TAG === "Ok") {
+        return JestGlobals.fail("Expected validation error");
+      }
+      let errors = result._0;
+      globalThis.expect(errors.length).toBeGreaterThanOrEqual(1);
+      let err = errors[0];
+      globalThis.expect(err.message.includes("name")).toBe(true);
+      globalThis.expect(err.message.includes("string")).toBe(true);
+      globalThis.expect(err.message.includes("float")).toBe(true);
+    });
+    globalThis.test("passes with empty produced and consumed", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([], []);
+      globalThis.expect(result).toEqual({
+        TAG: "Ok",
+        _0: undefined
+      });
+    });
+    globalThis.test("collects multiple errors at once", () => {
+      let result = DcbValidation$Reventless.validateProducedAndConsumed([[
+          "AddItem",
+          producedASchema
+        ]], [
+        [
+          "DeleteHandler",
+          consumedDanglingSchema
+        ],
+        [
+          "BadTypeView",
+          consumedBadTypeSchema
+        ]
+      ]);
+      if (result.TAG === "Ok") {
+        return JestGlobals.fail("Expected validation errors");
+      }
+      globalThis.expect(result._0.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+  globalThis.describe("validateCompositeReads (Issue 5)", () => {
+    globalThis.test("warns when a composite read's consumed type carries an extra tag", () => {
+      let warnings = DcbValidation$Reventless.validateCompositeReads([[
+          "RecordDemand",
+          recordDemandCommandSchema,
+          demandConsumedSchema
+        ]], producedTagKeys);
+      globalThis.expect(warnings.length).toBe(1);
+      let w = warnings[0];
+      globalThis.expect(w.sliceName).toBe("RecordDemand");
+      globalThis.expect(w.message.includes("ProductDemandRevoked")).toBe(true);
+      globalThis.expect(w.message.includes("customerId")).toBe(true);
+    });
+    globalThis.test("does not warn for an exact-match consumed type", () => {
+      let warnings = DcbValidation$Reventless.validateCompositeReads([[
+          "RecordDemand",
+          recordDemandCommandSchema,
+          demandConsumedSchema
+        ]], producedTagKeys);
+      globalThis.expect(warnings.some(w => w.message.includes("ProductDemandRecorded"))).toBe(false);
+    });
+    globalThis.test("ignores single-tag commands (partition read, not composite)", () => {
+      let warnings = DcbValidation$Reventless.validateCompositeReads([[
+          "TouchDemand",
+          touchDemandCommandSchema,
+          demandConsumedSchema
+        ]], producedTagKeys);
+      globalThis.expect(warnings).toEqual([]);
+    });
+    globalThis.test("ignores tagged-array commands (per-element OR, not composite)", () => {
+      let warnings = DcbValidation$Reventless.validateCompositeReads([[
+          "PlaceOrder",
+          placeOrderCommandSchema,
+          demandConsumedSchema
+        ]], producedTagKeys);
+      globalThis.expect(warnings).toEqual([]);
+    });
+    globalThis.test("no warnings when nothing reads compositely", () => {
+      globalThis.expect(DcbValidation$Reventless.validateCompositeReads([], producedTagKeys)).toEqual([]);
+    });
+  });
+  globalThis.describe("validateCrossPartitionScope (Issue 13)", () => {
+    globalThis.test("no warning when every carrier of a key agrees on cross-partition scope", () => {
+      let warnings = DcbValidation$Reventless.validateCrossPartitionScope([
+        [
+          "Subscribe",
+          subscribedCrossPartitionSchema
+        ],
+        [
+          "Unsubscribe",
+          unsubscribedCrossPartitionSchema
+        ]
+      ]);
+      globalThis.expect(warnings).toEqual([]);
+    });
+    globalThis.test("warns when one producer leaves a cross-partition key partition-scoped", () => {
+      let warnings = DcbValidation$Reventless.validateCrossPartitionScope([
+        [
+          "Subscribe",
+          subscribedCrossPartitionSchema
+        ],
+        [
+          "Flag",
+          flaggedPartitionScopedSchema
+        ]
+      ]);
+      globalThis.expect(warnings.length).toBe(1);
+      let w = warnings[0];
+      globalThis.expect(w.sliceName).toBe("Flag");
+      globalThis.expect(w.message.includes("studentId")).toBe(true);
+    });
+    globalThis.test("no warning when no key is cross-partition anywhere", () => {
+      globalThis.expect(DcbValidation$Reventless.validateCrossPartitionScope([[
+          "Flag",
+          flaggedPartitionScopedSchema
+        ]])).toEqual([]);
+    });
+  });
+});
+
+let validate = DcbValidation$Reventless.validateProducedAndConsumed;
+
+export {
+  producedASchema,
+  producedBSchema,
+  producedADuplicateSchema,
+  producedAMismatchFieldsSchema,
+  producedAMismatchTagsSchema,
+  producedAMismatchTypeSchema,
+  consumedFullSchema,
+  consumedPartialSchema,
+  consumedPayloadLessSchema,
+  consumedDanglingSchema,
+  consumedBadFieldSchema,
+  consumedBadTypeSchema,
+  recordDemandCommandSchema,
+  touchDemandCommandSchema,
+  placeOrderCommandSchema,
+  demandConsumedSchema,
+  demandProducedSchema,
+  validate,
+  u,
+  producedTagKeys,
+  subscribedCrossPartitionSchema,
+  unsubscribedCrossPartitionSchema,
+  flaggedPartitionScopedSchema,
+}
+/* producedASchema Not a pure module */

package/tests/eventlog/EventLogFixtures.res

@@ -0,0 +1,113 @@
+S.enableJson()
+
+// ─────────────────────────────────────────────────────────────
+// Test event spec
+// ─────────────────────────────────────────────────────────────
+
+module ItemEventLogSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "TestItemEventLog"
+
+  @schema
+  type event = | ItemCreated({name: string}) | ItemDeleted({id: string})
+}
+
+// ─────────────────────────────────────────────────────────────
+// Mock storage
+// ─────────────────────────────────────────────────────────────
+
+let storedEvents: ref<dict<array<JSON.t>>> = ref(Dict.make())
+let failNextAppend = ref(false)
+// Inject N transient failures: each call decrements the counter and returns ThrottlingException
+let failNextAppendsWithTransient: ref<int> = ref(0)
+// Total number of storage.append calls (including retried attempts)
+let appendCallCount: ref<int> = ref(0)
+
+let mockStorage: EventLog_Adapter.operations = {
+  append: async (_seqNr, id, jsons) => {
+    appendCallCount := appendCallCount.contents + 1
+    if failNextAppend.contents {
+      failNextAppend := false
+      Error("mock storage failure")
+    } else if failNextAppendsWithTransient.contents > 0 {
+      failNextAppendsWithTransient := failNextAppendsWithTransient.contents - 1
+      Error("ThrottlingException: Rate exceeded")
+    } else {
+      let existing = storedEvents.contents->Dict.get(id)->Option.getOr([])
+      storedEvents.contents->Dict.set(id, existing->Array.concat(jsons))
+      Ok()
+    }
+  },
+  replay: async id => {
+    storedEvents.contents->Dict.get(id)->Option.getOr([])
+  },
+  replayStream: id =>
+    storedEvents.contents->Dict.get(id)->Option.getOr([])->Stream.fromIterable,
+  appendStream: (_startingSeqNr, id, stream) =>
+    stream->Stream.runForEach(json =>
+      Effect.sync(() => {
+        let existing = storedEvents.contents->Dict.get(id)->Option.getOr([])
+        storedEvents.contents->Dict.set(id, existing->Array.concat([json]))
+      })
+    ),
+}
+
+// ─────────────────────────────────────────────────────────────
+// Mock EventTopic module (stub make — never called in unit tests)
+// ─────────────────────────────────────────────────────────────
+
+let capturedPublishes: ref<array<Message.event'<string, ItemEventLogSpec.event>>> = ref([])
+
+module MockEventTopic: EventTopic.T
+  with module Spec.Id = ItemEventLogSpec.Id
+  and type Spec.event = ItemEventLogSpec.event = {
+  module Spec = {
+    module Id = ItemEventLogSpec.Id
+    let name = "TestItem"
+    @schema
+    type event = ItemEventLogSpec.event
+  }
+  type publish = EventTopic.publish<Spec.Id.t, Spec.event>
+  type operations = {
+    publish: publish,
+    publishJson: EventTopic.publishJson,
+    publishJsonStream: ReventlessInfra.EventTopic.publishJsonStream,
+  }
+  type component = Component.t<EventTopic.t, EventTopic.outputs, operations>
+  let make = (~name as _, ~storageResources as _, ~opts as _=?): component => Obj.magic(0)
+}
+
+let mockEventTopicOps: MockEventTopic.operations = {
+  publish: async events => {
+    capturedPublishes := capturedPublishes.contents->Array.concat(events)
+  },
+  publishJson: async (_service, _meta, _json) => (),
+  publishJsonStream: _stream => Effect.succeed(()),
+}
+
+// ─────────────────────────────────────────────────────────────
+// Test metadata
+// ─────────────────────────────────────────────────────────────
+
+let testMeta: Message.meta = {
+  service: "test",
+  time: "2024-01-01T00:00:00.000Z",
+  ip: "127.0.0.1",
+  user: "testuser",
+  msgId: "msg-001",
+  correlationId: "corr-001",
+}
+
+let makeEvent' = (id, event) => {
+  Reventless.Message.id,
+  meta: testMeta,
+  event,
+}
+
+let reset = () => {
+  storedEvents := Dict.make()
+  failNextAppend := false
+  failNextAppendsWithTransient := 0
+  appendCallCount := 0
+  capturedPublishes := []
+}