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

package/dist/cjs/__tests__/validations/validateRequestTransformation.spec.js

@@ -0,0 +1,291 @@
+"use strict";
+
+var _motionRuntimeTestContext = require("@wix/motion-runtime-test-context");
+
+var _lodash = require("lodash");
+
+var _ = require("../..");
+
+const validateRequestTransformation = _.validation.validateRequestTransformation;
+describe('validateRequestTransformation', () => {
+  describe('valid transformations', () => {
+    const validResults = {
+      isValid: true,
+      validationErrors: []
+    };
+    test('returns valid transformation response for a valid simple transformation', () => {
+      const validTransformation = '$[0].a.b.c';
+      expect(validateRequestTransformation(validTransformation)).toStrictEqual(validResults);
+    });
+    test('returns valid transformation response for a valid complex transformation', () => {
+      const validTransformation = {
+        a: '$[0].a.b.c'
+      };
+      expect(validateRequestTransformation(validTransformation)).toStrictEqual(validResults);
+    });
+  });
+  describe('invalid transformations', () => {
+    const validationErrorWith = ({
+      parentPath,
+      invalidValue,
+      description
+    }) => ({
+      isValid: false,
+      validationErrors: expect.arrayContaining([expect.objectContaining({
+        parentPath,
+        invalidValue,
+        description
+      })])
+    });
+
+    describe('invalid complex-transformation keys', () => {
+      test.each`
+        description                      | transformationKey  | expectedValidationMessage
+        ${'refers to an argument index'} | ${'$[0]'}          | ${"must start with '$.'"}
+        ${'refers to a custom function'} | ${'#someFunction'} | ${'cannot be a custom function call'}
+      `('returns a validation error when a transformation value segment $description', ({
+        transformationKey,
+        expectedValidationMessage
+      }) => {
+        const transformation = {
+          d: {
+            e: {
+              f: {
+                [transformationKey]: '$[0].a.b.c'
+              }
+            }
+          },
+          '*': '$[1]'
+        };
+        expect(validateRequestTransformation(transformation)).toStrictEqual(validationErrorWith({
+          parentPath: 'd.e.f',
+          invalidValue: transformationKey,
+          description: expectedValidationMessage
+        }));
+      });
+    });
+    describe('invalid transformations values', () => {
+      describe('omit transformation', () => {
+        const parentKey = (0, _motionRuntimeTestContext.aString)();
+        describe('invalid source', () => {
+          const invalidSourceValue = '$[x].a.b.c';
+          const invalidSourceTransformation = {
+            '@source': invalidSourceValue,
+            '@omit': (0, _lodash.times)(2, () => (0, _motionRuntimeTestContext.aString)())
+          };
+          test.each`
+            description    | invalidTransformation                           | expectedParentPath
+            ${'top level'} | ${invalidSourceTransformation}                  | ${'@source'}
+            ${'nested'}    | ${{
+            [parentKey]: invalidSourceTransformation
+          }} | ${`${parentKey}.@source`}
+          `('returns a validation error when the @source value is invalid', ({
+            invalidTransformation,
+            expectedParentPath
+          }) => {
+            expect(validateRequestTransformation(invalidTransformation)).toStrictEqual(validationErrorWith({
+              parentPath: expectedParentPath,
+              invalidValue: invalidSourceValue,
+              description: 'must start with $[N] where N is an index'
+            }));
+          });
+        });
+        describe('invalid @omit', () => {
+          const transformationWithOmitValue = value => ({
+            '@source': '$[0].a.b.c',
+            '@omit': value
+          });
+
+          const nonArray = (0, _motionRuntimeTestContext.aString)();
+          const nonStringArray = (0, _lodash.times)(2, () => (0, _motionRuntimeTestContext.aNumber)());
+          const arrayWithInvalidPaths = ['a.b.c', (0, _motionRuntimeTestContext.aString)()];
+          describe.each`
+            description    | invalidTransformation                                     | expectedParentPath
+            ${'top level'} | ${transformationWithOmitValue(nonArray)}                  | ${'@omit'}
+            ${'nested'}    | ${{
+            [parentKey]: transformationWithOmitValue(nonArray)
+          }} | ${`${parentKey}.@omit`}
+          `('@omit is not an array', ({
+            invalidTransformation,
+            expectedParentPath
+          }) => {
+            test('returns a validation error', () => {
+              expect(validateRequestTransformation(invalidTransformation)).toStrictEqual(validationErrorWith({
+                parentPath: expectedParentPath,
+                invalidValue: nonArray,
+                description: 'must be an array of strings'
+              }));
+            });
+          });
+          describe.each`
+            description    | invalidTransformation                                           | expectedParentPath
+            ${'top level'} | ${transformationWithOmitValue(nonStringArray)}                  | ${'@omit'}
+            ${'nested'}    | ${{
+            [parentKey]: transformationWithOmitValue(nonStringArray)
+          }} | ${`${parentKey}.@omit`}
+          `('@omit is an array of non-strings', ({
+            invalidTransformation,
+            expectedParentPath
+          }) => {
+            test('return a validation error', () => {
+              expect(validateRequestTransformation(invalidTransformation)).toStrictEqual(validationErrorWith({
+                parentPath: expectedParentPath,
+                invalidValue: nonStringArray,
+                description: 'must be an array of strings'
+              }));
+            });
+          });
+          /* eslint-disable max-len */
+
+          describe.each`
+            description    | invalidTransformation                                                  | expectedParentPath
+            ${'top level'} | ${transformationWithOmitValue(arrayWithInvalidPaths)}                  | ${'@omit'}
+            ${'nested'}    | ${{
+            [parentKey]: transformationWithOmitValue(arrayWithInvalidPaths)
+          }} | ${`${parentKey}.@omit`}
+          `('@omit is an array with invalid string paths', ({
+            description,
+            invalidTransformation,
+            expectedParentPath
+          }) => {
+            /* eslint-enable max-len */
+            test(`returns a validation error for invalid ${description} transformation`, () => {
+              expect(validateRequestTransformation(invalidTransformation)).toStrictEqual(validationErrorWith({
+                parentPath: expectedParentPath,
+                invalidValue: arrayWithInvalidPaths,
+                description: 'must contain non-nested paths only'
+              }));
+            });
+          });
+        });
+      });
+      describe('custom function expressions', () => {
+        test('returns a validation error when an invalid custom function-name is used', () => {
+          const invalidCustomFunctionCallExpression = '#1a';
+          const transformation = {
+            a: {
+              b: {
+                c: invalidCustomFunctionCallExpression
+              }
+            }
+          };
+          expect(validateRequestTransformation(transformation)).toStrictEqual(validationErrorWith({
+            parentPath: 'a.b.c',
+            invalidValue: invalidCustomFunctionCallExpression,
+            description: 'contains an invalid custom function expression'
+          }));
+        });
+        test('returns a validation error when a custom function argument is invalid for request transformation', () => {
+          const invalidCustomFunctionExpression = '#someFunction($.id)';
+          const transformation = {
+            a: {
+              b: {
+                c: invalidCustomFunctionExpression
+              }
+            }
+          };
+          expect(validateRequestTransformation(transformation)).toStrictEqual(validationErrorWith({
+            parentPath: 'a.b.c',
+            invalidValue: '$.id',
+            description: 'must start with $[N] where N is an index'
+          }));
+        });
+        describe('#constant function', () => {
+          test('returns a validation error when passed value is not a valid json value', () => {
+            const invalidCustomFunctionExpression = '#constant(not-json)';
+            const transformation = {
+              a: {
+                b: {
+                  c: invalidCustomFunctionExpression
+                }
+              }
+            };
+            expect(validateRequestTransformation(transformation)).toStrictEqual(validationErrorWith({
+              parentPath: 'a.b.c',
+              invalidValue: 'not-json',
+              description: 'must be a valid json value'
+            }));
+          });
+          test('allows passing non json-path arguments to the #constant function', () => {
+            const transformation = {
+              a: {
+                b: {
+                  c: '#constant("abc")'
+                }
+              }
+            };
+            expect(validateRequestTransformation(transformation)).toStrictEqual({
+              isValid: true,
+              validationErrors: []
+            });
+          });
+        });
+      });
+      /* eslint-disable max-len */
+
+      describe.each`
+        description                                                  | transformationValue | expectedValidationMessage
+        ${'does not start with $[N] where N is a numeric index'}     | ${'$[x].a.b.c'}     | ${'must start with $[N] where N is an index'}
+        ${'is not a valid json-path'}                                | ${'@'}              | ${'must start with $[N] where N is an index'}
+        ${'has several arguments referred to in the transformation'} | ${'$[0].$[1]'}      | ${'must have a single argument-index as the first path segment'}
+        ${'refers to * in the path'}                                 | ${'$[0].a.b.*'}     | ${'cannot refer to the * operator'}
+      `(
+      /* eslint-enable max-len */
+      'returns a validation error when a transformation value segment $description', ({
+        transformationValue,
+        expectedValidationMessage
+      }) => {
+        test('simple transformation', () => {
+          expect(validateRequestTransformation(transformationValue)).toStrictEqual(validationErrorWith({
+            parentPath: null,
+            invalidValue: transformationValue,
+            description: expectedValidationMessage
+          }));
+        });
+        test('complex transformation', () => {
+          const transformation = {
+            a: {
+              b: {
+                c: transformationValue
+              }
+            }
+          };
+          expect(validateRequestTransformation(transformation)).toStrictEqual(validationErrorWith({
+            parentPath: 'a.b.c',
+            invalidValue: transformationValue,
+            description: expectedValidationMessage
+          }));
+        });
+      });
+      describe('special fields', () => {
+        describe.each(['id', 'createdDate', 'updatedDate'])('%s', specialField => {
+          const transformationValue = `$[0].a.b.${specialField}`; // eslint-disable-next-line max-len
+
+          const expectedValidationMessage = `cannot refer to ${specialField} field, consider using _${specialField} instead`;
+          test('simple transformation', () => {
+            expect(validateRequestTransformation(transformationValue)).toStrictEqual(validationErrorWith({
+              parentPath: null,
+              invalidValue: transformationValue,
+              description: expectedValidationMessage
+            }));
+          });
+          test('complex transformation', () => {
+            const transformation = {
+              a: {
+                b: {
+                  c: transformationValue
+                }
+              }
+            };
+            expect(validateRequestTransformation(transformation)).toStrictEqual(validationErrorWith({
+              parentPath: 'a.b.c',
+              invalidValue: transformationValue,
+              description: expectedValidationMessage
+            }));
+          });
+        });
+      });
+    });
+  });
+});
+//# sourceMappingURL=validateRequestTransformation.spec.js.map

