@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/extensionpoint/ExtensionPointOperationsTest.res.mjs

@@ -0,0 +1,304 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as ExtensionPoint_Operations$ReventlessCore from "../../src/components/ExtensionPoint/ExtensionPoint_Operations.res.mjs";
+
+S.enableJson();
+
+let name = "OpsTestEP";
+
+let commandSchema = S.schema(s => ({
+  TAG: "OpsEPCmd",
+  id: s.m(S.string)
+}));
+
+let eventSchema = S.schema(s => ({
+  TAG: "OpsEPEvent",
+  result: s.m(S.string)
+}));
+
+let directiveSchema = S.literal("OpsEPNoDirective");
+
+let moduleUrl = import.meta.url;
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let OpsEPSpec = {
+  name: name,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  directiveSchema: directiveSchema,
+  moduleUrl: moduleUrl,
+  commandAuthorization: commandAuthorization
+};
+
+let capturedPublished = {
+  contents: []
+};
+
+let capturedCallCount = {
+  contents: 0
+};
+
+let outgoingMeta = {
+  service: "PublishAgg",
+  time: "2024-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "tester",
+  msgId: "ops-msg-1",
+  correlationId: "ops-corr-1"
+};
+
+let delegateName = "PublishAgg";
+
+function mapIncomingCommands(_topicItems, _createSchedule, _deleteSchedule, _queryEngine) {
+  return [];
+}
+
+let mapOutgoingEvent = (eventJson, _createSchedule, _deleteSchedule, _queryEngine) => [{
+    TAG: "AbstractPublishEvent",
+    _0: "ep-dest",
+    _1: outgoingMeta,
+    _2: eventJson
+  }];
+
+let TestPublishMapping = {
+  ExtensionPoint: undefined,
+  delegateName: delegateName,
+  mapIncomingCommands: mapIncomingCommands,
+  mapOutgoingEvent: mapOutgoingEvent
+};
+
+let delegateName$1 = "CallAgg";
+
+function mapIncomingCommands$1(_topicItems, _createSchedule, _deleteSchedule, _queryEngine) {
+  return [];
+}
+
+let mapOutgoingEvent$1 = (_eventJson, _createSchedule, _deleteSchedule, _queryEngine) => [{
+    TAG: "AbstractHandleDirective",
+    _0: async () => {
+      capturedCallCount.contents = capturedCallCount.contents + 1 | 0;
+    }
+  }];
+
+let TestCallMapping = {
+  ExtensionPoint: undefined,
+  delegateName: delegateName$1,
+  mapIncomingCommands: mapIncomingCommands$1,
+  mapOutgoingEvent: mapOutgoingEvent$1
+};
+
+let delegateName$2 = "AsyncAgg";
+
+function mapIncomingCommands$2(_topicItems, _createSchedule, _deleteSchedule, _queryEngine) {
+  return [];
+}
+
+let mapOutgoingEvent$2 = (eventJson, _createSchedule, _deleteSchedule, _queryEngine) => {
+  let asyncResult = Promise.resolve([
+    "ep-async-dest",
+    outgoingMeta,
+    eventJson
+  ]);
+  return [{
+      TAG: "AbstractPublishEventAsync",
+      _0: asyncResult
+    }];
+};
+
+let TestAsyncMapping = {
+  ExtensionPoint: undefined,
+  delegateName: delegateName$2,
+  mapIncomingCommands: mapIncomingCommands$2,
+  mapOutgoingEvent: mapOutgoingEvent$2
+};
+
+let moduleUrl$1 = import.meta.url;
+
+let mappings = [
+  {
+    delegateName: delegateName,
+    mapIncomingCommands: mapIncomingCommands,
+    mapOutgoingEvent: mapOutgoingEvent
+  },
+  {
+    delegateName: delegateName$1,
+    mapIncomingCommands: mapIncomingCommands$1,
+    mapOutgoingEvent: mapOutgoingEvent$1
+  },
+  {
+    delegateName: delegateName$2,
+    mapIncomingCommands: mapIncomingCommands$2,
+    mapOutgoingEvent: mapOutgoingEvent$2
+  }
+];
+
+let TestOpsMappings = {
+  Spec: undefined,
+  name: "TestOpsMappings",
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+async function publishToEventTopic(id, meta, eventJson) {
+  capturedPublished.contents = capturedPublished.contents.concat([[
+      id,
+      meta,
+      eventJson
+    ]]);
+}
+
+let commandTopicResources = [];
+
+async function scheduler_createSchedule(param, param$1) {
+  
+}
+
+async function scheduler_deleteSchedule(param, param$1) {
+  
+}
+
+let scheduler = {
+  createSchedule: scheduler_createSchedule,
+  deleteSchedule: scheduler_deleteSchedule
+};
+
+async function queryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function queryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let queryEngine = {
+  scan: queryEngine_scan,
+  query: queryEngine_query
+};
+
+function resourceNaming_validateName(n) {
+  return n;
+}
+
+function resourceNaming_urnName(n) {
+  return n;
+}
+
+let resourceNaming = {
+  validateName: resourceNaming_validateName,
+  urnName: resourceNaming_urnName
+};
+
+let TestOps = {
+  publishToEventTopic: publishToEventTopic,
+  commandTopicResources: commandTopicResources,
+  scheduler: scheduler,
+  queryEngine: queryEngine,
+  resourceNaming: resourceNaming
+};
+
+let EpOps = ExtensionPoint_Operations$ReventlessCore.Make({
+  name: name,
+  moduleUrl: moduleUrl,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  directiveSchema: directiveSchema
+})({
+  mappings: mappings
+})(TestOps);
+
+function makeEventJsonForAgg(aggregateName) {
+  let meta_ip = "127.0.0.1";
+  let meta_user = "tester";
+  let meta = {
+    service: aggregateName,
+    time: "2024-01-01T00:00:00Z",
+    ip: meta_ip,
+    user: meta_user,
+    msgId: "msg-test",
+    correlationId: "corr-test"
+  };
+  return Object.fromEntries([
+    [
+      "meta",
+      S.reverseConvertToJsonOrThrow(meta, Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      "SomeEvent"
+    ]
+  ]);
+}
+
+function reset() {
+  capturedPublished.contents = [];
+  capturedCallCount.contents = 0;
+}
+
+globalThis.describe("ExtensionPoint_Operations.Make:", () => {
+  globalThis.beforeEach(() => reset());
+  globalThis.describe("outgoingJsonEventsHandler — AbstractPublishEvent:", () => {
+    globalThis.test("known aggregate calls publishToEventTopic with correct destination id", async () => {
+      let eventJson = makeEventJsonForAgg("PublishAgg");
+      await EpOps.outgoingJsonEventsHandler(eventJson, undefined);
+      globalThis.expect(capturedPublished.contents.length).toBe(1);
+      let item = capturedPublished.contents[0];
+      globalThis.expect(item[0]).toBe("ep-dest");
+    });
+    globalThis.test("publishToEventTopic receives the original event JSON", async () => {
+      let eventJson = makeEventJsonForAgg("PublishAgg");
+      await EpOps.outgoingJsonEventsHandler(eventJson, undefined);
+      let item = capturedPublished.contents[0];
+      globalThis.expect(item[2]).toEqual(eventJson);
+    });
+  });
+  globalThis.describe("outgoingJsonEventsHandler — AbstractHandleDirective:", () => {
+    globalThis.test("known aggregate with AbstractHandleDirective invokes the handler", async () => {
+      let eventJson = makeEventJsonForAgg("CallAgg");
+      await EpOps.outgoingJsonEventsHandler(eventJson, undefined);
+      globalThis.expect(capturedCallCount.contents).toBe(1);
+      globalThis.expect(capturedPublished.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("outgoingJsonEventsHandler — AbstractPublishEventAsync:", () => {
+    globalThis.test("async mapping resolves and calls publishToEventTopic", async () => {
+      let eventJson = makeEventJsonForAgg("AsyncAgg");
+      await EpOps.outgoingJsonEventsHandler(eventJson, undefined);
+      globalThis.expect(capturedPublished.contents.length).toBe(1);
+      let item = capturedPublished.contents[0];
+      globalThis.expect(item[0]).toBe("ep-async-dest");
+    });
+  });
+  globalThis.describe("outgoingJsonEventsHandler — no matching mapping:", () => {
+    globalThis.test("event from unknown aggregate throws", async () => {
+      let eventJson = makeEventJsonForAgg("UnknownAgg");
+      let didThrow = false;
+      try {
+        await EpOps.outgoingJsonEventsHandler(eventJson, undefined);
+      } catch (exn) {
+        didThrow = true;
+      }
+      globalThis.expect(didThrow).toBe(true);
+    });
+  });
+});
+
+export {
+  OpsEPSpec,
+  capturedPublished,
+  capturedCallCount,
+  outgoingMeta,
+  TestPublishMapping,
+  TestCallMapping,
+  TestAsyncMapping,
+  TestOpsMappings,
+  TestOps,
+  EpOps,
+  makeEventJsonForAgg,
+  reset,
+}
+/*  Not a pure module */

package/tests/ftp/FTPTest.res

@@ -0,0 +1,64 @@
+open JestGlobals
+open FTP
+
+describe("FTP.SSH2 should", () => {
+  testSync("parse valid url, only url given", () => {
+    let t = "example.com"->parseUrl
+    let res = ("example.com", None, "")
+    expect(t)->toEqual(res)
+  })
+
+  testSync("parse valid url, url and relative path given", () => {
+    let t = "example.com/some/path"->parseUrl
+    let res = ("example.com", None, "some/path")
+    expect(t)->toEqual(res)
+  })
+
+  testSync("parse valid url, url and absolute path given", () => {
+    let t = "example.com//some/path"->parseUrl
+    let res = ("example.com", None, "/some/path")
+    expect(t)->toEqual(res)
+  })
+
+  testSync("parse valid url, url and port given", () => {
+    let t = "example.com:8080"->parseUrl
+    let res = ("example.com", Some(8080), "")
+    expect(t)->toEqual(res)
+  })
+
+  testSync("parse valid url, all parts given (relative path)", () => {
+    let t = "reventless.example.com:8025/some/path"->parseUrl
+    let res = ("reventless.example.com", Some(8025), "some/path")
+    expect(t)->toEqual(res)
+  })
+
+  testSync("parse valid url, all parts given (absolute path)", () => {
+    let t = "reventless.example.com:8025//some/path"->parseUrl
+    let res = ("reventless.example.com", Some(8025), "/some/path")
+    expect(t)->toEqual(res)
+  })
+
+  testSync("parse valid url, all parts given (relative path first)", () => {
+    let t = "example.com/some/path:8080"->parseUrl
+    let res = ("example.com", Some(8080), "some/path")
+    expect(t)->toEqual(res)
+  })
+
+  testSync("parse valid url, all parts given (absolute path first)", () => {
+    let t = "example.com//some/path:8080"->parseUrl
+    let res = ("example.com", Some(8080), "/some/path")
+    expect(t)->toEqual(res)
+  })
+
+  testSync("parse url with invalid port (relative path)", () => {
+    let t = "example.com/some/path:invalidPort"->parseUrl
+    let res = ("example.com", None, "some/path")
+    expect(t)->toEqual(res)
+  })
+
+  testSync("parse url with invalid port (absolute path)", () => {
+    let t = "example.com//some/path:invalidPort"->parseUrl
+    let res = ("example.com", None, "/some/path")
+    expect(t)->toEqual(res)
+  })
+})

package/tests/ftp/FTPTest.res.mjs

@@ -0,0 +1,88 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as FTP$ReventlessCore from "../../src/util/FTP.res.mjs";
+
+globalThis.describe("FTP.SSH2 should", () => {
+  globalThis.test("parse valid url, only url given", () => {
+    let t = FTP$ReventlessCore.parseUrl("example.com");
+    globalThis.expect(t).toEqual([
+      "example.com",
+      undefined,
+      ""
+    ]);
+  });
+  globalThis.test("parse valid url, url and relative path given", () => {
+    let t = FTP$ReventlessCore.parseUrl("example.com/some/path");
+    globalThis.expect(t).toEqual([
+      "example.com",
+      undefined,
+      "some/path"
+    ]);
+  });
+  globalThis.test("parse valid url, url and absolute path given", () => {
+    let t = FTP$ReventlessCore.parseUrl("example.com//some/path");
+    globalThis.expect(t).toEqual([
+      "example.com",
+      undefined,
+      "/some/path"
+    ]);
+  });
+  globalThis.test("parse valid url, url and port given", () => {
+    let t = FTP$ReventlessCore.parseUrl("example.com:8080");
+    globalThis.expect(t).toEqual([
+      "example.com",
+      8080,
+      ""
+    ]);
+  });
+  globalThis.test("parse valid url, all parts given (relative path)", () => {
+    let t = FTP$ReventlessCore.parseUrl("reventless.example.com:8025/some/path");
+    globalThis.expect(t).toEqual([
+      "reventless.example.com",
+      8025,
+      "some/path"
+    ]);
+  });
+  globalThis.test("parse valid url, all parts given (absolute path)", () => {
+    let t = FTP$ReventlessCore.parseUrl("reventless.example.com:8025//some/path");
+    globalThis.expect(t).toEqual([
+      "reventless.example.com",
+      8025,
+      "/some/path"
+    ]);
+  });
+  globalThis.test("parse valid url, all parts given (relative path first)", () => {
+    let t = FTP$ReventlessCore.parseUrl("example.com/some/path:8080");
+    globalThis.expect(t).toEqual([
+      "example.com",
+      8080,
+      "some/path"
+    ]);
+  });
+  globalThis.test("parse valid url, all parts given (absolute path first)", () => {
+    let t = FTP$ReventlessCore.parseUrl("example.com//some/path:8080");
+    globalThis.expect(t).toEqual([
+      "example.com",
+      8080,
+      "/some/path"
+    ]);
+  });
+  globalThis.test("parse url with invalid port (relative path)", () => {
+    let t = FTP$ReventlessCore.parseUrl("example.com/some/path:invalidPort");
+    globalThis.expect(t).toEqual([
+      "example.com",
+      undefined,
+      "some/path"
+    ]);
+  });
+  globalThis.test("parse url with invalid port (absolute path)", () => {
+    let t = FTP$ReventlessCore.parseUrl("example.com//some/path:invalidPort");
+    globalThis.expect(t).toEqual([
+      "example.com",
+      undefined,
+      "/some/path"
+    ]);
+  });
+});
+
+/*  Not a pure module */