@wix/motion-edm-autogen-transformations-core 1.3.0

package/dist/cjs/__tests__/corvid-entity.spec.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _motionRuntimeTestContext = require("@wix/motion-runtime-test-context");
+
+var _ = require("..");
+
+var _corvidEntity = require("../lib/corvid-entity");
+
+const toCorvidName = _.corvidEntities.toCorvidName,
+      fromCorvidName = _.corvidEntities.fromCorvidName;
+describe('corvid entities transformers', () => {
+  describe('toCorvidName', () => {
+    test.each`
+      name             | expected
+      ${'id'}          | ${'_id'}
+      ${'createdDate'} | ${'_createdDate'}
+      ${'updatedDate'} | ${'_updatedDate'}
+    `('adjusts $name to $expected', ({
+      name,
+      expected
+    }) => {
+      expect(toCorvidName(name)).toStrictEqual(expected);
+    });
+    test('returns the given name when it should not be changed', () => {
+      const name = (0, _motionRuntimeTestContext.aString)();
+      expect(toCorvidName(name)).toStrictEqual(name);
+    });
+  });
+  describe('fromCorvidName', () => {
+    test.each`
+      name              | expected
+      ${'_id'}          | ${'id'}
+      ${'_createdDate'} | ${'createdDate'}
+      ${'_updatedDate'} | ${'updatedDate'}
+    `('adjusts $name to $expected', ({
+      name,
+      expected
+    }) => {
+      expect(fromCorvidName(name)).toStrictEqual(expected);
+    });
+    test('returns the given name when it should not be changed', () => {
+      const name = (0, _motionRuntimeTestContext.aString)();
+      expect(fromCorvidName(name)).toStrictEqual(name);
+    });
+  });
+  describe('internal methods', () => {
+    const nonReservedName = (0, _motionRuntimeTestContext.aString)();
+    describe('isReservedCorvidFieldName', () => {
+      test('returns true if the provided name is a reserved Corvid field-name', () => {
+        const reservedCorvidName = (0, _motionRuntimeTestContext.aRandomItemFrom)(['_id', '_createdDate', '_updatedDate']);
+        expect((0, _corvidEntity.isReservedCorvidFieldName)(reservedCorvidName)).toBeTruthy();
+      });
+      test('returns false if the provided name is not a reserved common field-name', () => {
+        expect((0, _corvidEntity.isReservedCorvidFieldName)(nonReservedName)).toBeFalsy();
+      });
+    });
+    describe('isReservedCommonFieldName', () => {
+      test('returns true if the provided name is a reserved common field-name', () => {
+        const commonReservedName = (0, _motionRuntimeTestContext.aRandomItemFrom)(['id', 'createdDate', 'updatedDate']);
+        expect((0, _corvidEntity.isReservedCommonFieldName)(commonReservedName)).toBeTruthy();
+      });
+      test('returns false if the provided name is not a reserved common field-name', () => {
+        expect((0, _corvidEntity.isReservedCommonFieldName)(nonReservedName)).toBeFalsy();
+      });
+    });
+  });
+});
+//# sourceMappingURL=corvid-entity.spec.js.map

