@loadmill/executer 0.1.52 → 0.1.55

package/test/post-script-executor.spec.ts

@@ -1,685 +0,0 @@
-import { parameterFunctionOperations } from '@loadmill/core/dist/parameters';
-import { strict as assert } from 'assert';
-import { suite, describe, it } from 'mocha';
-
-import { PostScriptRunner } from '../src/post-script/post-script-executor';
-
-const runPostScript = new PostScriptRunner().run;
-
-suite('Post Script Executor', () => {
-  describe('Empty user code', () => {
-    it('should return empty object', () => {
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, { }, '');
-      assert.deepStrictEqual(result, { });
-    });
-
-    it('should return empty object when static not empty', () => {
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, { }, '');
-      assert.deepStrictEqual(result, { });
-    });
-
-    it('should return identical dynamic object', () => {
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, { key: 'value' }, '');
-      assert.deepStrictEqual(result, { key: 'value' });
-    });
-
-    it('should return identical dynamic function', () => {
-      const func = (a, b) => a + b;
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, { func }, '');
-      assert.deepStrictEqual(result, { func });
-      assert.equal(result.func(1, 2), 3);
-    });
-
-    it('should return identical dynamic array', () => {
-      const arr = [1, '2', null, {}, [], undefined];
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, { arr }, '');
-      assert.deepStrictEqual(result, { arr });
-      assert.equal(result.arr, arr);
-      assert.deepStrictEqual(result.arr, [1, '2', null, {}, [], undefined]);
-    });
-  });
-
-  describe('Override dynamic data', () => {
-    it('should override dynamic var with user code', () => {
-      const dynamicVar = 'arnon';
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, { dynamicVar }, `
-        dynamicVar = 'yochai';
-      `);
-      assert.notDeepStrictEqual(result, { dynamicVar });
-      assert.deepStrictEqual(result, { dynamicVar: 'yochai' });
-    });
-
-    it('should override dynamic function with user code', () => {
-      const dynamicFunc = (a, b) => a + b;
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, { dynamicFunc }, `
-        dynamicFunc = (a, b) => a - b;
-      `);
-      assert.notDeepStrictEqual(result, { dynamicFunc });
-      assert.deepStrictEqual(result.dynamicFunc(7,3), 4);
-    });
-  });
-
-  describe('simple variable declaration', () => {
-    it('should detect var declaration', () => {
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'var myVar = 123;');
-      assert.equal(result.myVar, 123);
-    });
-
-    it('should detect let declaration', () => {
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'let myVar = 123;');
-      assert.equal(result.myVar, 123);
-    });
-
-    it('should detect const declaration', () => {
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'const myVar = 123;');
-      assert.equal(result.myVar, 123);
-    });
-  });
-
-  describe('multiple declarations in one line', () => {
-    it('should detect 2 declarations in one line', () => {
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {},
-        'let username = \'ido\', password = \'solarwinds123\';'
-      );
-
-      assert.equal(result.username, 'ido');
-      assert.equal(result.password, 'solarwinds123');
-    });
-  });
-
-  describe('implicit declaration', () => {
-    const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {},
-      'implicitDeclaration = \'with not let, const or var\';'
-    );
-
-    it('should detect declaration with not let, const or var', () => {
-      assert.equal(result.implicitDeclaration, 'with not let, const or var');
-    });
-  });
-
-  describe('implicit & multiple declarations in one line', () => {
-    const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {},
-      'p1 = 1, p2 = 2;'
-    );
-
-    it('should detect 2 implicit & multiple declarations', () => {
-      assert.equal(result.p1, 1);
-      assert.equal(result.p2, 2);
-    });
-  });
-
-  describe('simple function declarations', () => {
-    it('should detect function declaration', () => {
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {},
-        `function add(x,y) {
-        return x + y;
-      }`
-      );
-      assert.equal(result.add(3,6), 9);
-    });
-
-    it('should detect pointer to function', () => {
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {},
-        `const add = function(x,y) {
-        return x + y;
-      }`
-      );
-      assert.equal(result.add(3, 6), 9);
-    });
-  });
-
-  describe('arrow function declarations', () => {
-    const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {},
-      `const add = (x,y) => {
-        return x + y;
-      }`
-    );
-
-    it('should detect function declaration', () => {
-      assert.equal(result.add(3,6), 9);
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should throw Uncaught ReferenceError', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'func()'), {
-        name: 'ReferenceError',
-        message: 'func is not defined',
-      });
-    });
-
-    it('should throw ReferenceError: process is not defined', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'process.exit()'), {
-        name: 'ReferenceError',
-        message: 'process is not defined',
-      });
-    });
-
-    it('should throw EvalError', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'eval("process.exit()")'), {
-        name: 'EvalError',
-        message: 'Code generation from strings disallowed for this context',
-      });
-    });
-
-    it('should throw Uncaught RangeError', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {},
-        `
-          function f() {
-            f();
-          }
-          f();
-        `
-      ), {
-        name: 'RangeError',
-        message: 'Maximum call stack size exceeded',
-      });
-    });
-  });
-
-  describe('Using the assert module', () => {
-    it('should have the assert module', () => {
-      assert.ok(runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'a = assert'));
-    });
-
-    it('should run assert.equal module', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-        const a = 1;
-        const ass = assert.equal(a, 2);
-      `
-      ), {
-        name: 'AssertionError',
-        message: /Expected values to be strictly equal/,
-      });
-    });
-  });
-
-
-  describe('static data read & write', () => {
-    const $ = {
-      a: 1,
-      b: 2
-    };
-
-    it('should read values from static data', () => {
-      const { result } = runPostScript({ staticContext: { $, __: {} } }, {},
-        `
-          resBodyCopy = $;
-          a = $.a;
-          b = $.b;
-        `);
-      assert.deepStrictEqual(result.a, 1);
-      assert.deepStrictEqual(result.b, 2);
-      assert.deepStrictEqual(result.resBodyCopy, { a: 1, b: 2 });
-    });
-  });
-
-  describe('endless loops are run time bounded', () => {
-    it('should halt the endless FOR loop', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'for(;;);'), {
-        name: 'Error',
-        message: /Script execution timed out/,
-      });
-    });
-
-    it('should halt the endless WHILE loop', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'while(true);'), {
-        name: 'Error',
-        message: /Script execution timed out/,
-      });
-    });
-
-    it('should halt the endless DO WHILE loop', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'do {} while(true);'), {
-        name: 'Error',
-        message: /Script execution timed out/,
-      });
-    });
-
-    it('should halt the endless FOR...OF loop', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-        const arr = [1];
-        for (const x of arr) {
-          arr.push(x);
-        }
-      `), {
-        name: 'Error',
-        message: /Script execution timed out/,
-      });
-    });
-  });
-
-  describe('code longer than 1 second throws error', () => {
-    it('should throw exceeded allowed execution time error', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {},
-        `
-          const wait = (ms) => {
-            const start = Date.now();
-            while (Date.now() - start < ms);
-          }
-          wait(2000)
-        `
-      ), {
-        name: 'Error',
-        message: 'Script execution timed out after 1000ms',
-      });
-    });
-
-  });
-
-  // possible solution here is using isolated vm (seperated process --max-old-space-size)
-  describe('Memory abuse', () => {
-    // it('should not allow memory bomb', () => {
-    //   const res = runPostScript({ staticContext: { $: {}, __: {} } }, {},
-    //     `
-    //     (new Array(Math.pow(2, 32) - 1)).fill(1);
-    //   `);
-    // });
-    it('should not allow access to Buffer', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {},
-        `
-          JSON.stringify(Buffer.alloc(1000000000))
-        `
-      ), {
-        name: 'TypeError',
-        message: /is not a function/,
-      });
-    });
-  });
-
-  describe('Cyclic object', () => {
-    it('should throw if circular object', () => {
-      assert.throws(() => runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-        a = {}
-        b = {}
-        a.b = b
-        b.a = a
-      `), {
-        name: 'TypeError',
-        message: 'Cyclic object value. Circular reference in property a',
-      });
-    });
-
-    it('should not throw if nested object exists more than once but not cyclic ', () => {
-      const obj = { };
-      const containsObj = { obj: obj };
-      const $ = { containsObj, obj };
-      assert.doesNotThrow(() => JSON.stringify($));
-      assert.doesNotThrow(() => runPostScript({ staticContext: { $: $, __: {} } }, {}, 'res = $;'));
-    });
-  });
-
-  describe('global object', () => {
-    it('should return an empty object for a variable referencing the global object', () => {
-      const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'c=global');
-      assert.deepEqual(
-        result.c,
-        {}
-      );
-    });
-  });
-
-  describe('destructuring', () => {
-    describe('object', () => {
-      it('should detect declaration of root property', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'const { x } = { x: 1 };');
-        assert.equal(result.x, 1);
-      });
-
-      it('should detect declaration of 2-level nested property', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            let { x: { y } } = { x: { y: 1 } };
-          `);
-        assert.equal(result.y, 1);
-      });
-
-      it('should detect declaration of 3-level nested property', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            let { x: { y: { z } } } = { x: { y: { z: 1 } } };
-          `);
-        assert.equal(result.z, 1);
-      });
-
-      it('should detect declaration of 4-level nested property', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            let { x: { y: { z: { w } } } } = { x: { y: { z: { w: 1 } } } };
-          `);
-        assert.equal(result.w, 1);
-      });
-
-      it('should detect declaration of two (2) root properties', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            let { x, y } = { x: 1, y: 2 };
-          `);
-        assert.equal(result.x, 1);
-        assert.equal(result.y, 2);
-      });
-
-      it('should detect declaration of a root property and a nested property', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            let { x, y: { z } } = { x: 1, y: { z: 2 } };
-          `);
-        assert.equal(result.x, 1);
-        assert.equal(result.z, 2);
-      });
-
-      it('should detect rest element object declaration', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            const {x, ...theRest } = { x: 1, y: 2, z: 3 };
-          `);
-        assert.equal(result.x, 1);
-        assert.equal(result.theRest.y, 2);
-        assert.equal(result.theRest.z, 3);
-      });
-
-      it('should detect implicit declaration of root property ', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, '({ x } = { x: 1 });');
-        assert.equal(result.x, 1);
-      });
-
-      it('should detect implicit declaration of 2-level nested property ', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, '({ x: { y } } = { x: { y: 1 } });');
-        assert.equal(result.y, 1);
-      });
-
-      it('should detect implicit declaration of 3-level nested property ', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, '({ x: { y: { z } } } = { x: { y: { z: 1 } } });');
-        assert.equal(result.z, 1);
-      });
-
-      it('should detect implicit declaration of two (2) root properties', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            ({ x, y } = { x: 1, y: 2 });
-          `);
-        assert.equal(result.x, 1);
-        assert.equal(result.y, 2);
-      });
-
-      it('should detect implicit declaration of a root property and a nested property', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            ({ x, y: { z } } = { x: 1, y: { z: 2 } });
-          `);
-        assert.equal(result.x, 1);
-        assert.equal(result.z, 2);
-      });
-    });
-
-    describe('array', () => {
-      it('should detect destructured array value', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            const [ x ] = [ 1 ];
-          `);
-        assert.equal(result.x, 1);
-      });
-
-      it('should detect 2 destructured array values', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            const [ x, y ] = [ 1, 2 ];
-          `);
-        assert.equal(result.x, 1);
-        assert.equal(result.y, 2);
-      });
-
-      it('should detect spread array values', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'let [...elements] = [1, 2];');
-        assert.equal(result.elements.length, 2);
-      });
-
-      it('should detect "regular" & spread array values', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'let [a, b, ...rest] = [10, 20, 30, 40, 50];');
-        assert.equal(result.a,10);
-        assert.equal(result.b,20);
-        assert.equal(result.rest.length,3);
-      });
-
-      it('should detect implicit declaration of array destructuring ', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, '([ x ] = [ 1 ]);');
-        assert.equal(result.x, 1);
-      });
-
-      it('should detect 2 implicit declarations of array destructuring ', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, '([ x, y ] = [ 1, 2 ]);');
-        assert.equal(result.x, 1);
-        assert.equal(result.y, 2);
-      });
-
-      it('should detect implicit spread array values', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, '[...elements] = [1, 2];');
-        assert.equal(result.elements.length, 2);
-      });
-
-      it('should detect implicit "regular" & spread array values', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, 'let [a, b, ...rest] = [10, 20, 30, 40, 50];');
-        assert.equal(result.a,10);
-        assert.equal(result.b,20);
-        assert.equal(result.rest.length,3);
-      });
-    });
-
-    describe('array of objects', () => {
-      it('should detect destructured object from array', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            const [ { x } ] = [ { x: 1 } ];
-          `);
-        assert.equal(result.x, 1);
-      });
-      it('should detect nested destructured object from array', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            const [ { x: { y } } ] = [ { x: { y: 1 } } ];
-          `);
-        assert.equal(result.y, 1);
-      });
-      it('should detect destructuring of 3-level nested property from array', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            let [{ x: { y: { z } } }] = [{ x: { y: { z: 1 } } }];
-          `);
-        assert.equal(result.z, 1);
-      });
-      it('should detect destructuring of two (2) root properties from array', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            let [{ x, y }] = [{ x: 1, y: 2 }];
-          `);
-        assert.equal(result.x, 1);
-        assert.equal(result.y, 2);
-      });
-      it('should detect destructuring of a root property and a nested property from array', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            let [{ x, y: { z } }] = [{ x: 1, y: { z: 2 } }];
-          `);
-        assert.equal(result.x, 1);
-        assert.equal(result.z, 2);
-      });
-      it('should detect destructuring of mixed type elements of array', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            let [{ x }, y, z, w, q, t] = [{ x: 1 }, 2, 'a', false, undefined, null];
-          `);
-        assert.equal(result.x, 1);
-        assert.equal(result.y, 2);
-        assert.equal(result.z, 'a');
-        assert.equal(result.w, false);
-        assert.equal(result.q, undefined);
-        assert.equal(result.t, null);
-      });
-    });
-
-    describe('object with array value', () => {
-      it('should detect an array value destructured from object', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            const { x } = { x: [1,2] };
-          `);
-        assert.ok(Array.isArray(result.x));
-        assert.equal(result.x[0], 1);
-        assert.equal(result.x[1], 2);
-      });
-      it('should detect an object destructured from array destructured from object', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            const { x: [ { y } ] } = { x: [ { y: 1 } ] };
-          `);
-        assert.equal(result.y, 1);
-      });
-      it('should detect a deep nested destructuring mix of obj and arr', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            const { a: [ { b: [ { c } ], } ], } = { a: [ { b: [ { c: ['unacceptable'] } ] } ] }
-          `);
-        assert.ok(Array.isArray(result.c));
-        assert.equal(result.c[0], 'unacceptable');
-        assert.equal(result.c.length, 1);
-      });
-    });
-
-    describe('implicit object with array value', () => {
-      it('should detect an implicit array value destructured from object', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            ({ x } = { x: [1,2] });
-          `);
-        assert.ok(Array.isArray(result.x));
-        assert.equal(result.x[0], 1);
-        assert.equal(result.x[1], 2);
-      });
-      it('should detect an object destructured from array destructured from object', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            ({ x: [ { y } ] } = { x: [ { y: 1 } ] });
-          `);
-        assert.equal(result.y, 1);
-      });
-      it('should detect a deep nested destructuring mix of obj and arr', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-            ({ a: [ { b: [ { c } ], } ], } = { a: [ { b: [ { c: ['unacceptable'] } ] } ] });
-          `);
-        assert.ok(Array.isArray(result.c));
-        assert.equal(result.c[0], 'unacceptable');
-        assert.equal(result.c.length, 1);
-      });
-      it('console.log in post script', () => {
-        const { stdout } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-          const a = { "A":1,"B":2,"C":3 };
-          const b = 'print me';
-          const c = [ 1,2,3 ];
-          console.log(a);
-          console.log(b,c);
-        `);
-        assert.deepEqual(stdout , ['{\n  "A": 1,\n  "B": 2,\n  "C": 3\n} ','print me [\n  1,\n  2,\n  3\n] ']);
-      });
-    });
-
-    describe('array of arrays', () => {
-      it('should find destructured array element of array', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-          const [ [ x ] ] = [ [ 1 ] ];
-        `);
-        assert.equal(result.x, 1);
-      });
-      it('should find destructured array elements of array', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-          const [ [ x, y ] ] = [ [ 1, 2 ] ];
-        `);
-        assert.equal(result.x, 1);
-        assert.equal(result.y, 2);
-      });
-      it('should find destructured array element of array inside an object', () => {
-        const { result } = runPostScript({ staticContext: { $: {}, __: {} } }, {}, `
-          const { x: [ [ y ] ] } = { x: [ [ 1 ] ] };
-        `);
-        assert.equal(result.y, 1);
-      });
-    });
-  });
-
-  describe('built-in functions', () => {
-    const $ = {
-      num: 1,
-      str: 'a',
-      bool: true,
-      undf: undefined,
-      nul: null,
-      arr: [2,'b',false, { c: 3 }],
-      obj: { nest: { d: 4 } },
-    };
-
-    const staticContext = { $, __: parameterFunctionOperations };
-    it('should have access to both built-in function and response body', () => {
-      const { result } = runPostScript( { staticContext }, {}, `
-        const x = __.usd();
-        const res = $;
-      `);
-      assert.deepStrictEqual(result.x, '$');
-      assert.deepStrictEqual(result.res, $);
-    });
-
-    describe('should have all the built-in function 😈', () => {
-      it('__random_hex', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_hex();')); });
-      it('__random_uuid', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_uuid();')); });
-      it('__random_from', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_from($.str);')); });
-      it('__random_chars', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_chars();')); });
-      it('__random_number', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_number();')); });
-      it('__random_digits', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_digits();')); });
-      it('__random_uppers', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_uppers();')); });
-      it('__random_lowers', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_lowers();')); });
-      it('__random_letters', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_letters();')); });
-      it('__random_boolean', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_boolean();')); });
-      it('__random_seeded_number', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.random_seeded_number();')); });
-      it('__usd', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.usd();')); });
-      it('__eq', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.eq();')); });
-      it('__neq', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.neq();')); });
-      it('__eqi', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.eqi($.str, "A");')); });
-      it('__neqi', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.neqi($.str, "A");')); });
-      it('__matches', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.matches();')); });
-      it('__array_matches', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.array_matches(JSON.stringify($.arr), "1");')); });
-      it('__array_pluck', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.array_pluck();')); });
-      it('__array_in_range', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.array_in_range(JSON.stringify($.arr), 0, 100);')); });
-      it('__array_includes', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.array_includes(JSON.stringify($.arr), JSON.stringify($.arr));')); });
-      it('__array_sum', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.array_sum(JSON.stringify($.arr));')); });
-      it('__array_sort', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.array_sort(JSON.stringify($.arr));')); });
-      it('__array_sort_numbers', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.array_sort_numbers("[4,3,2]");')); });
-      it('__array_is_unique', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.array_is_unique(JSON.stringify($.arr));')); });
-      it('__contains', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.contains($.str, "a");')); });
-      it('__containsi', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.containsi($.str, "a");')); });
-      it('__is_uuid', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.is_uuid($.str);')); });
-      it('__is_number', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.is_number();')); });
-      it('__length', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.length($.str);')); });
-      it('__array_length', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.array_length(JSON.stringify($.arr));')); });
-      it('__escape_regexp', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.escape_regexp();')); });
-      it('__escape_quotes', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.escape_quotes($.str);')); });
-      it('__encode_url', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.encode_url();')); });
-      it('__decode_url', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.decode_url();')); });
-      it('__decode_base64', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.decode_base64();')); });
-      it('__encode_base64', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.encode_base64();')); });
-      it('__lower', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.lower($.str);')); });
-      it('__upper', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.upper($.str);')); });
-      it('__if_then_else', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.if_then_else($.str,$.str,$.str);')); });
-      it('__switch', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.switch();')); });
-      it('__switchi', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.switchi($.str);')); });
-      it('__pick', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.pick("random",$.str);')); });
-      it('__pick_random', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.pick_random("random",$.str);')); });
-      it('__split_pick', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.split_pick($.str,$.str,"random");')); });
-      it('__slice', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.slice($.str,"1");')); });
-      it('__regexp', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.regexp();')); });
-      it('__json_keys', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.json_keys(JSON.stringify($));')); });
-      it('__jsonpath_keys', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.jsonpath_keys(JSON.stringify($),"$");')); });
-      it('__jsonpath', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.jsonpath(JSON.stringify($),"$");')); });
-      it('__jsonpath_all', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.jsonpath_all(JSON.stringify($),"$");')); });
-      it('__jsonpath_apply', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.jsonpath_apply(JSON.stringify($),"$.str","asd");')); });
-      it('__jsonschema', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.jsonschema(JSON.stringify($),"{}");')); });
-      it('__jquery', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.jquery($.str,$.str);')); });
-      it('__now', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.now();')); });
-      it('__now_ms', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.now_ms();')); });
-      it('__now_iso', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.now_iso();')); });
-      it('__date_iso', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.date_iso();')); });
-      it('__and', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.and();')); });
-      it('__or', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.or();')); });
-      it('__not', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.not();')); });
-      it('__true', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.true();')); });
-      it('__false', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.false();')); });
-      it('__add', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.add();')); });
-      it('__sub', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.sub($.num,$.num);')); });
-      it('__neg', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.neg($.num,$.num);')); });
-      it('__abs', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.abs($.num);')); });
-      it('__mult', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.mult();')); });
-      it('__div', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.div($.num,$.num);')); });
-      it('__lt', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.lt();')); });
-      it('__lte', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.lte();')); });
-      it('__gt', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.gt();')); });
-      it('__gt', () => { assert.doesNotThrow(() => runPostScript({ staticContext }, {}, '__.gt();')); });
-    });
-  });
-});