@fincity/kirun-js 3.4.0 → 3.6.0

package/__tests__/engine/runtime/KIRuntimeIterationGuardTest.ts

@@ -0,0 +1,140 @@
+import {
+    FunctionDefinition,
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    KIRuntime,
+} from '../../../src';
+
+/**
+ * Regression test for the runaway-execution guard.
+ *
+ * The counter used to be incremented only when a queue size changed, which disabled the guard
+ * in exactly the case it exists for: a graph making no progress leaves the queue sizes
+ * untouched, so the counter never advanced and executeGraph could spin forever. The check was
+ * also `==` rather than `>=`, so a skipped boundary value would never trip it.
+ */
+
+// A CountLoop with a step in its body, so execution takes many statement iterations.
+const loopingDefinition = {
+    name: 'loops',
+    namespace: 'TestUI',
+    steps: {
+        loop: {
+            statementName: 'loop',
+            name: 'CountLoop',
+            namespace: 'System.Loop',
+            parameterMap: {
+                count: {
+                    one: {
+                        key: 'one',
+                        type: 'VALUE',
+                        value: 40,
+                    },
+                },
+            },
+        },
+        printer: {
+            statementName: 'printer',
+            name: 'Print',
+            namespace: 'System',
+            dependentStatements: {
+                'Steps.loop.iteration': true,
+            },
+            parameterMap: {
+                values: {
+                    one: {
+                        key: 'one',
+                        type: 'EXPRESSION',
+                        expression: 'Steps.loop.iteration.index',
+                    },
+                },
+            },
+        },
+    },
+};
+
+function run(): Promise<any> {
+    const runtime = new KIRuntime(FunctionDefinition.from(loopingDefinition));
+
+    return runtime.execute(
+        new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map()),
+    );
+}
+
+describe('KIRuntime execution iteration guard', () => {
+    const originalMax = KIRuntime.MAX_EXECUTION_ITERATIONS;
+
+    afterEach(() => {
+        KIRuntime.MAX_EXECUTION_ITERATIONS = originalMax;
+    });
+
+    test('default cap is 1,000,000 and is tunable', () => {
+        expect(originalMax).toBe(1000000);
+    });
+
+    test('a loop that exceeds the cap is stopped', async () => {
+        // Low enough that a 40-pass loop is guaranteed to cross it. If the counter were still
+        // gated on a queue-size change this would run to completion instead of throwing.
+        KIRuntime.MAX_EXECUTION_ITERATIONS = 5;
+
+        await expect(run()).rejects.toThrow(/Execution locked in an infinite loop/);
+    });
+
+    test('the same loop completes when the cap is not exceeded', async () => {
+        KIRuntime.MAX_EXECUTION_ITERATIONS = originalMax;
+
+        await expect(run()).resolves.toBeDefined();
+    });
+
+    // A linear chain pops one vertex and pushes its successor, so the queue size is unchanged
+    // across passes even though real work happened. Under the old "only count when a queue size
+    // changed" rule the counter stayed at zero here, which is precisely why a stuck graph could
+    // never trip the guard. Counting must now advance.
+    test('counts passes even when the queue size never changes', async () => {
+        const linearChain = {
+            name: 'linear',
+            namespace: 'TestUI',
+            steps: {
+                first: {
+                    statementName: 'first',
+                    name: 'Print',
+                    namespace: 'System',
+                    parameterMap: {
+                        values: { one: { key: 'one', type: 'VALUE', value: 'a' } },
+                    },
+                },
+                second: {
+                    statementName: 'second',
+                    name: 'Print',
+                    namespace: 'System',
+                    dependentStatements: { 'Steps.first.output': true },
+                    parameterMap: {
+                        values: { one: { key: 'one', type: 'VALUE', value: 'b' } },
+                    },
+                },
+                third: {
+                    statementName: 'third',
+                    name: 'Print',
+                    namespace: 'System',
+                    dependentStatements: { 'Steps.second.output': true },
+                    parameterMap: {
+                        values: { one: { key: 'one', type: 'VALUE', value: 'c' } },
+                    },
+                },
+            },
+        };
+
+        const params = new FunctionExecutionParameters(
+            new KIRunFunctionRepository(),
+            new KIRunSchemaRepository(),
+        ).setArguments(new Map());
+
+        await new KIRuntime(FunctionDefinition.from(linearChain)).execute(params);
+
+        expect(params.getCount()).toBeGreaterThanOrEqual(3);
+    });
+});

