@aerokit/sdk 12.83.0 → 12.85.0

package/dist/cjs/junit/junit.js

@@ -21,47 +21,134 @@ __export(junit_exports, {
   assertFalse: () => assertFalse,
   assertNotEquals: () => assertNotEquals,
   assertTrue: () => assertTrue,
+  clearResults: () => clearResults,
   fail: () => fail,
+  getResults: () => getResults,
+  getResultsSummary: () => getResultsSummary,
+  storeResults: () => storeResults,
   test: () => test
 });
 module.exports = __toCommonJS(junit_exports);
-const Assert = Java.type("org.junit.Assert");
+var import_http = require("@aerokit/sdk/http");
+const Assertions = Java.type("org.junit.jupiter.api.Assertions");
+const TestResultsService = Java.type("org.eclipse.dirigible.components.ide.junit.service.TestResultsService");
+const ArrayList = Java.type("java.util.ArrayList");
+const TestResult = Java.type("org.eclipse.dirigible.components.ide.junit.domain.TestResult");
+class TestResultCollector {
+  results = [];
+  currentTest = null;
+  haveFailedTests = false;
+  hasFailedTests() {
+    return this.haveFailedTests;
+  }
+  recordTestStart(name) {
+    this.currentTest = { name, startTime: (/* @__PURE__ */ new Date()).getTime() };
+  }
+  recordTestComplete(status, error) {
+    if (!this.currentTest) return;
+    const result = {
+      name: this.currentTest.name,
+      status,
+      duration: (/* @__PURE__ */ new Date()).getTime() - this.currentTest.startTime,
+      timestamp: (/* @__PURE__ */ new Date()).getTime()
+    };
+    if (error) {
+      result.error = error.message;
+      result.stackTrace = error.stackTrace;
+    }
+    this.results.push(result);
+    this.currentTest = null;
+    if (status === "failed" || error) {
+      this.haveFailedTests = true;
+    }
+  }
+  getResults() {
+    return [...this.results];
+  }
+  storeResults() {
+    const resultsList = new ArrayList();
+    this.results.forEach((e) => resultsList.add(new TestResult(e.name, e.status, e.duration, e.error, e.stackTrace, e.timestamp)));
+    TestResultsService.get().storeResults(resultsList);
+    import_http.Response.sendRedirect("/services/web/ide-junit-results/junit-results");
+  }
+  getSummary() {
+    const results = this.results;
+    const total = results.length;
+    const passed = results.filter((r) => r.status === "passed").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const duration = results.reduce((sum, r) => sum + r.duration, 0);
+    return { total, passed, failed, skipped, duration };
+  }
+  clearResults() {
+    this.results = [];
+    this.currentTest = null;
+    this.haveFailedTests = false;
+  }
+}
+const resultCollector = new TestResultCollector();
 function test(name, testFn) {
-  globalThis.test(name, testFn);
+  resultCollector.recordTestStart(name);
+  if (resultCollector.hasFailedTests()) {
+    resultCollector.recordTestComplete("skipped");
+    console.log(`- Skipping test "${name}" due to previous failures`);
+  } else {
+    try {
+      testFn();
+      resultCollector.recordTestComplete("passed");
+    } catch (error) {
+      resultCollector.recordTestComplete("failed", {
+        message: error?.message || String(error),
+        stackTrace: error?.stack
+      });
+    }
+  }
 }
 function assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined) {
   if (arguments.length === 3) {
-    Assert.assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined);
+    Assertions.assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined);
   } else {
-    Assert.assertEquals(messageOrExpected, expectedOrActual);
+    Assertions.assertEquals(messageOrExpected, expectedOrActual);
   }
 }
 function assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined) {
   if (arguments.length === 3) {
-    Assert.assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined);
+    Assertions.assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined);
   } else {
-    Assert.assertNotEquals(messageOrUnexpected, unexpectedOrActual);
+    Assertions.assertNotEquals(messageOrUnexpected, unexpectedOrActual);
   }
 }
 function assertTrue(messageOrCondition, conditionOrUndefined) {
   if (arguments.length === 2) {
-    Assert.assertTrue(messageOrCondition, conditionOrUndefined);
+    Assertions.assertTrue(messageOrCondition, conditionOrUndefined);
   } else {
-    Assert.assertTrue(messageOrCondition);
+    Assertions.assertTrue(messageOrCondition);
   }
 }
 function assertFalse(messageOrCondition, conditionOrUndefined) {
   if (arguments.length === 2) {
-    Assert.assertFalse(messageOrCondition, conditionOrUndefined);
+    Assertions.assertFalse(messageOrCondition, conditionOrUndefined);
   } else {
-    Assert.assertFalse(messageOrCondition);
+    Assertions.assertFalse(messageOrCondition);
   }
 }
 function fail(message) {
   if (message) {
-    Assert.fail(message);
+    Assertions.fail(message);
   } else {
-    Assert.fail();
+    Assertions.fail();
   }
 }
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/junit/junit.ts"],
  "sourcesContent": ["/**\n * @module junit/junit\n * @package @aerokit/sdk/junit\n * @name JUnit\n * @overview\n * \n * The JUnit module provides a set of utility functions for defining tests and performing assertions, wrapping the native JUnit Assertions for use in TypeScript/JavaScript tests. It allows developers to write test cases in a familiar format while leveraging the powerful assertion capabilities of JUnit, making it easier to validate code behavior and ensure correctness.\n * \n * ### Key Features:\n * - **Test Definition**: The `test` function allows developers to define individual test cases with a descriptive name and a function containing the test logic.\n * - **Assertions**: Functions such as `assertEquals`, `assertNotEquals`, `assertTrue`, `assertFalse`, and `fail` provide a variety of assertion methods to validate conditions and compare values within tests.\n * \n * ### Use Cases:\n * - **Unit Testing**: These utilities are primarily used for writing unit tests to verify the functionality of individual components or functions in isolation.\n * - **Integration Testing**: They can also be used in integration tests to validate the behavior of multiple components working together, ensuring that they interact correctly.\n * \n * ### Example Usage:\n * ```ts\n * import { test, assertEquals, assertTrue } from \"@aerokit/sdk/junit\";\n * \n * test(\"should add two numbers correctly\", () => {\n *     const result = add(2, 3);\n *     assertEquals(5, result);\n * });\n * \n * test(\"should return true for valid input\", () => {\n *     const isValid = validateInput(\"valid input\");\n *     assertTrue(isValid);\n * });\n * ```\n */\n\nconst Assert = Java.type('org.junit.Assert');\n\n/**\n * Defines a test case.\n *\n * @param name The name of the test case.\n * @param testFn The function containing the test logic and assertions.\n */\nexport function test(name: string, testFn: () => void) {\n    // Calls the global test runner function provided by the SDK environment.\n    (globalThis as any).test(name, testFn);\n}\n\n/**\n * Asserts that two objects or primitive values are equal.\n *\n * @template T The type of the values being compared.\n * @param expected The expected value.\n * @param actual The actual value.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertEquals<T>(expected: T, actual: T): void\nexport function assertEquals<T>(message: string, expected: T, actual: T): void\nexport function assertEquals<T>(messageOrExpected?: string | T, expectedOrActual?: T, actualOrUndefined?: T): void {\n    if (arguments.length === 3) {\n        Assert.assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined);\n    } else {\n        Assert.assertEquals(messageOrExpected, expectedOrActual);\n    }\n}\n\n/**\n * Asserts that two objects or primitive values are not equal.\n *\n * @template T The type of the values being compared.\n * @param unexpected The unexpected value.\n * @param actual The actual value.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertNotEquals<T>(unexpected: T, actual: T): void\nexport function assertNotEquals<T>(message: string, unexpected: T, actual: T): void\nexport function assertNotEquals<T>(messageOrUnexpected?: string | T, unexpectedOrActual?: T, actualOrUndefined?: T): void {\n    if (arguments.length === 3) {\n        Assert.assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined);\n    } else {\n        Assert.assertNotEquals(messageOrUnexpected, unexpectedOrActual);\n    }\n}\n\n/**\n * Asserts that a condition is true.\n *\n * @param condition The condition to test.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertTrue(condition: boolean): void\nexport function assertTrue(message: string, condition: boolean): void\nexport function assertTrue(messageOrCondition?: string | boolean, conditionOrUndefined?: boolean): void {\n    if (arguments.length === 2) {\n        Assert.assertTrue(messageOrCondition, conditionOrUndefined);\n    } else {\n        Assert.assertTrue(messageOrCondition);\n    }\n}\n\n/**\n * Asserts that a condition is false.\n *\n * @param condition The condition to test.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertFalse(condition: boolean): void\nexport function assertFalse(message: string, condition: boolean): void\nexport function assertFalse(messageOrCondition?: string | boolean, conditionOrUndefined?: boolean): void {\n    if (arguments.length === 2) {\n        Assert.assertFalse(messageOrCondition, conditionOrUndefined);\n    } else {\n        Assert.assertFalse(messageOrCondition);\n    }\n}\n\n/**\n * Fails a test immediately.\n *\n * @param message Optional message to display indicating the reason for the failure.\n */\nexport function fail(): void\nexport function fail(message: string): void\nexport function fail(message?: string): void {\n    if (message) {\n        Assert.fail(message);\n    } else {\n        Assert.fail();\n    }\n}"],
  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCA,MAAM,SAAS,KAAK,KAAK,kBAAkB;AAQpC,SAAS,KAAK,MAAc,QAAoB;AAEnD,EAAC,WAAmB,KAAK,MAAM,MAAM;AACzC;AAYO,SAAS,aAAgB,mBAAgC,kBAAsB,mBAA6B;AAC/G,MAAI,UAAU,WAAW,GAAG;AACxB,WAAO,aAAa,mBAAmB,kBAAkB,iBAAiB;AAAA,EAC9E,OAAO;AACH,WAAO,aAAa,mBAAmB,gBAAgB;AAAA,EAC3D;AACJ;AAYO,SAAS,gBAAmB,qBAAkC,oBAAwB,mBAA6B;AACtH,MAAI,UAAU,WAAW,GAAG;AACxB,WAAO,gBAAgB,qBAAqB,oBAAoB,iBAAiB;AAAA,EACrF,OAAO;AACH,WAAO,gBAAgB,qBAAqB,kBAAkB;AAAA,EAClE;AACJ;AAUO,SAAS,WAAW,oBAAuC,sBAAsC;AACpG,MAAI,UAAU,WAAW,GAAG;AACxB,WAAO,WAAW,oBAAoB,oBAAoB;AAAA,EAC9D,OAAO;AACH,WAAO,WAAW,kBAAkB;AAAA,EACxC;AACJ;AAUO,SAAS,YAAY,oBAAuC,sBAAsC;AACrG,MAAI,UAAU,WAAW,GAAG;AACxB,WAAO,YAAY,oBAAoB,oBAAoB;AAAA,EAC/D,OAAO;AACH,WAAO,YAAY,kBAAkB;AAAA,EACzC;AACJ;AASO,SAAS,KAAK,SAAwB;AACzC,MAAI,SAAS;AACT,WAAO,KAAK,OAAO;AAAA,EACvB,OAAO;AACH,WAAO,KAAK;AAAA,EAChB;AACJ;",
  "names": []
}