package/dist/cjs/__tests__/corvid-entity.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/__tests__/corvid-entity.spec.ts"],"names":["toCorvidName","corvidEntities","fromCorvidName","describe","test","each","name","expected","expect","toStrictEqual","nonReservedName","reservedCorvidName","toBeTruthy","toBeFalsy","commonReservedName"],"mappings":";;AAAA;;AACA;;AACA;;AAKA,MAAQA,YAAR,GAAyCC,gBAAzC,CAAQD,YAAR;AAAA,MAAsBE,cAAtB,GAAyCD,gBAAzC,CAAsBC,cAAtB;AAEAC,QAAQ,CAAC,8BAAD,EAAiC,MAAM;AAC7CA,EAAAA,QAAQ,CAAC,cAAD,EAAiB,MAAM;AAC7BC,IAAAA,IAAI,CAACC,IAAK;AACd;AACA,QAAQ,IAAK,eAAc,KAAM;AACjC,QAAQ,aAAc,MAAK,cAAe;AAC1C,QAAQ,aAAc,MAAK,cAAe;AAC1C,KALI,CAKE,4BALF,EAKgC,CAAC;AAAEC,MAAAA,IAAF;AAAQC,MAAAA;AAAR,KAAD,KAAwB;AACtDC,MAAAA,MAAM,CAACR,YAAY,CAACM,IAAD,CAAb,CAAN,CAA2BG,aAA3B,CAAyCF,QAAzC;AACD,KAPD;AASAH,IAAAA,IAAI,CAAC,sDAAD,EAAyD,MAAM;AACjE,YAAME,IAAI,GAAG,wCAAb;AAEAE,MAAAA,MAAM,CAACR,YAAY,CAACM,IAAD,CAAb,CAAN,CAA2BG,aAA3B,CAAyCH,IAAzC;AACD,KAJG,CAAJ;AAKD,GAfO,CAAR;AAiBAH,EAAAA,QAAQ,CAAC,gBAAD,EAAmB,MAAM;AAC/BC,IAAAA,IAAI,CAACC,IAAK;AACd;AACA,QAAQ,KAAM,eAAc,IAAK;AACjC,QAAQ,cAAe,MAAK,aAAc;AAC1C,QAAQ,cAAe,MAAK,aAAc;AAC1C,KALI,CAKE,4BALF,EAKgC,CAAC;AAAEC,MAAAA,IAAF;AAAQC,MAAAA;AAAR,KAAD,KAAwB;AACtDC,MAAAA,MAAM,CAACN,cAAc,CAACI,IAAD,CAAf,CAAN,CAA6BG,aAA7B,CAA2CF,QAA3C;AACD,KAPD;AASAH,IAAAA,IAAI,CAAC,sDAAD,EAAyD,MAAM;AACjE,YAAME,IAAI,GAAG,wCAAb;AAEAE,MAAAA,MAAM,CAACN,cAAc,CAACI,IAAD,CAAf,CAAN,CAA6BG,aAA7B,CAA2CH,IAA3C;AACD,KAJG,CAAJ;AAKD,GAfO,CAAR;AAiBAH,EAAAA,QAAQ,CAAC,kBAAD,EAAqB,MAAM;AACjC,UAAMO,eAAe,GAAG,wCAAxB;AAEAP,IAAAA,QAAQ,CAAC,2BAAD,EAA8B,MAAM;AAC1CC,MAAAA,IAAI,CAAC,mEAAD,EAAsE,MAAM;AAC9E,cAAMO,kBAAkB,GAAG,+CAAgB,CACzC,KADyC,EAEzC,cAFyC,EAGzC,cAHyC,CAAhB,CAA3B;AAMAH,QAAAA,MAAM,CAAC,6CAA0BG,kBAA1B,CAAD,CAAN,CAAsDC,UAAtD;AACD,OARG,CAAJ;AAUAR,MAAAA,IAAI,CAAC,wEAAD,EAA2E,MAAM;AACnFI,QAAAA,MAAM,CAAC,6CAA0BE,eAA1B,CAAD,CAAN,CAAmDG,SAAnD;AACD,OAFG,CAAJ;AAGD,KAdO,CAAR;AAgBAV,IAAAA,QAAQ,CAAC,2BAAD,EAA8B,MAAM;AAC1CC,MAAAA,IAAI,CAAC,mEAAD,EAAsE,MAAM;AAC9E,cAAMU,kBAAkB,GAAG,+CAAgB,CACzC,IADyC,EAEzC,aAFyC,EAGzC,aAHyC,CAAhB,CAA3B;AAMAN,QAAAA,MAAM,CAAC,6CAA0BM,kBAA1B,CAAD,CAAN,CAAsDF,UAAtD;AACD,OARG,CAAJ;AAUAR,MAAAA,IAAI,CAAC,wEAAD,EAA2E,MAAM;AACnFI,QAAAA,MAAM,CAAC,6CAA0BE,eAA1B,CAAD,CAAN,CAAmDG,SAAnD;AACD,OAFG,CAAJ;AAGD,KAdO,CAAR;AAeD,GAlCO,CAAR;AAmCD,CAtEO,CAAR","sourcesContent":["import { aString, aRandomItemFrom } from '@wix/motion-runtime-test-context';\nimport { corvidEntities } from '..';\nimport {\n  isReservedCorvidFieldName,\n  isReservedCommonFieldName,\n} from '../lib/corvid-entity';\n\nconst { toCorvidName, fromCorvidName } = corvidEntities;\n\ndescribe('corvid entities transformers', () => {\n  describe('toCorvidName', () => {\n    test.each`\n      name             | expected\n      ${'id'}          | ${'_id'}\n      ${'createdDate'} | ${'_createdDate'}\n      ${'updatedDate'} | ${'_updatedDate'}\n    `('adjusts $name to $expected', ({ name, expected }) => {\n      expect(toCorvidName(name)).toStrictEqual(expected);\n    });\n\n    test('returns the given name when it should not be changed', () => {\n      const name = aString();\n\n      expect(toCorvidName(name)).toStrictEqual(name);\n    });\n  });\n\n  describe('fromCorvidName', () => {\n    test.each`\n      name              | expected\n      ${'_id'}          | ${'id'}\n      ${'_createdDate'} | ${'createdDate'}\n      ${'_updatedDate'} | ${'updatedDate'}\n    `('adjusts $name to $expected', ({ name, expected }) => {\n      expect(fromCorvidName(name)).toStrictEqual(expected);\n    });\n\n    test('returns the given name when it should not be changed', () => {\n      const name = aString();\n\n      expect(fromCorvidName(name)).toStrictEqual(name);\n    });\n  });\n\n  describe('internal methods', () => {\n    const nonReservedName = aString();\n\n    describe('isReservedCorvidFieldName', () => {\n      test('returns true if the provided name is a reserved Corvid field-name', () => {\n        const reservedCorvidName = aRandomItemFrom([\n          '_id',\n          '_createdDate',\n          '_updatedDate',\n        ]);\n\n        expect(isReservedCorvidFieldName(reservedCorvidName)).toBeTruthy();\n      });\n\n      test('returns false if the provided name is not a reserved common field-name', () => {\n        expect(isReservedCorvidFieldName(nonReservedName)).toBeFalsy();\n      });\n    });\n\n    describe('isReservedCommonFieldName', () => {\n      test('returns true if the provided name is a reserved common field-name', () => {\n        const commonReservedName = aRandomItemFrom([\n          'id',\n          'createdDate',\n          'updatedDate',\n        ]);\n\n        expect(isReservedCommonFieldName(commonReservedName)).toBeTruthy();\n      });\n\n      test('returns false if the provided name is not a reserved common field-name', () => {\n        expect(isReservedCommonFieldName(nonReservedName)).toBeFalsy();\n      });\n    });\n  });\n});\n"]}

