@fincity/kirun-js 3.8.0 → 3.14.0

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

@@ -256,6 +256,133 @@ describe('ExpressionEvaluator with Bracket Notation', () => {
         });
     });
 
+    // Keys whose characters collide with operators. `http-equiv` is the real
+    // case: it is one of the four attributes a `properties.metas.<uid>` entry
+    // can carry in an app definition, and a hyphen is also subtraction.
+    describe('Keys containing operator characters', () => {
+        beforeEach(() => {
+            testData.obj['key-with-hyphen'] = 'hyphenValue';
+            testData.obj['key with space'] = 'spaceValue';
+            testData.obj['key+plus'] = 'plusValue';
+            testData.obj['key:colon'] = 'colonValue';
+            testData.obj['key/slash'] = 'slashValue';
+            testData.obj['a-b'] = 'literalAMinusB';
+            testData.obj.a = 10;
+            testData.obj.b = 3;
+            testData.metas = { m1: { 'http-equiv': 'X-UA-Compatible', content: 'IE=edge' } };
+            testData.k = 'm1';
+        });
+
+        test('hyphen in a double-quoted key', () => {
+            expect(
+                new ExpressionEvaluator('Context.obj["key-with-hyphen"]').evaluate(evaluatorMap),
+            ).toBe('hyphenValue');
+        });
+
+        test('hyphen in a single-quoted key', () => {
+            expect(
+                new ExpressionEvaluator("Context.obj['key-with-hyphen']").evaluate(evaluatorMap),
+            ).toBe('hyphenValue');
+        });
+
+        test('http-equiv, the app definition meta attribute', () => {
+            expect(
+                new ExpressionEvaluator('Context.metas.m1["http-equiv"]').evaluate(evaluatorMap),
+            ).toBe('X-UA-Compatible');
+        });
+
+        test('space, plus, colon and slash in a key', () => {
+            expect(
+                new ExpressionEvaluator('Context.obj["key with space"]').evaluate(evaluatorMap),
+            ).toBe('spaceValue');
+            expect(new ExpressionEvaluator('Context.obj["key+plus"]').evaluate(evaluatorMap)).toBe(
+                'plusValue',
+            );
+            expect(new ExpressionEvaluator('Context.obj["key:colon"]').evaluate(evaluatorMap)).toBe(
+                'colonValue',
+            );
+            expect(new ExpressionEvaluator('Context.obj["key/slash"]').evaluate(evaluatorMap)).toBe(
+                'slashValue',
+            );
+        });
+
+        test('a quoted key wins over the arithmetic it looks like', () => {
+            expect(new ExpressionEvaluator('Context.obj["a-b"]').evaluate(evaluatorMap)).toBe(
+                'literalAMinusB',
+            );
+        });
+
+        test('the SAME key unquoted is arithmetic, and throws', () => {
+            expect(() =>
+                new ExpressionEvaluator('Context.obj.key-with-hyphen').evaluate(evaluatorMap),
+            ).toThrow();
+            expect(() =>
+                new ExpressionEvaluator('Context.metas.m1.http-equiv').evaluate(evaluatorMap),
+            ).toThrow();
+        });
+
+        test('chained brackets, both keys hyphenated or dotted', () => {
+            expect(
+                new ExpressionEvaluator("Context.metas['m1']['http-equiv']").evaluate(evaluatorMap),
+            ).toBe('X-UA-Compatible');
+        });
+
+        test('a variable key resolves, including into a hyphenated leaf', () => {
+            expect(
+                new ExpressionEvaluator('Context.metas[Context.k].content').evaluate(evaluatorMap),
+            ).toBe('IE=edge');
+            expect(
+                new ExpressionEvaluator("Context.metas[Context.k]['http-equiv']").evaluate(
+                    evaluatorMap,
+                ),
+            ).toBe('X-UA-Compatible');
+        });
+
+        // LIMITATION, asserted so a fix shows up as a failing test rather than
+        // going unnoticed: a bracket segment is a literal or a token path, never
+        // an expression. A concatenation inside brackets is taken as the key
+        // text itself and silently misses, with no error.
+        test('an expression inside brackets is NOT evaluated (documented gap)', () => {
+            expect(
+                new ExpressionEvaluator("Context.metas['m' + '1'].content").evaluate(evaluatorMap),
+            ).toBeUndefined();
+        });
+    });
+
+    // A token whose FIRST separator is a bracket used to match no extractor at
+    // all: the prefix is taken as the text up to the first dot, so `Context[0]`
+    // produced an empty prefix and fell through to the literal extractor, which
+    // throws. In the UI that throw reached the root error boundary and replaced
+    // the whole page with an error card. `Parent[0]` was the case that surfaced
+    // it, from a repeater bound to ObjectEntries output ([key, value] pairs),
+    // but it was never Parent-specific.
+    describe('Root level bracket access', () => {
+        test('numeric index directly on the extractor root', () => {
+            const arr: any = ['zero', 'one', 'two'];
+            const map = new Map([['Context.', new TestExtractor(arr)]]);
+            expect(new ExpressionEvaluator('Context[0]').evaluate(map)).toBe('zero');
+            expect(new ExpressionEvaluator('Context[2]').evaluate(map)).toBe('two');
+        });
+
+        test('the dotted form keeps working', () => {
+            const arr: any = ['zero', 'one', 'two'];
+            const map = new Map([['Context.', new TestExtractor(arr)]]);
+            expect(new ExpressionEvaluator('Context.0').evaluate(map)).toBe('zero');
+        });
+
+        test('quoted key directly on the extractor root', () => {
+            const map = new Map([['Context.', new TestExtractor({ 'a.b': 'dotted', plain: 'p' })]]);
+            expect(new ExpressionEvaluator('Context["a.b"]').evaluate(map)).toBe('dotted');
+            expect(new ExpressionEvaluator('Context["plain"]').evaluate(map)).toBe('p');
+            expect(new ExpressionEvaluator("Context['plain']").evaluate(map)).toBe('p');
+        });
+
+        test('a bracket after a dotted path is untouched', () => {
+            const map = new Map([['Context.', new TestExtractor({ arr: [1, 2, 3] })]]);
+            expect(new ExpressionEvaluator('Context.arr[1]').evaluate(map)).toBe(2);
+        });
+    });
+
     describe('Edge cases', () => {
         test('should handle property with multiple dots', () => {
             testData.obj['a.b.c.d'] = 'deepValue';