+function getResults() {
+  return resultCollector.getResults();
+}
+function getResultsSummary() {
+  return resultCollector.getSummary();
+}
+function clearResults() {
+  resultCollector.clearResults();
+}
+function storeResults() {
+  resultCollector.storeResults();
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/junit/junit.ts"],
  "sourcesContent": ["/**\n * @module junit/junit\n * @package @aerokit/sdk/junit\n * @name JUnit\n * @overview\n * \n * The JUnit module provides a set of utility functions for defining tests and performing assertions, wrapping the native JUnit Assertions for use in TypeScript/JavaScript tests. It allows developers to write test cases in a familiar format while leveraging the powerful assertion capabilities of JUnit, making it easier to validate code behavior and ensure correctness.\n * \n * ### Key Features:\n * - **Test Definition**: The `test` function allows developers to define individual test cases with a descriptive name and a function containing the test logic.\n * - **Assertions**: Functions such as `assertEquals`, `assertNotEquals`, `assertTrue`, `assertFalse`, and `fail` provide a variety of assertion methods to validate conditions and compare values within tests.\n * - **Result Tracking**: Test results are automatically captured and can be retrieved via the results API.\n * \n * ### Use Cases:\n * - **Unit Testing**: These utilities are primarily used for writing unit tests to verify the functionality of individual components or functions in isolation.\n * - **Integration Testing**: They can also be used in integration tests to validate the behavior of multiple components working together, ensuring that they interact correctly.\n * \n * ### Example Usage:\n * ```ts\n * import { test, assertEquals, assertTrue, storeResults } from \"@aerokit/sdk/junit\";\n * \n * test(\"should add two numbers correctly\", () => {\n *     const result = 2 + 3;\n *     assertEquals(5, result);\n * });\n * \n * test(\"should return true for valid input\", () => {\n *     const isValid = false; // Replace with actual validation logic\n *     assertTrue(isValid);\n * });\n * \n * // After running tests, store results for later retrieval\n * storeResults();\n * ```\n */\n\nimport { Response } from '@aerokit/sdk/http';\n\nconst Assertions = Java.type('org.junit.jupiter.api.Assertions');\nconst TestResultsService = Java.type('org.eclipse.dirigible.components.ide.junit.service.TestResultsService');\nconst ArrayList = Java.type('java.util.ArrayList');\nconst TestResult = Java.type('org.eclipse.dirigible.components.ide.junit.domain.TestResult');\n\n// Test Result Tracking\ninterface TestResult {\n    name: string;\n    status: 'passed' | 'failed' | 'skipped';\n    duration: number;\n    error?: string;\n    stackTrace?: string;\n    timestamp: number;\n}\n\nclass TestResultCollector {\n    private results: TestResult[] = [];\n    private currentTest: { name: string; startTime: number } | null = null;\n    private haveFailedTests: boolean = false;\n\n    public hasFailedTests(): boolean {\n        return this.haveFailedTests;\n    }\n\n    public recordTestStart(name: string): void {\n        this.currentTest = { name, startTime: new Date().getTime() };\n    }\n\n    public recordTestComplete(status: 'passed' | 'failed' | 'skipped', error?: { message: string; stackTrace?: string }): void {\n        if (!this.currentTest) return;\n\n        const result: TestResult = {\n            name: this.currentTest.name,\n            status,\n            duration: new Date().getTime() - this.currentTest.startTime,\n            timestamp: new Date().getTime(),\n        };\n\n        if (error) {\n            result.error = error.message;\n            result.stackTrace = error.stackTrace;\n        }\n\n        this.results.push(result);\n        this.currentTest = null;\n\n        if (status === 'failed' || error) {\n            this.haveFailedTests = true;\n        }\n    }\n\n    public getResults(): TestResult[] {\n        return [...this.results];\n    }\n\n    public storeResults(): void {\n        const resultsList = new ArrayList();\n        this.results.forEach(e => resultsList.add(new TestResult(e.name, e.status, e.duration, e.error, e.stackTrace, e.timestamp)));\n        TestResultsService.get().storeResults(resultsList);\n        Response.sendRedirect('/services/web/ide-junit-results/junit-results');\n    }\n\n    public getSummary(): {\n        total: number;\n        passed: number;\n        failed: number;\n        skipped: number;\n        duration: number;\n    } {\n        const results = this.results;\n        const total = results.length;\n        const passed = results.filter(r => r.status === 'passed').length;\n        const failed = results.filter(r => r.status === 'failed').length;\n        const skipped = results.filter(r => r.status === 'skipped').length;\n        const duration = results.reduce((sum, r) => sum + r.duration, 0);\n\n        return { total, passed, failed, skipped, duration };\n    }\n\n    public clearResults(): void {\n        this.results = [];\n        this.currentTest = null;\n        this.haveFailedTests = false;\n    }\n}\n\nconst resultCollector = new TestResultCollector();\n\n/**\n * Defines a test case.\n *\n * @param name The name of the test case.\n * @param testFn The function containing the test logic and assertions.\n */\nexport function test(name: string, testFn: () => void) {\n    resultCollector.recordTestStart(name);\n    if (resultCollector.hasFailedTests()) {\n        resultCollector.recordTestComplete('skipped');\n        console.log(`- Skipping test \"${name}\" due to previous failures`);\n    } else {\n        try {\n            testFn();\n            resultCollector.recordTestComplete('passed');\n        } catch (error: any) {\n            resultCollector.recordTestComplete('failed', {\n                message: error?.message || String(error),\n                stackTrace: error?.stack,\n            });\n        }\n    }\n}\n\n/**\n * Asserts that two objects or primitive values are equal.\n *\n * @template T The type of the values being compared.\n * @param expected The expected value.\n * @param actual The actual value.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertEquals<T>(expected: T, actual: T): void\nexport function assertEquals<T>(message: string, expected: T, actual: T): void\nexport function assertEquals<T>(messageOrExpected?: string | T, expectedOrActual?: T, actualOrUndefined?: T): void {\n    if (arguments.length === 3) {\n        Assertions.assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined);\n    } else {\n        Assertions.assertEquals(messageOrExpected, expectedOrActual);\n    }\n}\n\n/**\n * Asserts that two objects or primitive values are not equal.\n *\n * @template T The type of the values being compared.\n * @param unexpected The unexpected value.\n * @param actual The actual value.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertNotEquals<T>(unexpected: T, actual: T): void\nexport function assertNotEquals<T>(message: string, unexpected: T, actual: T): void\nexport function assertNotEquals<T>(messageOrUnexpected?: string | T, unexpectedOrActual?: T, actualOrUndefined?: T): void {\n    if (arguments.length === 3) {\n        Assertions.assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined);\n    } else {\n        Assertions.assertNotEquals(messageOrUnexpected, unexpectedOrActual);\n    }\n}\n\n/**\n * Asserts that a condition is true.\n *\n * @param condition The condition to test.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertTrue(condition: boolean): void\nexport function assertTrue(message: string, condition: boolean): void\nexport function assertTrue(messageOrCondition?: string | boolean, conditionOrUndefined?: boolean): void {\n    if (arguments.length === 2) {\n        Assertions.assertTrue(messageOrCondition, conditionOrUndefined);\n    } else {\n        Assertions.assertTrue(messageOrCondition);\n    }\n}\n\n/**\n * Asserts that a condition is false.\n *\n * @param condition The condition to test.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertFalse(condition: boolean): void\nexport function assertFalse(message: string, condition: boolean): void\nexport function assertFalse(messageOrCondition?: string | boolean, conditionOrUndefined?: boolean): void {\n    if (arguments.length === 2) {\n        Assertions.assertFalse(messageOrCondition, conditionOrUndefined);\n    } else {\n        Assertions.assertFalse(messageOrCondition);\n    }\n}\n\n/**\n * Fails a test immediately.\n *\n * @param message Optional message to display indicating the reason for the failure.\n */\nexport function fail(): void\nexport function fail(message: string): void\nexport function fail(message?: string): void {\n    if (message) {\n        Assertions.fail(message);\n    } else {\n        Assertions.fail();\n    }\n}\n\n/**\n * Retrieves all test results collected during this session.\n *\n * @returns An array of test results.\n */\nexport function getResults(): Array<{\n    name: string;\n    status: 'passed' | 'failed' | 'skipped';\n    duration: number;\n    error?: string;\n    stackTrace?: string;\n    timestamp: number;\n}> {\n    return resultCollector.getResults();\n}\n\n/**\n * Retrieves a summary of test execution.\n *\n * @returns An object containing counts and total duration.\n */\nexport function getResultsSummary(): {\n    total: number;\n    passed: number;\n    failed: number;\n    skipped: number;\n    duration: number;\n} {\n    return resultCollector.getSummary();\n}\n\n/**\n * Clears all collected test results.\n */\nexport function clearResults(): void {\n    resultCollector.clearResults();\n}\n\n/**\n * Clears all collected test results.\n */\nexport function storeResults(): void {\n    resultCollector.storeResults();\n}"],
  "mappings": "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",
  "names": []
}