package/dist/cjs/__tests__/getArgumentCardinality.spec.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _motionRuntimeTestContext = require("@wix/motion-runtime-test-context");
+
+var _ = require("..");
+
+describe('getArgumentCardinality', () => {
+  describe('simple transformation', () => {
+    const simpleTransformation = `$[${(0, _motionRuntimeTestContext.aNumber)({
+      min: 0,
+      max: 9
+    })}].${(0, _motionRuntimeTestContext.aString)()}`;
+    expect((0, _.getArgumentCardinality)(simpleTransformation)).toStrictEqual(1);
+  });
+  describe('complex transformations', () => {
+    const nonArgumentMapping = (0, _motionRuntimeTestContext.anObject)();
+    const argumentMapping = {
+      [(0, _motionRuntimeTestContext.aString)()]: '$[0].abc',
+      [(0, _motionRuntimeTestContext.aString)()]: '$[1].id',
+      [(0, _motionRuntimeTestContext.aString)()]: '$[2].a',
+      [(0, _motionRuntimeTestContext.aString)()]: '$[3].a.b.c',
+      ...nonArgumentMapping
+    };
+    const argumentMappingArray = ['$[0].a', '$[1].b', 'a.b.c'];
+    test('counts the number of arguments referenced in a given transformation object', () => {
+      const complexMappingTransformation = { ...nonArgumentMapping,
+        ...argumentMapping
+      };
+      expect((0, _.getArgumentCardinality)(complexMappingTransformation)).toStrictEqual(4);
+    });
+    test('counts the number of arguments referenced in a transformation object with arrays', () => {
+      const complexMappingTransformation = { ...nonArgumentMapping,
+        [(0, _motionRuntimeTestContext.aString)()]: argumentMappingArray
+      };
+      expect((0, _.getArgumentCardinality)(complexMappingTransformation)).toStrictEqual(2);
+    });
+    test('counts only unique occurrences', () => {
+      const complexMappingTransformation = { ...nonArgumentMapping,
+        ...argumentMapping,
+        [(0, _motionRuntimeTestContext.aString)()]: argumentMappingArray
+      };
+      expect((0, _.getArgumentCardinality)(complexMappingTransformation)).toStrictEqual(4);
+    });
+    test('does not fail on special transformation cases', () => {
+      const specialTransformation = {
+        [(0, _motionRuntimeTestContext.aString)()]: {
+          '@constant': true
+        },
+        [(0, _motionRuntimeTestContext.aString)()]: {
+          '@constant': null
+        },
+        [(0, _motionRuntimeTestContext.aString)()]: '$[0].a.b.c.'
+      };
+      expect((0, _.getArgumentCardinality)(specialTransformation)).toStrictEqual(1);
+    });
+  });
+});
+//# sourceMappingURL=getArgumentCardinality.spec.js.map

