@zohodesk/library-platform 1.2.2-exp.1 → 1.2.2-exp.2

package/es/library/custom-component/frameworks/json-schema-validator/__tests__/Validator.test.js

@@ -1,478 +0,0 @@
-import Validator from "../Validator"; // Schemas extracted from src/cc/table-connected/Properties.ts
-
-const preferencesSchema = {
-  type: 'object',
-  properties: {
-    rowActions: {
-      type: 'object',
-      additionalProperties: {
-        width: {
-          type: 'string'
-        }
-      }
-    },
-    fields: {
-      type: 'object',
-      additionalProperties: {
-        type: 'object',
-        properties: {
-          initialWidth: {
-            type: 'number'
-          },
-          currencyLocale: {
-            type: 'string'
-          },
-          currencySymbol: {
-            type: 'string'
-          }
-        }
-      }
-    },
-    autoColumnSizing: {
-      type: 'boolean'
-    }
-  }
-};
-const moduleNameSchema = {
-  type: 'string'
-};
-const textOverflowConfigSchema = {
-  type: 'object',
-  properties: {
-    isEnabled: {
-      type: 'boolean'
-    },
-    mode: {
-      type: 'string',
-      enum: ['clip', 'wrap']
-    }
-  }
-};
-const nameFieldsConfigSchema = {
-  type: 'object'
-};
-const componentMappingSchema = {
-  type: 'object',
-  properties: {
-    fields: {
-      type: 'object'
-    },
-    rowActionsComponentName: {
-      type: 'string'
-    },
-    emptyState: {
-      type: 'string'
-    }
-  }
-};
-const selectionConfigSchema = {
-  type: 'object',
-  properties: {
-    isEnabled: {
-      type: 'boolean'
-    },
-    maxSelectionCount: {
-      type: 'number'
-    },
-    limitExceedAlertMessage: {
-      type: 'string'
-    },
-    isSelectAllEnabled: {
-      type: 'boolean'
-    }
-  }
-};
-describe('Validator', () => {
-  describe('validate() — direct schema (no schema.schema)', () => {
-    it('should return valid for a correct object value', () => {
-      const result = Validator.validate(preferencesSchema, {
-        fields: {},
-        autoColumnSizing: false
-      });
-      expect(result.isValid).toBe(true);
-      expect(result.errors).toEqual([]);
-      expect(result.warnings).toEqual([]);
-    });
-    it('should return invalid when a property has wrong type', () => {
-      const result = Validator.validate(preferencesSchema, {
-        fields: 'not-an-object',
-        autoColumnSizing: false
-      });
-      expect(result.isValid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-    it('should return valid for a correct string value', () => {
-      const result = Validator.validate(moduleNameSchema, 'deals');
-      expect(result.isValid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-    it('should return invalid when string expected but number given', () => {
-      const result = Validator.validate(moduleNameSchema, 123);
-      expect(result.isValid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-    it('should return valid for a value matching an enum', () => {
-      const result = Validator.validate(textOverflowConfigSchema, {
-        isEnabled: true,
-        mode: 'clip'
-      });
-      expect(result.isValid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-    it('should return invalid for a value not in enum', () => {
-      const result = Validator.validate(textOverflowConfigSchema, {
-        isEnabled: true,
-        mode: 'scroll'
-      });
-      expect(result.isValid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-      expect(result.errors.some(e => e.keyword === 'enum')).toBe(true);
-    });
-    it('should return valid for nested object with additionalProperties', () => {
-      const result = Validator.validate(preferencesSchema, {
-        fields: {
-          name: {
-            initialWidth: 200,
-            currencyLocale: 'en-US'
-          }
-        },
-        autoColumnSizing: true
-      });
-      expect(result.isValid).toBe(true);
-    });
-    it('should return invalid for nested additionalProperties with wrong type', () => {
-      const result = Validator.validate(preferencesSchema, {
-        fields: {
-          name: {
-            initialWidth: 'wide'
-          }
-        }
-      });
-      expect(result.isValid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-    it('should return valid for a loose object schema with any object', () => {
-      const result = Validator.validate(nameFieldsConfigSchema, {
-        isEnabled: true,
-        isPreventDefault: false,
-        constructUrl: null,
-        extraProp: 'anything'
-      });
-      expect(result.isValid).toBe(true);
-    });
-    it('should return valid for selectionConfig with correct values', () => {
-      const result = Validator.validate(selectionConfigSchema, {
-        isEnabled: true,
-        maxSelectionCount: 50,
-        limitExceedAlertMessage: 'Maximum records selected',
-        isSelectAllEnabled: false
-      });
-      expect(result.isValid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-    it('should return invalid for selectionConfig with wrong types', () => {
-      const result = Validator.validate(selectionConfigSchema, {
-        isEnabled: 'yes',
-        maxSelectionCount: 'fifty'
-      });
-      expect(result.isValid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-    it('should return valid for componentMapping with partial properties', () => {
-      const result = Validator.validate(componentMappingSchema, {
-        fields: {},
-        emptyState: 'NoDataComponent'
-      });
-      expect(result.isValid).toBe(true);
-    });
-    it('should return valid for an empty object when no properties are required', () => {
-      const result = Validator.validate(preferencesSchema, {});
-      expect(result.isValid).toBe(true);
-    });
-  });
-  describe('checkFunctionsRecursively() — function type handling', () => {
-    it('should return valid when value is a function for function type schema', () => {
-      const schema = {
-        type: 'function'
-      };
-      const result = Validator.validate(schema, () => {});
-      expect(result.isValid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-    it('should return error when value is not a function for function type schema', () => {
-      const schema = {
-        type: 'function'
-      };
-      const result = Validator.validate(schema, 'not a function');
-      expect(result.isValid).toBe(false);
-      expect(result.errors).toEqual(expect.arrayContaining([expect.objectContaining({
-        keyword: 'type',
-        params: {
-          type: 'function'
-        },
-        message: 'should be function'
-      })]));
-    });
-    it('should validate nested function property in object schema', () => {
-      const schema = {
-        type: 'object',
-        properties: {
-          onClick: {
-            type: 'function'
-          },
-          label: {
-            type: 'string'
-          }
-        }
-      };
-      const result = Validator.validate(schema, {
-        onClick: () => {},
-        label: 'Click me'
-      });
-      expect(result.isValid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-    it('should return error with correct dataPath for nested function property', () => {
-      const schema = {
-        type: 'object',
-        properties: {
-          onClick: {
-            type: 'function'
-          },
-          label: {
-            type: 'string'
-          }
-        }
-      };
-      const result = Validator.validate(schema, {
-        onClick: 'not a function',
-        label: 'Click me'
-      });
-      expect(result.isValid).toBe(false);
-      expect(result.errors).toEqual(expect.arrayContaining([expect.objectContaining({
-        keyword: 'type',
-        dataPath: '.onClick',
-        schemaPath: '#/properties/onClick/type',
-        message: 'should be function'
-      })]));
-    });
-    it('should validate function items in array schema', () => {
-      const schema = {
-        type: 'array',
-        items: {
-          type: 'function'
-        }
-      };
-
-      const fn1 = () => {};
-
-      const fn2 = () => {};
-
-      const result = Validator.validate(schema, [fn1, fn2]);
-      expect(result.isValid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-    it('should return error for non-function item in array of functions', () => {
-      const schema = {
-        type: 'array',
-        items: {
-          type: 'function'
-        }
-      };
-      const result = Validator.validate(schema, [() => {}, 'not a function']);
-      expect(result.isValid).toBe(false);
-      expect(result.errors).toEqual(expect.arrayContaining([expect.objectContaining({
-        keyword: 'type',
-        dataPath: '.[1]',
-        message: 'should be function'
-      })]));
-    });
-    it('should validate deeply nested function in object > object', () => {
-      const schema = {
-        type: 'object',
-        properties: {
-          handlers: {
-            type: 'object',
-            properties: {
-              onMount: {
-                type: 'function'
-              }
-            }
-          }
-        }
-      };
-      const result = Validator.validate(schema, {
-        handlers: {
-          onMount: 42
-        }
-      });
-      expect(result.isValid).toBe(false);
-      expect(result.errors).toEqual(expect.arrayContaining([expect.objectContaining({
-        dataPath: '.handlers.onMount',
-        schemaPath: '#/properties/handlers/properties/onMount/type'
-      })]));
-    });
-  });
-  describe('validatePropertySchema() — property schema path (schema.schema exists)', () => {
-    it('should return valid with key for required property provided with correct value', () => {
-      const propertySchema = {
-        required: true,
-        isValueProvided: true,
-        name: 'moduleName',
-        schema: moduleNameSchema
-      };
-      const result = Validator.validate(propertySchema, 'deals');
-      expect(result.isValid).toBe(true);
-      expect(result.key).toBe('moduleName');
-      expect(result.errors).toEqual([]);
-      expect(result.warnings).toEqual([]);
-    });
-    it('should return invalid for required property provided with wrong type', () => {
-      const propertySchema = {
-        required: true,
-        isValueProvided: true,
-        name: 'moduleName',
-        schema: moduleNameSchema
-      };
-      const result = Validator.validate(propertySchema, 123);
-      expect(result.isValid).toBe(false);
-      expect(result.key).toBe('moduleName');
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-    it('should return valid with warning when required property missing but has default', () => {
-      const propertySchema = {
-        required: true,
-        isValueProvided: false,
-        defaultValue: {
-          isEnabled: true
-        },
-        name: 'keyboardControlsConfig',
-        schema: {
-          type: 'object',
-          properties: {
-            isEnabled: {
-              type: 'boolean'
-            }
-          }
-        }
-      };
-      const result = Validator.validate(propertySchema, undefined);
-      expect(result.isValid).toBe(true);
-      expect(result.errors).toEqual([]);
-      expect(result.warnings.length).toBeGreaterThan(0);
-      expect(result.warnings[0].message).toContain('Default value will be used');
-    });
-    it('should return invalid when required property missing and no default', () => {
-      const propertySchema = {
-        required: true,
-        isValueProvided: false,
-        name: 'moduleName',
-        schema: moduleNameSchema
-      };
-      const result = Validator.validate(propertySchema, undefined);
-      expect(result.isValid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-      expect(result.errors[0].message).toContain('required but missing');
-    });
-    it('should return invalid when required property missing and default is undefined', () => {
-      const propertySchema = {
-        required: true,
-        isValueProvided: false,
-        defaultValue: undefined,
-        name: 'testProp',
-        schema: moduleNameSchema
-      };
-      const result = Validator.validate(propertySchema, undefined);
-      expect(result.isValid).toBe(false);
-      expect(result.errors[0].message).toContain('default value is undefined');
-    });
-    it('should return valid with no warnings for optional property not provided', () => {
-      const propertySchema = {
-        required: false,
-        isValueProvided: false,
-        name: 'preferences',
-        defaultValue: {
-          fields: {},
-          autoColumnSizing: false
-        },
-        schema: preferencesSchema
-      };
-      const result = Validator.validate(propertySchema, undefined);
-      expect(result.isValid).toBe(true);
-      expect(result.errors).toEqual([]);
-      expect(result.warnings).toEqual([]);
-    });
-    it('should return invalid for optional property provided with invalid value', () => {
-      const propertySchema = {
-        required: false,
-        isValueProvided: true,
-        name: 'textOverflowConfig',
-        schema: textOverflowConfigSchema
-      };
-      const result = Validator.validate(propertySchema, {
-        isEnabled: true,
-        mode: 'invalid'
-      });
-      expect(result.isValid).toBe(false);
-      expect(result.key).toBe('textOverflowConfig');
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-    it('should return valid for optional property provided with valid value', () => {
-      const propertySchema = {
-        required: false,
-        isValueProvided: true,
-        name: 'textOverflowConfig',
-        schema: textOverflowConfigSchema
-      };
-      const result = Validator.validate(propertySchema, {
-        isEnabled: true,
-        mode: 'wrap'
-      });
-      expect(result.isValid).toBe(true);
-      expect(result.key).toBe('textOverflowConfig');
-    });
-    it('should validate componentMapping property schema with valid data', () => {
-      const propertySchema = {
-        required: false,
-        isValueProvided: true,
-        name: 'componentMapping',
-        defaultValue: {
-          fields: {},
-          emptyState: ''
-        },
-        schema: componentMappingSchema
-      };
-      const result = Validator.validate(propertySchema, {
-        fields: {
-          name: 'TextField'
-        },
-        rowActionsComponentName: 'RowActions',
-        emptyState: 'EmptyState'
-      });
-      expect(result.isValid).toBe(true);
-      expect(result.key).toBe('componentMapping');
-    });
-  });
-  describe('AJV useDefaults behavior', () => {
-    it('should fill in default values defined in schema', () => {
-      const schema = {
-        type: 'object',
-        properties: {
-          isEnabled: {
-            type: 'boolean',
-            default: true
-          },
-          mode: {
-            type: 'string',
-            default: 'clip'
-          }
-        }
-      };
-      const value = {};
-      const result = Validator.validate(schema, value);
-      expect(result.isValid).toBe(true);
-      expect(value.isEnabled).toBe(true);
-      expect(value.mode).toBe('clip');
-    });
-  });
-});