package/dist/dts/junit/junit.d.ts

@@ -9,6 +9,7 @@
  * ### Key Features:
  * - **Test Definition**: The `test` function allows developers to define individual test cases with a descriptive name and a function containing the test logic.
  * - **Assertions**: Functions such as `assertEquals`, `assertNotEquals`, `assertTrue`, `assertFalse`, and `fail` provide a variety of assertion methods to validate conditions and compare values within tests.
+ * - **Result Tracking**: Test results are automatically captured and can be retrieved via the results API.
  *
  * ### Use Cases:
  * - **Unit Testing**: These utilities are primarily used for writing unit tests to verify the functionality of individual components or functions in isolation.
@@ -16,17 +17,20 @@
  *
  * ### Example Usage:
  * ```ts
- * import { test, assertEquals, assertTrue } from "@aerokit/sdk/junit";
+ * import { test, assertEquals, assertTrue, storeResults } from "@aerokit/sdk/junit";
  *
  * test("should add two numbers correctly", () => {
- *     const result = add(2, 3);
+ *     const result = 2 + 3;
  *     assertEquals(5, result);
  * });
  *
  * test("should return true for valid input", () => {
- *     const isValid = validateInput("valid input");
+ *     const isValid = false; // Replace with actual validation logic
  *     assertTrue(isValid);
  * });
+ *
+ * // After running tests, store results for later retrieval
+ * storeResults();
  * ```
  */
 /**
@@ -79,3 +83,36 @@ export declare function assertFalse(message: string, condition: boolean): void;
  */
 export declare function fail(): void;
 export declare function fail(message: string): void;