package/dist/cjs/__tests__/getArgumentCardinality.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/__tests__/getArgumentCardinality.spec.ts"],"names":["describe","simpleTransformation","min","max","expect","toStrictEqual","nonArgumentMapping","argumentMapping","argumentMappingArray","test","complexMappingTransformation","specialTransformation"],"mappings":";;AAAA;;AACA;;AAEAA,QAAQ,CAAC,wBAAD,EAA2B,MAAM;AACvCA,EAAAA,QAAQ,CAAC,uBAAD,EAA0B,MAAM;AACtC,UAAMC,oBAAoB,GAAI,KAAI,uCAAQ;AACxCC,MAAAA,GAAG,EAAE,CADmC;AAExCC,MAAAA,GAAG,EAAE;AAFmC,KAAR,CAG/B,KAAI,wCAAU,EAHjB;AAKAC,IAAAA,MAAM,CAAC,8BAAuBH,oBAAvB,CAAD,CAAN,CAAqDI,aAArD,CAAmE,CAAnE;AACD,GAPO,CAAR;AASAL,EAAAA,QAAQ,CAAC,yBAAD,EAA4B,MAAM;AACxC,UAAMM,kBAAkB,GAAG,yCAA3B;AAEA,UAAMC,eAAe,GAAG;AACtB,OAAC,wCAAD,GAAa,UADS;AAEtB,OAAC,wCAAD,GAAa,SAFS;AAGtB,OAAC,wCAAD,GAAa,QAHS;AAItB,OAAC,wCAAD,GAAa,YAJS;AAKtB,SAAGD;AALmB,KAAxB;AAQA,UAAME,oBAAoB,GAAG,CAAC,QAAD,EAAW,QAAX,EAAqB,OAArB,CAA7B;AAEAC,IAAAA,IAAI,CAAC,4EAAD,EAA+E,MAAM;AACvF,YAAMC,4BAA4B,GAAG,EACnC,GAAGJ,kBADgC;AAEnC,WAAGC;AAFgC,OAArC;AAKAH,MAAAA,MAAM,CACJ,8BAAuBM,4BAAvB,CADI,CAAN,CAEEL,aAFF,CAEgB,CAFhB;AAGD,KATG,CAAJ;AAWAI,IAAAA,IAAI,CAAC,kFAAD,EAAqF,MAAM;AAC7F,YAAMC,4BAA4B,GAAG,EACnC,GAAGJ,kBADgC;AAEnC,SAAC,wCAAD,GAAaE;AAFsB,OAArC;AAKAJ,MAAAA,MAAM,CACJ,8BAAuBM,4BAAvB,CADI,CAAN,CAEEL,aAFF,CAEgB,CAFhB;AAGD,KATG,CAAJ;AAWAI,IAAAA,IAAI,CAAC,gCAAD,EAAmC,MAAM;AAC3C,YAAMC,4BAA4B,GAAG,EACnC,GAAGJ,kBADgC;AAEnC,WAAGC,eAFgC;AAGnC,SAAC,wCAAD,GAAaC;AAHsB,OAArC;AAMAJ,MAAAA,MAAM,CACJ,8BAAuBM,4BAAvB,CADI,CAAN,CAEEL,aAFF,CAEgB,CAFhB;AAGD,KAVG,CAAJ;AAYAI,IAAAA,IAAI,CAAC,+CAAD,EAAkD,MAAM;AAC1D,YAAME,qBAAqB,GAAG;AAC5B,SAAC,wCAAD,GAAa;AAAE,uBAAa;AAAf,SADe;AAE5B,SAAC,wCAAD,GAAa;AAAE,uBAAa;AAAf,SAFe;AAG5B,SAAC,wCAAD,GAAa;AAHe,OAA9B;AAMAP,MAAAA,MAAM,CAAC,8BAAuBO,qBAAvB,CAAD,CAAN,CAAsDN,aAAtD,CAAoE,CAApE;AACD,KARG,CAAJ;AASD,GAxDO,CAAR;AAyDD,CAnEO,CAAR","sourcesContent":["import { aNumber, aString, anObject } from '@wix/motion-runtime-test-context';\nimport { getArgumentCardinality } from '..';\n\ndescribe('getArgumentCardinality', () => {\n  describe('simple transformation', () => {\n    const simpleTransformation = `$[${aNumber({\n      min: 0,\n      max: 9,\n    })}].${aString()}`;\n\n    expect(getArgumentCardinality(simpleTransformation)).toStrictEqual(1);\n  });\n\n  describe('complex transformations', () => {\n    const nonArgumentMapping = anObject();\n\n    const argumentMapping = {\n      [aString()]: '$[0].abc',\n      [aString()]: '$[1].id',\n      [aString()]: '$[2].a',\n      [aString()]: '$[3].a.b.c',\n      ...nonArgumentMapping,\n    };\n\n    const argumentMappingArray = ['$[0].a', '$[1].b', 'a.b.c'];\n\n    test('counts the number of arguments referenced in a given transformation object', () => {\n      const complexMappingTransformation = {\n        ...nonArgumentMapping,\n        ...argumentMapping,\n      };\n\n      expect(\n        getArgumentCardinality(complexMappingTransformation),\n      ).toStrictEqual(4);\n    });\n\n    test('counts the number of arguments referenced in a transformation object with arrays', () => {\n      const complexMappingTransformation = {\n        ...nonArgumentMapping,\n        [aString()]: argumentMappingArray,\n      };\n\n      expect(\n        getArgumentCardinality(complexMappingTransformation),\n      ).toStrictEqual(2);\n    });\n\n    test('counts only unique occurrences', () => {\n      const complexMappingTransformation = {\n        ...nonArgumentMapping,\n        ...argumentMapping,\n        [aString()]: argumentMappingArray,\n      };\n\n      expect(\n        getArgumentCardinality(complexMappingTransformation),\n      ).toStrictEqual(4);\n    });\n\n    test('does not fail on special transformation cases', () => {\n      const specialTransformation = {\n        [aString()]: { '@constant': true },\n        [aString()]: { '@constant': null },\n        [aString()]: '$[0].a.b.c.',\n      };\n\n      expect(getArgumentCardinality(specialTransformation)).toStrictEqual(1);\n    });\n  });\n});\n"]}

