jinaga-server 3.5.2 → 3.5.4

package/integration-test/jinaga-test/http-test-helpers.js

@@ -0,0 +1,77 @@
+const express = require('express');
+const { JinagaServer } = require('./jinaga-server');
+
+const host = "db";
+const connectionString = `postgresql://dev:devpw@${host}:5432/integrationtest`;
+
+/**
+ * Creates an Express app with HTTP router for testing
+ * @returns {Promise<{app: express.Application, close: Function}>}
+ */
+async function createTestApp() {
+  const { handler, close } = JinagaServer.create({
+    pgKeystore: connectionString,
+    pgStore: connectionString
+  });
+
+  const app = express();
+  app.use(express.json());
+  app.use(express.text());
+  app.use(handler);
+
+  return { app, close };
+}
+
+/**
+ * Creates test data with a Root and specified number of Successors
+ * @param {Object} j - Jinaga instance
+ * @param {Object} Root - Root class
+ * @param {Object} Successor - Successor class
+ * @param {number} count - Number of successors to create
+ * @returns {Promise<{root: Object, successors: Array}>}
+ */
+async function createTestData(j, Root, Successor, count) {
+  const root = await j.fact(new Root(Math.random().toString(36).substring(2, 10)));
+  const successors = [];
+  
+  for (let i = 0; i < count; i++) {
+    const successor = await j.fact(new Successor(`successor-${i}`, root));
+    successors.push(successor);
+  }
+  
+  return { root, successors };
+}
+
+/**
+ * Parses NDJSON response text
+ * @param {string} text - Response text in NDJSON format
+ * @returns {Array} Array of parsed JSON objects
+ */
+function parseNDJSON(text) {
+  return text
+    .trim()
+    .split('\n')
+    .filter(line => line.trim() !== '')
+    .map(line => JSON.parse(line));
+}
+
+/**
+ * Measures memory usage during function execution
+ * @param {Function} fn - Async function to execute
+ * @returns {Promise<{result: any, heapUsed: number}>}
+ */
+async function measureMemory(fn) {
+  const startMemory = process.memoryUsage().heapUsed;
+  const result = await fn();
+  const endMemory = process.memoryUsage().heapUsed;
+  const heapUsed = endMemory - startMemory;
+  
+  return { result, heapUsed };
+}
+
+module.exports = {
+  createTestApp,
+  createTestData,
+  parseNDJSON,
+  measureMemory
+};

package/integration-test/jinaga-test/jinaga.test.js

@@ -21,7 +21,7 @@ class Successor {
 
     constructor(identifier, predecessor) {
         this.identifier = identifier;
-        this.predecessor = predecessor;
+        this.pred = predecessor;
     }
 }
 
@@ -30,7 +30,7 @@ class UnknownType {
     type = UnknownType.Type;
 
     constructor(predecessor) {
-        this.predecessor = predecessor;
+        this.pred = predecessor;
     }
 }
 
@@ -95,10 +95,10 @@ class MembershipRestored {
 const model = buildModel(b => b
     .type(Root)
     .type(Successor, m => m
-        .predecessor("predecessor", Root)
+        .predecessor("pred", Root)
     )
     .type(UnknownType, m => m
-        .predecessor("predecessor", Root)
+        .predecessor("pred", Root)
     )
     .type(User)
     .type(UserName, m => m
@@ -147,12 +147,12 @@ function randomTenant(creator) {
 
 const successorsOfRoot = model.given(Root).match((root, facts) =>
     facts.ofType(Successor)
-        .join(s => s.predecessor, root)
+        .join(s => s.pred, root)
 );
 
 const unknownOfRoot = model.given(Root).match((root, facts) =>
     facts.ofType(UnknownType)
-        .join(s => s.predecessor, root)
+        .join(s => s.pred, root)
 );
 
 const configurationFromDevice = model.given(Device).match((device, facts) =>
@@ -248,7 +248,7 @@ describe("Jinaga as a device", () => {
         const successor = await j.fact(new Successor("test-successor", root));
 
         expect(successor.identifier).toEqual("test-successor");
-        expect(successor.predecessor).toEqual(root);
+        expect(successor.pred).toEqual(root);
     });
 
     it("should query a successor fact", async () => {
@@ -274,7 +274,7 @@ describe("Jinaga as a device", () => {
         const successor = await j.fact(new Successor("test-successor", root));
 
         expect(successor.identifier).toEqual("test-successor");
-        expect(successor.predecessor).toEqual(root);
+        expect(successor.pred).toEqual(root);
     });
 
 
@@ -282,7 +282,7 @@ describe("Jinaga as a device", () => {
         const successor = await j.fact(new Successor("test-successor", randomRoot()));
 
         expect(successor.identifier).toEqual("test-successor");
-        expect(successor.predecessor.type).toEqual("IntegrationTest.Root");
+        expect(successor.pred.type).toEqual("IntegrationTest.Root");
     });
 
     it("should get the device identity", async () => {