+/**
+ * Retrieves all test results collected during this session.
+ *
+ * @returns An array of test results.
+ */
+export declare function getResults(): Array<{
+    name: string;
+    status: 'passed' | 'failed' | 'skipped';
+    duration: number;
+    error?: string;
+    stackTrace?: string;
+    timestamp: number;
+}>;
+/**
+ * Retrieves a summary of test execution.
+ *
+ * @returns An object containing counts and total duration.
+ */
+export declare function getResultsSummary(): {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration: number;
+};
+/**
+ * Clears all collected test results.
+ */
+export declare function clearResults(): void;
+/**
+ * Clears all collected test results.
+ */
+export declare function storeResults(): void;

package/dist/esm/junit/junit.mjs

@@ -1,48 +1,135 @@
-const Assert = Java.type("org.junit.Assert");
+import { Response } from "@aerokit/sdk/http";
+const Assertions = Java.type("org.junit.jupiter.api.Assertions");
+const TestResultsService = Java.type("org.eclipse.dirigible.components.ide.junit.service.TestResultsService");
+const ArrayList = Java.type("java.util.ArrayList");
+const TestResult = Java.type("org.eclipse.dirigible.components.ide.junit.domain.TestResult");
+class TestResultCollector {
+  results = [];
+  currentTest = null;
+  haveFailedTests = false;
+  hasFailedTests() {
+    return this.haveFailedTests;
+  }
+  recordTestStart(name) {
+    this.currentTest = { name, startTime: (/* @__PURE__ */ new Date()).getTime() };
+  }
+  recordTestComplete(status, error) {
+    if (!this.currentTest) return;
+    const result = {
+      name: this.currentTest.name,
+      status,
+      duration: (/* @__PURE__ */ new Date()).getTime() - this.currentTest.startTime,
+      timestamp: (/* @__PURE__ */ new Date()).getTime()
+    };
+    if (error) {
+      result.error = error.message;
+      result.stackTrace = error.stackTrace;
+    }
+    this.results.push(result);
+    this.currentTest = null;
+    if (status === "failed" || error) {
+      this.haveFailedTests = true;
+    }
+  }
+  getResults() {
+    return [...this.results];
+  }
+  storeResults() {
+    const resultsList = new ArrayList();
+    this.results.forEach((e) => resultsList.add(new TestResult(e.name, e.status, e.duration, e.error, e.stackTrace, e.timestamp)));
+    TestResultsService.get().storeResults(resultsList);
+    Response.sendRedirect("/services/web/ide-junit-results/junit-results");
+  }
+  getSummary() {
+    const results = this.results;
+    const total = results.length;
+    const passed = results.filter((r) => r.status === "passed").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const duration = results.reduce((sum, r) => sum + r.duration, 0);
+    return { total, passed, failed, skipped, duration };
+  }
+  clearResults() {
+    this.results = [];
+    this.currentTest = null;
+    this.haveFailedTests = false;
+  }
+}
+const resultCollector = new TestResultCollector();
 function test(name, testFn) {
-  globalThis.test(name, testFn);
+  resultCollector.recordTestStart(name);
+  if (resultCollector.hasFailedTests()) {
+    resultCollector.recordTestComplete("skipped");
+    console.log(`- Skipping test "${name}" due to previous failures`);
+  } else {
+    try {
+      testFn();
+      resultCollector.recordTestComplete("passed");
+    } catch (error) {
+      resultCollector.recordTestComplete("failed", {
+        message: error?.message || String(error),
+        stackTrace: error?.stack
+      });
+    }
+  }
 }
 function assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined) {
   if (arguments.length === 3) {
-    Assert.assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined);
+    Assertions.assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined);
   } else {
-    Assert.assertEquals(messageOrExpected, expectedOrActual);
+    Assertions.assertEquals(messageOrExpected, expectedOrActual);
   }
 }
 function assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined) {
   if (arguments.length === 3) {
-    Assert.assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined);
+    Assertions.assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined);
   } else {
-    Assert.assertNotEquals(messageOrUnexpected, unexpectedOrActual);
+    Assertions.assertNotEquals(messageOrUnexpected, unexpectedOrActual);
   }
 }
 function assertTrue(messageOrCondition, conditionOrUndefined) {
   if (arguments.length === 2) {
-    Assert.assertTrue(messageOrCondition, conditionOrUndefined);
+    Assertions.assertTrue(messageOrCondition, conditionOrUndefined);
   } else {
-    Assert.assertTrue(messageOrCondition);
+    Assertions.assertTrue(messageOrCondition);
   }
 }
 function assertFalse(messageOrCondition, conditionOrUndefined) {
   if (arguments.length === 2) {
-    Assert.assertFalse(messageOrCondition, conditionOrUndefined);
+    Assertions.assertFalse(messageOrCondition, conditionOrUndefined);
   } else {
-    Assert.assertFalse(messageOrCondition);
+    Assertions.assertFalse(messageOrCondition);
   }
 }
 function fail(message) {
   if (message) {
-    Assert.fail(message);
+    Assertions.fail(message);
   } else {
-    Assert.fail();
+    Assertions.fail();
   }
 }