package/dist/cjs/__tests__/helpers.spec.js

@@ -0,0 +1,90 @@
+"use strict";
+
+var _motionEdmAutogenTestContext = require("@wix/motion-edm-autogen-test-context");
+
+var _motionRuntimeTestContext = require("@wix/motion-runtime-test-context");
+
+var _lodash = require("lodash");
+
+var _helpers = require("../lib/helpers");
+
+describe('helper functions', () => {
+  const index = (0, _motionRuntimeTestContext.aNumber)({
+    min: 0,
+    max: 1
+  }); // @ts-expect-error
+
+  const nestedPath = (0, _lodash.times)(3, (0, _motionRuntimeTestContext.aString)()).join('.');
+  const simpleTransformation = `$[${index}]`;
+  const simpleTransformationWithNestedPath = `$[${index}].${nestedPath}`;
+  describe('isSimpleTransformation', () => {
+    test.each`
+      transformation                                    | expectedValue | transformationType
+      ${(0, _motionEdmAutogenTestContext.aSimpleMappingTransformation)().simpleMapping}   | ${true}       | ${'simple'}
+      ${(0, _motionEdmAutogenTestContext.aComplexMappingTransformation)().complexMapping} | ${false}      | ${'complex'}
+    `('returns $expectedValue for $transformationType transformation', ({
+      transformation,
+      expectedValue
+    }) => {
+      expect((0, _helpers.isSimpleTransformation)(transformation)).toStrictEqual(expectedValue);
+    });
+  });
+  describe('extractIndexAndPath', () => {
+    test('extracts the index and nested-path of the argument from a simple tranformation', () => {
+      expect((0, _helpers.extractIndexAndPath)(simpleTransformationWithNestedPath)).toStrictEqual({
+        index,
+        nestedPath
+      });
+    });
+    test('sets the nestedPath to null when one could not be found', () => {
+      expect((0, _helpers.extractIndexAndPath)(simpleTransformation)).toStrictEqual({
+        index,
+        nestedPath: null
+      });
+    });
+  });
+  describe('getArgumentIndex', () => {
+    test('extracts the index of an argument within a jsonpath', () => {
+      expect((0, _helpers.getArgumentIndex)(simpleTransformation)).toStrictEqual(index);
+    });
+    test('return null when no index was found', () => {
+      expect((0, _helpers.getArgumentIndex)((0, _motionRuntimeTestContext.aString)())).toBeNull();
+    });
+  });
+  describe('isJsonPathExpression', () => {
+    test.each`
+      description                | expression           | expectedResult
+      ${'starts with $'}         | ${(0, _motionEdmAutogenTestContext.aRandomJsonPath)()} | ${true}
+      ${'does not start with $'} | ${(0, _motionRuntimeTestContext.aString)()}         | ${false}
+    `('return $expectedResult when the expression $description', ({
+      expression,
+      expectedResult
+    }) => {
+      expect((0, _helpers.isJsonPathExpression)(expression)).toStrictEqual(expectedResult);
+    });
+  });
+  describe('stripJsonPathRootPrefix', () => {
+    const nonJsonPathString = (0, _motionRuntimeTestContext.aString)();
+    const jsonPath = (0, _motionEdmAutogenTestContext.aRandomResponseTransformationJsonPath)();
+    test.each`
+      description                | expression           | expectedResult
+      ${'is $'}                  | ${'$'}               | ${'$'}
+      ${'does not start with $'} | ${nonJsonPathString} | ${nonJsonPathString}
+      ${'starts with $.'}        | ${jsonPath}          | ${jsonPath.slice(2)}
+    `('return $expectedResult when the expression $description', ({
+      expression,
+      expectedResult
+    }) => {
+      expect((0, _helpers.stripJsonPathRootPrefix)(expression)).toStrictEqual(expectedResult);
+    });
+  });
+  describe('isInvalidJsonValue', () => {
+    test('returns true for an invalid json-value', () => {
+      expect((0, _helpers.isInvalidJsonValue)('x-y-z')).toBeTruthy();
+    });
+    test('returns false for a valid json-value', () => {
+      expect((0, _helpers.isInvalidJsonValue)('"string"')).toBeFalsy();
+    });
+  });
+});
+//# sourceMappingURL=helpers.spec.js.map