package/__tests__/engine/runtime/expression/ExpressionDoubleEqualsChipLabelTest.ts

@@ -0,0 +1,84 @@
+import {
+    ExpressionEvaluator,
+    KIRunSchemaRepository,
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+} from '../../../../src';
+
+// Reproduces the sitezump buyTokens status-filter chip label expression.
+//
+// Kirun's equality operator is '=' (Operation.EQUAL = new Operation('=')),
+// NOT '=='. Writing '==' makes the lexer read two consecutive '=' tokens,
+// which leaves a dangling operator and throws "Extra operator ... found."
+// This is exactly the error reported on the chip label.
+
+let inMap: Map<string, any> = new Map();
+inMap.set('status', 'PAID'); // Page.invoiceQuery.status equivalent (active)
+inMap.set('emptyStatus', ''); // Page.invoiceQuery.status when "All" (inactive)
+inMap.set('value', 'PAID'); // Parent.value equivalent
+inMap.set('label', 'Paid'); // Parent.label equivalent
+
+let output: Map<string, Map<string, Map<string, any>>> = new Map([
+    ['step1', new Map([['output', inMap]])],
+]);
+
+let parameters: FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository(),
+)
+    .setArguments(new Map())
+    .setSteps(output);
+
+test('Double-equals (==) is not a valid Kirun operator and throws', () => {
+    const expr = new ExpressionEvaluator(
+        "((Steps.step1.output.status ?? '') == Steps.step1.output.value ? '● ' : '') + Steps.step1.output.label",
+    );
+    expect(() => expr.evaluate(parameters.getValuesMap())).toThrow();
+});
+
+test('Single-equals (=) evaluates the chip label correctly', () => {
+    // active chip: status = value -> prefixed with the bullet
+    let expr = new ExpressionEvaluator(
+        "((Steps.step1.output.status ?? '') = Steps.step1.output.value ? '● ' : '') + Steps.step1.output.label",
+    );
+    expect(expr.evaluate(parameters.getValuesMap())).toBe('● Paid');
+
+    // inactive chip: emptyStatus (All) != value -> no prefix
+    expr = new ExpressionEvaluator(
+        "((Steps.step1.output.emptyStatus ?? '') = Steps.step1.output.value ? '● ' : '') + Steps.step1.output.label",
+    );
+    expect(expr.evaluate(parameters.getValuesMap())).toBe('Paid');
+});
+
+// Investigating Kiran's hypothesis: does an expression that ENDS with a string
+// literal (like the original chip label that ended in '') need a trailing space?
+test('Expression ending in a string literal: trailing space should not matter', () => {
+    // exact shape Kiran quoted, ending in '' — no trailing space
+    let noTrail = new ExpressionEvaluator(
+        "(Steps.step1.output.status ?? '') = Steps.step1.output.value ? '● ' : ''",
+    );
+    expect(noTrail.evaluate(parameters.getValuesMap())).toBe('● ');
+
+    // same, WITH a trailing space
+    let withTrail = new ExpressionEvaluator(
+        "(Steps.step1.output.status ?? '') = Steps.step1.output.value ? '● ' : '' ",
+    );
+    expect(withTrail.evaluate(parameters.getValuesMap())).toBe('● ');
+});
+
+test('Bare string literals at end of expression, with/without trailing space', () => {
+    expect(new ExpressionEvaluator("'hello'").evaluate(parameters.getValuesMap())).toBe('hello');
+    expect(new ExpressionEvaluator("'hello' ").evaluate(parameters.getValuesMap())).toBe('hello');
+    expect(new ExpressionEvaluator("''").evaluate(parameters.getValuesMap())).toBe('');
+    expect(new ExpressionEvaluator("'' ").evaluate(parameters.getValuesMap())).toBe('');
+});
+
+// Kiran's platform example: a {{ }} template that expands to a bare quoted string
+// literal followed by trailing spaces. Before the fix this evaluated to undefined,
+// which would have made e.g. a FetchData url resolve to undefined.
+test('Template expanding to a quoted literal with trailing spaces resolves (not undefined)', () => {
+    const expr = new ExpressionEvaluator(
+        '"api/ui/personalization/{{Steps.step1.output.label}}/{{Steps.step1.output.value}}"  ',
+    );
+    expect(expr.evaluate(parameters.getValuesMap())).toBe('api/ui/personalization/Paid/PAID');
+});