+function getResults() {
+  return resultCollector.getResults();
+}
+function getResultsSummary() {
+  return resultCollector.getSummary();
+}
+function clearResults() {
+  resultCollector.clearResults();
+}
+function storeResults() {
+  resultCollector.storeResults();
+}
 export {
   assertEquals,
   assertFalse,
   assertNotEquals,
   assertTrue,
+  clearResults,
   fail,
+  getResults,
+  getResultsSummary,
+  storeResults,
   test
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/junit/junit.ts"],
  "sourcesContent": ["/**\n * @module junit/junit\n * @package @aerokit/sdk/junit\n * @name JUnit\n * @overview\n * \n * The JUnit module provides a set of utility functions for defining tests and performing assertions, wrapping the native JUnit Assertions for use in TypeScript/JavaScript tests. It allows developers to write test cases in a familiar format while leveraging the powerful assertion capabilities of JUnit, making it easier to validate code behavior and ensure correctness.\n * \n * ### Key Features:\n * - **Test Definition**: The `test` function allows developers to define individual test cases with a descriptive name and a function containing the test logic.\n * - **Assertions**: Functions such as `assertEquals`, `assertNotEquals`, `assertTrue`, `assertFalse`, and `fail` provide a variety of assertion methods to validate conditions and compare values within tests.\n * \n * ### Use Cases:\n * - **Unit Testing**: These utilities are primarily used for writing unit tests to verify the functionality of individual components or functions in isolation.\n * - **Integration Testing**: They can also be used in integration tests to validate the behavior of multiple components working together, ensuring that they interact correctly.\n * \n * ### Example Usage:\n * ```ts\n * import { test, assertEquals, assertTrue } from \"@aerokit/sdk/junit\";\n * \n * test(\"should add two numbers correctly\", () => {\n *     const result = add(2, 3);\n *     assertEquals(5, result);\n * });\n * \n * test(\"should return true for valid input\", () => {\n *     const isValid = validateInput(\"valid input\");\n *     assertTrue(isValid);\n * });\n * ```\n */\n\nconst Assert = Java.type('org.junit.Assert');\n\n/**\n * Defines a test case.\n *\n * @param name The name of the test case.\n * @param testFn The function containing the test logic and assertions.\n */\nexport function test(name: string, testFn: () => void) {\n    // Calls the global test runner function provided by the SDK environment.\n    (globalThis as any).test(name, testFn);\n}\n\n/**\n * Asserts that two objects or primitive values are equal.\n *\n * @template T The type of the values being compared.\n * @param expected The expected value.\n * @param actual The actual value.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertEquals<T>(expected: T, actual: T): void\nexport function assertEquals<T>(message: string, expected: T, actual: T): void\nexport function assertEquals<T>(messageOrExpected?: string | T, expectedOrActual?: T, actualOrUndefined?: T): void {\n    if (arguments.length === 3) {\n        Assert.assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined);\n    } else {\n        Assert.assertEquals(messageOrExpected, expectedOrActual);\n    }\n}\n\n/**\n * Asserts that two objects or primitive values are not equal.\n *\n * @template T The type of the values being compared.\n * @param unexpected The unexpected value.\n * @param actual The actual value.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertNotEquals<T>(unexpected: T, actual: T): void\nexport function assertNotEquals<T>(message: string, unexpected: T, actual: T): void\nexport function assertNotEquals<T>(messageOrUnexpected?: string | T, unexpectedOrActual?: T, actualOrUndefined?: T): void {\n    if (arguments.length === 3) {\n        Assert.assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined);\n    } else {\n        Assert.assertNotEquals(messageOrUnexpected, unexpectedOrActual);\n    }\n}\n\n/**\n * Asserts that a condition is true.\n *\n * @param condition The condition to test.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertTrue(condition: boolean): void\nexport function assertTrue(message: string, condition: boolean): void\nexport function assertTrue(messageOrCondition?: string | boolean, conditionOrUndefined?: boolean): void {\n    if (arguments.length === 2) {\n        Assert.assertTrue(messageOrCondition, conditionOrUndefined);\n    } else {\n        Assert.assertTrue(messageOrCondition);\n    }\n}\n\n/**\n * Asserts that a condition is false.\n *\n * @param condition The condition to test.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertFalse(condition: boolean): void\nexport function assertFalse(message: string, condition: boolean): void\nexport function assertFalse(messageOrCondition?: string | boolean, conditionOrUndefined?: boolean): void {\n    if (arguments.length === 2) {\n        Assert.assertFalse(messageOrCondition, conditionOrUndefined);\n    } else {\n        Assert.assertFalse(messageOrCondition);\n    }\n}\n\n/**\n * Fails a test immediately.\n *\n * @param message Optional message to display indicating the reason for the failure.\n */\nexport function fail(): void\nexport function fail(message: string): void\nexport function fail(message?: string): void {\n    if (message) {\n        Assert.fail(message);\n    } else {\n        Assert.fail();\n    }\n}"],
  "mappings": "AAgCA,MAAM,SAAS,KAAK,KAAK,kBAAkB;AAQpC,SAAS,KAAK,MAAc,QAAoB;AAEnD,EAAC,WAAmB,KAAK,MAAM,MAAM;AACzC;AAYO,SAAS,aAAgB,mBAAgC,kBAAsB,mBAA6B;AAC/G,MAAI,UAAU,WAAW,GAAG;AACxB,WAAO,aAAa,mBAAmB,kBAAkB,iBAAiB;AAAA,EAC9E,OAAO;AACH,WAAO,aAAa,mBAAmB,gBAAgB;AAAA,EAC3D;AACJ;AAYO,SAAS,gBAAmB,qBAAkC,oBAAwB,mBAA6B;AACtH,MAAI,UAAU,WAAW,GAAG;AACxB,WAAO,gBAAgB,qBAAqB,oBAAoB,iBAAiB;AAAA,EACrF,OAAO;AACH,WAAO,gBAAgB,qBAAqB,kBAAkB;AAAA,EAClE;AACJ;AAUO,SAAS,WAAW,oBAAuC,sBAAsC;AACpG,MAAI,UAAU,WAAW,GAAG;AACxB,WAAO,WAAW,oBAAoB,oBAAoB;AAAA,EAC9D,OAAO;AACH,WAAO,WAAW,kBAAkB;AAAA,EACxC;AACJ;AAUO,SAAS,YAAY,oBAAuC,sBAAsC;AACrG,MAAI,UAAU,WAAW,GAAG;AACxB,WAAO,YAAY,oBAAoB,oBAAoB;AAAA,EAC/D,OAAO;AACH,WAAO,YAAY,kBAAkB;AAAA,EACzC;AACJ;AASO,SAAS,KAAK,SAAwB;AACzC,MAAI,SAAS;AACT,WAAO,KAAK,OAAO;AAAA,EACvB,OAAO;AACH,WAAO,KAAK;AAAA,EAChB;AACJ;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/junit/junit.ts"],
  "sourcesContent": ["/**\n * @module junit/junit\n * @package @aerokit/sdk/junit\n * @name JUnit\n * @overview\n * \n * The JUnit module provides a set of utility functions for defining tests and performing assertions, wrapping the native JUnit Assertions for use in TypeScript/JavaScript tests. It allows developers to write test cases in a familiar format while leveraging the powerful assertion capabilities of JUnit, making it easier to validate code behavior and ensure correctness.\n * \n * ### Key Features:\n * - **Test Definition**: The `test` function allows developers to define individual test cases with a descriptive name and a function containing the test logic.\n * - **Assertions**: Functions such as `assertEquals`, `assertNotEquals`, `assertTrue`, `assertFalse`, and `fail` provide a variety of assertion methods to validate conditions and compare values within tests.\n * - **Result Tracking**: Test results are automatically captured and can be retrieved via the results API.\n * \n * ### Use Cases:\n * - **Unit Testing**: These utilities are primarily used for writing unit tests to verify the functionality of individual components or functions in isolation.\n * - **Integration Testing**: They can also be used in integration tests to validate the behavior of multiple components working together, ensuring that they interact correctly.\n * \n * ### Example Usage:\n * ```ts\n * import { test, assertEquals, assertTrue, storeResults } from \"@aerokit/sdk/junit\";\n * \n * test(\"should add two numbers correctly\", () => {\n *     const result = 2 + 3;\n *     assertEquals(5, result);\n * });\n * \n * test(\"should return true for valid input\", () => {\n *     const isValid = false; // Replace with actual validation logic\n *     assertTrue(isValid);\n * });\n * \n * // After running tests, store results for later retrieval\n * storeResults();\n * ```\n */\n\nimport { Response } from '@aerokit/sdk/http';\n\nconst Assertions = Java.type('org.junit.jupiter.api.Assertions');\nconst TestResultsService = Java.type('org.eclipse.dirigible.components.ide.junit.service.TestResultsService');\nconst ArrayList = Java.type('java.util.ArrayList');\nconst TestResult = Java.type('org.eclipse.dirigible.components.ide.junit.domain.TestResult');\n\n// Test Result Tracking\ninterface TestResult {\n    name: string;\n    status: 'passed' | 'failed' | 'skipped';\n    duration: number;\n    error?: string;\n    stackTrace?: string;\n    timestamp: number;\n}\n\nclass TestResultCollector {\n    private results: TestResult[] = [];\n    private currentTest: { name: string; startTime: number } | null = null;\n    private haveFailedTests: boolean = false;\n\n    public hasFailedTests(): boolean {\n        return this.haveFailedTests;\n    }\n\n    public recordTestStart(name: string): void {\n        this.currentTest = { name, startTime: new Date().getTime() };\n    }\n\n    public recordTestComplete(status: 'passed' | 'failed' | 'skipped', error?: { message: string; stackTrace?: string }): void {\n        if (!this.currentTest) return;\n\n        const result: TestResult = {\n            name: this.currentTest.name,\n            status,\n            duration: new Date().getTime() - this.currentTest.startTime,\n            timestamp: new Date().getTime(),\n        };\n\n        if (error) {\n            result.error = error.message;\n            result.stackTrace = error.stackTrace;\n        }\n\n        this.results.push(result);\n        this.currentTest = null;\n\n        if (status === 'failed' || error) {\n            this.haveFailedTests = true;\n        }\n    }\n\n    public getResults(): TestResult[] {\n        return [...this.results];\n    }\n\n    public storeResults(): void {\n        const resultsList = new ArrayList();\n        this.results.forEach(e => resultsList.add(new TestResult(e.name, e.status, e.duration, e.error, e.stackTrace, e.timestamp)));\n        TestResultsService.get().storeResults(resultsList);\n        Response.sendRedirect('/services/web/ide-junit-results/junit-results');\n    }\n\n    public getSummary(): {\n        total: number;\n        passed: number;\n        failed: number;\n        skipped: number;\n        duration: number;\n    } {\n        const results = this.results;\n        const total = results.length;\n        const passed = results.filter(r => r.status === 'passed').length;\n        const failed = results.filter(r => r.status === 'failed').length;\n        const skipped = results.filter(r => r.status === 'skipped').length;\n        const duration = results.reduce((sum, r) => sum + r.duration, 0);\n\n        return { total, passed, failed, skipped, duration };\n    }\n\n    public clearResults(): void {\n        this.results = [];\n        this.currentTest = null;\n        this.haveFailedTests = false;\n    }\n}\n\nconst resultCollector = new TestResultCollector();\n\n/**\n * Defines a test case.\n *\n * @param name The name of the test case.\n * @param testFn The function containing the test logic and assertions.\n */\nexport function test(name: string, testFn: () => void) {\n    resultCollector.recordTestStart(name);\n    if (resultCollector.hasFailedTests()) {\n        resultCollector.recordTestComplete('skipped');\n        console.log(`- Skipping test \"${name}\" due to previous failures`);\n    } else {\n        try {\n            testFn();\n            resultCollector.recordTestComplete('passed');\n        } catch (error: any) {\n            resultCollector.recordTestComplete('failed', {\n                message: error?.message || String(error),\n                stackTrace: error?.stack,\n            });\n        }\n    }\n}\n\n/**\n * Asserts that two objects or primitive values are equal.\n *\n * @template T The type of the values being compared.\n * @param expected The expected value.\n * @param actual The actual value.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertEquals<T>(expected: T, actual: T): void\nexport function assertEquals<T>(message: string, expected: T, actual: T): void\nexport function assertEquals<T>(messageOrExpected?: string | T, expectedOrActual?: T, actualOrUndefined?: T): void {\n    if (arguments.length === 3) {\n        Assertions.assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined);\n    } else {\n        Assertions.assertEquals(messageOrExpected, expectedOrActual);\n    }\n}\n\n/**\n * Asserts that two objects or primitive values are not equal.\n *\n * @template T The type of the values being compared.\n * @param unexpected The unexpected value.\n * @param actual The actual value.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertNotEquals<T>(unexpected: T, actual: T): void\nexport function assertNotEquals<T>(message: string, unexpected: T, actual: T): void\nexport function assertNotEquals<T>(messageOrUnexpected?: string | T, unexpectedOrActual?: T, actualOrUndefined?: T): void {\n    if (arguments.length === 3) {\n        Assertions.assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined);\n    } else {\n        Assertions.assertNotEquals(messageOrUnexpected, unexpectedOrActual);\n    }\n}\n\n/**\n * Asserts that a condition is true.\n *\n * @param condition The condition to test.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertTrue(condition: boolean): void\nexport function assertTrue(message: string, condition: boolean): void\nexport function assertTrue(messageOrCondition?: string | boolean, conditionOrUndefined?: boolean): void {\n    if (arguments.length === 2) {\n        Assertions.assertTrue(messageOrCondition, conditionOrUndefined);\n    } else {\n        Assertions.assertTrue(messageOrCondition);\n    }\n}\n\n/**\n * Asserts that a condition is false.\n *\n * @param condition The condition to test.\n * @param message Optional message to display if the assertion fails.\n */\nexport function assertFalse(condition: boolean): void\nexport function assertFalse(message: string, condition: boolean): void\nexport function assertFalse(messageOrCondition?: string | boolean, conditionOrUndefined?: boolean): void {\n    if (arguments.length === 2) {\n        Assertions.assertFalse(messageOrCondition, conditionOrUndefined);\n    } else {\n        Assertions.assertFalse(messageOrCondition);\n    }\n}\n\n/**\n * Fails a test immediately.\n *\n * @param message Optional message to display indicating the reason for the failure.\n */\nexport function fail(): void\nexport function fail(message: string): void\nexport function fail(message?: string): void {\n    if (message) {\n        Assertions.fail(message);\n    } else {\n        Assertions.fail();\n    }\n}\n\n/**\n * Retrieves all test results collected during this session.\n *\n * @returns An array of test results.\n */\nexport function getResults(): Array<{\n    name: string;\n    status: 'passed' | 'failed' | 'skipped';\n    duration: number;\n    error?: string;\n    stackTrace?: string;\n    timestamp: number;\n}> {\n    return resultCollector.getResults();\n}\n\n/**\n * Retrieves a summary of test execution.\n *\n * @returns An object containing counts and total duration.\n */\nexport function getResultsSummary(): {\n    total: number;\n    passed: number;\n    failed: number;\n    skipped: number;\n    duration: number;\n} {\n    return resultCollector.getSummary();\n}\n\n/**\n * Clears all collected test results.\n */\nexport function clearResults(): void {\n    resultCollector.clearResults();\n}\n\n/**\n * Clears all collected test results.\n */\nexport function storeResults(): void {\n    resultCollector.storeResults();\n}"],
  "mappings": "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",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aerokit/sdk",
-  "version": "12.83.0",
+  "version": "12.85.0",
   "description": "Unified TypeScript SDK for modern cloud platforms.",
   "scripts": {
     "clean": "rm -rf dist",