package/dist/cjs/__tests__/helpers.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/__tests__/helpers.spec.ts"],"names":["describe","index","min","max","nestedPath","join","simpleTransformation","simpleTransformationWithNestedPath","test","each","simpleMapping","complexMapping","transformation","expectedValue","expect","toStrictEqual","toBeNull","expression","expectedResult","nonJsonPathString","jsonPath","slice","toBeTruthy","toBeFalsy"],"mappings":"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","sourcesContent":["import {\n  aSimpleMappingTransformation,\n  aComplexMappingTransformation,\n  aRandomJsonPath,\n  aRandomResponseTransformationJsonPath,\n} from '@wix/motion-edm-autogen-test-context';\nimport { aNumber, aString } from '@wix/motion-runtime-test-context';\nimport { times } from 'lodash';\nimport {\n  isSimpleTransformation,\n  extractIndexAndPath,\n  getArgumentIndex,\n  isJsonPathExpression,\n  stripJsonPathRootPrefix,\n  isInvalidJsonValue,\n} from '../lib/helpers';\n\ndescribe('helper functions', () => {\n  const index = aNumber({ min: 0, max: 1 });\n  // @ts-expect-error\n  const nestedPath = times(3, aString()).join('.');\n  const simpleTransformation = `$[${index}]`;\n  const simpleTransformationWithNestedPath = `$[${index}].${nestedPath}`;\n\n  describe('isSimpleTransformation', () => {\n    test.each`\n      transformation                                    | expectedValue | transformationType\n      ${aSimpleMappingTransformation().simpleMapping}   | ${true}       | ${'simple'}\n      ${aComplexMappingTransformation().complexMapping} | ${false}      | ${'complex'}\n    `(\n      'returns $expectedValue for $transformationType transformation',\n      ({ transformation, expectedValue }) => {\n        expect(isSimpleTransformation(transformation)).toStrictEqual(\n          expectedValue,\n        );\n      },\n    );\n  });\n\n  describe('extractIndexAndPath', () => {\n    test('extracts the index and nested-path of the argument from a simple tranformation', () => {\n      expect(\n        extractIndexAndPath(simpleTransformationWithNestedPath),\n      ).toStrictEqual({ index, nestedPath });\n    });\n\n    test('sets the nestedPath to null when one could not be found', () => {\n      expect(extractIndexAndPath(simpleTransformation)).toStrictEqual({\n        index,\n        nestedPath: null,\n      });\n    });\n  });\n\n  describe('getArgumentIndex', () => {\n    test('extracts the index of an argument within a jsonpath', () => {\n      expect(getArgumentIndex(simpleTransformation)).toStrictEqual(index);\n    });\n\n    test('return null when no index was found', () => {\n      expect(getArgumentIndex(aString())).toBeNull();\n    });\n  });\n\n  describe('isJsonPathExpression', () => {\n    test.each`\n      description                | expression           | expectedResult\n      ${'starts with $'}         | ${aRandomJsonPath()} | ${true}\n      ${'does not start with $'} | ${aString()}         | ${false}\n    `(\n      'return $expectedResult when the expression $description',\n      ({ expression, expectedResult }) => {\n        expect(isJsonPathExpression(expression)).toStrictEqual(expectedResult);\n      },\n    );\n  });\n\n  describe('stripJsonPathRootPrefix', () => {\n    const nonJsonPathString = aString();\n    const jsonPath = aRandomResponseTransformationJsonPath();\n\n    test.each`\n      description                | expression           | expectedResult\n      ${'is $'}                  | ${'$'}               | ${'$'}\n      ${'does not start with $'} | ${nonJsonPathString} | ${nonJsonPathString}\n      ${'starts with $.'}        | ${jsonPath}          | ${jsonPath.slice(2)}\n    `(\n      'return $expectedResult when the expression $description',\n      ({ expression, expectedResult }) => {\n        expect(stripJsonPathRootPrefix(expression)).toStrictEqual(\n          expectedResult,\n        );\n      },\n    );\n  });\n\n  describe('isInvalidJsonValue', () => {\n    test('returns true for an invalid json-value', () => {\n      expect(isInvalidJsonValue('x-y-z')).toBeTruthy();\n    });\n\n    test('returns false for a valid json-value', () => {\n      expect(isInvalidJsonValue('\"string\"')).toBeFalsy();\n    });\n  });\n});\n"]}