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

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

@@ -0,0 +1,753 @@
+import { Validator } from "./..";
+describe('Validator', () => {
+  // --- 1. Type Validation ---
+  describe('type validation', () => {
+    it('should accept valid string', () => {
+      const result = Validator.validate({
+        type: 'string'
+      }, 'hello');
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+    it('should reject number when string expected', () => {
+      const result = Validator.validate({
+        type: 'string'
+      }, 123);
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0]).toMatchObject({
+        keyword: 'type',
+        message: 'should be string'
+      });
+    });
+    it('should accept valid number', () => {
+      const result = Validator.validate({
+        type: 'number'
+      }, 42);
+      expect(result.isValid).toBe(true);
+    });
+    it('should reject string when number expected', () => {
+      const result = Validator.validate({
+        type: 'number'
+      }, '42');
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].keyword).toBe('type');
+    });
+    it('should accept valid boolean', () => {
+      expect(Validator.validate({
+        type: 'boolean'
+      }, true).isValid).toBe(true);
+      expect(Validator.validate({
+        type: 'boolean'
+      }, false).isValid).toBe(true);
+    });
+    it('should reject non-boolean', () => {
+      expect(Validator.validate({
+        type: 'boolean'
+      }, 1).isValid).toBe(false);
+    });
+    it('should accept valid object', () => {
+      expect(Validator.validate({
+        type: 'object'
+      }, {
+        a: 1
+      }).isValid).toBe(true);
+    });
+    it('should reject null and array for object type', () => {
+      expect(Validator.validate({
+        type: 'object'
+      }, null).isValid).toBe(false);
+      expect(Validator.validate({
+        type: 'object'
+      }, [1, 2]).isValid).toBe(false);
+    });
+    it('should accept valid array', () => {
+      expect(Validator.validate({
+        type: 'array'
+      }, [1, 2, 3]).isValid).toBe(true);
+    });
+    it('should reject object for array type', () => {
+      expect(Validator.validate({
+        type: 'array'
+      }, {
+        length: 0
+      }).isValid).toBe(false);
+    });
+    it('should accept null for null type', () => {
+      expect(Validator.validate({
+        type: 'null'
+      }, null).isValid).toBe(true);
+    });
+    it('should reject undefined for null type', () => {
+      // undefined is skipped entirely — no validation error
+      expect(Validator.validate({
+        type: 'null'
+      }, undefined).isValid).toBe(true);
+    });
+    it('should accept function for function type', () => {
+      expect(Validator.validate({
+        type: 'function'
+      }, () => {}).isValid).toBe(true);
+    });
+    it('should reject string for function type', () => {
+      const result = Validator.validate({
+        type: 'function'
+      }, 'notAFunction');
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].keyword).toBe('type');
+    });
+    it('should accept anything for any/unknown type', () => {
+      expect(Validator.validate({
+        type: 'any'
+      }, 'hello').isValid).toBe(true);
+      expect(Validator.validate({
+        type: 'any'
+      }, 123).isValid).toBe(true);
+      expect(Validator.validate({
+        type: 'any'
+      }, null).isValid).toBe(true);
+    });
+  }); // --- 2. Type Arrays ---
+
+  describe('type arrays', () => {
+    const schema = {
+      type: ['string', 'number']
+    };
+    it('should accept string when type is [string, number]', () => {
+      expect(Validator.validate(schema, 'hello').isValid).toBe(true);
+    });
+    it('should accept number when type is [string, number]', () => {
+      expect(Validator.validate(schema, 42).isValid).toBe(true);
+    });
+    it('should reject boolean when type is [string, number]', () => {
+      const result = Validator.validate(schema, true);
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].message).toBe('should be string,number');
+    });
+  }); // --- 3. Enum ---
+
+  describe('enum', () => {
+    const schema = {
+      type: 'string',
+      enum: ['small', 'medium', 'large']
+    };
+    it('should accept valid enum value', () => {
+      expect(Validator.validate(schema, 'medium').isValid).toBe(true);
+    });
+    it('should reject invalid enum value', () => {
+      const result = Validator.validate(schema, 'extra-large');
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].keyword).toBe('enum');
+    });
+    it('should work with runtime Object.values() enum values', () => {
+      const SortOrder = {
+        ASC: 'ASC',
+        DES: 'DES',
+        NONE: 'NONE'
+      };
+      const runtimeSchema = {
+        type: 'string',
+        enum: Object.values(SortOrder)
+      };
+      expect(Validator.validate(runtimeSchema, 'ASC').isValid).toBe(true);
+      expect(Validator.validate(runtimeSchema, 'INVALID').isValid).toBe(false);
+    });
+  }); // --- 4. String Constraints ---
+
+  describe('string constraints', () => {
+    it('should pass minLength when string is long enough', () => {
+      expect(Validator.validate({
+        type: 'string',
+        minLength: 3
+      }, 'abc').isValid).toBe(true);
+    });
+    it('should fail minLength when string is too short', () => {
+      const result = Validator.validate({
+        type: 'string',
+        minLength: 3
+      }, 'ab');
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].keyword).toBe('minLength');
+    });
+    it('should pass maxLength when string is within limit', () => {
+      expect(Validator.validate({
+        type: 'string',
+        maxLength: 5
+      }, 'hello').isValid).toBe(true);
+    });
+    it('should fail maxLength when string exceeds limit', () => {
+      const result = Validator.validate({
+        type: 'string',
+        maxLength: 5
+      }, 'hello!');
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].keyword).toBe('maxLength');
+    });
+    it('should pass pattern when string matches', () => {
+      expect(Validator.validate({
+        type: 'string',
+        pattern: '^[a-z]+$'
+      }, 'abc').isValid).toBe(true);
+    });
+    it('should fail pattern when string does not match', () => {
+      const result = Validator.validate({
+        type: 'string',
+        pattern: '^[a-z]+$'
+      }, 'ABC');
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].keyword).toBe('pattern');
+    });
+  }); // --- 5. Array Constraints ---
+
+  describe('array constraints', () => {
+    it('should pass minItems when array has enough items', () => {
+      expect(Validator.validate({
+        type: 'array',
+        minItems: 2
+      }, [1, 2]).isValid).toBe(true);
+    });
+    it('should fail minItems when array has too few items', () => {
+      const result = Validator.validate({
+        type: 'array',
+        minItems: 2
+      }, [1]);
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].keyword).toBe('minItems');
+    });
+    it('should pass uniqueItems when items are unique', () => {
+      expect(Validator.validate({
+        type: 'array',
+        uniqueItems: true
+      }, ['a', 'b', 'c']).isValid).toBe(true);
+    });
+    it('should fail uniqueItems when items have duplicates', () => {
+      const result = Validator.validate({
+        type: 'array',
+        uniqueItems: true
+      }, ['a', 'b', 'a']);
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].keyword).toBe('uniqueItems');
+    });
+    it('should detect duplicate objects in uniqueItems', () => {
+      const result = Validator.validate({
+        type: 'array',
+        uniqueItems: true
+      }, [{
+        id: '1'
+      }, {
+        id: '2'
+      }, {
+        id: '1'
+      }]);
+      expect(result.isValid).toBe(false);
+    });
+    it('should validate each item against items schema', () => {
+      const schema = {
+        type: 'array',
+        items: {
+          type: 'string'
+        }
+      };
+      expect(Validator.validate(schema, ['a', 'b']).isValid).toBe(true);
+    });
+    it('should report invalid item with index in dataPath', () => {
+      const schema = {
+        type: 'array',
+        items: {
+          type: 'string'
+        }
+      };
+      const result = Validator.validate(schema, ['a', 42, 'c']);
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].dataPath).toBe('[1]');
+      expect(result.errors[0].keyword).toBe('type');
+    });
+  }); // --- 6. Object Constraints ---
+
+  describe('object constraints', () => {
+    it('should pass when all required properties are present', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string'
+          }
+        },
+        required: ['id']
+      };
+      expect(Validator.validate(schema, {
+        id: '123'
+      }).isValid).toBe(true);
+    });
+    it('should fail when required property is missing', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string'
+          }
+        },
+        required: ['id']
+      };
+      const result = Validator.validate(schema, {});
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0]).toMatchObject({
+        keyword: 'required',
+        dataPath: '.id'
+      });
+    });
+    it('should validate nested property values', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string'
+          },
+          age: {
+            type: 'number'
+          }
+        }
+      };
+      const result = Validator.validate(schema, {
+        name: 'John',
+        age: 'thirty'
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0]).toMatchObject({
+        keyword: 'type',
+        dataPath: '.age'
+      });
+    });
+    it('should skip properties not present in value', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string'
+          },
+          age: {
+            type: 'number'
+          }
+        }
+      };
+      expect(Validator.validate(schema, {
+        name: 'John'
+      }).isValid).toBe(true);
+    });
+    it('should reject extra properties when additionalProperties is false', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string'
+          }
+        },
+        additionalProperties: false
+      };
+      const result = Validator.validate(schema, {
+        name: 'John',
+        extra: true
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0]).toMatchObject({
+        keyword: 'additionalProperties',
+        dataPath: '.extra'
+      });
+    });
+    it('should allow extra properties when additionalProperties is true', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string'
+          }
+        },
+        additionalProperties: true
+      };
+      expect(Validator.validate(schema, {
+        name: 'John',
+        extra: true
+      }).isValid).toBe(true);
+    });
+    it('should validate extra properties against additionalProperties schema', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string'
+          }
+        },
+        additionalProperties: {
+          type: 'number'
+        }
+      };
+      expect(Validator.validate(schema, {
+        name: 'John',
+        score: 100
+      }).isValid).toBe(true);
+      const result = Validator.validate(schema, {
+        name: 'John',
+        score: 'high'
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0]).toMatchObject({
+        keyword: 'type',
+        dataPath: '.score'
+      });
+    });
+    it('should validate nested objects 2+ levels deep', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          config: {
+            type: 'object',
+            properties: {
+              enabled: {
+                type: 'boolean'
+              }
+            }
+          }
+        }
+      };
+      const result = Validator.validate(schema, {
+        config: {
+          enabled: 'yes'
+        }
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0]).toMatchObject({
+        keyword: 'type',
+        dataPath: '.config.enabled'
+      });
+    });
+    it('should skip validation for undefined property values', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          isEnabled: {
+            type: 'boolean'
+          },
+          count: {
+            type: 'number'
+          }
+        }
+      };
+      expect(Validator.validate(schema, {
+        isEnabled: undefined,
+        count: undefined
+      }).isValid).toBe(true);
+    });
+  }); // --- 7. Composition: anyOf / oneOf / not ---
+
+  describe('composition', () => {
+    describe('anyOf', () => {
+      const schema = {
+        anyOf: [{
+          type: 'string'
+        }, {
+          type: 'number'
+        }]
+      };
+      it('should pass when value matches one schema', () => {
+        expect(Validator.validate(schema, 'hello').isValid).toBe(true);
+        expect(Validator.validate(schema, 42).isValid).toBe(true);
+      });
+      it('should fail when value matches no schema', () => {
+        const result = Validator.validate(schema, true);
+        expect(result.isValid).toBe(false);
+        expect(result.errors[0].keyword).toBe('anyOf');
+      });
+    });
+    describe('oneOf', () => {
+      const schema = {
+        oneOf: [{
+          type: 'string',
+          minLength: 1
+        }, {
+          type: 'string',
+          maxLength: 3
+        }]
+      };
+      it('should pass when exactly one schema matches', () => {
+        // 'abcd' matches minLength:1 but fails maxLength:3 → exactly 1
+        expect(Validator.validate(schema, 'abcd').isValid).toBe(true);
+      });
+      it('should fail when no schema matches', () => {
+        // '' fails minLength:1; passes maxLength:3 → exactly 1 actually. Use number instead.
+        const numSchema = {
+          oneOf: [{
+            type: 'string'
+          }, {
+            type: 'number'
+          }]
+        };
+        expect(Validator.validate(numSchema, true).isValid).toBe(false);
+      });
+      it('should fail when more than one schema matches', () => {
+        // 'ab' matches both minLength:1 and maxLength:3 → 2 matches
+        const result = Validator.validate(schema, 'ab');
+        expect(result.isValid).toBe(false);
+        expect(result.errors[0].keyword).toBe('oneOf');
+      });
+    });
+    describe('not', () => {
+      const schema = {
+        not: {
+          type: 'string'
+        }
+      };
+      it('should pass when value does NOT match', () => {
+        expect(Validator.validate(schema, 42).isValid).toBe(true);
+      });
+      it('should fail when value matches', () => {
+        const result = Validator.validate(schema, 'hello');
+        expect(result.isValid).toBe(false);
+        expect(result.errors[0].keyword).toBe('not');
+      });
+    });
+  }); // --- 8. $ref + definitions ---
+
+  describe('$ref and definitions', () => {
+    it('should resolve $ref to definition', () => {
+      const schema = {
+        definitions: {
+          Name: {
+            type: 'string'
+          }
+        },
+        $ref: '#/definitions/Name'
+      };
+      expect(Validator.validate(schema, 'John').isValid).toBe(true);
+      expect(Validator.validate(schema, 123).isValid).toBe(false);
+    });
+    it('should resolve $ref in array items', () => {
+      const schema = {
+        definitions: {
+          Item: {
+            type: 'object',
+            properties: {
+              id: {
+                type: 'string'
+              }
+            },
+            required: ['id']
+          }
+        },
+        type: 'array',
+        items: {
+          $ref: '#/definitions/Item'
+        }
+      };
+      expect(Validator.validate(schema, [{
+        id: '1'
+      }, {
+        id: '2'
+      }]).isValid).toBe(true);
+      const result = Validator.validate(schema, [{
+        id: '1'
+      }, {}]);
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].keyword).toBe('required');
+    });
+    it('should support $defs as alternative to definitions', () => {
+      const schema = {
+        $defs: {
+          Count: {
+            type: 'number'
+          }
+        },
+        $ref: '#/$defs/Count'
+      };
+      expect(Validator.validate(schema, 5).isValid).toBe(true);
+      expect(Validator.validate(schema, 'five').isValid).toBe(false);
+    });
+    it('should silently skip unresolved $ref', () => {
+      const schema = {
+        $ref: '#/definitions/NonExistent'
+      };
+      const result = Validator.validate(schema, 'anything');
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  }); // --- 9. Edge Cases ---
+
+  describe('edge cases', () => {
+    it('should skip validation for undefined value', () => {
+      expect(Validator.validate({
+        type: 'string'
+      }, undefined).isValid).toBe(true);
+    });
+    it('should not error on empty/missing schema properties', () => {
+      expect(Validator.validate({}, 'anything').isValid).toBe(true);
+      expect(Validator.validate({
+        type: undefined
+      }, 'anything').isValid).toBe(true);
+    });
+    it('should accept anything with empty schema', () => {
+      expect(Validator.validate({}, 'hello').isValid).toBe(true);
+      expect(Validator.validate({}, 42).isValid).toBe(true);
+      expect(Validator.validate({}, null).isValid).toBe(true);
+    });
+    it('should ignore $schema keyword', () => {
+      const schema = {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        type: 'string'
+      };
+      expect(Validator.validate(schema, 'hello').isValid).toBe(true);
+    });
+    it('should hoist nested definitions from property-level schema', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          data: {
+            definitions: {
+              Tag: {
+                type: 'object',
+                properties: {
+                  label: {
+                    type: 'string'
+                  }
+                },
+                required: ['label']
+              }
+            },
+            type: 'array',
+            items: {
+              $ref: '#/definitions/Tag'
+            }
+          }
+        }
+      };
+      expect(Validator.validate(schema, {
+        data: [{
+          label: 'test'
+        }]
+      }).isValid).toBe(true);
+    });
+    it('should short-circuit on type mismatch — no further checks', () => {
+      const schema = {
+        type: 'string',
+        minLength: 5
+      };
+      const result = Validator.validate(schema, 123); // Only type error, no minLength error
+
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].keyword).toBe('type');
+    });
+    it('should return warnings as empty array for validate()', () => {
+      const result = Validator.validate({
+        type: 'string'
+      }, 'hello');
+      expect(result.warnings).toEqual([]);
+    });
+  }); // --- 10. validatePropertySchema + validateRequired ---
+
+  describe('validatePropertySchema', () => {
+    it('should delegate to validatePropertySchema when schema.schema is present', () => {
+      const propertySchema = {
+        required: false,
+        isValueProvided: true,
+        name: 'testProp',
+        schema: {
+          type: 'string'
+        }
+      };
+      const result = Validator.validate(propertySchema, 'hello');
+      expect(result.isValid).toBe(true);
+      expect(result.key).toBe('testProp');
+    });
+    it('should return warning when required + not provided + has default', () => {
+      const propertySchema = {
+        required: true,
+        isValueProvided: false,
+        defaultValue: 'fallback',
+        name: 'myProp',
+        schema: {
+          type: 'string'
+        }
+      };
+      const result = Validator.validate(propertySchema, undefined);
+      expect(result.isValid).toBe(true);
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0].message).toContain('Default value will be used');
+    });
+    it('should return error when required + not provided + default is undefined', () => {
+      const propertySchema = {
+        required: true,
+        isValueProvided: false,
+        defaultValue: undefined,
+        name: 'myProp',
+        schema: {
+          type: 'string'
+        }
+      };
+      const result = Validator.validate(propertySchema, undefined);
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].message).toContain('default value is undefined');
+    });
+    it('should return error when required + not provided + no default', () => {
+      const propertySchema = {
+        required: true,
+        isValueProvided: false,
+        name: 'myProp',
+        schema: {
+          type: 'string'
+        }
+      };
+      const result = Validator.validate(propertySchema, undefined);
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].message).toContain('neither a value nor a default value');
+    });
+    it('should validate schema when required and provided', () => {
+      const propertySchema = {
+        required: true,
+        isValueProvided: true,
+        name: 'myProp',
+        schema: {
+          type: 'number'
+        }
+      };
+      const result = Validator.validate(propertySchema, 'not-a-number');
+      expect(result.isValid).toBe(false);
+      expect(result.key).toBe('myProp');
+      expect(result.errors[0].keyword).toBe('type');
+    });
+    it('should be valid when not required and not provided', () => {
+      const propertySchema = {
+        required: false,
+        isValueProvided: false,
+        name: 'optionalProp',
+        schema: {
+          type: 'string'
+        }
+      };
+      const result = Validator.validate(propertySchema, undefined);
+      expect(result.isValid).toBe(true);
+    });
+    it('should validate schema when not required but provided', () => {
+      const propertySchema = {
+        required: false,
+        isValueProvided: true,
+        name: 'optionalProp',
+        schema: {
+          type: 'boolean'
+        }
+      };
+      expect(Validator.validate(propertySchema, true).isValid).toBe(true);
+      expect(Validator.validate(propertySchema, 'yes').isValid).toBe(false);
+    });
+    it('should include key in result from propertySchema.name', () => {
+      const propertySchema = {
+        required: false,
+        isValueProvided: true,
+        name: 'selectionConfig',
+        schema: {
+          type: 'object'
+        }
+      };
+      const result = Validator.validate(propertySchema, {
+        enabled: true
+      });
+      expect(result.key).toBe('selectionConfig');
+    });
+  });
+});