package/dist/cjs/__tests__/validations/validateRequestTransformation.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/__tests__/validations/validateRequestTransformation.spec.ts"],"names":["validateRequestTransformation","validation","describe","validResults","isValid","validationErrors","test","validTransformation","expect","toStrictEqual","a","validationErrorWith","parentPath","invalidValue","description","arrayContaining","objectContaining","each","transformationKey","expectedValidationMessage","transformation","d","e","f","parentKey","invalidSourceValue","invalidSourceTransformation","invalidTransformation","expectedParentPath","transformationWithOmitValue","value","nonArray","nonStringArray","arrayWithInvalidPaths","invalidCustomFunctionCallExpression","b","c","invalidCustomFunctionExpression","transformationValue","specialField"],"mappings":"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","sourcesContent":["import { aString, aNumber } from '@wix/motion-runtime-test-context';\nimport { times } from 'lodash';\nimport { validation } from '../..';\n\nconst { validateRequestTransformation } = validation;\n\ndescribe('validateRequestTransformation', () => {\n  describe('valid transformations', () => {\n    const validResults = { isValid: true, validationErrors: [] };\n\n    test('returns valid transformation response for a valid simple transformation', () => {\n      const validTransformation = '$[0].a.b.c';\n\n      expect(validateRequestTransformation(validTransformation)).toStrictEqual(\n        validResults,\n      );\n    });\n\n    test('returns valid transformation response for a valid complex transformation', () => {\n      const validTransformation = { a: '$[0].a.b.c' };\n\n      expect(validateRequestTransformation(validTransformation)).toStrictEqual(\n        validResults,\n      );\n    });\n  });\n\n  describe('invalid transformations', () => {\n    const validationErrorWith = ({\n      parentPath,\n      invalidValue,\n      description,\n    }) => ({\n      isValid: false,\n      validationErrors: expect.arrayContaining([\n        expect.objectContaining({\n          parentPath,\n          invalidValue,\n          description,\n        }),\n      ]),\n    });\n\n    describe('invalid complex-transformation keys', () => {\n      test.each`\n        description                      | transformationKey  | expectedValidationMessage\n        ${'refers to an argument index'} | ${'$[0]'}          | ${\"must start with '$.'\"}\n        ${'refers to a custom function'} | ${'#someFunction'} | ${'cannot be a custom function call'}\n      `(\n        'returns a validation error when a transformation value segment $description',\n        ({ transformationKey, expectedValidationMessage }) => {\n          const transformation = {\n            d: { e: { f: { [transformationKey]: '$[0].a.b.c' } } },\n            '*': '$[1]',\n          };\n\n          expect(validateRequestTransformation(transformation)).toStrictEqual(\n            validationErrorWith({\n              parentPath: 'd.e.f',\n              invalidValue: transformationKey,\n              description: expectedValidationMessage,\n            }),\n          );\n        },\n      );\n    });\n\n    describe('invalid transformations values', () => {\n      describe('omit transformation', () => {\n        const parentKey = aString();\n\n        describe('invalid source', () => {\n          const invalidSourceValue = '$[x].a.b.c';\n          const invalidSourceTransformation = {\n            '@source': invalidSourceValue,\n            '@omit': times(2, () => aString()),\n          };\n\n          test.each`\n            description    | invalidTransformation                           | expectedParentPath\n            ${'top level'} | ${invalidSourceTransformation}                  | ${'@source'}\n            ${'nested'}    | ${{ [parentKey]: invalidSourceTransformation }} | ${`${parentKey}.@source`}\n          `(\n            'returns a validation error when the @source value is invalid',\n            ({ invalidTransformation, expectedParentPath }) => {\n              expect(\n                validateRequestTransformation(invalidTransformation),\n              ).toStrictEqual(\n                validationErrorWith({\n                  parentPath: expectedParentPath,\n                  invalidValue: invalidSourceValue,\n                  description: 'must start with $[N] where N is an index',\n                }),\n              );\n            },\n          );\n        });\n\n        describe('invalid @omit', () => {\n          const transformationWithOmitValue = (value) => ({\n            '@source': '$[0].a.b.c',\n            '@omit': value,\n          });\n\n          const nonArray = aString();\n          const nonStringArray = times(2, () => aNumber());\n          const arrayWithInvalidPaths = ['a.b.c', aString()];\n\n          describe.each`\n            description    | invalidTransformation                                     | expectedParentPath\n            ${'top level'} | ${transformationWithOmitValue(nonArray)}                  | ${'@omit'}\n            ${'nested'}    | ${{ [parentKey]: transformationWithOmitValue(nonArray) }} | ${`${parentKey}.@omit`}\n          `(\n            '@omit is not an array',\n            ({ invalidTransformation, expectedParentPath }) => {\n              test('returns a validation error', () => {\n                expect(\n                  validateRequestTransformation(invalidTransformation),\n                ).toStrictEqual(\n                  validationErrorWith({\n                    parentPath: expectedParentPath,\n                    invalidValue: nonArray,\n                    description: 'must be an array of strings',\n                  }),\n                );\n              });\n            },\n          );\n\n          describe.each`\n            description    | invalidTransformation                                           | expectedParentPath\n            ${'top level'} | ${transformationWithOmitValue(nonStringArray)}                  | ${'@omit'}\n            ${'nested'}    | ${{ [parentKey]: transformationWithOmitValue(nonStringArray) }} | ${`${parentKey}.@omit`}\n          `(\n            '@omit is an array of non-strings',\n            ({ invalidTransformation, expectedParentPath }) => {\n              test('return a validation error', () => {\n                expect(\n                  validateRequestTransformation(invalidTransformation),\n                ).toStrictEqual(\n                  validationErrorWith({\n                    parentPath: expectedParentPath,\n                    invalidValue: nonStringArray,\n                    description: 'must be an array of strings',\n                  }),\n                );\n              });\n            },\n          );\n\n          /* eslint-disable max-len */\n          describe.each`\n            description    | invalidTransformation                                                  | expectedParentPath\n            ${'top level'} | ${transformationWithOmitValue(arrayWithInvalidPaths)}                  | ${'@omit'}\n            ${'nested'}    | ${{ [parentKey]: transformationWithOmitValue(arrayWithInvalidPaths) }} | ${`${parentKey}.@omit`}\n          `(\n            '@omit is an array with invalid string paths',\n            ({ description, invalidTransformation, expectedParentPath }) => {\n              /* eslint-enable max-len */\n              test(`returns a validation error for invalid ${description} transformation`, () => {\n                expect(\n                  validateRequestTransformation(invalidTransformation),\n                ).toStrictEqual(\n                  validationErrorWith({\n                    parentPath: expectedParentPath,\n                    invalidValue: arrayWithInvalidPaths,\n                    description: 'must contain non-nested paths only',\n                  }),\n                );\n              });\n            },\n          );\n        });\n      });\n\n      describe('custom function expressions', () => {\n        test('returns a validation error when an invalid custom function-name is used', () => {\n          const invalidCustomFunctionCallExpression = '#1a';\n          const transformation = {\n            a: { b: { c: invalidCustomFunctionCallExpression } },\n          };\n\n          expect(validateRequestTransformation(transformation)).toStrictEqual(\n            validationErrorWith({\n              parentPath: 'a.b.c',\n              invalidValue: invalidCustomFunctionCallExpression,\n              description: 'contains an invalid custom function expression',\n            }),\n          );\n        });\n\n        test('returns a validation error when a custom function argument is invalid for request transformation', () => {\n          const invalidCustomFunctionExpression = '#someFunction($.id)';\n          const transformation = {\n            a: { b: { c: invalidCustomFunctionExpression } },\n          };\n\n          expect(validateRequestTransformation(transformation)).toStrictEqual(\n            validationErrorWith({\n              parentPath: 'a.b.c',\n              invalidValue: '$.id',\n              description: 'must start with $[N] where N is an index',\n            }),\n          );\n        });\n\n        describe('#constant function', () => {\n          test('returns a validation error when passed value is not a valid json value', () => {\n            const invalidCustomFunctionExpression = '#constant(not-json)';\n            const transformation = {\n              a: { b: { c: invalidCustomFunctionExpression } },\n            };\n\n            expect(validateRequestTransformation(transformation)).toStrictEqual(\n              validationErrorWith({\n                parentPath: 'a.b.c',\n                invalidValue: 'not-json',\n                description: 'must be a valid json value',\n              }),\n            );\n          });\n\n          test('allows passing non json-path arguments to the #constant function', () => {\n            const transformation = { a: { b: { c: '#constant(\"abc\")' } } };\n\n            expect(validateRequestTransformation(transformation)).toStrictEqual(\n              {\n                isValid: true,\n                validationErrors: [],\n              },\n            );\n          });\n        });\n      });\n\n      /* eslint-disable max-len */\n      describe.each`\n        description                                                  | transformationValue | expectedValidationMessage\n        ${'does not start with $[N] where N is a numeric index'}     | ${'$[x].a.b.c'}     | ${'must start with $[N] where N is an index'}\n        ${'is not a valid json-path'}                                | ${'@'}              | ${'must start with $[N] where N is an index'}\n        ${'has several arguments referred to in the transformation'} | ${'$[0].$[1]'}      | ${'must have a single argument-index as the first path segment'}\n        ${'refers to * in the path'}                                 | ${'$[0].a.b.*'}     | ${'cannot refer to the * operator'}\n      `(\n        /* eslint-enable max-len */\n        'returns a validation error when a transformation value segment $description',\n        ({ transformationValue, expectedValidationMessage }) => {\n          test('simple transformation', () => {\n            expect(\n              validateRequestTransformation(transformationValue),\n            ).toStrictEqual(\n              validationErrorWith({\n                parentPath: null,\n                invalidValue: transformationValue,\n                description: expectedValidationMessage,\n              }),\n            );\n          });\n\n          test('complex transformation', () => {\n            const transformation = { a: { b: { c: transformationValue } } };\n\n            expect(validateRequestTransformation(transformation)).toStrictEqual(\n              validationErrorWith({\n                parentPath: 'a.b.c',\n                invalidValue: transformationValue,\n                description: expectedValidationMessage,\n              }),\n            );\n          });\n        },\n      );\n\n      describe('special fields', () => {\n        describe.each(['id', 'createdDate', 'updatedDate'])(\n          '%s',\n          (specialField) => {\n            const transformationValue = `$[0].a.b.${specialField}`;\n            // eslint-disable-next-line max-len\n            const expectedValidationMessage = `cannot refer to ${specialField} field, consider using _${specialField} instead`;\n\n            test('simple transformation', () => {\n              expect(\n                validateRequestTransformation(transformationValue),\n              ).toStrictEqual(\n                validationErrorWith({\n                  parentPath: null,\n                  invalidValue: transformationValue,\n                  description: expectedValidationMessage,\n                }),\n              );\n            });\n\n            test('complex transformation', () => {\n              const transformation = { a: { b: { c: transformationValue } } };\n\n              expect(\n                validateRequestTransformation(transformation),\n              ).toStrictEqual(\n                validationErrorWith({\n                  parentPath: 'a.b.c',\n                  invalidValue: transformationValue,\n                  description: expectedValidationMessage,\n                }),\n              );\n            });\n          },\n        );\n      });\n    });\n  });\n});\n"]}